/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.commons.io;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Random;
import org.apache.commons.io.input.DemuxInputStream;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.io.output.DemuxOutputStream;
import org.junit.Test;
/**
* Basic unit tests for the multiplexing streams.
*/
public class DemuxTestCase {
private static final String T1 = "Thread1";
private static final String T2 = "Thread2";
private static final String T3 = "Thread3";
private static final String T4 = "Thread4";
private static final String DATA1 = "Data for thread1";
private static final String DATA2 = "Data for thread2";
private static final String DATA3 = "Data for thread3";
private static final String DATA4 = "Data for thread4";
private static final Random c_random = new Random();
private final HashMap<String, ByteArrayOutputStream> m_outputMap = new HashMap<String, ByteArrayOutputStream>();
private final HashMap<String, Thread> m_threadMap = new HashMap<String, Thread>();
private String getOutput( final String threadName )
{
final ByteArrayOutputStream output =
m_outputMap.get( threadName );
assertNotNull( "getOutput()", output );
return output.toString(Charsets.UTF_8);
}
private String getInput( final String threadName )
{
final ReaderThread thread = (ReaderThread)m_threadMap.get( threadName );
assertNotNull( "getInput()", thread );
return thread.getData();
}
private void doStart()
throws Exception
{
final Iterator<String> iterator = m_threadMap.keySet().iterator();
while( iterator.hasNext() )
{
final String name = iterator.next();
final Thread thread = m_threadMap.get( name );
thread.start();
}
}
private void doJoin()
throws Exception
{
final Iterator<String> iterator = m_threadMap.keySet().iterator();
while( iterator.hasNext() )
{
final String name = iterator.next();
final Thread thread = m_threadMap.get( name );
thread.join();
}
}
private void startWriter( final String name,
final String data,
final DemuxOutputStream demux )
throws Exception
{
final ByteArrayOutputStream output = new ByteArrayOutputStream();
m_outputMap.put( name, output );
final WriterThread thread =
new WriterThread( name, data, output, demux );
m_threadMap.put( name, thread );
}
private void startReader( final String name,
final String data,
final DemuxInputStream demux )
throws Exception
{
final ByteArrayInputStream input = new ByteArrayInputStream( data.getBytes() );
final ReaderThread thread = new ReaderThread( name, input, demux );
m_threadMap.put( name, thread );
}
@Test
public void testOutputStream()
throws Exception
{
final DemuxOutputStream output = new DemuxOutputStream();
startWriter( T1, DATA1, output );
startWriter( T2, DATA2, output );
startWriter( T3, DATA3, output );
startWriter( T4, DATA4, output );
doStart();
doJoin();
assertEquals( "Data1", DATA1, getOutput( T1 ) );
assertEquals( "Data2", DATA2, getOutput( T2 ) );
assertEquals( "Data3", DATA3, getOutput( T3 ) );
assertEquals( "Data4", DATA4, getOutput( T4 ) );
}
@Test
public void testInputStream()
throws Exception
{
final DemuxInputStream input = new DemuxInputStream();
startReader( T1, DATA1, input );
startReader( T2, DATA2, input );
startReader( T3, DATA3, input );
startReader( T4, DATA4, input );
doStart();
doJoin();
assertEquals( "Data1", DATA1, getInput( T1 ) );
assertEquals( "Data2", DATA2, getInput( T2 ) );
assertEquals( "Data3", DATA3, getInput( T3 ) );
assertEquals( "Data4", DATA4, getInput( T4 ) );
}
private static class ReaderThread
extends Thread
{
private final StringBuffer m_buffer = new StringBuffer();
private final InputStream m_input;
private final DemuxInputStream m_demux;
ReaderThread( final String name,
final InputStream input,
final DemuxInputStream demux )
{
super( name );
m_input = input;
m_demux = demux;
}
public String getData()
{
return m_buffer.toString();
}
@Override
public void run()
{
m_demux.bindStream( m_input );
try
{
int ch = m_demux.read();
while( -1 != ch )
{
//System.out.println( "Reading: " + (char)ch );
m_buffer.append( (char)ch );
final int sleepTime = Math.abs( c_random.nextInt() % 10 );
Thread.sleep( sleepTime );
ch = m_demux.read();
}
}
catch( final Exception e )
{
e.printStackTrace();
}
}
}
private static class WriterThread
extends Thread
{
private final byte[] m_data;
private final OutputStream m_output;
private final DemuxOutputStream m_demux;
WriterThread( final String name,
final String data,
final OutputStream output,
final DemuxOutputStream demux )
{
super( name );
m_output = output;
m_demux = demux;
m_data = data.getBytes();
}
@Override
public void run()
{
m_demux.bindStream( m_output );
for (final byte element : m_data) {
try
{
//System.out.println( "Writing: " + (char)m_data[ i ] );
m_demux.write( element );
final int sleepTime = Math.abs( c_random.nextInt() % 10 );
Thread.sleep( sleepTime );
}
catch( final Exception e )
{
e.printStackTrace();
}
}
}
}
}