| /* |
| * Copyright (c) 2010, Rickard Öberg. All Rights Reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| package org.apache.zest.io; |
| |
| import java.io.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.PrintWriter; |
| import java.io.Writer; |
| import java.net.URL; |
| import java.nio.ByteBuffer; |
| import java.nio.charset.Charset; |
| import java.rmi.RemoteException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.concurrent.locks.Lock; |
| import java.util.concurrent.locks.ReentrantLock; |
| import java.util.logging.Logger; |
| import org.hamcrest.CoreMatchers; |
| import org.junit.Assert; |
| import org.junit.Test; |
| import org.apache.zest.functional.Function; |
| import org.apache.zest.functional.Visitor; |
| |
| import static java.util.Arrays.asList; |
| import static org.apache.zest.functional.Iterables.iterable; |
| import static org.apache.zest.io.Inputs.text; |
| import static org.apache.zest.io.Transforms.lock; |
| import static org.apache.zest.test.util.Assume.assumeConnectivity; |
| |
| /** |
| * Test Input/Output. |
| */ |
| public class InputOutputTest |
| { |
| @Test |
| public void testCopyFileNoAPI() |
| throws IOException |
| { |
| File source = sourceFile(); |
| File destination = File.createTempFile( "test", ".txt" ); |
| destination.deleteOnExit(); |
| |
| BufferedReader reader = new BufferedReader( new FileReader( source ) ); |
| long count = 0; |
| try |
| { |
| BufferedWriter writer = new BufferedWriter( new FileWriter( destination ) ); |
| try |
| { |
| String line; |
| while( ( line = reader.readLine() ) != null ) |
| { |
| count++; |
| writer.append( line ).append( '\n' ); |
| } |
| writer.close(); |
| } |
| catch( IOException e ) |
| { |
| writer.close(); |
| destination.delete(); |
| } |
| } |
| finally |
| { |
| reader.close(); |
| } |
| System.out.println( count ); |
| } |
| |
| @Test |
| public void testInputOutput() |
| throws IOException |
| { |
| URL source = getClass().getResource( "/iotest.txt" ); |
| File destination = File.createTempFile( "test", ".txt" ); |
| destination.deleteOnExit(); |
| text( source ).transferTo( Outputs.text( destination ) ); |
| } |
| |
| @Test |
| public void testCopyFile() |
| throws IOException |
| { |
| File source = sourceFile(); |
| File tempFile = File.createTempFile( "test", ".txt" ); |
| tempFile.deleteOnExit(); |
| |
| Inputs.byteBuffer( source, 1024 ).transferTo( Outputs.byteBuffer( tempFile ) ); |
| |
| Assert.assertThat( tempFile.length(), CoreMatchers.equalTo( source.length() ) ); |
| } |
| |
| @Test |
| public void testCopyURL() |
| throws IOException |
| { |
| assumeConnectivity( "www.google.com", 80 ); |
| |
| File tempFile = File.createTempFile( "test", ".txt" ); |
| tempFile.deleteOnExit(); |
| |
| Inputs.text( new URL( "http://www.google.com" ) ).transferTo( Outputs.text( tempFile ) ); |
| |
| // Uncomment to check output Inputs.text( tempFile ).transferTo( Outputs.systemOut() ); |
| } |
| |
| @Test |
| public void testCopyFileStreams() |
| throws IOException |
| { |
| File source = sourceFile(); |
| File tempFile = File.createTempFile( "test", ".txt" ); |
| tempFile.deleteOnExit(); |
| |
| Inputs.byteBuffer( new FileInputStream( source ), 1024 ).transferTo( |
| Outputs.byteBuffer( new FileOutputStream( tempFile ) ) ); |
| |
| Assert.assertThat( tempFile.length(), CoreMatchers.equalTo( source.length() ) ); |
| } |
| |
| @Test |
| public void testLog() |
| throws IOException |
| { |
| File source = sourceFile(); |
| |
| text( source ).transferTo( |
| Transforms.map( new Transforms.Log<String>( Logger.getLogger( getClass().getName() ), "Line: {0}" ), |
| Outputs.<String>noop() ) ); |
| } |
| |
| @Test |
| public void testProgressLog() |
| throws Throwable |
| { |
| Integer[] data = new Integer[ 105 ]; |
| Arrays.fill( data, 42 ); |
| |
| Inputs.iterable( iterable( data ) ).transferTo( |
| Transforms.map( |
| new Transforms.ProgressLog<Integer>( |
| Logger.getLogger( InputOutputTest.class.getName() ), "Data transferred: {0}", 10 ), |
| Outputs.<Integer>noop() ) ); |
| } |
| |
| @Test |
| public void testTextInputsOutputs() |
| throws IOException |
| { |
| File tempFile = File.createTempFile( "test", ".txt" ); |
| tempFile.deleteOnExit(); |
| File sourceFile = sourceFile(); |
| Transforms.Counter<String> stringCounter = new Transforms.Counter<>(); |
| text( sourceFile ).transferTo( |
| Transforms.map( |
| stringCounter, |
| Transforms.map( new Function<String, String>() |
| { |
| public String map( String s ) |
| { |
| System.out.println( s ); |
| return s; |
| } |
| }, Outputs.text( tempFile ) ) |
| ) |
| ); |
| |
| Assert.assertThat( tempFile.length(), CoreMatchers.equalTo( sourceFile.length() ) ); |
| Assert.assertThat( stringCounter.count(), CoreMatchers.equalTo( 4L ) ); |
| } |
| |
| @Test |
| public void testCombineInputs() |
| throws IOException |
| { |
| File tempFile = File.createTempFile( "test", ".txt" ); |
| tempFile.deleteOnExit(); |
| File sourceFile = sourceFile(); |
| Transforms.Counter<String> stringCounter = new Transforms.Counter<>(); |
| Input<String, IOException> text1 = text( sourceFile ); |
| Input<String, IOException> text2 = text( sourceFile ); |
| List<Input<String, IOException>> list = createList( text1, text2 ); |
| Inputs.combine( list ).transferTo( |
| Transforms.map( |
| stringCounter, |
| Transforms.map( new Function<String, String>() |
| { |
| public String map( String s ) |
| { |
| System.out.println( s ); |
| return s; |
| } |
| }, Outputs.text( tempFile ) ) |
| ) |
| ); |
| |
| Assert.assertThat( tempFile.length(), CoreMatchers.equalTo( sourceFile.length() * 2 ) ); |
| Assert.assertThat( stringCounter.count(), CoreMatchers.equalTo( 8L ) ); |
| } |
| |
| @SuppressWarnings( "unchecked" ) |
| private List<Input<String, IOException>> createList( Input<String, IOException> text1, |
| Input<String, IOException> text2 |
| ) |
| { |
| return asList( text1, text2 ); |
| } |
| |
| @Test( expected = IOException.class ) |
| public void testInputOutputOutputException() |
| throws IOException |
| { |
| |
| text( sourceFile() ). |
| transferTo( writerOutput( new Writer() |
| { |
| @Override |
| public void write( char[] cbuf, int off, int len ) |
| throws IOException |
| { |
| throw new IOException(); |
| } |
| |
| @Override |
| public void flush() |
| throws IOException |
| { |
| throw new IOException(); |
| } |
| |
| @Override |
| public void close() |
| throws IOException |
| { |
| throw new IOException(); |
| } |
| } ) ); |
| } |
| |
| @Test( expected = RemoteException.class ) |
| public void testInputOutputInputException() |
| throws IOException |
| { |
| |
| Input<String, RemoteException> input = new Input<String, RemoteException>() |
| { |
| @Override |
| public <OutputThrowableType extends Throwable> void transferTo( Output<? super String, OutputThrowableType> output ) |
| throws RemoteException, OutputThrowableType |
| { |
| output.receiveFrom( new Sender<String, RemoteException>() |
| { |
| @Override |
| public <ReceiverThrowableType extends Throwable> void sendTo( Receiver<? super String, ReceiverThrowableType> receiverThrowableTypeReceiver ) |
| throws ReceiverThrowableType, RemoteException |
| { |
| throw new RemoteException(); |
| } |
| } ); |
| } |
| }; |
| |
| input.transferTo( |
| Transforms.map( |
| new Transforms.Log<String>( Logger.getLogger( getClass().getName() ), "Line: {0}" ), |
| Outputs.systemOut() |
| ) |
| ); |
| } |
| |
| @Test |
| public void testLock() |
| throws IOException |
| { |
| Lock inputLock = new ReentrantLock(); |
| Lock outputLock = new ReentrantLock(); |
| |
| URL source = getClass().getResource( "/iotest.txt" ); |
| File destination = File.createTempFile( "test", ".txt" ); |
| destination.deleteOnExit(); |
| lock( inputLock, text( source ) ).transferTo( lock( outputLock, Outputs.text( destination ) ) ); |
| } |
| |
| @Test |
| public void testGenerics() |
| { |
| ArrayList<Object> objects = new ArrayList<>( 3 ); |
| Inputs.iterable( Arrays.asList( "Foo", "Bar", "Xyzzy" ) ).transferTo( Outputs.collection( objects ) ); |
| |
| Inputs.iterable( objects ).transferTo( Outputs.systemOut() ); |
| } |
| |
| @Test |
| public void testOutputstreamInput() |
| throws Throwable |
| { |
| Input<ByteBuffer, IOException> input = Inputs.output( new Visitor<OutputStream, IOException>() |
| { |
| @Override |
| public boolean visit( OutputStream visited ) |
| throws IOException |
| { |
| try( PrintWriter writer = new PrintWriter( visited ) ) |
| { |
| writer.print( "Hello World!" ); |
| } |
| return true; |
| } |
| }, 256 ); |
| |
| input.transferTo( Transforms.map( new Transforms.ByteBuffer2String( Charset.defaultCharset() ), Outputs.systemOut() ) ); |
| input.transferTo( Transforms.map( new Transforms.ByteBuffer2String( Charset.defaultCharset() ), Outputs.systemOut() ) ); |
| } |
| |
| public Output<String, IOException> writerOutput( final Writer writer ) |
| { |
| return new Output<String, IOException>() |
| { |
| @Override |
| public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends String, SenderThrowableType> sender ) |
| throws IOException, SenderThrowableType |
| { |
| // Here we initiate the transfer |
| System.out.println( "Open output" ); |
| final StringBuilder builder = new StringBuilder(); |
| try |
| { |
| sender.sendTo( new Receiver<String, IOException>() |
| { |
| @Override |
| public void receive( String item ) |
| throws IOException |
| { |
| System.out.println( "Receive input" ); |
| |
| // Here we can do batch writes if needed |
| builder.append( item ).append( "\n" ); |
| } |
| } ); |
| |
| // If transfer went well, do something with it |
| writer.write( builder.toString() ); |
| writer.flush(); |
| System.out.println( "Output written" ); |
| } |
| catch( IOException e ) |
| { |
| // If transfer failed, potentially rollback writes |
| System.out.println( "Input failed" ); |
| throw e; |
| } |
| } |
| }; |
| } |
| |
| private File sourceFile() |
| { |
| String path = getClass().getResource( "/iotest.txt" ).getFile(); |
| return new File( path.replaceAll( "%20", " " ) ); |
| } |
| } |