/* $Id: TestBinaryTaggedDataInOut.java 712757 2008-08-22 16:39:29Z sccomer $
*
* Copyright 2007-2008 Cisco Systems Inc.
*
* 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 etch.bindings.java.transport.fmt.binary;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Date;
import org.junit.Assert;
import org.junit.Test;
import etch.bindings.java.msg.Field;
import etch.bindings.java.msg.Message;
import etch.bindings.java.msg.StructValue;
import etch.bindings.java.msg.Type;
import etch.bindings.java.msg.TypeMap;
import etch.bindings.java.msg.Validator;
import etch.bindings.java.msg.Validator.Level;
import etch.bindings.java.support.Class2TypeMap;
import etch.bindings.java.support.DefaultValueFactory;
import etch.bindings.java.support.Validator_boolean;
import etch.bindings.java.support.Validator_byte;
import etch.bindings.java.support.Validator_double;
import etch.bindings.java.support.Validator_float;
import etch.bindings.java.support.Validator_int;
import etch.bindings.java.support.Validator_long;
import etch.bindings.java.support.Validator_object;
import etch.bindings.java.support.Validator_short;
import etch.bindings.java.support.Validator_string;
import etch.bindings.java.transport.Messagizer;
import etch.bindings.java.transport.fmt.TypeCode;
import etch.util.FlexBuffer;
import etch.util.Log;
import etch.util.Resources;
import etch.util.URL;
import etch.util.core.Who;
import etch.util.core.io.SessionPacket;
import etch.util.core.io.Transport;
import etch.util.core.io.TransportPacket;
/**
* Test binary input and output.
*/
public class TestBinaryTaggedDataInOut
{
private static final double DOUBLE_MIN_NORMAL = 0x1.0p-1022; // Double.MIN_NORMAL;
private static final float FLOAT_MIN_NORMAL = 0x1.0p-126f; // Float.MIN_NORMAL;
static
{
Log.addSink( null );
}
/**
* @throws Exception
*/
@Test public void test_check_value() throws Exception
{
// i'm testing with hard coded constants on the left hand
// side here because this represents our external interface
// for messages. if these values change, it could bring about
// accidental missile launches, inadvertant bank balance transfers
// to unfriendly foreign nations, or the dropping of a small
// child's lollipop into the sand. like a pizza face down in
// the parking lot, you don't wanna go there.
// ValueFactory vf = new DummyValueFactory();
BinaryTaggedDataOutput btdo = new BinaryTaggedDataOutput( vf, "none:" );
// byte values
for (byte i: getBytes( Byte.MIN_VALUE, 256 ))
if (i >= TypeCode.MIN_TINY_INT && i <= TypeCode.MAX_TINY_INT)
Assert.assertEquals( i, btdo.checkValue( i ) );
else
Assert.assertEquals( TypeCode.BYTE, btdo.checkValue( i ) );
// short values
for (short i: getShorts( Short.MIN_VALUE, 65536 ))
if (i >= TypeCode.MIN_TINY_INT && i <= TypeCode.MAX_TINY_INT)
Assert.assertEquals( (byte) i, btdo.checkValue( i ) );
else if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE)
Assert.assertEquals( TypeCode.BYTE, btdo.checkValue( i ) );
else
Assert.assertEquals( TypeCode.SHORT, btdo.checkValue( i ) );
// int values
for (int i: getTestInts())
if (i >= TypeCode.MIN_TINY_INT && i <= TypeCode.MAX_TINY_INT)
Assert.assertEquals( (byte) i, btdo.checkValue( i ) );
else if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE)
Assert.assertEquals( TypeCode.BYTE, btdo.checkValue( i ) );
else if (i >= Short.MIN_VALUE && i <= Short.MAX_VALUE)
Assert.assertEquals( TypeCode.SHORT, btdo.checkValue( i ) );
else
Assert.assertEquals( TypeCode.INT, btdo.checkValue( i ) );
// long values
for (long i: getTestLongs())
if (i >= TypeCode.MIN_TINY_INT && i <= TypeCode.MAX_TINY_INT)
Assert.assertEquals( (byte) i, btdo.checkValue( i ) );
else if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE)
Assert.assertEquals( TypeCode.BYTE, btdo.checkValue( i ) );
else if (i >= Short.MIN_VALUE && i <= Short.MAX_VALUE)
Assert.assertEquals( TypeCode.SHORT, btdo.checkValue( i ) );
else if (i >= Integer.MIN_VALUE && i <= Integer.MAX_VALUE)
Assert.assertEquals( TypeCode.INT, btdo.checkValue( i ) );
else
Assert.assertEquals( TypeCode.LONG, btdo.checkValue( i ) );
// null value
Assert.assertEquals( TypeCode.NULL, btdo.checkValue( null ) );
// boolean values
Assert.assertEquals( TypeCode.BOOLEAN_FALSE, btdo.checkValue( false ) );
Assert.assertEquals( TypeCode.BOOLEAN_TRUE, btdo.checkValue( true ) );
// float
Assert.assertEquals( TypeCode.FLOAT, btdo.checkValue( 3.14159f ) );
// double
Assert.assertEquals( TypeCode.DOUBLE, btdo.checkValue( 3.14159 ) );
// byte array
Assert.assertEquals( TypeCode.BYTES, btdo.checkValue( new byte[0] ) );
Assert.assertEquals( TypeCode.BYTES, btdo.checkValue( new byte[1] ) );
// string
Assert.assertEquals( TypeCode.EMPTY_STRING, btdo.checkValue( "" ) );
Assert.assertEquals( TypeCode.STRING, btdo.checkValue( "abc" ) );
// struct
Assert.assertEquals( TypeCode.CUSTOM, btdo.checkValue( new StructValue( new Type( "foo" ), vf ) ) );
// custom
Assert.assertEquals( TypeCode.CUSTOM, btdo.checkValue( new Date() ) );
// none
Assert.assertEquals( TypeCode.NONE, btdo.checkValue( BinaryTaggedData.NONE ) );
}
private long[] getTestLongs()
{
int n = 65536+2+6;
int k = 65536+2;
int min = Short.MIN_VALUE-1;
long[] vals = new long[n];
int i = 0;
while (k-- > 0)
vals[i++] = min++;
vals[i++] = Integer.MIN_VALUE;
vals[i++] = Integer.MAX_VALUE;
vals[i++] = Integer.MIN_VALUE-1L;
vals[i++] = Integer.MAX_VALUE+1L;
vals[i++] = Long.MIN_VALUE;
vals[i++] = Long.MAX_VALUE;
return vals;
}
private int[] getTestInts()
{
int n = 65536+2+2;
int k = 65536+2;
int min = Short.MIN_VALUE-1;
int[] vals = new int[n];
int i = 0;
while (k-- > 0)
vals[i++] = min++;
vals[i++] = Integer.MIN_VALUE;
vals[i++] = Integer.MAX_VALUE;
return vals;
}
private short[] getShorts( short min, int n )
{
short[] vals = new short[n];
int i = 0;
while (n-- > 0)
vals[i++] = min++;
return vals;
}
private byte[] getBytes( byte min, int n )
{
byte[] vals = new byte[n];
int i = 0;
while (n-- > 0)
vals[i++] = min++;
return vals;
}
/**
* @throws Exception
*/
@Test public void test_boolean() throws Exception
{
testx( new boolean[][] { { false, true }, { true, false } },
Validator_boolean.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_byte() throws Exception
{
testx( new byte[][] { { Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE }, { 23 } },
Validator_byte.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_short() throws Exception
{
testx( new short[][] { { Short.MIN_VALUE, Byte.MIN_VALUE, -1, 0, 1,
Byte.MAX_VALUE, Short.MAX_VALUE }, { 23 } },
Validator_short.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_int() throws Exception
{
testx( new int[][] { { Integer.MIN_VALUE, Short.MIN_VALUE, Byte.MIN_VALUE,
-1, 0, 1, Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE }, { 23 } },
Validator_int.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_long() throws Exception
{
testx( new long[][] { { Long.MIN_VALUE, Integer.MIN_VALUE, Short.MIN_VALUE,
Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE, Short.MAX_VALUE,
Integer.MAX_VALUE, Long.MAX_VALUE }, { 23 } },
Validator_long.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_float() throws Exception
{
testx( new float[][] { { -1, 0, 1, Float.MIN_VALUE, FLOAT_MIN_NORMAL,
Float.MAX_VALUE, Float.NaN, Float.NEGATIVE_INFINITY,
Float.POSITIVE_INFINITY, -0.0f, 1.1f,
3.141592653589793238462643383279f }, { 23 } },
Validator_float.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_double() throws Exception
{
testx( new double[][] { { -1, 0, 1, Double.MIN_VALUE, DOUBLE_MIN_NORMAL,
Double.MAX_VALUE, Double.NaN, Double.NEGATIVE_INFINITY,
Double.POSITIVE_INFINITY, -0.0f, 1.1f,
3.141592653589793238462643383279 }, { 23 } },
Validator_double.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_String() throws Exception
{
testx( new String[][] { { "", "a", "ab", "abc" }, { "23" } },
Validator_string.get( 2 ) );
}
/**
* @throws Exception
*/
@Test public void test_add() throws Exception
{
Type add = vf.getType( "add" );
Field x = new Field( "x" );
add.putValidator( x, Validator_int.get( 0 ) );
Field y = new Field( "y" );
add.putValidator( y, Validator_int.get( 0 ) );
Field _mf__messageId = DefaultValueFactory._mf__messageId;
add.putValidator( _mf__messageId, Validator_long.get( 0 ) );
long msgid = 0x0102030405060708L;
// System.out.printf( "add.id() = %04x\n", add.getId() );
// System.out.printf( "x.id() = %04x\n", x.getId() );
// System.out.printf( "y.id() = %04x\n", y.getId() );
// System.out.printf( "_mf__messageId.id() = %04x\n", _mf__messageId.getId() );
// System.out.printf( "msgid = %08x\n", msgid );
Message msg = new Message( add, vf );
msg.put( x, 1 );
msg.put( y, 2 );
msg.put( _mf__messageId, msgid );
testmsg2bytes( msg, null, new byte[] { 3, -122, 39, -23, -73, -100, 3, -122, 21, 10, 44, -77, 1, -122, 99, 6, -76, 104, -121, 1, 2, 3, 4, 5, 6, 7, 8, -122, 21, 10, 44, -76, 2, -127 } );
testmsg2bytes( msg, false, new byte[] { 3, -122, 39, -23, -73, -100, 3, -122, 21, 10, 44, -77, 1, -122, 99, 6, -76, 104, -121, 1, 2, 3, 4, 5, 6, 7, 8, -122, 21, 10, 44, -76, 2, -127 } );
testmsg2bytes( msg, true, new byte[] { 3, -109, 3, 97, 100, 100, 3, -109, 1, 120, 1, -109, 10, 95, 109, 101, 115, 115, 97, 103, 101, 73, 100, -121, 1, 2, 3, 4, 5, 6, 7, 8, -109, 1, 121, 2, -127 } );
msg = new Message( add, vf );
msg.put( x, 1000000000 );
msg.put( y, 2000000000 );
msg.put( _mf__messageId, msgid );
testmsg2bytes( msg, null, new byte[] { 3, -122, 39, -23, -73, -100, 3, -122, 21, 10, 44, -77, -122, 59, -102, -54, 0, -122, 99, 6, -76, 104, -121, 1, 2, 3, 4, 5, 6, 7, 8, -122, 21, 10, 44, -76, -122, 119, 53, -108, 0, -127 } );
testmsg2bytes( msg, false, new byte[] { 3, -122, 39, -23, -73, -100, 3, -122, 21, 10, 44, -77, -122, 59, -102, -54, 0, -122, 99, 6, -76, 104, -121, 1, 2, 3, 4, 5, 6, 7, 8, -122, 21, 10, 44, -76, -122, 119, 53, -108, 0, -127 } );
testmsg2bytes( msg, true, new byte[] { 3, -109, 3, 97, 100, 100, 3, -109, 1, 120, -122, 59, -102, -54, 0, -109, 10, 95, 109, 101, 115, 115, 97, 103, 101, 73, 100, -121, 1, 2, 3, 4, 5, 6, 7, 8, -109, 1, 121, -122, 119, 53, -108, 0, -127 } );
}
private void testmsg2bytes( Message msg, Boolean stringTypeAndField,
byte[] expected ) throws Exception
{
byte[] actual = msg2bytes( msg, stringTypeAndField );
try
{
assertArrayEquals( expected, actual );
}
catch ( AssertionError e )
{
dump( expected );
dump( actual );
throw e;
}
}
/** Tests reading a pre-canned add message.
* @throws Exception */
@Test public void test_add_in() throws Exception
{
Type add = vf.getType( "add" );
Field x = new Field( "x" );
add.putValidator( x, Validator_int.get( 0 ) );
Field y = new Field( "y" );
add.putValidator( y, Validator_int.get( 0 ) );
Field _mf__messageId = DefaultValueFactory._mf__messageId;
add.putValidator( _mf__messageId, Validator_long.get( 0 ) );
long msgid = 0x0123456789abcdefL;
byte[] buf =
{
3, // version
-122, // INT (type)
39, -23, -73, -100, // add
3, // length
-122, // INT (key)
99, 6, -76, 104,
-121, // LONG (value)
1, 35, 69, 103, -119, -85, -51, -17,
-122, // INT (key)
21, 10, 44, -76, // y
2, // tiny int = 2 (value)
-122, // INT (key)
21, 10, 44, -77, // x
1, // tiny int = 1 (value)
-127 // NONE
};
Message msg = bytes2msg( buf );
msg.checkType( add );
Assert.assertEquals( 3, msg.size() );
Assert.assertEquals( 1, msg.get( x ) );
Assert.assertEquals( 2, msg.get( y ) );
Assert.assertEquals( msgid, msg.get( _mf__messageId ) );
buf = new byte[]
{
3, // version
-122, // INT (type)
39, -23, -73, -100, // add
3, // length
-122, // INT (key)
99, 6, -76, 104,
-121, // LONG (value)
1, 35, 69, 103, -119, -85, -51, -17,
-122, // INT (key)
21, 10, 44, -76, // y
-122, // INT (value)
119, 53, -108, 0,
-122, // INT (key)
21, 10, 44, -77, // x
-122, // INT (value)
59, -102, -54, 0,
-127 // NONE
};
msg = bytes2msg( buf );
msg.checkType( add );
Assert.assertEquals( 3, msg.size() );
Assert.assertEquals( 1000000000, msg.get( x ) );
Assert.assertEquals( 2000000000, msg.get( y ) );
Assert.assertEquals( msgid, msg.get( _mf__messageId ) );
}
/** Tests add performance.
* @throws Exception */
@Test public void test_add_perf() throws Exception
{
Type add = vf.getType( "add" );
Field x = new Field( "x" );
add.putValidator( x, Validator_int.get( 0 ) );
Field y = new Field( "y" );
add.putValidator( y, Validator_int.get( 0 ) );
Field _mf__messageId = DefaultValueFactory._mf__messageId;
add.putValidator( _mf__messageId, Validator_long.get( 0 ) );
long msgid = 0x0123456789abcdefL;
// System.out.printf( "add.id() = %04x\n", add.getId() );
// System.out.printf( "x.id() = %04x\n", x.getId() );
// System.out.printf( "y.id() = %04x\n", y.getId() );
// System.out.printf( "_mf__messageId.id() = %04x\n", _mf__messageId.getId() );
// System.out.printf( "msgid = %08x\n", msgid );
Message msg = new Message( add, vf );
msg.put( x, 123456789 );
msg.put( y, 876543210 );
msg.put( _mf__messageId, msgid );
// System.out.println( "msg = "+msg );
Resources res = new Resources();
res.put( Transport.VALUE_FACTORY, vf );
MyPacketSource ps = new MyPacketSource();
Messagizer m = new Messagizer( ps, "foo:?Messagizer.format=binary", res );
m.transportMessage( null, msg );
int n = 900973;
for (int i = 0; i < 3; i++)
testPerf( "test_add_perf", i, m, msg, n );
}
/** Tests sum performance.
* @throws Exception */
@Test public void test_sum_perf() throws Exception
{
Type sum = vf.getType( "sum" );
Field values = new Field( "values" );
sum.putValidator( values, Validator_int.get( 1 ) );
Field _mf__messageId = DefaultValueFactory._mf__messageId;
sum.putValidator( _mf__messageId, Validator_long.get( 0 ) );
long msgid = 0x0123456789abcdefL;
// System.out.printf( "add.id() = %04x\n", add.getId() );
// System.out.printf( "x.id() = %04x\n", x.getId() );
// System.out.printf( "y.id() = %04x\n", y.getId() );
// System.out.printf( "_mf__messageId.id() = %04x\n", _mf__messageId.getId() );
// System.out.printf( "msgid = %08x\n", msgid );
int[] array = new int[2];
for (int i = 0; i < array.length; i++)
array[i] = 123456789;
Message msg = new Message( sum, vf );
msg.put( values, array );
msg.put( _mf__messageId, msgid );
// System.out.println( "msg = "+msg );
Resources res = new Resources();
res.put( Transport.VALUE_FACTORY, vf );
MyPacketSource ps = new MyPacketSource();
Messagizer m = new Messagizer( ps, "foo:?Messagizer.format=binary", res );
m.transportMessage( null, msg );
int n = 509520;
for (int i = 0; i < 3; i++)
testPerf( "test_sum_perf", i, m, msg, n );
}
/** @throws Exception */
@Test
public void testValueToBytes() throws Exception
{
// nulls
assertValueToBytes( null,
new byte[] { 3, 1, 0, -127 } );
assertValueToBytes( new Object[] { null },
new byte[] { 3, 1, 1, 2, -111, -106, 1, 1, -128, -127, -127 } );
// booleans:
assertValueToBytes( false,
new byte[] { 3, 1, 1, 2, -126, -127 } );
assertValueToBytes( true,
new byte[] { 3, 1, 1, 2, -125, -127 } );
// tiny ints:
assertValueToBytes( 0,
new byte[] { 3, 1, 1, 2, 0, -127 } );
assertValueToBytes( 1,
new byte[] { 3, 1, 1, 2, 1, -127 } );
assertValueToBytes( -1,
new byte[] { 3, 1, 1, 2, -1, -127 } );
// bytes:
assertValueToBytes( -100,
new byte[] { 3, 1, 1, 2, -124, -100, -127 } );
// shorts:
assertValueToBytes( 10000,
new byte[] { 3, 1, 1, 2, -123, 39, 16, -127 } );
assertValueToBytes( -10000,
new byte[] { 3, 1, 1, 2, -123, -40, -16, -127 } );
// ints:
assertValueToBytes( 1000000000,
new byte[] { 3, 1, 1, 2, -122, 59, -102, -54, 0, -127 } );
assertValueToBytes( -1000000000,
new byte[] { 3, 1, 1, 2, -122, -60, 101, 54, 0, -127 } );
// longs:
assertValueToBytes( 1000000000000000000L,
new byte[] { 3, 1, 1, 2, -121, 13, -32, -74, -77, -89, 100, 0, 0, -127 } );
assertValueToBytes( -1000000000000000000L,
new byte[] { 3, 1, 1, 2, -121, -14, 31, 73, 76, 88, -100, 0, 0, -127 } );
// float:
assertValueToBytes( 12345f,
new byte[] { 3, 1, 1, 2, -120, 70, 64, -28, 0, -127 } );
// double:
assertValueToBytes( 23456d,
new byte[] { 3, 1, 1, 2, -119, 64, -42, -24, 0, 0, 0, 0, 0, -127 } );
// boolean[]:
assertValueToBytes( new boolean[] { true, false },
new byte[] { 3, 1, 1, 2, -111, -125, 1, 2, -125, -126, -127, -127 } );
// byte[]:
assertValueToBytes( new byte[] { 1, 2, 3 },
new byte[] { 3, 1, 1, 2, -117, 3, 1, 2, 3, -127 } );
// byte[][]:
assertValueToBytes( new byte[][] { new byte[] { 1, 2, 3 }, new byte[] { 2, 3, 4 } },
new byte[] { 3, 1, 1, 2, -111, -124, 2, 2, -117, 3, 1, 2, 3, -117, 3, 2, 3, 4, -127, -127 } );
// short[]:
assertValueToBytes( new short[] { 1, 2, 3 },
new byte[] { 3, 1, 1, 2, -111, -123, 1, 3, 1, 2, 3, -127, -127 } );
// int[]:
assertValueToBytes( new int[] { 1, 2, 3 },
new byte[] { 3, 1, 1, 2, -111, -122, 1, 3, 1, 2, 3, -127, -127 } );
// long[]:
assertValueToBytes( new long[] { 1, 2, 3 },
new byte[] { 3, 1, 1, 2, -111, -121, 1, 3, 1, 2, 3, -127, -127 } );
// float[]:
assertValueToBytes( new float[] { 1, 2, 3 },
new byte[] { 3, 1, 1, 2, -111, -120, 1, 3, -120, 63, -128, 0, 0, -120, 64, 0, 0, 0, -120, 64, 64, 0, 0, -127, -127 } );
// double[]:
assertValueToBytes( new double[] { 1, 2, 3 },
new byte[] { 3, 1, 1, 2, -111, -119, 1, 3, -119, 63, -16, 0, 0, 0, 0, 0, 0, -119, 64, 0, 0, 0, 0, 0, 0, 0, -119, 64, 8, 0, 0, 0, 0, 0, 0, -127, -127 } );
// empty string:
assertValueToBytes( "",
new byte[] { 3, 1, 1, 2, -110, -127 } );
// string:
assertValueToBytes( "abc",
new byte[] { 3, 1, 1, 2, -109, 3, 97, 98, 99, -127 } );
// string[]:
assertValueToBytes( new String[] { "a", "", "c" },
new byte[] { 3, 1, 1, 2, -111, -109, 1, 3, -109, 1, 97, -110, -109, 1, 99, -127, -127 } );
// Date:
assertValueToBytes( new Date( 1234567890L ),
new byte[] { 3, 1, 1, 2, -107, -122, 43, 57, 107, -52, 1, -122, 102, 0, 26, 64, -122, 73, -106, 2, -46, -127, -127 } );
// Date[]:
assertValueToBytes( new Date[] { new Date( 1234567890L ), new Date( 2345678901L ) },
new byte[] { 3, 1, 1, 2, -111, -107, -122, 43, 57, 107, -52, 1, 2, -107, -122, 43, 57, 107, -52, 1, -122, 102, 0, 26, 64, -122, 73, -106, 2, -46, -127, -107, -122, 43, 57, 107, -52, 1, -122, 102, 0, 26, 64, -121, 0, 0, 0, 0, -117, -48, 56, 53, -127, -127, -127 } );
}
/** @throws Exception */
@Test
public void badtype() throws Exception
{
@SuppressWarnings("unused")
Message msg = bytes2msg( new byte[] { 3, 1, 0, -127 } );
// System.out.println( "msg = "+msg );
}
/** @throws Exception */
@Test( expected = IllegalArgumentException.class )
public void badmsglen1() throws Exception
{
@SuppressWarnings("unused")
Message msg = bytes2msg( new byte[] { 3, 1, -1, -127 } );
// System.out.println( "msg = "+msg );
}
/** @throws Exception */
@Test( expected = IllegalArgumentException.class )
public void badmsglen2() throws Exception
{
@SuppressWarnings("unused")
Message msg = bytes2msg( new byte[] { 3, 1, 99, -127 } );
// System.out.println( "msg = "+msg );
}
/** @throws Exception */
@Test
public void badfield() throws Exception
{
@SuppressWarnings("unused")
Message msg = bytes2msg( new byte[] { 3, 1, 1, 2, 2, -127 }, Level.MISSING_OK );
// System.out.println( "msg = "+msg );
}
private void assertValueToBytes( Object value, byte[] expectedBytes ) throws Exception
{
Type t = new Type( 1, "a" );
Field f = new Field( 2, "b" );
t.putValidator( f, Validator_object.get( 0 ) );
Message msg = new Message( t, vf );
msg.put( f, value );
// System.out.println( "msg = "+msg );
BinaryTaggedDataOutput btdo = new BinaryTaggedDataOutput( vf, "none:" );
FlexBuffer buf = new FlexBuffer();
btdo.writeMessage( msg, buf );
buf.setIndex( 0 );
byte[] b = buf.getAvailBytes();
// dump( b );
assertArrayEquals( expectedBytes, b );
}
private final static void testPerf( String name, int iter, Messagizer m,
Message msg, int n ) throws Exception
{
long t0 = System.nanoTime();
for (int i = 0; i < n; i++)
m.transportMessage( null, msg );
long t1 = System.nanoTime();
double t = (t1-t0) / 1000000000.0;
double r = n / t;
Log.report( name, "iteration", iter, "time", t, "count", n, "rate", r );
}
/**
* Test jig for perf tests.
*/
public static class MyPacketSource implements TransportPacket
{
public int headerSize()
{
return 0;
}
public void transportPacket( Who recipient, FlexBuffer buf ) throws Exception
{
// ignore.
// System.out.println( buf.avail() );
}
public SessionPacket getSession()
{
// ignore
return null;
}
public void setSession( SessionPacket session )
{
// ignore
}
public void transportControl( Object control, Object value )
throws Exception
{
// ignore
}
public void transportNotify( Object event ) throws Exception
{
// ignore
}
public Object transportQuery( Object query ) throws Exception
{
// ignore
return null;
}
}
private byte[] msg2bytes( Message msg, Boolean stringTypeAndField ) throws IOException
{
FlexBuffer buf = new FlexBuffer();
URL u = new URL( "none:" );
if (stringTypeAndField != null)
u.addTerm( BinaryTaggedDataOutput.STRING_TYPE_AND_FIELD, stringTypeAndField );
BinaryTaggedDataOutput btdo = new BinaryTaggedDataOutput( vf, u.toString() );
btdo.writeMessage( msg, buf );
buf.setIndex( 0 );
return buf.getAvailBytes();
}
private Message bytes2msg( byte[] buf ) throws Exception
{
return bytes2msg( buf, Level.FULL );
}
private Message bytes2msg( byte[] buf, Level level ) throws Exception
{
Level oldLevel = vf.setLevel( level );
try
{
BinaryTaggedDataInput btdi = new BinaryTaggedDataInput( vf, "none:" );
return btdi.readMessage( new FlexBuffer( buf ) );
}
finally
{
vf.setLevel( oldLevel );
}
}
private void testx( Object x, Validator v )
throws Exception
{
Class<?> c = x.getClass();
if (c.isArray())
{
int n = Array.getLength( x );
for (int i = 0; i < n; i++)
{
testx( Array.get( x, i ), v.elementValidator() );
}
}
test( x, v, null );
test( x, v, false );
test( x, v, true );
}
/**
* value factory for tests. it is ok that it is shared between tests.
*/
final DefaultValueFactory vf = new MyValueFactory( "tcp:" );
private final Type mt_foo = vf.getType( "foo" );
private final Field mf_x = new Field( "x" );
private void test( Object x, Validator v, Boolean stringTypeAndField ) throws Exception
{
// System.out.println( "-----------------------------------------" );
mt_foo.clearValidator( mf_x );
mt_foo.putValidator( mf_x, v );
Message msg = new Message( mt_foo, vf );
msg.put( mf_x, x );
// System.out.println( "msg = "+msg );
byte[] bufx = msg2bytes( msg, stringTypeAndField );
// dump( bufx );
Message msg2 = bytes2msg( bufx );
// System.out.println( "msg2 = "+msg2 );
msg2.checkType( mt_foo );
Assert.assertEquals( 1, msg2.size() );
Assert.assertTrue( msg.containsKey( mf_x ) );
Object y = msg2.get( mf_x );
assertEquals( x, y );
}
@SuppressWarnings("unused")
private void dump( byte[] buf )
{
System.out.print( "byte[/*"+buf.length+"*/] buf = {" );
for (int i = 0; i < buf.length; i++)
{
if (i > 0)
System.out.print( ", " );
else
System.out.print( " " );
System.out.printf( "%d", buf[i] );
}
System.out.println( " }" );
}
private void assertEquals( Object a, Object b )
{
if (a == null || b == null)
{
Assert.assertEquals( a, b );
return;
}
Class<?> aClass = a.getClass();
Class<?> bClass = b.getClass();
if (aClass == bClass)
{
if (aClass.isArray() && bClass.isArray())
assertArrayEquals( a, b );
else
Assert.assertEquals( a, b );
}
//else if (a instanceof Number && b instanceof Number)
else
{
// System.out.printf( "a %s, b %s\n", aClass, bClass );
Assert.assertEquals( a, b );
}
}
private void assertArrayEquals( Object a, Object b )
{
int an = Array.getLength( a );
int bn = Array.getLength( b );
assertEquals( an, bn );
for (int i = 0; i < an; i++)
assertEquals( Array.get( a, i ), Array.get( b, i ) );
}
/** */
static class MyValueFactory extends DefaultValueFactory
{
private final static TypeMap types = new TypeMap();
private final static Class2TypeMap class2type = new Class2TypeMap();
static
{
DefaultValueFactory.init( types, class2type );
}
/**
* Constructs the MyValueFactory.
* @param uri
*/
public MyValueFactory( String uri )
{
super( uri, types, class2type );
}
}
}