basicplugintest.java

FMJ（freedom media for java)是java视频开发的新选择

package net.sf.fmj.test.compat.sun;

import java.util.Vector;

import javax.media.Buffer;
import javax.media.Format;
import javax.media.PlugInManager;
import javax.media.ResourceUnavailableException;
import javax.media.format.AudioFormat;
import javax.media.format.RGBFormat;
import javax.media.format.VideoFormat;

import net.sf.fmj.test.tracing.TracingBuffer;

import junit.framework.TestCase;

import com.sun.media.BasicPlugIn;

/**
 * 
 * @author Ken Larson
 *
 */
public class BasicPlugInTest extends TestCase
{

	public void testBasicPlugIn()
	{
		final MyBasicPlugIn p = new MyBasicPlugIn();
		
		assertEquals(p.getControls().length, 0);
		
	}
	public void testMatches()
	{
		

		final MyBasicPlugIn p = new MyBasicPlugIn();
		{
			final Format in = new VideoFormat(null, null, -1, null, -1.0f);
			final Format[] outs = new Format[]{
					new AudioFormat("ULAW", 8000.0, 8, 1, -1, -1, -1, -1.0, Format.byteArray),
					new RGBFormat(null, -1, Format.intArray, -1.0f, 32, 0xff0000, 0xff00, 0xff, 1, -1, 0, -1)
					
			};
			assertTrue(BasicPlugIn.matches(in, outs) == outs[1]);
			
			// Sun's BasicPlugIn throws an NPE in this situation.  So for now, so will FMJ's.
			try
			{
				BasicPlugIn.matches(null, outs);
				assertTrue(false);
			}
			catch (NullPointerException e)
			{
			}
		}

		{
			final Format in = new VideoFormat(null, null, -1, null, -1.0f);
			final Format[] outs = new Format[]{
					new AudioFormat("ULAW", 8000.0, 8, 1, -1, -1, -1, -1.0, Format.byteArray),
					new AudioFormat("ULAW", 8000.0, 8, 1, -1, -1, -1, -1.0, Format.intArray)
					
			};
			assertTrue(BasicPlugIn.matches(in, outs) == null);
		}
		
		{
			final Format in = new VideoFormat(null, null, -1, null, -1.0f);
			final Format[] outs = new Format[]{
					
					
			};
			assertTrue(BasicPlugIn.matches(in, outs) == null);
		}

	}
	public void testValidateByteArraySize()
	{
		final MyBasicPlugIn p = new MyBasicPlugIn();
		
		// test empty buffer:
		{
			final Buffer b = new Buffer();
			assertEquals(b.getData(), null);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final byte[] ba = p.doValidateByteArraySize(b, i);
				assertEquals(ba.length, i);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// buf of len 5 with length set to 5:
		{
			final Buffer b = new Buffer();
			final byte[] bBuf = new byte[5];
			b.setData(bBuf);
			b.setLength(bBuf.length);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), bBuf.length);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final byte[] ba = p.doValidateByteArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), bBuf.length);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// buf of len 5 with length set to 0:
		{
			final Buffer b = new Buffer();
			final byte[] bBuf = new byte[5];
			b.setData(bBuf);
			b.setLength(0);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final byte[] ba = p.doValidateByteArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// it appears that getLength/setLength has nothing to do with doValidateByteArraySize.
		// doValidateByteArraySize looks like it checks the size of the buf, and reallocates it
		// if too small.
		
		// try with a non-bytearray
		{
			final Buffer b = new Buffer();
			final int[] bBuf = new int[5];
			b.setData(bBuf);
			b.setLength(0);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final byte[] ba = p.doValidateByteArraySize(b, i);
//				if (i >  bBuf.length)
//					assertTrue(ba != bBuf);
//				else
//					assertTrue(ba == bBuf);
				assertEquals(ba.length, i);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// appears to simply reallocate if not a byte array.
		// See if it copies existing data:
		{
			final Buffer b = new Buffer();
			final byte[] bBuf = new byte[] {0, 1, 2, 3, 4};
			b.setData(bBuf);
			b.setLength(0);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final byte[] ba = p.doValidateByteArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	
					if (j < bBuf.length)
						assertEquals(ba[j], bBuf[j]);
					else
						assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// it does copy existing data.

	}
	
	public void testValidateShortArraySize()
	{
		final MyBasicPlugIn p = new MyBasicPlugIn();
		
		// test empty buffer:
		{
			final Buffer b = new Buffer();
			assertEquals(b.getData(), null);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final short[] ba = p.doValidateShortArraySize(b, i);
				assertEquals(ba.length, i);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// buf of len 5 with length set to 5:
		{
			final Buffer b = new Buffer();
			final short[] bBuf = new short[5];
			b.setData(bBuf);
			b.setLength(bBuf.length);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), bBuf.length);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final short[] ba = p.doValidateShortArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), bBuf.length);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// buf of len 5 with length set to 0:
		{
			final Buffer b = new Buffer();
			final short[] bBuf = new short[5];
			b.setData(bBuf);
			b.setLength(0);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final short[] ba = p.doValidateShortArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// it appears that getLength/setLength has nothing to do with doValidateShortArraySize.
		// doValidateShortArraySize looks like it checks the size of the buf, and reallocates it
		// if too small.
		
		// try with a non-shortarray
		{
			final Buffer b = new Buffer();
			final int[] bBuf = new int[5];
			b.setData(bBuf);
			b.setLength(0);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final short[] ba = p.doValidateShortArraySize(b, i);
//				if (i >  bBuf.length)
//					assertTrue(ba != bBuf);
//				else
//					assertTrue(ba == bBuf);
				assertEquals(ba.length, i);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// appears to simply reallocate if not a short array.
		// See if it copies existing data:
		{
			final Buffer b = new Buffer();
			final short[] bBuf = new short[] {0, 1, 2, 3, 4};
			b.setData(bBuf);
			b.setLength(0);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final short[] ba = p.doValidateShortArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	
					if (j < bBuf.length)
						assertEquals(ba[j], bBuf[j]);
					else
						assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// it does copy existing data.

	}
	
	public void testValidateIntArraySize()
	{
		final MyBasicPlugIn p = new MyBasicPlugIn();
		
		// test empty buffer:
		{
			final Buffer b = new Buffer();
			assertEquals(b.getData(), null);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final int[] ba = p.doValidateIntArraySize(b, i);
				assertEquals(ba.length, i);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// buf of len 5 with length set to 5:
		{
			final Buffer b = new Buffer();
			final int[] bBuf = new int[5];
			b.setData(bBuf);
			b.setLength(bBuf.length);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), bBuf.length);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final int[] ba = p.doValidateIntArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), bBuf.length);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// buf of len 5 with length set to 0:
		{
			final Buffer b = new Buffer();
			final int[] bBuf = new int[5];
			b.setData(bBuf);
			b.setLength(0);
			assertTrue(b.getData() == bBuf);
			assertEquals(b.getLength(), 0);
			assertEquals(b.getOffset(), 0);
			
			for (int i = 0; i < 10; ++i)
			{
				final int[] ba = p.doValidateIntArraySize(b, i);
				if (i >  bBuf.length)
					assertTrue(ba != bBuf);
				else
					assertTrue(ba == bBuf);
				final int max = i > bBuf.length ? i : bBuf.length;
				assertEquals(ba.length, max);
				for (int j = 0; j < i; ++j)
				{	assertEquals(ba[j], 0);
				}
				assertEquals(b.getData(), ba);
				assertEquals(b.getLength(), 0);
				assertEquals(b.getOffset(), 0);
			}
		}
		
		// it appears that getLength/setLength has nothing to do with doValidateIntArraySize.
		// doValidateIntArraySize looks like it checks the size of the buf, and reallocates it
		// if too small.
		
		// try with a non-intarray
		{
			final Buffer b = new Buffer();
			final short[] bBuf = new short[5];