broker-plugins/amqp-0-8-protocol/src/test/java/org/apache/qpid/server/protocol/v0_8/FieldTableTest.java - qpid-broker-j - Git at Google

 /*
  *
  * 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.qpid.server.protocol.v0_8;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;

 import org.junit.Test;

 import org.apache.qpid.server.bytebuffer.QpidByteBuffer;
 import org.apache.qpid.test.utils.UnitTestBase;

 public class FieldTableTest extends UnitTestBase
 {

     /**
      * Set a boolean and check that we can only get it back as a boolean and a string
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testBoolean()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", true));
         assertTrue(table1.containsKey("value"));
         assertEquals(true, table1.get("value"));
     }

     /**
      * Set a byte and check that we can only get it back as a byte and a string
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testByte()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Byte.MAX_VALUE));
         assertTrue(table1.containsKey("value"));
         assertEquals(Byte.MAX_VALUE, table1.get("value"));
     }

     /**
      * Set a short and check that we can only get it back as a short and a string
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testShort()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Short.MAX_VALUE));
         assertTrue(table1.containsKey("value"));
         assertEquals(Short.MAX_VALUE, table1.get("value"));
     }

     /**
      * Set a char and check that we can only get it back as a char
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testChar()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", 'c'));
         assertTrue(table1.containsKey("value"));
         assertEquals('c', table1.get("value"));
     }

     /**
      * Set a double and check that we can only get it back as a double
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testDouble()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Double.MAX_VALUE));
         assertTrue(table1.containsKey("value"));
         assertEquals(Double.MAX_VALUE, table1.get("value"));
     }

     /**
      * Set a float and check that we can only get it back as a float
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testFloat()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Float.MAX_VALUE));
         assertTrue(table1.containsKey("value"));
         assertEquals(Float.MAX_VALUE, table1.get("value"));
     }

     /**
      * Set an int and check that we can only get it back as an int
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testInt()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Integer.MAX_VALUE));
         assertTrue(table1.containsKey("value"));
         assertEquals(Integer.MAX_VALUE, table1.get("value"));
     }

     /**
      * Set a long and check that we can only get it back as a long
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testLong()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Long.MAX_VALUE));
         assertTrue(table1.containsKey("value"));
         assertEquals(Long.MAX_VALUE, table1.get("value"));
     }

     /**
      * Set a double and check that we can only get it back as a double
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testBytes()
     {
         byte[] bytes = { 99, 98, 97, 96, 95 };

         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", bytes));
         assertTrue(table1.containsKey("value"));
         assertBytesEqual(bytes, (byte[])table1.get("value"));
     }

     /**
      * Set a String and check that we can only get it back as a String
      * Check that attempting to lookup a non existent value returns null
      */
     @Test
     public void testString()
     {
         FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", "Hello"));
         assertTrue(table1.containsKey("value"));

         assertEquals("Hello", table1.get("value"));
     }

     /** Check that a nested field table parameter correctly encodes and decodes to a byte buffer. */
     @Test
     public void testNestedFieldTable() throws AMQFrameDecodingException
     {
         byte[] testBytes = new byte[] { 0, 1, 2, 3, 4, 5 };

         Map<String, Object> innerTable = new LinkedHashMap<>();

         // Put some stuff in the inner table.
         innerTable.put("bool", true);
         innerTable.put("byte", Byte.MAX_VALUE);
         innerTable.put("bytes", testBytes);
         innerTable.put("char", 'c');
         innerTable.put("double", Double.MAX_VALUE);
         innerTable.put("float", Float.MAX_VALUE);
         innerTable.put("int", Integer.MAX_VALUE);
         innerTable.put("long", Long.MAX_VALUE);
         innerTable.put("short", Short.MAX_VALUE);
         innerTable.put("string", "hello");
         innerTable.put("null-string", null);
         innerTable.put("field-array",Arrays.asList("hello", 42, Collections.emptyList()));

         // Put the inner table in the outer one.
         FieldTable outerTable = FieldTableFactory.createFieldTable(Collections.singletonMap("innerTable",
                                                                                          FieldTableFactory.createFieldTable(innerTable)));

         // Write the outer table into the buffer.
         QpidByteBuffer buf = QpidByteBuffer.allocate(EncodingUtils.encodedFieldTableLength(outerTable));

         outerTable.writeToBuffer(buf);

         buf.flip();

         // Extract the table back from the buffer again.
         FieldTable extractedOuterTable = EncodingUtils.readFieldTable(buf);
         assertNotNull("Unexpected outer table", extractedOuterTable);

         FieldTable extractedTable = (FieldTable)extractedOuterTable.get("innerTable");

         assertEquals(Boolean.TRUE, extractedTable.get("bool"));
         assertEquals(Byte.MAX_VALUE, extractedTable.get("byte"));
         assertBytesEqual(testBytes, (byte[])extractedTable.get("bytes"));
         assertEquals('c', extractedTable.get("char"));
         assertEquals(Double.MAX_VALUE, extractedTable.get("double"));
         assertEquals(Float.MAX_VALUE, extractedTable.get("float"));
         assertEquals(Integer.MAX_VALUE, extractedTable.get("int"));
         assertEquals(Long.MAX_VALUE, extractedTable.get("long"));
         assertEquals(Short.MAX_VALUE, extractedTable.get("short"));
         assertEquals("hello", extractedTable.get("string"));
         assertNull(extractedTable.get("null-string"));
         Collection fieldArray = (Collection) extractedTable.get("field-array");
         assertEquals(3, fieldArray.size());
         Iterator iter = fieldArray.iterator();
         assertEquals("hello", iter.next());
         assertEquals(42, iter.next());
         assertTrue(((Collection)iter.next()).isEmpty());
     }

     public void testUnsupportedObject()
     {
         try
         {
             FieldTableFactory.createFieldTable(Collections.singletonMap("value", new Exception()));
             fail("Non primitive values are not allowed");
         }
         catch (AMQPInvalidClassException aice)
         {
             assertEquals("Non primitive values are not allowed to be set",
                          AMQPInvalidClassException.INVALID_OBJECT_MSG + Exception.class,
                          aice.getMessage());
         }
     }

     @Test
     public void testValues() throws Exception
     {
         Map<String, Object> map = new LinkedHashMap<>();
         map.put("bool", true);
         map.put("byte", Byte.MAX_VALUE);
         byte[] bytes = { 99, 98, 97, 96, 95 };
         map.put("bytes", bytes);
         map.put("char", 'c');
         map.put("double", Double.MAX_VALUE);
         map.put("float", Float.MAX_VALUE);
         map.put("int", Integer.MAX_VALUE);
         map.put("long", Long.MAX_VALUE);
         map.put("short", Short.MAX_VALUE);
         map.put("string", "Hello");
         map.put("null-string", null);
         map.put("object-bool", true);
         map.put("object-byte", Byte.MAX_VALUE);
         map.put("object-bytes", bytes);
         map.put("object-char", 'c');
         map.put("object-double", Double.MAX_VALUE);
         map.put("object-float", Float.MAX_VALUE);
         map.put("object-int", Integer.MAX_VALUE);
         map.put("object-long", Long.MAX_VALUE);
         map.put("object-short", Short.MAX_VALUE);
         map.put("object-string", "Hello");

         FieldTable mapTable = FieldTableFactory.createFieldTable(map);
         QpidByteBuffer buf = QpidByteBuffer.allocate(EncodingUtils.encodedFieldTableLength(mapTable));
         mapTable.writeToBuffer(buf);
         buf.flip();

         FieldTable table = EncodingUtils.readFieldTable(buf);
         assertNotNull(table);

         assertEquals(Boolean.TRUE, table.get("bool"));
         assertEquals(Byte.MAX_VALUE, table.get("byte"));
         assertBytesEqual(bytes, (byte[])table.get("bytes"));
         assertEquals('c', table.get("char"));
         assertEquals(Double.MAX_VALUE, table.get("double"));
         assertEquals(Float.MAX_VALUE, table.get("float"));
         assertEquals(Integer.MAX_VALUE, table.get("int"));
         assertEquals(Long.MAX_VALUE, table.get("long"));
         assertEquals(Short.MAX_VALUE, table.get("short"));
         assertEquals("Hello", table.get("string"));
         assertNull(table.get("null-string"));
         assertEquals(true, table.get("object-bool"));
         assertEquals(Byte.MAX_VALUE, table.get("object-byte"));
         assertBytesEqual(bytes, (byte[]) table.get("object-bytes"));
         assertEquals('c', table.get("object-char"));
         assertEquals(Double.MAX_VALUE, table.get("object-double"));
         assertEquals(Float.MAX_VALUE, table.get("object-float"));
         assertEquals(Integer.MAX_VALUE, table.get("object-int"));
         assertEquals(Long.MAX_VALUE, table.get("object-long"));
         assertEquals(Short.MAX_VALUE, table.get("object-short"));
         assertEquals("Hello", table.get("object-string"));
     }

     @Test
     public void testWriteBuffer()
     {
         byte[] bytes = { 99, 98, 97, 96, 95 };

         Map<String, Object> map = new LinkedHashMap<>();
         map.put("bool", true);
         map.put("byte", Byte.MAX_VALUE);
         map.put("bytes", bytes);
         map.put("char", 'c');
         map.put("int", Integer.MAX_VALUE);
         map.put("long", Long.MAX_VALUE);
         map.put("double", Double.MAX_VALUE);
         map.put("float", Float.MAX_VALUE);
         map.put("short", Short.MAX_VALUE);
         map.put("string", "hello");
         map.put("null-string", null);

         FieldTable table = FieldTableFactory.createFieldTable(map);

         QpidByteBuffer buf = QpidByteBuffer.allocate((int) table.getEncodedSize() + 4);
         table.writeToBuffer(buf);

         buf.flip();

         long length = buf.getInt() & 0xFFFFFFFFL;
         QpidByteBuffer bufSlice = buf.slice();
         bufSlice.limit((int)length);


         FieldTable table2 = FieldTableFactory.createFieldTable(buf);
         assertNotNull(table2);

         assertEquals(true, table2.get("bool"));
         assertEquals(Byte.MAX_VALUE, table2.get("byte"));
         assertBytesEqual(bytes, (byte[])table2.get("bytes"));
         assertEquals('c', table2.get("char"));
         assertEquals(Double.MAX_VALUE, table2.get("double"));
         assertEquals(Float.MAX_VALUE, table2.get("float"));
         assertEquals(Integer.MAX_VALUE, table2.get("int"));
         assertEquals(Long.MAX_VALUE, table2.get("long"));
         assertEquals(Short.MAX_VALUE, table2.get("short"));
         assertEquals("hello", table2.get("string"));
         assertNull(table2.get("null-string"));
         buf.dispose();
         bufSlice.dispose();
         table.dispose();
         table2.dispose();
     }

     @Test
     public void testEncodingSize()
     {
         Map<String, Object> result = new LinkedHashMap<>();
         int size = 0;

         result.put("boolean", true);
         size += 1 + EncodingUtils.encodedShortStringLength("boolean") + EncodingUtils.encodedBooleanLength();

         result.put("byte", Byte.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("byte") + EncodingUtils.encodedByteLength();

         byte[] _bytes = { 99, 98, 97, 96, 95 };

         result.put("bytes", _bytes);
         size += 1 + EncodingUtils.encodedShortStringLength("bytes") + 4 + _bytes.length;

         result.put("char", 'c');
         size += 1 + EncodingUtils.encodedShortStringLength("char") + EncodingUtils.encodedCharLength();

         result.put("double", Double.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("double") + EncodingUtils.encodedDoubleLength();

         result.put("float", Float.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("float") + EncodingUtils.encodedFloatLength();

         result.put("int", Integer.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("int") + EncodingUtils.encodedIntegerLength();

         result.put("long", Long.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("long") + EncodingUtils.encodedLongLength();

         result.put("short", Short.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("short") + EncodingUtils.encodedShortLength();

         result.put("result", "Hello");
         size += 1 + EncodingUtils.encodedShortStringLength("result") + EncodingUtils.encodedLongStringLength("Hello");

         result.put("object-bool", true);
         size += 1 + EncodingUtils.encodedShortStringLength("object-bool") + EncodingUtils.encodedBooleanLength();

         result.put("object-byte", Byte.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("object-byte") + EncodingUtils.encodedByteLength();

         result.put("object-bytes", _bytes);
         size += 1 + EncodingUtils.encodedShortStringLength("object-bytes") + 4 + _bytes.length;

         result.put("object-char", 'c');
         size += 1 + EncodingUtils.encodedShortStringLength("object-char") + EncodingUtils.encodedCharLength();

         result.put("object-double", Double.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("object-double") + EncodingUtils.encodedDoubleLength();

         result.put("object-float", Float.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("object-float") + EncodingUtils.encodedFloatLength();

         result.put("object-int", Integer.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("object-int") + EncodingUtils.encodedIntegerLength();

         result.put("object-long", Long.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("object-long") + EncodingUtils.encodedLongLength();

         result.put("object-short", Short.MAX_VALUE);
         size += 1 + EncodingUtils.encodedShortStringLength("object-short") + EncodingUtils.encodedShortLength();

         assertEquals(size, FieldTableFactory.createFieldTable(result).getEncodedSize());
     }

     /**
      * Additional test checkPropertyName doesn't accept Null
      */
     @Test
     public void testCheckPropertyNameIsNull()
     {
         try
         {
             FieldTableFactory.createFieldTable(Collections.singletonMap(null, "String"));
             fail("Null property name is not allowed");
         }
         catch (IllegalArgumentException iae)
         {
             // normal path
         }
     }

     /**
      * Additional test checkPropertyName doesn't accept an empty String
      */
     @Test
     public void testCheckPropertyNameIsEmptyString()
     {
         try
         {
             FieldTableFactory.createFieldTable(Collections.singletonMap("", "String"));
             fail("empty property name is not allowed");
         }
         catch (IllegalArgumentException iae)
         {
             // normal path
         }
     }

     /**
      * Additional test checkPropertyName doesn't accept an empty String
      */
     @Test
     public void testCheckPropertyNameHasMaxLength()
     {
         StringBuilder longPropertyName = new StringBuilder(129);

         for (int i = 0; i < 129; i++)
         {
             longPropertyName.append("x");
         }

         boolean strictAMQP = FieldTable._strictAMQP;
         try
         {
             FieldTable._strictAMQP = true;
             new FieldTable(Collections.singletonMap(longPropertyName.toString(), "String"));
             fail("property name must be < 128 characters");
         }
         catch (IllegalArgumentException iae)
         {
             // normal path
         }
         finally
         {
             FieldTable._strictAMQP = strictAMQP;
         }
     }

     /**
      * Additional test checkPropertyName starts with a letter
      */
     @Test
     public void testCheckPropertyNameStartCharacterIsLetter()
     {
         boolean strictAMQP = FieldTable._strictAMQP;

         // Try a name that starts with a number
         try
         {
             FieldTable._strictAMQP = true;
             new FieldTable(Collections.singletonMap("1", "String"));
             fail("property name must start with a letter");
         }
         catch (IllegalArgumentException iae)
         {
             // normal path
         }
         finally
         {
             FieldTable._strictAMQP = strictAMQP;
         }
     }

     /**
      * Additional test checkPropertyName starts with a hash or a dollar
      */
     @Test
     public void testCheckPropertyNameStartCharacterIsHashOrDollar()
     {
         try
         {
             FieldTableFactory.createFieldTable(Collections.singletonMap("#", "String"));
         }
         catch (IllegalArgumentException iae)
         {
             fail("property name are allowed to start with # and $s");
         }

         try
         {
             FieldTableFactory.createFieldTable(Collections.singletonMap("$", "String"));
         }
         catch (IllegalArgumentException iae)
         {
             fail("property name are allowed to start with # and $s");
         }
     }

     @Test
     public void testValidateMalformedFieldTable()
     {
         final FieldTable fieldTable = buildMalformedFieldTable();

         try
         {
             fieldTable.validate();
             fail("Exception is expected");
         }
         catch (RuntimeException e)
         {
             // pass
         }
     }

     @Test
     public void testValidateCorrectFieldTable()
     {
         final FieldTable ft = new FieldTable(Collections.singletonMap("testKey", "testValue"));
         final int encodedSize = (int)ft.getEncodedSize() + Integer.BYTES;
         final QpidByteBuffer buf = QpidByteBuffer.allocate(encodedSize);
         ft.writeToBuffer(buf);
         buf.flip();
         buf.position(Integer.BYTES);

         final FieldTable fieldTable = new FieldTable(buf);
         assertEquals(1, fieldTable.size());
         fieldTable.validate();
         assertTrue("Expected key is not found", fieldTable.containsKey("testKey"));
     }

     private FieldTable buildMalformedFieldTable()
     {
         final QpidByteBuffer buf = QpidByteBuffer.allocate(1);
         buf.put((byte) -1);

         buf.flip();

         return FieldTableFactory.createFieldTable(buf);
     }

     private void assertBytesEqual(byte[] expected, byte[] actual)
     {
         assertEquals(expected.length, actual.length);

         for (int index = 0; index < expected.length; index++)
         {
             assertEquals(expected[index], actual[index]);
         }
     }

     public static junit.framework.Test suite()
     {
         return new junit.framework.TestSuite(FieldTableTest.class);
     }

 }
	/*
	*
	* 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.qpid.server.protocol.v0_8;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;

	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.Map;

	import org.junit.Test;

	import org.apache.qpid.server.bytebuffer.QpidByteBuffer;
	import org.apache.qpid.test.utils.UnitTestBase;

	public class FieldTableTest extends UnitTestBase
	{

	/**
	* Set a boolean and check that we can only get it back as a boolean and a string
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testBoolean()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", true));
	assertTrue(table1.containsKey("value"));
	assertEquals(true, table1.get("value"));
	}

	/**
	* Set a byte and check that we can only get it back as a byte and a string
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testByte()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Byte.MAX_VALUE));
	assertTrue(table1.containsKey("value"));
	assertEquals(Byte.MAX_VALUE, table1.get("value"));
	}

	/**
	* Set a short and check that we can only get it back as a short and a string
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testShort()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Short.MAX_VALUE));
	assertTrue(table1.containsKey("value"));
	assertEquals(Short.MAX_VALUE, table1.get("value"));
	}

	/**
	* Set a char and check that we can only get it back as a char
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testChar()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", 'c'));
	assertTrue(table1.containsKey("value"));
	assertEquals('c', table1.get("value"));
	}

	/**
	* Set a double and check that we can only get it back as a double
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testDouble()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Double.MAX_VALUE));
	assertTrue(table1.containsKey("value"));
	assertEquals(Double.MAX_VALUE, table1.get("value"));
	}

	/**
	* Set a float and check that we can only get it back as a float
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testFloat()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Float.MAX_VALUE));
	assertTrue(table1.containsKey("value"));
	assertEquals(Float.MAX_VALUE, table1.get("value"));
	}

	/**
	* Set an int and check that we can only get it back as an int
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testInt()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Integer.MAX_VALUE));
	assertTrue(table1.containsKey("value"));
	assertEquals(Integer.MAX_VALUE, table1.get("value"));
	}

	/**
	* Set a long and check that we can only get it back as a long
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testLong()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", Long.MAX_VALUE));
	assertTrue(table1.containsKey("value"));
	assertEquals(Long.MAX_VALUE, table1.get("value"));
	}

	/**
	* Set a double and check that we can only get it back as a double
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testBytes()
	{
	byte[] bytes = { 99, 98, 97, 96, 95 };

	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", bytes));
	assertTrue(table1.containsKey("value"));
	assertBytesEqual(bytes, (byte[])table1.get("value"));
	}

	/**
	* Set a String and check that we can only get it back as a String
	* Check that attempting to lookup a non existent value returns null
	*/
	@Test
	public void testString()
	{
	FieldTable table1 = FieldTableFactory.createFieldTable(Collections.singletonMap("value", "Hello"));
	assertTrue(table1.containsKey("value"));

	assertEquals("Hello", table1.get("value"));
	}

	/** Check that a nested field table parameter correctly encodes and decodes to a byte buffer. */
	@Test
	public void testNestedFieldTable() throws AMQFrameDecodingException
	{
	byte[] testBytes = new byte[] { 0, 1, 2, 3, 4, 5 };

	Map<String, Object> innerTable = new LinkedHashMap<>();

	// Put some stuff in the inner table.
	innerTable.put("bool", true);
	innerTable.put("byte", Byte.MAX_VALUE);
	innerTable.put("bytes", testBytes);
	innerTable.put("char", 'c');
	innerTable.put("double", Double.MAX_VALUE);
	innerTable.put("float", Float.MAX_VALUE);
	innerTable.put("int", Integer.MAX_VALUE);
	innerTable.put("long", Long.MAX_VALUE);
	innerTable.put("short", Short.MAX_VALUE);
	innerTable.put("string", "hello");
	innerTable.put("null-string", null);
	innerTable.put("field-array",Arrays.asList("hello", 42, Collections.emptyList()));

	// Put the inner table in the outer one.
	FieldTable outerTable = FieldTableFactory.createFieldTable(Collections.singletonMap("innerTable",
	FieldTableFactory.createFieldTable(innerTable)));

	// Write the outer table into the buffer.
	QpidByteBuffer buf = QpidByteBuffer.allocate(EncodingUtils.encodedFieldTableLength(outerTable));

	outerTable.writeToBuffer(buf);

	buf.flip();

	// Extract the table back from the buffer again.
	FieldTable extractedOuterTable = EncodingUtils.readFieldTable(buf);
	assertNotNull("Unexpected outer table", extractedOuterTable);

	FieldTable extractedTable = (FieldTable)extractedOuterTable.get("innerTable");

	assertEquals(Boolean.TRUE, extractedTable.get("bool"));
	assertEquals(Byte.MAX_VALUE, extractedTable.get("byte"));
	assertBytesEqual(testBytes, (byte[])extractedTable.get("bytes"));
	assertEquals('c', extractedTable.get("char"));
	assertEquals(Double.MAX_VALUE, extractedTable.get("double"));
	assertEquals(Float.MAX_VALUE, extractedTable.get("float"));
	assertEquals(Integer.MAX_VALUE, extractedTable.get("int"));
	assertEquals(Long.MAX_VALUE, extractedTable.get("long"));
	assertEquals(Short.MAX_VALUE, extractedTable.get("short"));
	assertEquals("hello", extractedTable.get("string"));
	assertNull(extractedTable.get("null-string"));
	Collection fieldArray = (Collection) extractedTable.get("field-array");
	assertEquals(3, fieldArray.size());
	Iterator iter = fieldArray.iterator();
	assertEquals("hello", iter.next());
	assertEquals(42, iter.next());
	assertTrue(((Collection)iter.next()).isEmpty());
	}

	public void testUnsupportedObject()
	{
	try
	{
	FieldTableFactory.createFieldTable(Collections.singletonMap("value", new Exception()));
	fail("Non primitive values are not allowed");
	}
	catch (AMQPInvalidClassException aice)
	{
	assertEquals("Non primitive values are not allowed to be set",
	AMQPInvalidClassException.INVALID_OBJECT_MSG + Exception.class,
	aice.getMessage());
	}
	}

	@Test
	public void testValues() throws Exception
	{
	Map<String, Object> map = new LinkedHashMap<>();
	map.put("bool", true);
	map.put("byte", Byte.MAX_VALUE);
	byte[] bytes = { 99, 98, 97, 96, 95 };
	map.put("bytes", bytes);
	map.put("char", 'c');
	map.put("double", Double.MAX_VALUE);
	map.put("float", Float.MAX_VALUE);
	map.put("int", Integer.MAX_VALUE);
	map.put("long", Long.MAX_VALUE);
	map.put("short", Short.MAX_VALUE);
	map.put("string", "Hello");
	map.put("null-string", null);
	map.put("object-bool", true);
	map.put("object-byte", Byte.MAX_VALUE);
	map.put("object-bytes", bytes);
	map.put("object-char", 'c');
	map.put("object-double", Double.MAX_VALUE);
	map.put("object-float", Float.MAX_VALUE);
	map.put("object-int", Integer.MAX_VALUE);
	map.put("object-long", Long.MAX_VALUE);
	map.put("object-short", Short.MAX_VALUE);
	map.put("object-string", "Hello");

	FieldTable mapTable = FieldTableFactory.createFieldTable(map);
	QpidByteBuffer buf = QpidByteBuffer.allocate(EncodingUtils.encodedFieldTableLength(mapTable));
	mapTable.writeToBuffer(buf);
	buf.flip();

	FieldTable table = EncodingUtils.readFieldTable(buf);
	assertNotNull(table);

	assertEquals(Boolean.TRUE, table.get("bool"));
	assertEquals(Byte.MAX_VALUE, table.get("byte"));
	assertBytesEqual(bytes, (byte[])table.get("bytes"));
	assertEquals('c', table.get("char"));
	assertEquals(Double.MAX_VALUE, table.get("double"));
	assertEquals(Float.MAX_VALUE, table.get("float"));
	assertEquals(Integer.MAX_VALUE, table.get("int"));
	assertEquals(Long.MAX_VALUE, table.get("long"));
	assertEquals(Short.MAX_VALUE, table.get("short"));
	assertEquals("Hello", table.get("string"));
	assertNull(table.get("null-string"));
	assertEquals(true, table.get("object-bool"));
	assertEquals(Byte.MAX_VALUE, table.get("object-byte"));
	assertBytesEqual(bytes, (byte[]) table.get("object-bytes"));
	assertEquals('c', table.get("object-char"));
	assertEquals(Double.MAX_VALUE, table.get("object-double"));
	assertEquals(Float.MAX_VALUE, table.get("object-float"));
	assertEquals(Integer.MAX_VALUE, table.get("object-int"));
	assertEquals(Long.MAX_VALUE, table.get("object-long"));
	assertEquals(Short.MAX_VALUE, table.get("object-short"));
	assertEquals("Hello", table.get("object-string"));
	}

	@Test
	public void testWriteBuffer()
	{
	byte[] bytes = { 99, 98, 97, 96, 95 };

	Map<String, Object> map = new LinkedHashMap<>();
	map.put("bool", true);
	map.put("byte", Byte.MAX_VALUE);
	map.put("bytes", bytes);
	map.put("char", 'c');
	map.put("int", Integer.MAX_VALUE);
	map.put("long", Long.MAX_VALUE);
	map.put("double", Double.MAX_VALUE);
	map.put("float", Float.MAX_VALUE);
	map.put("short", Short.MAX_VALUE);
	map.put("string", "hello");
	map.put("null-string", null);

	FieldTable table = FieldTableFactory.createFieldTable(map);

	QpidByteBuffer buf = QpidByteBuffer.allocate((int) table.getEncodedSize() + 4);
	table.writeToBuffer(buf);

	buf.flip();

	long length = buf.getInt() & 0xFFFFFFFFL;
	QpidByteBuffer bufSlice = buf.slice();
	bufSlice.limit((int)length);


	FieldTable table2 = FieldTableFactory.createFieldTable(buf);
	assertNotNull(table2);

	assertEquals(true, table2.get("bool"));
	assertEquals(Byte.MAX_VALUE, table2.get("byte"));
	assertBytesEqual(bytes, (byte[])table2.get("bytes"));
	assertEquals('c', table2.get("char"));
	assertEquals(Double.MAX_VALUE, table2.get("double"));
	assertEquals(Float.MAX_VALUE, table2.get("float"));
	assertEquals(Integer.MAX_VALUE, table2.get("int"));
	assertEquals(Long.MAX_VALUE, table2.get("long"));
	assertEquals(Short.MAX_VALUE, table2.get("short"));
	assertEquals("hello", table2.get("string"));
	assertNull(table2.get("null-string"));
	buf.dispose();
	bufSlice.dispose();
	table.dispose();
	table2.dispose();
	}

	@Test
	public void testEncodingSize()
	{
	Map<String, Object> result = new LinkedHashMap<>();
	int size = 0;

	result.put("boolean", true);
	size += 1 + EncodingUtils.encodedShortStringLength("boolean") + EncodingUtils.encodedBooleanLength();

	result.put("byte", Byte.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("byte") + EncodingUtils.encodedByteLength();

	byte[] _bytes = { 99, 98, 97, 96, 95 };

	result.put("bytes", _bytes);
	size += 1 + EncodingUtils.encodedShortStringLength("bytes") + 4 + _bytes.length;

	result.put("char", 'c');
	size += 1 + EncodingUtils.encodedShortStringLength("char") + EncodingUtils.encodedCharLength();

	result.put("double", Double.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("double") + EncodingUtils.encodedDoubleLength();

	result.put("float", Float.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("float") + EncodingUtils.encodedFloatLength();

	result.put("int", Integer.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("int") + EncodingUtils.encodedIntegerLength();

	result.put("long", Long.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("long") + EncodingUtils.encodedLongLength();

	result.put("short", Short.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("short") + EncodingUtils.encodedShortLength();

	result.put("result", "Hello");
	size += 1 + EncodingUtils.encodedShortStringLength("result") + EncodingUtils.encodedLongStringLength("Hello");

	result.put("object-bool", true);
	size += 1 + EncodingUtils.encodedShortStringLength("object-bool") + EncodingUtils.encodedBooleanLength();

	result.put("object-byte", Byte.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("object-byte") + EncodingUtils.encodedByteLength();

	result.put("object-bytes", _bytes);
	size += 1 + EncodingUtils.encodedShortStringLength("object-bytes") + 4 + _bytes.length;

	result.put("object-char", 'c');
	size += 1 + EncodingUtils.encodedShortStringLength("object-char") + EncodingUtils.encodedCharLength();

	result.put("object-double", Double.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("object-double") + EncodingUtils.encodedDoubleLength();

	result.put("object-float", Float.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("object-float") + EncodingUtils.encodedFloatLength();

	result.put("object-int", Integer.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("object-int") + EncodingUtils.encodedIntegerLength();

	result.put("object-long", Long.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("object-long") + EncodingUtils.encodedLongLength();

	result.put("object-short", Short.MAX_VALUE);
	size += 1 + EncodingUtils.encodedShortStringLength("object-short") + EncodingUtils.encodedShortLength();

	assertEquals(size, FieldTableFactory.createFieldTable(result).getEncodedSize());
	}

	/**
	* Additional test checkPropertyName doesn't accept Null
	*/
	@Test
	public void testCheckPropertyNameIsNull()
	{
	try
	{
	FieldTableFactory.createFieldTable(Collections.singletonMap(null, "String"));
	fail("Null property name is not allowed");
	}
	catch (IllegalArgumentException iae)
	{
	// normal path
	}
	}

	/**
	* Additional test checkPropertyName doesn't accept an empty String
	*/
	@Test
	public void testCheckPropertyNameIsEmptyString()
	{
	try
	{
	FieldTableFactory.createFieldTable(Collections.singletonMap("", "String"));
	fail("empty property name is not allowed");
	}
	catch (IllegalArgumentException iae)
	{
	// normal path
	}
	}

	/**
	* Additional test checkPropertyName doesn't accept an empty String
	*/
	@Test
	public void testCheckPropertyNameHasMaxLength()
	{
	StringBuilder longPropertyName = new StringBuilder(129);

	for (int i = 0; i < 129; i++)
	{
	longPropertyName.append("x");
	}

	boolean strictAMQP = FieldTable._strictAMQP;
	try
	{
	FieldTable._strictAMQP = true;
	new FieldTable(Collections.singletonMap(longPropertyName.toString(), "String"));
	fail("property name must be < 128 characters");
	}
	catch (IllegalArgumentException iae)
	{
	// normal path
	}
	finally
	{
	FieldTable._strictAMQP = strictAMQP;
	}
	}

	/**
	* Additional test checkPropertyName starts with a letter
	*/
	@Test
	public void testCheckPropertyNameStartCharacterIsLetter()
	{
	boolean strictAMQP = FieldTable._strictAMQP;

	// Try a name that starts with a number
	try
	{
	FieldTable._strictAMQP = true;
	new FieldTable(Collections.singletonMap("1", "String"));
	fail("property name must start with a letter");
	}
	catch (IllegalArgumentException iae)
	{
	// normal path
	}
	finally
	{
	FieldTable._strictAMQP = strictAMQP;
	}
	}

	/**
	* Additional test checkPropertyName starts with a hash or a dollar
	*/
	@Test
	public void testCheckPropertyNameStartCharacterIsHashOrDollar()
	{
	try
	{
	FieldTableFactory.createFieldTable(Collections.singletonMap("#", "String"));
	}
	catch (IllegalArgumentException iae)
	{
	fail("property name are allowed to start with # and $s");
	}

	try
	{
	FieldTableFactory.createFieldTable(Collections.singletonMap("$", "String"));
	}
	catch (IllegalArgumentException iae)
	{
	fail("property name are allowed to start with # and $s");
	}
	}

	@Test
	public void testValidateMalformedFieldTable()
	{
	final FieldTable fieldTable = buildMalformedFieldTable();

	try
	{
	fieldTable.validate();
	fail("Exception is expected");
	}
	catch (RuntimeException e)
	{
	// pass
	}
	}

	@Test
	public void testValidateCorrectFieldTable()
	{
	final FieldTable ft = new FieldTable(Collections.singletonMap("testKey", "testValue"));
	final int encodedSize = (int)ft.getEncodedSize() + Integer.BYTES;
	final QpidByteBuffer buf = QpidByteBuffer.allocate(encodedSize);
	ft.writeToBuffer(buf);
	buf.flip();
	buf.position(Integer.BYTES);

	final FieldTable fieldTable = new FieldTable(buf);
	assertEquals(1, fieldTable.size());
	fieldTable.validate();
	assertTrue("Expected key is not found", fieldTable.containsKey("testKey"));
	}

	private FieldTable buildMalformedFieldTable()
	{
	final QpidByteBuffer buf = QpidByteBuffer.allocate(1);
	buf.put((byte) -1);

	buf.flip();

	return FieldTableFactory.createFieldTable(buf);
	}

	private void assertBytesEqual(byte[] expected, byte[] actual)
	{
	assertEquals(expected.length, actual.length);

	for (int index = 0; index < expected.length; index++)
	{
	assertEquals(expected[index], actual[index]);
	}
	}

	public static junit.framework.Test suite()
	{
	return new junit.framework.TestSuite(FieldTableTest.class);
	}

	}