@Override public ContentReader getReader() throws ContentIOException { return delegatee.getReader(); }
@Override public ContentReader getReader() throws ContentIOException { return delegatee.getReader(); }
@Override public ContentReader getReader() throws ContentIOException { return this.cacheWriter.getReader(); }
@Override public ContentReader getReader() throws ContentIOException { return this.cacheWriter.getReader(); }
@Override public long getSize() { if (!this.cacheWriter.getReader().exists()) { return this.bsWriter.getSize(); } return this.cacheWriter.getSize(); }
@Override public ContentData getContentData() { if (!this.cacheWriter.getReader().exists()) { return this.bsWriter.getContentData(); } return this.cacheWriter.getContentData(); }
@Override public long getSize() { if (!this.cacheWriter.getReader().exists()) { return this.bsWriter.getSize(); } return this.cacheWriter.getSize(); }
@Override public ContentData getContentData() { if (!this.cacheWriter.getReader().exists()) { return this.bsWriter.getContentData(); } return this.cacheWriter.getContentData(); }
@Test public void testReadAndWriteStreamByPull() throws Exception { ContentWriter writer = getWriter(); String content = "ABC"; // put the content using a stream InputStream is = new ByteArrayInputStream(content.getBytes()); writer.putContent(is); assertTrue("Stream close not detected", writer.isClosed()); // get the content using a stream ByteArrayOutputStream os = new ByteArrayOutputStream(100); ContentReader reader = writer.getReader(); reader.getContent(os); byte[] bytes = os.toByteArray(); String check = new String(bytes); assertEquals("Write out and read in using streams failed", content, check); }
@Test public void testReadAndWriteStreamByPush() throws Exception { ContentWriter writer = getWriter(); String content = "Some Random Content"; // get the content output stream OutputStream os = writer.getContentOutputStream(); os.write(content.getBytes()); assertFalse("Stream has not been closed", writer.isClosed()); // close the stream and check again os.close(); assertTrue("Stream close not detected", writer.isClosed()); // pull the content from a stream ContentReader reader = writer.getReader(); InputStream is = reader.getContentInputStream(); byte[] buffer = new byte[100]; int count = is.read(buffer); assertEquals("No content read", content.length(), count); is.close(); String check = new String(buffer, 0, count); assertEquals("Write out of and read into files failed", content, check); }
public Void execute() throws Throwable { ContentWriter writer = contentService.getWriter(contentNodeRef, ContentModel.PROP_CONTENT, true); writer.putContent("UNLUCKY CONTENT"); ContentReader reader = contentService.getReader(contentNodeRef, ContentModel.PROP_CONTENT); assertEquals("Incorrect content", "UNLUCKY CONTENT", reader.getContentString()); assertEquals("Incorrect content", "UNLUCKY CONTENT", writer.getReader().getContentString()); readers[0] = reader; throw new RuntimeException("aaa"); } };
public void testDITAFileWithoutDoctype() throws Exception { // Munge the file to skip the doctype ContentReader reader = getReader(FILE_DITA_FILE); assertTrue(reader.exists()); String contents = reader.getContentString(); String noDocType = contents.replaceAll("<!DOCTYPE.*?>", ""); File tmp = File.createTempFile("alfresco", ".xml"); tmp.deleteOnExit(); ContentWriter w = new FileContentWriter(tmp); w.setEncoding(reader.getEncoding()); w.setMimetype(reader.getMimetype()); w.putContent(noDocType); // Now test extraction doTestDITAFile(w.getReader()); } private void doTestDITAFile(ContentReader reader) throws Exception
/** * Writes some content using the mimetype and encoding specified. * * @param mimetype String * @param encoding String * @return Returns a reader onto the newly written content */ private ContentReader writeContent(String mimetype, String encoding) { ContentWriter writer = new FileContentWriter(getTempFile()); writer.setMimetype(mimetype); writer.setEncoding(encoding); // put content writer.putContent(SOME_CONTENT); // return a reader onto the new content return writer.getReader(); }
/** * The simplest test. Write a string and read it again, checking that we receive the same values. * If the resource accessed by {@link #getReader(String)} and {@link #getWriter()} is not the same, then * values written and read won't be the same. */ @Test public void testWriteAndReadString() throws Exception { ContentWriter writer = getWriter(); String content = "ABC"; writer.putContent(content); assertTrue("Stream close not detected", writer.isClosed()); ContentReader reader = writer.getReader(); String check = reader.getContentString(); assertTrue("Read and write may not share same resource", check.length() > 0); assertEquals("Write and read didn't work", content, check); }
public void testCsvOutput() throws Exception { File sourceFile = AbstractContentTransformerTest.loadQuickTestFile("xls"); ContentReader sourceReader = new FileContentReader(sourceFile); File targetFile = TempFileProvider.createTempFile( getClass().getSimpleName() + "_" + getName() + "_xls_", ".csv"); ContentWriter targetWriter = new FileContentWriter(targetFile); sourceReader.setMimetype(MimetypeMap.MIMETYPE_EXCEL); targetWriter.setMimetype(MimetypeMap.MIMETYPE_TEXT_CSV); transformer.transform(sourceReader, targetWriter); ContentReader targetReader = targetWriter.getReader(); String checkContent = targetReader.getContentString(); additionalContentCheck( MimetypeMap.MIMETYPE_EXCEL, MimetypeMap.MIMETYPE_TEXT_CSV, checkContent ); }
@Test public void testStringTruncation() throws Exception { String content = "1234567890"; ContentWriter writer = getWriter(); writer.setMimetype(MimetypeMap.MIMETYPE_TEXT_PLAIN); writer.setEncoding("UTF-8"); // shorter format i.t.o. bytes used // write the content writer.putContent(content); // get a reader - get it in a larger format i.t.o. bytes ContentReader reader = writer.getReader(); String checkContent = reader.getContentString(5); assertEquals("Truncated strings don't match", "12345", checkContent); }
public void testCopyCommand() throws Exception { String content = "<A><B></B></A>"; // create the source File sourceFile = TempFileProvider.createTempFile(getName() + "_", ".txt"); ContentWriter tempWriter = new FileContentWriter(sourceFile); tempWriter.setMimetype(MimetypeMap.MIMETYPE_TEXT_PLAIN); tempWriter.putContent(content); ContentReader reader = tempWriter.getReader(); // create the target File targetFile = TempFileProvider.createTempFile(getName() + "_", ".xml"); ContentWriter writer = new FileContentWriter(targetFile); writer.setMimetype(MimetypeMap.MIMETYPE_XML); // do the transformation transformer.transform(reader, writer); // no options on the copy // make sure that the content was copied over ContentReader checkReader = writer.getReader(); String checkContent = checkReader.getContentString(); assertEquals("Content not copied", content, checkContent); } }
public void testDirectTransform() throws Exception { ContentReader reader = writeContent("text/plain", "MacDingbat"); // check transformability assertTrue(transformer.isTransformable(reader.getMimetype(), -1, targetWriter.getMimetype(), new TransformationOptions())); // transform transformer.transform(reader, targetWriter); // get a reader onto the transformed content and check ContentReader checkReader = targetWriter.getReader(); String checkContent = checkReader.getContentString(); assertEquals("Content check failed", SOME_CONTENT, checkContent); }
public void testInterTextTransform() throws Exception { ContentReader reader = writeContent("text/xml", "MacDingbat"); // check transformability assertTrue(transformer.isTransformable(reader.getMimetype(), -1, targetWriter.getMimetype(), new TransformationOptions())); // transform transformer.transform(reader, targetWriter); // get a reader onto the transformed content and check ContentReader checkReader = targetWriter.getReader(); String checkContent = checkReader.getContentString(); assertEquals("Content check failed", SOME_CONTENT, checkContent); }
@Test public void writeToCacheWithExistingReader() { ContentWriter oldWriter = store.getWriter(ContentContext.NULL_CONTEXT); oldWriter.putContent("Old content for " + getClass().getSimpleName()); ContentReader existingReader = oldWriter.getReader(); // Write through the caching content store - cache during the process. final String proposedUrl = FileContentStore.createNewFileStoreUrl(); ContentWriter writer = store.getWriter(new ContentContext(existingReader, proposedUrl)); final String content = makeContent(); writer.putContent(content); assertEquals("Writer should have correct URL", proposedUrl, writer.getContentUrl()); assertFalse("Old and new writers must have different URLs", oldWriter.getContentUrl().equals(writer.getContentUrl())); ContentReader reader = store.getReader(writer.getContentUrl()); assertEquals("Reader and writer should have same URLs", writer.getContentUrl(), reader.getContentUrl()); assertEquals("Reader should get correct content", content, reader.getContentString()); }