TestRecordAndUnionTemplate.java

/*
   Copyright (c) 2012 LinkedIn Corp.

   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 com.linkedin.data.template;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.testng.annotations.Test;

import com.linkedin.data.ByteString;
import com.linkedin.data.Data;
import com.linkedin.data.DataList;
import com.linkedin.data.DataMap;
import com.linkedin.data.TestUtil;
import com.linkedin.data.schema.EnumDataSchema;
import com.linkedin.data.schema.FixedDataSchema;
import com.linkedin.data.schema.IntegerDataSchema;
import com.linkedin.data.schema.RecordDataSchema;
import com.linkedin.data.schema.UnionDataSchema;

import static org.testng.Assert.*;


/**
* Unit tests for record and union {@link DataTemplate}'s.
*
* @author slim
*/
public class TestRecordAndUnionTemplate
{
  public static class Bar extends RecordTemplate
  {
    public static final RecordDataSchema SCHEMA = (RecordDataSchema) DataTemplateUtil.parseSchema
    (
      "{ \"type\" : \"record\", \"name\" : \"Bar\", \"fields\" : [ { \"name\" : \"int\", \"type\" : \"int\" } ] }"
    );
    private static final RecordDataSchema.Field FIELD_int = SCHEMA.getField("int");

    public Bar()
    {
      super(new DataMap(), SCHEMA);
    }

    public Bar(DataMap map)
    {
      super(map, SCHEMA);
    }

    public Integer getInt()
    {
      return getInt(GetMode.STRICT);
    }

    public Integer getInt(GetMode mode)
    {
      return obtainDirect(FIELD_int, Integer.TYPE, mode);
    }

    public void removeInt()
    {
      remove(FIELD_int);
    }

    public Bar setInt(int value)
    {
      putDirect(FIELD_int, Integer.class, Integer.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Bar setInt(int value, SetMode mode)
    {
      putDirect(FIELD_int, Integer.class, Integer.class, value, mode);
      return this;
    }

    @Override
    public Bar clone() throws CloneNotSupportedException
    {
      return (Bar) super.clone();
    }

    @Override
    public Bar copy() throws CloneNotSupportedException
    {
      return (Bar) super.copy();
    }
  }

  public enum EnumType
  {
    APPLE,
    ORANGE,
    BANANA,
    $UNKNOWN
  }

  public static class FixedType extends FixedTemplate
  {
    public static final FixedDataSchema SCHEMA = (FixedDataSchema) DataTemplateUtil.parseSchema("{ \"type\" : \"fixed\", \"name\" : \"fixedType\", \"size\" : 4 }");

    public FixedType(Object object)
    {
      super(object, SCHEMA);
    }
  }

  public static class Foo extends RecordTemplate
  {

    public static final RecordDataSchema SCHEMA = (RecordDataSchema) DataTemplateUtil.parseSchema
    (
     "{ \"type\" : \"record\", \"name\" : \"Foo\", \"fields\" : [\n" +
     "{ \"name\" : \"boolean\", \"type\" : \"boolean\", \"default\" : true }, \n" +
     "{ \"name\" : \"int\", \"type\" : \"int\", \"default\" : -1 }, \n" +
     "{ \"name\" : \"long\", \"type\" : \"long\" }, \n" +
     "{ \"name\" : \"float\", \"type\" : \"float\", \"optional\" : true }, \n" +
     "{ \"name\" : \"double\", \"type\" : \"double\", \"optional\" : true, \"default\" : -4.0 }, \n" +
     "{ \"name\" : \"string\", \"type\" : \"string\", \"default\" : \"default_string\" }, \n" +
     "{ \"name\" : \"bytes\", \"type\" : \"bytes\", \"default\" : \"default_bytes\" }, \n" +
     "{ \"name\" : \"array\", \"type\" : { \"type\" : \"array\", \"items\" : \"int\" }, \"default\" : [ -1, -2, -3, -4 ] }, \n" +
     "{ \"name\" : \"recordArray\", \"type\" : { \"type\" : \"array\", \"items\" : \"Foo\" }, \"default\" : [ ] }, \n" +
     "{ \"name\" : \"enum\", \"type\" : { \"type\" : \"enum\", \"name\" : \"EnumType\", \"symbols\" : [ \"APPLE\", \"ORANGE\", \"BANANA\" ] }, \"default\" : \"APPLE\" }, \n" +
     "{ \"name\" : \"fixed\", \"type\" : { \"type\" : \"fixed\", \"name\" : \"fixedType\", \"size\" : 4 }, \"default\" : \"1234\" }, \n" +
     "{ \"name\" : \"map\", \"type\" : { \"type\" : \"map\", \"values\" : \"int\" }, \"default\" : { \"key1\" : -5 } }, \n" +
     "{ \"name\" : \"record\", \"type\" : { \"type\" : \"record\", \"name\" : \"Bar\", \"fields\" : [ { \"name\" : \"int\", \"type\" : \"int\" } ] }, \"default\" : { \"int\" : -6 } }, \n" +
     "{ \"name\" : \"recordNoDefault\", \"type\" : \"Bar\" }, \n" +
     "{ \"name\" : \"recordOptional\", \"type\" : \"Bar\", \"optional\" : true }, \n" +
     "{ \"name\" : \"union\", \"type\" : [ \"int\", \"Bar\", \"EnumType\", \"fixedType\", \"Foo\" ], \"default\" : { \"EnumType\" : \"ORANGE\"} }, \n" +
     "{ \"name\" : \"unionWithNull\", \"type\" : [ \"null\", \"EnumType\", \"fixedType\" ], \"default\" : null } \n" +
     "] }"
    );

    public static final RecordDataSchema.Field FIELD_boolean = SCHEMA.getField("boolean");
    public static final RecordDataSchema.Field FIELD_int = SCHEMA.getField("int");
    public static final RecordDataSchema.Field FIELD_long = SCHEMA.getField("long");
    public static final RecordDataSchema.Field FIELD_float = SCHEMA.getField("float");
    public static final RecordDataSchema.Field FIELD_double = SCHEMA.getField("double");
    public static final RecordDataSchema.Field FIELD_string = SCHEMA.getField("string");
    public static final RecordDataSchema.Field FIELD_bytes = SCHEMA.getField("bytes");

    public static final RecordDataSchema.Field FIELD_enum = SCHEMA.getField("enum");

    public static final RecordDataSchema.Field FIELD_fixed = SCHEMA.getField("fixed");
    public static final RecordDataSchema.Field FIELD_array = SCHEMA.getField("array");
    public static final RecordDataSchema.Field FIELD_arrayRecord = SCHEMA.getField("recordArray");
    public static final RecordDataSchema.Field FIELD_record = SCHEMA.getField("record");
    public static final RecordDataSchema.Field FIELD_recordNoDefault = SCHEMA.getField("recordNoDefault");
    public static final RecordDataSchema.Field FIELD_recordOptional = SCHEMA.getField("recordOptional");

    public static final RecordDataSchema.Field FIELD_union = SCHEMA.getField("union");

    public Foo()
    {
      super(new DataMap(), SCHEMA);
    }

    public Foo(DataMap map)
    {
      super(map, SCHEMA);
    }

    public boolean hasBoolean()
    {
      return contains(FIELD_boolean);
    }

    public Boolean isBoolean()
    {
      return isBoolean(GetMode.STRICT);
    }

    public Boolean isBoolean(GetMode mode)
    {
      return obtainDirect(FIELD_boolean, Boolean.class, mode);
    }

    public void removeBoolean()
    {
      remove(FIELD_boolean);
    }

    public Foo set1Boolean(boolean value)
    {
      // old generated code uses this
      putDirect(FIELD_boolean, Boolean.class, value);
      return this;
    }

    public Foo set2Boolean(boolean value)
    {
      // old generated code uses this
      putDirect(FIELD_boolean, Boolean.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2Boolean(Boolean value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_boolean, Boolean.class, value, mode);
      return this;
    }

    public Foo setBoolean(boolean value)
    {
      putDirect(FIELD_boolean, Boolean.class, Boolean.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setBoolean(Boolean value, SetMode mode)
    {
      putDirect(FIELD_boolean, Boolean.class, Boolean.class, value, mode);
      return this;
    }

    public boolean hasInt()
    {
      return contains(FIELD_int);
    }

    public Integer getInt()
    {
      return getInt(GetMode.STRICT);
    }

    public Integer getInt(GetMode mode)
    {
      return obtainDirect(FIELD_int, Integer.class, mode);
    }

    public void removeInt()
    {
      remove(FIELD_int);
    }

    public Foo set1Int(int value)
    {
      // old generated code uses this
      putDirect(FIELD_int, Integer.class, value);
      return this;
    }

    public Foo set2Int(int value)
    {
      // old generated code uses this
      putDirect(FIELD_int, Integer.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2Int(Integer value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_int, Integer.class, value, mode);
      return this;
    }

    public Foo setInt(int value)
    {
      putDirect(FIELD_int, Integer.class, Integer.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setInt(Integer value, SetMode mode)
    {
      putDirect(FIELD_int, Integer.class, Integer.class, value, mode);
      return this;
    }

    public boolean hasLong()
    {
      return contains(FIELD_long);
    }

    public Long getLong()
    {
      return getLong(GetMode.STRICT);
    }

    public Long getLong(GetMode mode)
    {
      return obtainDirect(FIELD_long, Long.class, mode);
    }

    public void removeLong()
    {
      remove(FIELD_long);
    }

    public Foo set1Long(long value)
    {
      // old generated code uses this
      putDirect(FIELD_long, Long.class, value);
      return this;
    }

    public Foo set2Long(long value)
    {
      // old generated code uses this
      putDirect(FIELD_long, Long.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2Long(Long value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_long, Long.class, value, mode);
      return this;
    }

    public Foo setLong(long value)
    {
      putDirect(FIELD_long, Long.class, Long.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setLong(Long value, SetMode mode)
    {
      putDirect(FIELD_long, Long.class, Long.class, value, mode);
      return this;
    }

    public boolean hasFloat()
    {
      return contains(FIELD_float);
    }

    public Float getFloat()
    {
      return getFloat(GetMode.STRICT);
    }

    public Float getFloat(GetMode mode)
    {
      return obtainDirect(FIELD_float, Float.class, mode);
    }

    public void removeFloat()
    {
      remove(FIELD_float);
    }

    public Foo set1Float(float value)
    {
      // old generated code uses this
      putDirect(FIELD_float, Float.class, value);
      return this;
    }

    public Foo set2Float(float value)
    {
      // old generated code uses this
      putDirect(FIELD_float, Float.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2Float(Float value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_float, Float.class, value, mode);
      return this;
    }

    public Foo setFloat(float value)
    {
      putDirect(FIELD_float, Float.class, Float.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setFloat(Float value, SetMode mode)
    {
      putDirect(FIELD_float, Float.class, Float.class, value, mode);
      return this;
    }

    public boolean hasDouble()
    {
      return contains(FIELD_double);
    }

    public Double getDouble()
    {
      return getDouble(GetMode.STRICT);
    }

    public Double getDouble(GetMode mode)
    {
      return obtainDirect(FIELD_double, Double.class, mode);
    }

    public void removeDouble()
    {
      remove(FIELD_double);
    }

    public Foo set1Double(double value)
    {
      // old generated code uses this
      putDirect(FIELD_double, Double.class, value);
      return this;
    }

    public Foo set2Double(double value)
    {
      // old generated code uses this
      putDirect(FIELD_double, Double.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2Double(Double value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_double, Double.class, value, mode);
      return this;
    }

    public Foo setDouble(double value)
    {
      putDirect(FIELD_double, Double.class, Double.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setDouble(Double value, SetMode mode)
    {
      putDirect(FIELD_double, Double.class, Double.class, value, mode);
      return this;
    }

    public boolean hasString()
    {
      return contains(FIELD_string);
    }

    public String getString()
    {
      return getString(GetMode.STRICT);
    }

    public String getString(GetMode mode)
    {
      return obtainDirect(FIELD_string, String.class, mode);
    }

    public void removeString()
    {
      remove(FIELD_string);
    }

    public Foo set1String(String value)
    {
      // old generated code uses this
      putDirect(FIELD_string, String.class, value);
      return this;
    }

    public Foo set2String(String value)
    {
      // old generated code uses this
      putDirect(FIELD_string, String.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2String(String value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_string, String.class, value, mode);
      return this;
    }

    public Foo setString(String value)
    {
      putDirect(FIELD_string, String.class, String.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setString(String value, SetMode mode)
    {
      putDirect(FIELD_string, String.class, String.class, value, mode);
      return this;
    }

    public boolean hasBytes()
    {
      return contains(FIELD_bytes);
    }

    public ByteString getBytes()
    {
      return getBytes(GetMode.STRICT);
    }

    public ByteString getBytes(GetMode mode)
    {
      return obtainDirect(FIELD_bytes, ByteString.class, mode);
    }

    public void removeBytes()
    {
      remove(FIELD_bytes);
    }

    public Foo set1Bytes(ByteString value)
    {
      // old generated code uses this
      putDirect(FIELD_bytes, ByteString.class, value);
      return this;
    }

    public Foo set2Bytes(ByteString value)
    {
      // old generated code uses this
      putDirect(FIELD_bytes, ByteString.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2Bytes(ByteString value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_bytes, ByteString.class, value, mode);
      return this;
    }

    public Foo setBytes(ByteString value)
    {
      putDirect(FIELD_bytes, ByteString.class, ByteString.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setBytes(ByteString value, SetMode mode)
    {
      putDirect(FIELD_bytes, ByteString.class, ByteString.class, value, mode);
      return this;
    }

    public boolean hasEnum()
    {
      return contains(FIELD_enum);
    }

    public EnumType getEnum()
    {
      return getEnum(GetMode.STRICT);
    }

    public EnumType getEnum(GetMode mode)
    {
      return obtainDirect(FIELD_enum, EnumType.class, mode);
    }

    public void removeEnum()
    {
      remove(FIELD_enum);
    }

    public Foo set1Enum(EnumType value)
    {
      // old generated code uses this
      putDirect(FIELD_enum, EnumType.class, value);
      return this;
    }

    public Foo set2Enum(EnumType value)
    {
      // old generated code uses this
      putDirect(FIELD_enum, EnumType.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo set2Enum(EnumType value, SetMode mode)
    {
      // old generated code uses this
      putDirect(FIELD_enum, EnumType.class, value, mode);
      return this;
    }

    public Foo setEnum(EnumType value)
    {
      putDirect(FIELD_enum, EnumType.class, String.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setEnum(EnumType value, SetMode mode)
    {
      putDirect(FIELD_enum, EnumType.class, String.class, value, mode);
      return this;
    }

    public boolean hasFixed()
    {
      return contains(FIELD_fixed);
    }

    public FixedType getFixed()
    {
      return getFixed(GetMode.STRICT);
    }

    public FixedType getFixed(GetMode mode)
    {
      return obtainWrapped(FIELD_fixed, FixedType.class, mode);
    }

    public void removeFixed()
    {
      remove(FIELD_fixed);
    }

    public Foo set1Fixed(FixedType value)
    {
      // old generated code uses this
      putWrapped(FIELD_fixed, FixedType.class, value);
      return this;
    }

    public Foo setFixed(FixedType value)
    {
      putWrapped(FIELD_fixed, FixedType.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setFixed(FixedType value, SetMode mode)
    {
      putWrapped(FIELD_fixed, FixedType.class, value, mode);
      return this;
    }

    public boolean hasArray()
    {
      return contains(FIELD_array);
    }

    public IntegerArray getArray()
    {
      return getArray(GetMode.STRICT);
    }

    public IntegerArray getArray(GetMode mode)
    {
      return obtainWrapped(FIELD_array, IntegerArray.class, mode);
    }

    public void removeArray()
    {
      remove(FIELD_array);
    }

    public Foo set1Array(IntegerArray value)
    {
      // old generated code uses this
      putWrapped(FIELD_array, IntegerArray.class, value);
      return this;
    }

    public Foo setArray(IntegerArray value)
    {
      putWrapped(FIELD_array, IntegerArray.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setArray(IntegerArray value, SetMode mode)
    {
      putWrapped(FIELD_array, IntegerArray.class, value, mode);
      return this;
    }

    public boolean hasRecord()
    {
      return contains(FIELD_record);
    }

    public Bar getRecord()
    {
      return getRecord(GetMode.STRICT);
    }

    public Bar getRecord(GetMode mode)
    {
      return obtainWrapped(FIELD_record, Bar.class, mode);
    }

    public void removeRecord()
    {
      remove(FIELD_record);
    }

    public Foo set1Record(Bar value)
    {
      // old generated code uses this
      putWrapped(FIELD_record, Bar.class, value);
      return this;
    }

    public Foo setRecord(Bar value)
    {
      putWrapped(FIELD_record, Bar.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setRecord(Bar value, SetMode mode)
    {
      putWrapped(FIELD_record, Bar.class, value, mode);
      return this;
    }

    public boolean hasRecordNoDefault()
    {
      return contains(FIELD_recordNoDefault);
    }

    public Bar getRecordNoDefault()
    {
      return getRecordNoDefault(GetMode.STRICT);
    }

    public Bar getRecordNoDefault(GetMode mode)
    {
      return obtainWrapped(FIELD_recordNoDefault, Bar.class, mode);
    }

    public void removeRecordNoDefault()
    {
      remove(FIELD_recordNoDefault);
    }

    public Foo set1RecordNoDefault(Bar value)
    {
      // old generated code uses this
      putWrapped(FIELD_recordNoDefault, Bar.class, value);
      return this;
    }

    public Foo setRecordNoDefault(Bar value)
    {
      putWrapped(FIELD_recordNoDefault, Bar.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setRecordNoDefault(Bar value, SetMode mode)
    {
      putWrapped(FIELD_recordNoDefault, Bar.class, value, mode);
      return this;
    }

    public boolean hasRecordOptional()
    {
      return contains(FIELD_recordOptional);
    }

    public Bar getRecordOptional()
    {
      return getRecordOptional(GetMode.STRICT);
    }

    public Bar getRecordOptional(GetMode mode)
    {
      return obtainWrapped(FIELD_recordOptional, Bar.class, mode);
    }

    public void removeRecordOptional()
    {
      remove(FIELD_recordOptional);
    }

    public Foo set1RecordOptional(Bar value)
    {
      // old generated code uses this
      putWrapped(FIELD_recordOptional, Bar.class, value);
      return this;
    }

    public Foo setRecordOptional(Bar value)
    {
      putWrapped(FIELD_recordOptional, Bar.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setRecordOptional(Bar value, SetMode mode)
    {
      putWrapped(FIELD_recordOptional, Bar.class, value, mode);
      return this;
    }

    public static class Union extends UnionTemplate
    {
      public static final UnionDataSchema SCHEMA = (UnionDataSchema) FIELD_union.getType();
      public static final IntegerDataSchema MEMBER_int = (IntegerDataSchema) SCHEMA.getType("int");
      public static final EnumDataSchema MEMBER_EnumType = (EnumDataSchema) SCHEMA.getType("EnumType");
      public static final RecordDataSchema MEMBER_Bar = (RecordDataSchema) SCHEMA.getType("Bar");

      public Union()
      {
        super(Data.NULL, SCHEMA);
      }
      public Union(Object o)
      {
        super(o, SCHEMA);
      }

      public Integer getInt()
      {
        return obtainDirect(MEMBER_int, Integer.class, "int");
      }

      public void set2Int(int value)
      {
        // old generated code uses this
        selectDirect(MEMBER_int, Integer.class, "int", value);
      }

      public void setInt(int value)
      {
        selectDirect(MEMBER_int, Integer.class, Integer.class, "int", value);
      }

      public boolean isInt()
      {
        return memberIs("int");
      }

      public EnumType getEnumType()
      {
        return obtainDirect(MEMBER_EnumType, EnumType.class, "EnumType");
      }

      public void set2EnumType(EnumType value)
      {
        // old generated code uses this
        selectDirect(MEMBER_EnumType, EnumType.class, "EnumType", value);
      }

      public void setEnumType(EnumType value)
      {
        selectDirect(MEMBER_EnumType, EnumType.class, String.class, "EnumType", value);
      }

      public boolean isEnumType()
      {
        return memberIs("EnumType");
      }

      public Bar getBar()
      {
        return obtainWrapped(MEMBER_Bar, Bar.class, "Bar");
      }

      public void setBar(Bar value)
      {
        selectWrapped(MEMBER_Bar, Bar.class, "Bar", value);
      }

      public boolean isBar()
      {
        return memberIs("Bar");
      }

      @Override
      public Union clone() throws CloneNotSupportedException
      {
        return (Union) super.clone();
      }

      @Override
      public Union copy() throws CloneNotSupportedException
      {
        return (Union) super.copy();
      }
    }

    public boolean hasUnion()
    {
      return contains(FIELD_union);
    }

    public Union getUnion()
    {
      return getUnion(GetMode.STRICT);
    }

    public Union getUnion(GetMode mode)
    {
      return obtainWrapped(FIELD_union, Union.class, mode);
    }

    public void removeUnion()
    {
      remove(FIELD_union);
    }

    public Foo setUnion(Union value)
    {
      putWrapped(FIELD_union, Union.class, value, SetMode.DISALLOW_NULL);
      return this;
    }

    public Foo setUnion(Union value, SetMode mode)
    {
      putWrapped(FIELD_union, Union.class, value, mode);
      return this;
    }

    @Override
    public Foo clone() throws CloneNotSupportedException
    {
      return (Foo) super.clone();
    }

    @Override
    public Foo copy() throws CloneNotSupportedException
    {
      return (Foo) super.copy();
    }
  }

  @Test
  public void testGetMode()
  {
    Foo foo1 = new Foo();

    // has default value of -1
    assertFalse(foo1.hasInt());
    assertTrue(foo1.getInt(GetMode.NULL) == null);
    assertEquals(foo1.getInt(GetMode.DEFAULT), Integer.valueOf(-1));
    assertEquals(foo1.getInt(GetMode.STRICT), Integer.valueOf(-1));
    assertEquals(foo1.getInt(), Integer.valueOf(-1));
    assertFalse(foo1.hasInt());
    foo1.setInt(42);
    assertTrue(foo1.hasInt());
    assertEquals(foo1.getInt(), Integer.valueOf(42));
    assertEquals(foo1.getInt(GetMode.NULL), Integer.valueOf(42));
    assertEquals(foo1.getInt(GetMode.DEFAULT), Integer.valueOf(42));
    assertEquals(foo1.getInt(GetMode.STRICT), Integer.valueOf(42));
    assertTrue(foo1.hasInt());
    foo1.removeInt();
    assertFalse(foo1.hasInt());
    assertTrue(foo1.getInt(GetMode.NULL) == null);
    assertEquals(foo1.getInt(GetMode.DEFAULT), Integer.valueOf(-1));
    assertEquals(foo1.getInt(GetMode.STRICT), Integer.valueOf(-1));
    assertEquals(foo1.getInt(), Integer.valueOf(-1));

    Bar bar1 = new Bar();
    bar1.setInt(888);

    assertFalse(foo1.hasRecord());
    assertTrue(foo1.getRecord(GetMode.NULL) == null);
    assertEquals(foo1.getRecord(GetMode.DEFAULT).getInt(), Integer.valueOf(-6));
    assertEquals(foo1.getRecord(GetMode.STRICT).getInt(), Integer.valueOf(-6));
    assertEquals(foo1.getRecord().getInt(), Integer.valueOf(-6));
    assertEquals(foo1.getRecord(GetMode.DEFAULT).getInt().intValue(), -6);
    assertEquals(foo1.getRecord(GetMode.STRICT).getInt().intValue(), -6);
    assertEquals(foo1.getRecord().getInt().intValue(), -6);
    assertFalse(foo1.hasRecord());
    foo1.setRecord(bar1);
    assertTrue(foo1.hasRecord());
    assertEquals(foo1.getRecord().getInt(), Integer.valueOf(888));
    assertEquals(foo1.getRecord(GetMode.NULL).getInt(), Integer.valueOf(888));
    assertEquals(foo1.getRecord(GetMode.DEFAULT).getInt(), Integer.valueOf(888));
    assertEquals(foo1.getRecord(GetMode.STRICT).getInt(), Integer.valueOf(888));
    assertTrue(foo1.hasRecord());
    foo1.removeRecord();
    assertFalse(foo1.hasRecord());
    assertTrue(foo1.getRecord(GetMode.NULL) == null);
    assertEquals(foo1.getRecord(GetMode.DEFAULT).getInt(), Integer.valueOf(-6));
    assertEquals(foo1.getRecord(GetMode.STRICT).getInt(), Integer.valueOf(-6));

    // required and no default value
    assertFalse(foo1.hasLong());
    assertTrue(foo1.getLong(GetMode.NULL) == null);
    assertTrue(foo1.getLong(GetMode.DEFAULT) == null);
    Exception exc;
    try
    {
      exc = null;
      foo1.getLong(GetMode.STRICT);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);
    try
    {
      exc = null;
      foo1.getLong();
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);
    assertFalse(foo1.hasLong());
    foo1.setLong(42L);
    assertTrue(foo1.hasLong());
    assertEquals(foo1.getLong(), Long.valueOf(42L));
    assertEquals(foo1.getLong(GetMode.NULL), Long.valueOf(42L));
    assertEquals(foo1.getLong(GetMode.DEFAULT), Long.valueOf(42L));
    assertEquals(foo1.getLong(GetMode.STRICT), Long.valueOf(42L));
    assertTrue(foo1.hasLong());
    foo1.removeLong();
    assertFalse(foo1.hasLong());
    assertTrue(foo1.getLong(GetMode.NULL) == null);
    assertTrue(foo1.getLong(GetMode.DEFAULT) == null);
    try
    {
      exc = null;
      foo1.getLong(GetMode.STRICT);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);
    try
    {
      exc = null;
      foo1.getLong();
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);

    // optional and no default value
    assertFalse(foo1.hasFloat());
    assertTrue(foo1.getFloat(GetMode.NULL) == null);
    assertTrue(foo1.getFloat(GetMode.DEFAULT) == null);
    assertTrue(foo1.getFloat(GetMode.STRICT) == null);
    assertTrue(foo1.getFloat() == null);
    assertFalse(foo1.hasFloat());
    foo1.setFloat(17.0f);
    assertTrue(foo1.hasFloat());
    assertEquals(foo1.getFloat(), 17.0f);
    assertEquals(foo1.getFloat(GetMode.NULL), 17.0f);
    assertEquals(foo1.getFloat(GetMode.DEFAULT), 17.0f);
    assertEquals(foo1.getFloat(GetMode.STRICT), 17.0f);
    assertTrue(foo1.hasFloat());
    foo1.removeFloat();
    assertFalse(foo1.hasFloat());
    assertTrue(foo1.getFloat(GetMode.NULL) == null);
    assertTrue(foo1.getFloat(GetMode.DEFAULT) == null);
    assertTrue(foo1.getFloat(GetMode.STRICT) == null);
    assertTrue(foo1.getFloat() == null);

    // optional and has default value
    assertFalse(foo1.hasDouble());
    assertTrue(foo1.getDouble(GetMode.NULL) == null);
    assertEquals(foo1.getDouble(GetMode.DEFAULT), -4.0);
    assertEquals(foo1.getDouble(GetMode.STRICT), -4.0);
    assertEquals(foo1.getDouble(), -4.0);
    assertFalse(foo1.hasDouble());
    foo1.setDouble(87.0);
    assertTrue(foo1.hasDouble());
    assertEquals(foo1.getDouble(), 87.0);
    assertEquals(foo1.getDouble(GetMode.NULL), 87.0);
    assertEquals(foo1.getDouble(GetMode.DEFAULT), 87.0);
    assertEquals(foo1.getDouble(GetMode.STRICT), 87.0);
    assertTrue(foo1.hasDouble());
    foo1.removeDouble();
    assertFalse(foo1.hasDouble());
    assertEquals(foo1.getDouble(GetMode.DEFAULT), -4.0);
    assertEquals(foo1.getDouble(GetMode.STRICT), -4.0);
    assertEquals(foo1.getDouble(), -4.0);

    // record with no default value
    assertFalse(foo1.hasRecordNoDefault());
    assertTrue(foo1.getRecordNoDefault(GetMode.NULL) == null);
    assertTrue(foo1.getRecordNoDefault(GetMode.DEFAULT) == null);
    try
    {
      exc = null;
      foo1.getRecordNoDefault(GetMode.STRICT);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);
    try
    {
      exc = null;
      foo1.getRecordNoDefault();
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);
    assertFalse(foo1.hasRecordNoDefault());
    foo1.setRecordNoDefault(bar1);
    assertTrue(foo1.hasRecordNoDefault());
    assertEquals(foo1.getRecordNoDefault().getInt(), Integer.valueOf(888));
    assertEquals(foo1.getRecordNoDefault(GetMode.NULL).getInt(), Integer.valueOf(888));
    assertEquals(foo1.getRecordNoDefault(GetMode.DEFAULT).getInt(), Integer.valueOf(888));
    assertEquals(foo1.getRecordNoDefault(GetMode.STRICT).getInt(), Integer.valueOf(888));
    assertTrue(foo1.hasRecordNoDefault());
    foo1.removeRecordNoDefault();
    assertFalse(foo1.hasRecordNoDefault());
    assertTrue(foo1.getRecordNoDefault(GetMode.NULL) == null);
    assertTrue(foo1.getRecordNoDefault(GetMode.DEFAULT) == null);
    try
    {
      exc = null;
      foo1.getRecordNoDefault(GetMode.STRICT);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);
    try
    {
      exc = null;
      foo1.getRecordNoDefault();
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof RequiredFieldNotPresentException);
  }

  @Test
  public void testSetMode()
  {
    Foo foo1 = new Foo();

    //
    // mandatory primitive field
    //
    assertFalse(foo1.hasInt());
    foo1.setInt(42);
    assertEquals(foo1.getInt().intValue(), 42);
    foo1.setInt(44, SetMode.IGNORE_NULL);
    assertEquals(foo1.getInt().intValue(), 44);
    foo1.setInt(46, SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getInt().intValue(), 46);
    foo1.setInt(48, SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertEquals(foo1.getInt().intValue(), 48);
    foo1.setInt(50, SetMode.DISALLOW_NULL);
    assertEquals(foo1.getInt().intValue(), 50);

    // optional primitive field
    assertFalse(foo1.hasDouble());
    foo1.setDouble(42.0);
    assertEquals(foo1.getDouble().doubleValue(), 42.0);
    foo1.setDouble(44.0, SetMode.IGNORE_NULL);
    assertEquals(foo1.getDouble().doubleValue(), 44.0);
    foo1.setDouble(46.0, SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getDouble().doubleValue(), 46.0);
    foo1.setDouble(48.0, SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertEquals(foo1.getDouble().doubleValue(), 48.0);
    foo1.setDouble(50.0, SetMode.DISALLOW_NULL);
    assertEquals(foo1.getDouble().doubleValue(), 50.0);

    // mandatory complex field
    assertFalse(foo1.hasRecord());
    foo1.setRecord(new Bar().setInt(42));
    assertEquals(foo1.getRecord().getInt().intValue(), 42);
    foo1.setRecord(new Bar().setInt(44), SetMode.IGNORE_NULL);
    assertEquals(foo1.getRecord().getInt().intValue(), 44);
    foo1.setRecord(new Bar().setInt(46), SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getRecord().getInt().intValue(), 46);
    foo1.setRecord(new Bar().setInt(48), SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertEquals(foo1.getRecord().getInt().intValue(), 48);
    foo1.setRecord(new Bar().setInt(50), SetMode.DISALLOW_NULL);
    assertEquals(foo1.getInt().intValue(), 50);

    // mandatory complex field
    assertFalse(foo1.hasRecordOptional());
    foo1.setRecordOptional(new Bar().setInt(42));
    assertEquals(foo1.getRecordOptional().getInt().intValue(), 42);
    foo1.setRecordOptional(new Bar().setInt(44), SetMode.IGNORE_NULL);
    assertEquals(foo1.getRecordOptional().getInt().intValue(), 44);
    foo1.setRecordOptional(new Bar().setInt(46), SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getRecordOptional().getInt().intValue(), 46);
    foo1.setRecordOptional(new Bar().setInt(48), SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertEquals(foo1.getRecordOptional().getInt().intValue(), 48);
    foo1.setRecordOptional(new Bar().setInt(50), SetMode.DISALLOW_NULL);
    assertEquals(foo1.getInt().intValue(), 50);

    // primitive mandatory field with null
    // IGNORE_NULL
    foo1 = new Foo();
    foo1.setInt(null, SetMode.IGNORE_NULL);
    assertFalse(foo1.hasInt());
    foo1.setInt(42);
    foo1.setInt(null, SetMode.IGNORE_NULL);
    assertEquals(foo1.getInt(GetMode.NULL).intValue(), 42);
    // REMOVE_IF_NULL
    foo1.setInt(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasInt());
    foo1.setInt(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasInt());
    foo1.setInt(44, SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getInt(GetMode.NULL).intValue(), 44);
    // REMOVE_OPTIONAL_IF_NULL
    Exception exc;
    try
    {
      exc = null;
      foo1.setInt(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof IllegalArgumentException);
    assertEquals(foo1.getInt(GetMode.NULL).intValue(), 44);
    // does not matter if value is present
    foo1.removeInt();
    try
    {
      exc = null;
      foo1.setInt(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof IllegalArgumentException);
    assertFalse(foo1.hasInt());
    foo1.setInt(46, SetMode.REMOVE_OPTIONAL_IF_NULL);
    // DISALLOW_NULL
    try
    {
      exc = null;
      foo1.setInt(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertEquals(foo1.getInt(GetMode.NULL).intValue(), 46);
    // does not matter if value is present
    foo1.removeInt();
    try
    {
      exc = null;
      foo1.setInt(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertFalse(foo1.hasInt());
    foo1.setInt(48, SetMode.DISALLOW_NULL);
    assertEquals(foo1.getInt(GetMode.NULL).intValue(), 48);

    //
    // primitive optional field with null
    //
    // IGNORE_NULL
    foo1 = new Foo();
    foo1.setDouble(null, SetMode.IGNORE_NULL);
    assertFalse(foo1.hasDouble());
    foo1.setDouble(42.0);
    foo1.setDouble(null, SetMode.IGNORE_NULL);
    assertEquals(foo1.getDouble(GetMode.NULL).doubleValue(), 42.0);
    // REMOVE_IF_NULL
    foo1.setDouble(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasDouble());
    foo1.setDouble(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasDouble());
    foo1.setDouble(44.0, SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getDouble(GetMode.NULL).doubleValue(), 44.0);
    // REMOVE_OPTIONAL_IF_NULL
    foo1.setDouble(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertFalse(foo1.hasDouble());
    foo1.setDouble(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertFalse(foo1.hasDouble());
    foo1.setDouble(46.0, SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertEquals(foo1.getDouble(GetMode.NULL).doubleValue(), 46.0);
    // DISALLOW_NULL
    try
    {
      exc = null;
      foo1.setDouble(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertEquals(foo1.getDouble(GetMode.NULL).doubleValue(), 46.0);
    // does not matter if value is present
    foo1.removeDouble();
    try
    {
      exc = null;
      foo1.setDouble(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertFalse(foo1.hasDouble());
    foo1.setDouble(48.0, SetMode.DISALLOW_NULL);
    assertEquals(foo1.getDouble(GetMode.NULL).doubleValue(), 48.0);

    //
    // complex mandatory field with null
    //
    // IGNORE_NULL
    foo1 = new Foo();
    foo1.setRecord(null, SetMode.IGNORE_NULL);
    assertFalse(foo1.hasRecord());
    foo1.setRecord(new Bar().setInt(42));
    foo1.setRecord(null, SetMode.IGNORE_NULL);
    assertEquals(foo1.getRecord(GetMode.NULL).getInt().intValue(), 42);
    // REMOVE_IF_NULL
    foo1.setRecord(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasRecord());
    foo1.setRecord(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasRecord());
    foo1.setRecord(new Bar().setInt(44), SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getRecord(GetMode.NULL).getInt().intValue(), 44);
    // REMOVE_OPTIONAL_IF_NULL
    try
    {
      exc = null;
      foo1.setRecord(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof IllegalArgumentException);
    assertEquals(foo1.getRecord(GetMode.NULL).getInt().intValue(), 44);
    // does not matter if value is present
    foo1.removeRecord();
    try
    {
      exc = null;
      foo1.setRecord(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof IllegalArgumentException);
    assertFalse(foo1.hasRecord());
    foo1.setRecord(new Bar().setInt(46), SetMode.REMOVE_OPTIONAL_IF_NULL);
    // DISALLOW_NULL
    try
    {
      exc = null;
      foo1.setRecord(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertEquals(foo1.getRecord(GetMode.NULL).getInt().intValue(), 46);
    // does not matter if value is present
    foo1.removeRecord();
    try
    {
      exc = null;
      foo1.setRecord(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertFalse(foo1.hasRecord());
    foo1.setRecord(new Bar().setInt(48), SetMode.DISALLOW_NULL);
    assertEquals(foo1.getRecord(GetMode.NULL).getInt().intValue(), 48);

    //
    // complex optional field with null
    //
    // IGNORE_NULL
    foo1 = new Foo();
    foo1.setRecordOptional(null, SetMode.IGNORE_NULL);
    assertFalse(foo1.hasRecordOptional());
    foo1.setRecordOptional(new Bar().setInt(42));
    foo1.setRecordOptional(null, SetMode.IGNORE_NULL);
    assertEquals(foo1.getRecordOptional(GetMode.NULL).getInt().intValue(), 42);
    // REMOVE_IF_NULL
    foo1.setRecordOptional(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasRecordOptional());
    foo1.setRecordOptional(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo1.hasRecordOptional());
    foo1.setRecordOptional(new Bar().setInt(44), SetMode.REMOVE_IF_NULL);
    assertEquals(foo1.getRecordOptional(GetMode.NULL).getInt().intValue(), 44);
    // REMOVE_OPTIONAL_IF_NULL
    foo1.setRecordOptional(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertFalse(foo1.hasRecordOptional());
    foo1.setRecordOptional(null, SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertFalse(foo1.hasRecordOptional());
    foo1.setRecordOptional(new Bar().setInt(46), SetMode.REMOVE_OPTIONAL_IF_NULL);
    assertEquals(foo1.getRecordOptional(GetMode.NULL).getInt().intValue(), 46);
    // DISALLOW_NULL
    try
    {
      exc = null;
      foo1.setRecordOptional(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertEquals(foo1.getRecordOptional(GetMode.NULL).getInt().intValue(), 46);
    // does not matter if value is present
    foo1.removeRecordOptional();
    try
    {
      exc = null;
      foo1.setRecordOptional(null, SetMode.DISALLOW_NULL);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullPointerException);
    assertFalse(foo1.hasRecordOptional());
    foo1.setRecordOptional(new Bar().setInt(48), SetMode.DISALLOW_NULL);
    assertEquals(foo1.getRecordOptional(GetMode.NULL).getInt().intValue(), 48);
  }

  @Test
  public void testSchema()
  {
    assertEquals(Bar.SCHEMA, new Bar().schema());
    assertEquals(Foo.SCHEMA, new Foo().schema());
    assertEquals(Foo.Union.SCHEMA, new Foo.Union().schema());
  }

  @Test
  public void testHashCode()
  {
    List<EnumType> good = Arrays.asList(EnumType.APPLE, EnumType.ORANGE, EnumType.BANANA);
    Foo foo = new Foo();
    Integer lastHashCode = null;
    for (EnumType type : good)
    {
      foo.setEnum(type);
      int newHashCode = foo.hashCode();
      if (lastHashCode != null)
      {
        assertTrue(newHashCode != lastHashCode.intValue());
      }
      assertEquals(newHashCode, foo.data().hashCode());
      lastHashCode = newHashCode;
    }
  }

  @Test
  public void testBooleanField()
  {
    List<Boolean> good = Arrays.asList(Boolean.FALSE, Boolean.TRUE);
    Foo foo = new Foo();
    for (Boolean aBoolean : good)
    {
      // Object
      foo.setBoolean(aBoolean, SetMode.DISALLOW_NULL);
      assertEquals(foo.isBoolean(), aBoolean);
      assertTrue(foo.hasBoolean());
      assertEquals(foo.toString(), "{boolean=" + aBoolean + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeBoolean();
        assertTrue(foo.hasBoolean());
        assertEquals(foo.isBoolean(), aBoolean);
        assertFalse(fooClone.hasBoolean());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeBoolean();
        assertTrue(foo.hasBoolean());
        assertEquals(foo.isBoolean(), aBoolean);
        assertFalse(fooCopy.hasBoolean());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeBoolean();
      assertFalse(foo.hasBoolean());
      assertEquals(foo.toString(), "{}");

      // primitive
      foo.setBoolean(aBoolean.booleanValue());
      assertEquals(foo.isBoolean(), aBoolean);
      assertTrue(foo.hasBoolean());
      assertEquals(foo.toString(), "{boolean=" + aBoolean + '}');
      exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeBoolean();
        assertTrue(foo.hasBoolean());
        assertEquals(foo.isBoolean(), aBoolean);
        assertFalse(fooClone.hasBoolean());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeBoolean();
        assertTrue(foo.hasBoolean());
        assertEquals(foo.isBoolean(), aBoolean);
        assertFalse(fooCopy.hasBoolean());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeBoolean();
      assertFalse(foo.hasBoolean());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(3, "abc", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("boolean", bad);
      Exception exc = null;
      try
      {
        foo.isBoolean();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    // legacy test
    Boolean[] t = { true, false, true };
    foo = new Foo();
    foo.set1Boolean(t[0].booleanValue());
    assertEquals(foo.isBoolean(), t[0]);
    foo.set2Boolean(t[1].booleanValue());
    assertEquals(foo.isBoolean(), t[1]);
    foo.set2Boolean(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.isBoolean(), t[2]);
    foo.set2Boolean(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasBoolean());
  }

  @Test
  public void testEnumField()
  {
    List<EnumType> good = Arrays.asList(EnumType.APPLE, EnumType.ORANGE, EnumType.BANANA);
    Foo foo = new Foo();
    for (EnumType type : good)
    {
      foo.setEnum(type);
      assertEquals(foo.getEnum(), type);
      assertTrue(foo.hasEnum());
      assertEquals(foo.toString(), "{enum=" + type + '}');

      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeEnum();
        assertTrue(foo.hasEnum());
        assertEquals(foo.getEnum(), type);
        assertFalse(fooClone.hasEnum());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeEnum();
        assertTrue(foo.hasEnum());
        assertEquals(foo.getEnum(), type);
        assertFalse(fooCopy.hasEnum());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeEnum();
      assertFalse(foo.hasEnum());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("enum", bad);
      Exception exc = null;
      try
      {
        EnumType result = foo.getEnum();
        assertEquals(bad.getClass(), String.class);
        assertEquals(result, EnumType.$UNKNOWN);
      }
      catch (Exception e)
      {
        exc = e;
      }
      if (bad.getClass() != String.class)
      {
        assertTrue(exc != null);
        assertTrue(exc instanceof TemplateOutputCastException);
      }
    }

    foo.setEnum(EnumType.APPLE);
    assertEquals(foo.getEnum(), EnumType.APPLE);
    foo.setEnum(EnumType.ORANGE);
    assertEquals(foo.getEnum(), EnumType.ORANGE);
    foo.setEnum(EnumType.BANANA);
    assertEquals(foo.getEnum(), EnumType.BANANA);

    // legacy test
    EnumType[] t = { EnumType.APPLE, EnumType.ORANGE, EnumType.BANANA };
    foo = new Foo();
    foo.set1Enum(t[0]);
    assertEquals(foo.getEnum(), t[0]);
    foo.set2Enum(t[1]);
    assertEquals(foo.getEnum(), t[1]);
    foo.set2Enum(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.getEnum(), t[2]);
    foo.set2Enum(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasEnum());
  }

  @Test
  public void testIntegerField()
  {
    List<Integer> good = Arrays.asList(11, 22, 33);
    Foo foo = new Foo();
    for (Integer i : good)
    {
      foo.setInt(i.intValue());
      assertEquals(foo.getInt(), i);
      assertTrue(foo.hasInt());
      assertEquals(foo.toString(), "{int=" + i + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeInt();
        assertTrue(foo.hasInt());
        assertEquals(foo.getInt(), i);
        assertFalse(fooClone.hasInt());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeInt();
        assertTrue(foo.hasInt());
        assertEquals(foo.getInt(), i);
        assertFalse(fooCopy.hasInt());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeInt();
      assertFalse(foo.hasInt());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("int", bad);
      Exception exc = null;
      try
      {
        foo.getInt();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    List<?> castFrom = TestUtil.asList(88L, 99.0f, 77.0);
    List<?> castTo = TestUtil.asList(88, 99, 77);
    for (int i = 0; i < castFrom.size(); ++i)
    {
      map.put("int", castFrom.get(i));
      Integer result = foo.getInt();
      assertEquals(result, castTo.get(i));
    }

    // legacy test
    Integer[] t = { 77, 88, 99 };
    foo = new Foo();
    foo.set1Int(t[0].intValue());
    assertEquals(foo.getInt(), t[0]);
    foo.set2Int(t[1].intValue());
    assertEquals(foo.getInt(), t[1]);
    foo.set2Int(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.getInt(), t[2]);
    foo.set2Int(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasInt());
  }

  @Test
  public void testLongField()
  {
    List<Long> good = Arrays.asList(11L, 22L, 33L);
    Foo foo = new Foo();
    for (Long aLong : good)
    {
      foo.setLong(aLong.longValue());
      assertEquals(foo.getLong(), aLong);
      assertTrue(foo.hasLong());
      assertEquals(foo.toString(), "{long=" + aLong + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeLong();
        assertTrue(foo.hasLong());
        assertEquals(foo.getLong(), aLong);
        assertFalse(fooClone.hasLong());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeLong();
        assertTrue(foo.hasLong());
        assertEquals(foo.getLong(), aLong);
        assertFalse(fooCopy.hasLong());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeLong();
      assertFalse(foo.hasLong());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("long", bad);
      Exception exc = null;
      try
      {
        foo.getLong();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    List<?> castFrom = TestUtil.asList(88, 99.0f, 77.0);
    List<?> castTo = TestUtil.asList(88L, 99L, 77L);
    for (int i = 0; i < castFrom.size(); ++i)
    {
      map.put("long", castFrom.get(i));
      Long result = foo.getLong();
      assertEquals(result, castTo.get(i));
    }

    // legacy test
    Long[] t = { 77L, 88L, 99L };
    foo = new Foo();
    foo.set1Long(t[0].longValue());
    assertEquals(foo.getLong(), t[0]);
    foo.set2Long(t[1].longValue());
    assertEquals(foo.getLong(), t[1]);
    foo.set2Long(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.getLong(), t[2]);
    foo.set2Long(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasLong());
  }

  @Test
  public void testFloatField()
  {
    List<Float> good = Arrays.asList(11.0f, 22.0f, 33.0f);
    Foo foo = new Foo();
    for (Float i : good)
    {
      foo.setFloat(i.floatValue());
      assertEquals(foo.getFloat(), i);
      assertTrue(foo.hasFloat());
      assertEquals(foo.toString(), "{float=" + i + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeFloat();
        assertTrue(foo.hasFloat());
        assertEquals(foo.getFloat(), i);
        assertFalse(fooClone.hasFloat());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeFloat();
        assertTrue(foo.hasFloat());
        assertEquals(foo.getFloat(), i);
        assertFalse(fooCopy.hasFloat());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeFloat();
      assertFalse(foo.hasFloat());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("float", bad);
      Exception exc = null;
      try
      {
        foo.getFloat();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    List<?> castFrom = TestUtil.asList(88, 99.0, 77.0);
    List<?> castTo = TestUtil.asList(88.0f, 99.0f, 77.0f);
    for (int i = 0; i < castFrom.size(); ++i)
    {
      map.put("float", castFrom.get(i));
      Float result = foo.getFloat();
      assertEquals(result, castTo.get(i));
    }

    // legacy test
    Float[] t = {77.0f, 88.0f, 99.0f};
    foo = new Foo();
    foo.set1Float(t[0].floatValue());
    assertEquals(foo.getFloat(), t[0]);
    foo.set2Float(t[1].floatValue());
    assertEquals(foo.getFloat(), t[1]);
    foo.set2Float(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.getFloat(), t[2]);
    foo.set2Float(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasFloat());
  }

  @Test
  public void testDoubleField()
  {
    List<Double> good = Arrays.asList(11.0, 22.0, 33.0);
    Foo foo = new Foo();
    for (Double aDouble : good)
    {
      foo.setDouble(aDouble.doubleValue());
      assertEquals(foo.getDouble(), aDouble);
      assertTrue(foo.hasDouble());
      assertEquals(foo.toString(), "{double=" + aDouble + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeDouble();
        assertTrue(foo.hasDouble());
        assertEquals(foo.getDouble(), aDouble);
        assertFalse(fooClone.hasDouble());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeDouble();
        assertTrue(foo.hasDouble());
        assertEquals(foo.getDouble(), aDouble);
        assertFalse(fooCopy.hasDouble());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeDouble();
      assertFalse(foo.hasDouble());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("double", bad);
      Exception exc = null;
      try
      {
        foo.getDouble();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    List<?> castFrom = TestUtil.asList(88, 99L, 77.0f);
    List<?> castTo = TestUtil.asList(88.0, 99.0, 77.0);
    for (int i = 0; i < castFrom.size(); ++i)
    {
      map.put("double", castFrom.get(i));
      Double result = foo.getDouble();
      assertEquals(result, castTo.get(i));
    }

    // legacy test
    Double[] t = { 77.0, 88.0, 99.0 };
    foo = new Foo();
    foo.set1Double(t[0].doubleValue());
    assertEquals(foo.getDouble(), t[0]);
    foo.set2Double(t[1].doubleValue());
    assertEquals(foo.getDouble(), t[1]);
    foo.set2Double(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.getDouble(), t[2]);
    foo.set2Double(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasDouble());
  }

  @Test
  public void testStringField()
  {
    List<String> good = Arrays.asList("11", "22.0", "33.0");
    Foo foo = new Foo();
    for (String s : good)
    {
      foo.setString(s);
      assertEquals(foo.getString(), s);
      assertTrue(foo.hasString());
      assertEquals(foo.toString(), "{string=" + s + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeString();
        assertTrue(foo.hasString());
        assertEquals(foo.getString(), s);
        assertFalse(fooClone.hasString());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeString();
        assertTrue(foo.hasString());
        assertEquals(foo.getString(), s);
        assertFalse(fooCopy.hasString());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeString();
      assertFalse(foo.hasString());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, 4, 5L, 6.0f, 7.0, new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("string", bad);
      Exception exc = null;
      try
      {
        foo.getString();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    // legacy test
    String[] t = { "77", "88", "99" };
    foo = new Foo();
    foo.set1String(t[0]);
    assertEquals(foo.getString(), t[0]);
    foo.set2String(t[1]);
    assertEquals(foo.getString(), t[1]);
    foo.set2String(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.getString(), t[2]);
    foo.set2String(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasString());
  }

  @Test
  public void testBytesField()
  {
    List<ByteString> good = Arrays.asList(ByteString.copyAvroString("11", false), ByteString.copyAvroString("22", false), ByteString.copyAvroString("33", false));
    Foo foo = new Foo();
    for (ByteString byteString : good)
    {
      foo.setBytes(byteString);
      assertEquals(foo.getBytes(), byteString);
      assertTrue(foo.hasBytes());
      assertEquals(foo.toString(), "{bytes=" + byteString + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        fooClone.removeBytes();
        assertTrue(foo.hasBytes());
        assertEquals(foo.getBytes(), byteString);
        assertFalse(fooClone.hasBytes());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        fooCopy.removeBytes();
        assertTrue(foo.hasBytes());
        assertEquals(foo.getBytes(), byteString);
        assertFalse(fooCopy.hasBytes());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeBytes();
      assertFalse(foo.hasBytes());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, 33, "\u0100", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("bytes", bad);
      Exception exc = null;
      try
      {
        foo.getBytes();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    List<?> castFrom = TestUtil.asList("88");
    List<?> castTo = TestUtil.asList(ByteString.copyAvroString("88", false));
    for (int i = 0; i < castFrom.size(); ++i)
    {
      map.put("bytes", castFrom.get(i));
      ByteString result = foo.getBytes();
      assertEquals(result, castTo.get(i));
    }

    // legacy test
    ByteString[] t = {
      ByteString.copyAvroString("apple", false), 
      ByteString.copyAvroString("orange", false), 
      ByteString.copyAvroString("banana", false) 
    };
    foo = new Foo();
    foo.set1Bytes(t[0]);
    assertEquals(foo.getBytes(), t[0]);
    foo.set2Bytes(t[1]);
    assertEquals(foo.getBytes(), t[1]);
    foo.set2Bytes(t[2], SetMode.DISALLOW_NULL);
    assertEquals(foo.getBytes(), t[2]);
    foo.set2Bytes(null, SetMode.REMOVE_IF_NULL);
    assertFalse(foo.hasBytes());
  }

  @Test
  public void testFixedField()
  {
    List<FixedType> good = Arrays.asList(
        new FixedType(ByteString.copyAvroString("abcd", false)),
        new FixedType(ByteString.copyAvroString("1234", false))
    );
    for (FixedType fixed : good)
    {
      Exception exc = null;
      try
      {
        FixedTemplate clone = fixed.clone();
        assertSame(clone.data(), fixed.data());
        assertSame(clone.schema(), fixed.schema());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assert exc == null;
    }
    Foo foo = new Foo();
    for (FixedType fixedType : good)
    {
      foo.setFixed(fixedType);
      assertEquals(foo.getFixed(), fixedType);
      assertEquals(foo.getFixed().bytes(), fixedType.bytes());
      assertSame(foo.getFixed().bytes(), fixedType.bytes());
      assertTrue(foo.hasFixed());
      assertEquals(foo.toString(), "{fixed=" + fixedType.bytes() + '}');
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        assertSame(fooClone.getFixed(), foo.getFixed());
        fooClone.removeFixed();
        assertTrue(foo.hasFixed());
        assertEquals(foo.getFixed(), fixedType);
        assertFalse(fooClone.hasFixed());

        // copy
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        assertNotSame(fooCopy.getFixed(), foo.getFixed());
        fooCopy.removeFixed();
        assertTrue(foo.hasFixed());
        assertEquals(foo.getFixed(), fixedType);
        assertFalse(fooCopy.hasFixed());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeFixed();
      assertFalse(foo.hasFixed());
      assertEquals(foo.toString(), "{}");
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataMap(), ByteString.empty(), ByteString.copyAvroString("abc", false));

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("fixed", bad);
      Exception exc = null;
      try
      {
        foo.getFixed();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    List<?> castFrom = TestUtil.asList("8888");
    List<?> castTo = TestUtil.asList(ByteString.copyAvroString("8888", false));
    for (int i = 0; i < castFrom.size(); ++i)
    {
      map.put("fixed", castFrom.get(i));
      ByteString result = foo.getFixed().bytes();
      assertEquals(result, castTo.get(i));
    }
  }

  @Test
  public void testBarField()
  {
    List<Bar> good = Arrays.asList(new Bar(), new Bar(), new Bar());
    Foo foo = new Foo();
    int index = 0;
    for (Bar bar : good)
    {
      int value = index * index;
      bar.setInt(value);
      foo.setRecord(bar);
      assertEquals(foo.getRecord(), bar);
      assertSame(foo.getRecord(), bar);
      assertTrue(foo.hasRecord());
      assertEquals(foo.toString(), "{record={int=" + value + "}}");
      Exception exc = null;
      try
      {
        // clone

        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        assertSame(fooClone.getRecord(), foo.getRecord());
        fooClone.removeRecord();
        assertTrue(foo.hasRecord());
        assertEquals(foo.getRecord(), bar);
        assertFalse(fooClone.hasRecord());

        // copy
        // mutate bar within foo
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        assertNotSame(fooCopy.getRecord(), foo.getRecord());
        Integer origValue = fooCopy.getRecord().getInt();
        Integer newValue = origValue + 1;
        fooCopy.getRecord().setInt(newValue);
        assertEquals(fooCopy.getRecord().getInt(), newValue);
        assertEquals(foo.getRecord().getInt(), origValue);

        // copy
        // remove bar
        fooCopy = foo.copy();
        fooCopy.removeRecord();
        assertTrue(foo.hasRecord());
        assertEquals(foo.getRecord(), bar);
        assertFalse(fooCopy.hasRecord());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeRecord();
      assertFalse(foo.hasRecord());
      assertEquals(foo.toString(), "{}");
      index++;
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataList());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("record", bad);
      Exception exc = null;
      try
      {
        foo.getRecord();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    Exception exc = null;
    try
    {
      foo.setRecord(new Bar() { });

    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof ClassCastException);
  }

  @Test
  public void testIntegerArrayField()
  {
    List<IntegerArray> good = Arrays.asList(new IntegerArray(), new IntegerArray(), new IntegerArray());
    Foo foo = new Foo();
    int index = 0;
    for (IntegerArray integerArray : good)
    {
      int value = index * index;
      integerArray.add(value);
      foo.setArray(integerArray);
      assertEquals(foo.getArray(), integerArray);
      assertSame(foo.getArray(), integerArray);
      assertTrue(foo.hasArray());
      assertEquals(foo.toString(), "{array=[" + value + "]}");
      Exception exc = null;
      try
      {
        // clone
        Foo fooClone = foo.clone();
        assertEquals(foo, fooClone);
        assertSame(fooClone.getArray(), foo.getArray());
        fooClone.removeArray();
        assertTrue(foo.hasArray());
        assertEquals(foo.getArray(), integerArray);
        assertFalse(fooClone.hasArray());

        // copy
        // mutate array within foo
        Foo fooCopy = foo.copy();
        assertEquals(foo, fooCopy);
        assertTrue(TestUtil.noCommonDataComplex(fooCopy.data(), foo.data()));
        assertNotSame(fooCopy.getArray(), foo.getArray());
        Integer origValue = foo.getArray().get(0);
        Integer newValue = origValue + 1;
        fooCopy.getArray().set(0, newValue);
        assertEquals(fooCopy.getArray().get(0), newValue);
        assertEquals(foo.getArray().get(0), origValue);

        // copy
        // remove array within foo
        fooCopy = foo.copy();
        fooCopy.removeArray();
        assertTrue(foo.hasArray());
        assertEquals(foo.getArray(), integerArray);
        assertFalse(fooCopy.hasArray());
      }
      catch (CloneNotSupportedException e)
      {
        exc = e;
      }
      assertTrue(exc == null);
      foo.removeArray();
      assertFalse(foo.hasArray());
      assertEquals(foo.toString(), "{}");
      index++;
    }

    List<?> badInput = TestUtil.asList(false, "abc", new DataMap());

    DataMap map = new DataMap();
    foo = new Foo(map);
    for (Object bad : badInput)
    {
      map.put("array", bad);
      Exception exc = null;
      try
      {
        foo.getArray();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }
  }

  @Test
  public void testUnionField() throws CloneNotSupportedException
  {
    List<?> badOutput = TestUtil.asList(false, "abc", new DataList());

    DataMap map = new DataMap();
    Foo foo = new Foo(map);
    for (Object bad : badOutput)
    {
      map.put("union", bad);
      Exception exc = null;
      try
      {
        foo.getUnion();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    // test memberType
    List<Object> badOutputMap = new ArrayList<Object>();
    badOutputMap.add(Data.NULL);
    badOutputMap.add(new DataMap());
    badOutputMap.add(new DataMap(TestUtil.asMap("int", 1, "invalid", 2)));
    badOutputMap.add(new DataMap(TestUtil.asMap("invalid", 2)));
    for (Object bad : badOutputMap)
    {
      map.put("union", bad);
      Exception exc = null;
      try
      {
        foo.getUnion().memberType();
      }
      catch (Exception e)
      {
        exc = e;
      }
      assertTrue(exc != null);
      assertTrue(exc instanceof TemplateOutputCastException);
    }

    // test union accessing underlying map
    DataMap unionMap = new DataMap();
    Integer value = 4;
    unionMap.put("int", value);
    map.put("union", unionMap);
    Foo.Union union2 = foo.getUnion();
    assertFalse(union2.isNull());
    assertTrue(union2.isInt());
    assertEquals(union2.getInt(), value);
    assertSame(union2.memberType(), Foo.Union.MEMBER_int);
    assertNull(union2.getBar());
    int lastHashCode = union2.hashCode();
    Foo.Union lastUnion = union2.clone();

    // test union set and get wrapped
    unionMap.clear();
    value = 32;
    Bar bar = new Bar();
    bar.setInt(value.intValue());
    union2.setBar(bar);
    assertFalse(union2.isNull());
    assertTrue(union2.isBar());
    assertEquals(union2.getBar().getInt(), value);
    assertSame(union2.memberType(), Foo.Union.MEMBER_Bar);
    assertNull(union2.getInt());
    assertTrue(union2.equals(union2));
    assertNotNull(union2);
    assertFalse(union2.equals(new Object()));
    int hashCode = union2.hashCode();
    assertFalse(hashCode == lastHashCode);
    lastHashCode = hashCode;
    assertFalse(union2.equals(lastUnion));
    lastUnion = union2.clone();

    // test union clone with wrapped member
    Exception exc;
    try
    {
      exc = null;
      Foo.Union unionClone = union2.clone();
      assertFalse(unionClone.isNull());
      assertFalse(unionClone.isInt());
      assertTrue(unionClone.isBar());
      assertEquals(unionClone.getBar().getInt(), value);
      assertSame(unionClone.getBar(), union2.getBar());
      assertEquals(unionClone.getBar(), union2.getBar());
      assertEquals(unionClone, union2);
    }
    catch (CloneNotSupportedException e)
    {
      exc = e;
    }
    assertTrue(exc == null);

    // test union copy with wrapped member
    try
    {
      Integer origValue = union2.getBar().getInt();
      Foo.Union unionCopy = union2.copy();
      assertEquals(union2, unionCopy);
      Integer newValue = origValue + 1;
      unionCopy.getBar().setInt(newValue);
      assertTrue(union2.isBar());
      assertTrue(unionCopy.isBar());
      assertEquals(unionCopy.getBar().getInt(), newValue);
      assertEquals(union2.getBar().getInt(), origValue);
      assertFalse(union2.equals(unionCopy));
      assertFalse(union2.getBar().equals(unionCopy.getBar()));

      unionCopy = union2.copy();
      unionCopy.setEnumType(EnumType.APPLE);
      assertTrue(union2.isBar());
      assertEquals(union2.getBar().getInt(), origValue);
      assertTrue(unionCopy.isEnumType());
      assertSame(unionCopy.getEnumType(), EnumType.APPLE);
    }
    catch (CloneNotSupportedException e)
    {
      exc = e;
    }
    assertTrue(exc == null);

    // test set bad wrapped
    try
    {
      exc = null;
      union2.setBar(new Bar() {});
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof ClassCastException);

    // test union set and get direct
    value = 127;
    union2.setInt(127);
    assertFalse(union2.isNull());
    assertTrue(union2.isInt());
    assertEquals(union2.getInt(), value);
    assertSame(union2.memberType(), Foo.Union.MEMBER_int);
    assertEquals(union2.toString(), "{int=127}");
    assertNull(union2.getBar());
    assertTrue(union2.equals(union2));
    assertNotNull(union2);
    assertFalse(union2.equals(new Object()));
    hashCode = union2.hashCode();
    assertFalse(hashCode == lastHashCode);
    assertFalse(union2.equals(lastUnion));
    union2.clone();

    // test union clone with direct member
    try
    {
      exc = null;
      Foo.Union unionClone = union2.clone();
      assertFalse(unionClone.isNull());
      assertTrue(unionClone.isInt());
      assertFalse(unionClone.isBar());
      assertEquals(unionClone.getInt(), value);
      assertEquals(unionClone.getInt(), union2.getInt());
      assertSame(unionClone.getInt(), union2.getInt());
      assertEquals(unionClone, union2);
      Integer newValue = 256;
      unionClone.setInt(newValue.intValue());
      assertEquals(unionClone.getInt(), newValue);
      assertEquals(union2.getInt(), value);
    }
    catch (CloneNotSupportedException e)
    {
      exc = e;
    }
    assertTrue(exc == null);

    // test union copy with direct member
    try
    {
      exc = null;
      Foo.Union unionCopy = union2.copy();
      assertEquals(union2, unionCopy);
      assertTrue(union2.isInt());
      Integer origValue = union2.getInt();
      Integer newValue = origValue + 1;
      unionCopy.setInt(newValue);
      assertTrue(unionCopy.isInt());
      assertEquals(unionCopy.getInt(), newValue);
      assertEquals(union2.getInt(), origValue);
      assertFalse(union2.equals(unionCopy));

      // change type
      unionCopy = union2.copy();
      unionCopy.setEnumType(EnumType.APPLE);
      assertTrue(unionCopy.isEnumType());
      assertSame(unionCopy.getEnumType(), EnumType.APPLE);
      assertTrue(union2.isInt());
      assertEquals(union2.getInt(), origValue);
    }
    catch (CloneNotSupportedException e)
    {
      exc = e;
    }
    assertTrue(exc == null);

    // test null union
    foo.setUnion(new Foo.Union());
    Foo.Union union = foo.getUnion();
    assertTrue(union.isNull());
    assertFalse(union.isInt());
    assertFalse(union.isBar());
    assertEquals(union.toString(), Data.NULL.toString());
    assertSame(union.data(), Data.NULL);
    try
    {
      // clone
      exc = null;
      Foo.Union unionClone = union.clone();
      assertTrue(unionClone.isNull());
      assertFalse(unionClone.isInt());
      assertFalse(unionClone.isBar());
      assertEquals(unionClone.toString(), Data.NULL.toString());
      assertSame(unionClone.data(), Data.NULL);

      // copy
      Foo.Union unionCopy = union.copy();
      assertTrue(unionCopy.isNull());
      assertFalse(unionCopy.isInt());
      assertFalse(unionCopy.isBar());
      assertEquals(unionCopy.toString(), Data.NULL.toString());
      assertSame(unionCopy.data(), Data.NULL);
    }
    catch (CloneNotSupportedException e)
    {
      exc = e;
    }
    assertTrue(exc == null);

    // test null unions throw exception on get and set methods.
    try
    {
      exc = null;
      union.getInt();
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullUnionUnsupportedOperationException);

    try
    {
      exc = null;
      union.setInt(4);
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullUnionUnsupportedOperationException);

    try
    {
      exc = null;
      union.getBar();
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullUnionUnsupportedOperationException);

    try
    {
      exc = null;
      union.setBar(new Bar());
    }
    catch (Exception e)
    {
      exc = e;
    }
    assertTrue(exc != null);
    assertTrue(exc instanceof NullUnionUnsupportedOperationException);

    // test legacy
    union = new Foo.Union(new DataMap());
    Integer i = 43;
    union.set2Int(i.intValue()); // legacy set
    assertTrue(union.isInt());
    assertEquals(union.getInt(), i);
    assertFalse(union.isEnumType());
    assertNull(union.getEnumType());

    union.set2EnumType(EnumType.ORANGE); // legacy set
    assertTrue(union.isEnumType());
    assertSame(union.getEnumType(), EnumType.ORANGE);
    assertFalse(union.isInt());
    assertNull(union.getInt());

    union.set2EnumType(EnumType.APPLE); // legacy set
    assertTrue(union.isEnumType());
    assertSame(union.getEnumType(), EnumType.APPLE);
    assertFalse(union.isInt());
    assertNull(union.getInt());

    i = 66;
    union.set2Int(i.intValue()); // legacy set
    assertTrue(union.isInt());
    assertEquals(union.getInt(), i);
    assertFalse(union.isEnumType());
    assertNull(union.getEnumType());
  }

  @Test
  public void testWrapping()
      throws InstantiationException, IllegalAccessException
  {
    DataMap map1 = new DataMap();
    Foo foo = DataTemplateUtil.wrap(map1, Foo.class);
    assertSame(map1, foo.data());

    DataMap map2 = new DataMap();
    Foo foo2 = DataTemplateUtil.wrap(map2, Foo.SCHEMA, Foo.class);
    assertSame(map2, foo2.data());

    DataMap map3 = new DataMap();
    Foo.Union u3 = DataTemplateUtil.wrap(map3, Foo.Union.class);
    assertSame(map3, u3.data());

    DataMap map4 = new DataMap();
    Foo.Union u4 = DataTemplateUtil.wrap(map4, Foo.Union.SCHEMA, Foo.Union.class);
    assertSame(map4, u4.data());

    Foo.Union u5 = DataTemplateUtil.wrap(null, Foo.Union.class);
    assertSame(Data.NULL, u5.data());

    Foo.Union u6 = DataTemplateUtil.wrap(null, Foo.Union.SCHEMA, Foo.Union.class);
    assertSame(Data.NULL, u6.data());

    Foo.Union u7 = DataTemplateUtil.wrap(Data.NULL, Foo.Union.class);
    assertSame(Data.NULL, u7.data());

    Foo.Union u8 = DataTemplateUtil.wrap(Data.NULL, Foo.Union.SCHEMA, Foo.Union.class);
    assertSame(Data.NULL, u8.data());
  }
}