/*
 * 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.ignite.internal.binary;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;
import org.apache.ignite.IgniteBinary;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.IgniteCheckedException;
import org.apache.ignite.binary.BinaryObject;
import org.apache.ignite.binary.BinaryObjectBuilder;
import org.apache.ignite.binary.BinaryObjectException;
import org.apache.ignite.binary.BinaryType;
import org.apache.ignite.configuration.BinaryConfiguration;
import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.internal.MarshallerPlatformIds;
import org.apache.ignite.internal.binary.builder.BinaryBuilderEnum;
import org.apache.ignite.internal.binary.builder.BinaryObjectBuilderImpl;
import org.apache.ignite.internal.binary.mutabletest.GridBinaryMarshalerAwareTestClass;
import org.apache.ignite.internal.binary.mutabletest.GridBinaryTestClasses;
import org.apache.ignite.internal.binary.test.GridBinaryTestClass2;
import org.apache.ignite.internal.processors.cache.binary.CacheObjectBinaryProcessorImpl;
import org.apache.ignite.internal.processors.cache.binary.IgniteBinaryImpl;
import org.apache.ignite.internal.util.lang.GridMapEntry;
import org.apache.ignite.marshaller.MarshallerContext;
import org.apache.ignite.testframework.GridTestUtils;
import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
import org.junit.Assert;
import org.junit.Test;

import static org.apache.ignite.cache.CacheMode.PARTITIONED;
import static org.apache.ignite.cache.CacheMode.REPLICATED;

/**
 *
 */
public class BinaryObjectBuilderAdditionalSelfTest extends GridCommonAbstractTest {
    /** {@inheritDoc} */
    @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception {
        IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);

        CacheConfiguration cacheCfg = new CacheConfiguration(DEFAULT_CACHE_NAME);
        cacheCfg.setCacheMode(REPLICATED);

        CacheConfiguration cacheCfg2 = new CacheConfiguration("partitioned");
        cacheCfg2.setCacheMode(PARTITIONED);

        cfg.setCacheConfiguration(cacheCfg, cacheCfg2);

        BinaryConfiguration bCfg = new BinaryConfiguration();

        bCfg.setCompactFooter(compactFooter());

        bCfg.setClassNames(Arrays.asList("org.apache.ignite.internal.binary.mutabletest.*"));

        cfg.setMarshaller(new BinaryMarshaller());

        return cfg;
    }

    /** {@inheritDoc} */
    @Override protected void beforeTestsStarted() throws Exception {
        startGrids(1);
    }

    /** {@inheritDoc} */
    @Override protected void afterTest() throws Exception {
        jcache(0).clear();
    }

    /**
     * @return Compact footer.
     */
    protected boolean compactFooter() {
        return true;
    }

    /**
     * @return Binaries API.
     */
    protected IgniteBinary binaries() {
        return grid(0).binary();
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testSimpleTypeFieldRead() throws Exception {
        GridBinaryTestClasses.TestObjectAllTypes exp = new GridBinaryTestClasses.TestObjectAllTypes();

        exp.setDefaultData();

        BinaryObjectBuilder mutPo = wrap(exp);

        for (Field field : GridBinaryTestClasses.TestObjectAllTypes.class.getDeclaredFields()) {
            Object expVal = field.get(exp);
            Object actVal = mutPo.getField(field.getName());

            switch (field.getName()) {
                case "anEnum":
                    assertEquals(((BinaryBuilderEnum)actVal).getOrdinal(), ((Enum)expVal).ordinal());
                    break;

                case "enumArr": {
                    BinaryBuilderEnum[] actArr = (BinaryBuilderEnum[])actVal;
                    Enum[] expArr = (Enum[])expVal;

                    assertEquals(expArr.length, actArr.length);

                    for (int i = 0; i < actArr.length; i++)
                        assertEquals(expArr[i].ordinal(), actArr[i].getOrdinal());

                    break;
                }
            }
        }
    }

    /**
     *
     */
    @Test
    public void testSimpleTypeFieldSerialize() {
        GridBinaryTestClasses.TestObjectAllTypes exp = new GridBinaryTestClasses.TestObjectAllTypes();

        exp.setDefaultData();

        BinaryObjectBuilderImpl mutPo = wrap(exp);

        GridBinaryTestClasses.TestObjectAllTypes res = mutPo.build().deserialize();

        GridTestUtils.deepEquals(exp, res);
    }

    /**
     * @throws Exception If any error occurs.
     */
    @Test
    public void testSimpleTypeFieldOverride() throws Exception {
        GridBinaryTestClasses.TestObjectAllTypes exp = new GridBinaryTestClasses.TestObjectAllTypes();

        exp.setDefaultData();

        BinaryObjectBuilderImpl mutPo = wrap(new GridBinaryTestClasses.TestObjectAllTypes());

        for (Field field : GridBinaryTestClasses.TestObjectAllTypes.class.getDeclaredFields())
            mutPo.setField(field.getName(), field.get(exp));

        GridBinaryTestClasses.TestObjectAllTypes res = mutPo.build().deserialize();

        GridTestUtils.deepEquals(exp, res);
    }

    /**
     * @throws Exception If any error occurs.
     */
    @Test
    public void testSimpleTypeFieldSetNull() throws Exception {
        GridBinaryTestClasses.TestObjectAllTypes exp = new GridBinaryTestClasses.TestObjectAllTypes();

        exp.setDefaultData();

        BinaryObjectBuilderImpl mutPo = wrap(exp);

        for (Field field : GridBinaryTestClasses.TestObjectAllTypes.class.getDeclaredFields()) {
            if (!field.getType().isPrimitive())
                mutPo.setField(field.getName(), null);
        }

        GridBinaryTestClasses.TestObjectAllTypes res = mutPo.build().deserialize();

        for (Field field : GridBinaryTestClasses.TestObjectAllTypes.class.getDeclaredFields()) {
            if (!field.getType().isPrimitive())
                assertNull(field.getName(), field.get(res));
        }
    }

    /**
     * @throws IgniteCheckedException If any error occurs.
     */
    @Test
    public void testMakeCyclicDependency() throws IgniteCheckedException {
        GridBinaryTestClasses.TestObjectOuter outer = new GridBinaryTestClasses.TestObjectOuter();
        outer.inner = new GridBinaryTestClasses.TestObjectInner();

        BinaryObjectBuilderImpl mutOuter = wrap(outer);

        BinaryObjectBuilderImpl mutInner = mutOuter.getField("inner");

        mutInner.setField("outer", mutOuter);
        mutInner.setField("foo", mutInner);

        GridBinaryTestClasses.TestObjectOuter res = mutOuter.build().deserialize();

        assertEquals(res, res.inner.outer);
        assertEquals(res.inner, res.inner.foo);
    }

    /**
     *
     */
    @Test
    public void testDateArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.dateArr = new Date[] {new Date(11111), new Date(11111), new Date(11111)};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Date[] arr = mutObj.getField("dateArr");
        arr[0] = new Date(22222);

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new Date[] {new Date(22222), new Date(11111), new Date(11111)}, res.dateArr);
    }

    /**
     *
     */
    @Test
    public void testTimestampArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.tsArr = new Timestamp[] {new Timestamp(111222333), new Timestamp(222333444)};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Timestamp[] arr = mutObj.getField("tsArr");
        arr[0] = new Timestamp(333444555);

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new Timestamp[] {new Timestamp(333444555), new Timestamp(222333444)}, res.tsArr);
    }

    /**
     *
     */
    @Test
    public void testUUIDArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.uuidArr = new UUID[] {new UUID(1, 1), new UUID(1, 1), new UUID(1, 1)};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        UUID[] arr = mutObj.getField("uuidArr");
        arr[0] = new UUID(2, 2);

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new UUID[] {new UUID(2, 2), new UUID(1, 1), new UUID(1, 1)}, res.uuidArr);
    }

    /**
     *
     */
    @Test
    public void testDecimalArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.bdArr = new BigDecimal[] {new BigDecimal(1000), new BigDecimal(1000), new BigDecimal(1000)};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        BigDecimal[] arr = mutObj.getField("bdArr");
        arr[0] = new BigDecimal(2000);

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new BigDecimal[] {new BigDecimal(1000), new BigDecimal(1000), new BigDecimal(1000)},
            res.bdArr);
    }

    /**
     *
     */
    @Test
    public void testBooleanArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.zArr = new boolean[] {false, false, false};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        boolean[] arr = mutObj.getField("zArr");
        arr[0] = true;

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        boolean[] expected = new boolean[] {true, false, false};

        assertEquals(expected.length, res.zArr.length);

        for (int i = 0; i < expected.length; i++)
            assertEquals(expected[i], res.zArr[i]);
    }

    /**
     *
     */
    @Test
    public void testCharArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.cArr = new char[] {'a', 'a', 'a'};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        char[] arr = mutObj.getField("cArr");
        arr[0] = 'b';

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new char[] {'b', 'a', 'a'}, res.cArr);
    }

    /**
     *
     */
    @Test
    public void testDoubleArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.dArr = new double[] {1.0, 1.0, 1.0};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        double[] arr = mutObj.getField("dArr");
        arr[0] = 2.0;

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new double[] {2.0, 1.0, 1.0}, res.dArr, 0);
    }

    /**
     *
     */
    @Test
    public void testFloatArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.fArr = new float[] {1.0f, 1.0f, 1.0f};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        float[] arr = mutObj.getField("fArr");
        arr[0] = 2.0f;

        BinaryObject resBinary = mutObj.build();

        GridBinaryTestClasses.TestObjectAllTypes res = resBinary.deserialize();

        Assert.assertArrayEquals(new float[] {2.0f, 1.0f, 1.0f}, res.fArr, 0);
    }

    /**
     *
     */
    @Test
    public void testLongArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.lArr = new long[] {1, 1, 1};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        long[] arr = mutObj.getField("lArr");
        arr[0] = 2;

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new long[] {2, 1, 1}, res.lArr);
    }

    /**
     *
     */
    @Test
    public void testIntArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.iArr = new int[] {1, 1, 1};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        int[] arr = mutObj.getField("iArr");
        arr[0] = 2;

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new int[] {2, 1, 1}, res.iArr);
    }

    /**
     *
     */
    @Test
    public void testShortArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.sArr = new short[] {1, 1, 1};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        short[] arr = mutObj.getField("sArr");
        arr[0] = 2;

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new short[] {2, 1, 1}, res.sArr);
    }

    /**
     *
     */
    @Test
    public void testByteArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.bArr = new byte[] {1, 1, 1};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        byte[] arr = mutObj.getField("bArr");
        arr[0] = 2;

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new byte[] {2, 1, 1}, res.bArr);
    }

    /**
     *
     */
    @Test
    public void testStringArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.strArr = new String[] {"a", "a", "a"};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        String[] arr = mutObj.getField("strArr");
        arr[0] = "b";

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new String[] {"b", "a", "a"}, res.strArr);
    }

    /**
     *
     */
    @Test
    public void testModifyObjectArray() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = new Object[] {"a"};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Object[] arr = mutObj.getField("foo");

        Assert.assertArrayEquals(new Object[] {"a"}, arr);

        arr[0] = "b";

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new Object[] {"b"}, (Object[])res.foo);
    }

    /**
     *
     */
    @Test
    public void testOverrideObjectArrayField() {
        BinaryObjectBuilderImpl mutObj = wrap(new GridBinaryTestClasses.TestObjectContainer());

        Object[] createdArr = {mutObj, "a", 1, new String[] {"s", "s"}, new byte[] {1, 2}, new UUID(3, 0)};

        mutObj.setField("foo", createdArr.clone(), Object.class);

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        createdArr[0] = res;

        assertTrue(Objects.deepEquals(createdArr, res.foo));
    }

    /**
     *
     */
    @Test
    public void testDeepArray() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = new Object[] {new Object[] {"a", obj}};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Object[] arr = (Object[])mutObj.<Object[]>getField("foo")[0];

        assertEquals("a", arr[0]);
        assertSame(mutObj, arr[1]);

        arr[0] = mutObj;

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        arr = (Object[])((Object[])res.foo)[0];

        assertSame(arr[0], res);
        assertSame(arr[0], arr[1]);
    }

    /**
     *
     */
    @Test
    public void testArrayListRead() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Lists.newArrayList(obj, "a");

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        List<Object> list = mutObj.getField("foo");

        assert list.equals(Lists.newArrayList(mutObj, "a"));
    }

    /**
     *
     */
    @Test
    public void testArrayListOverride() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        ArrayList<Object> list = Lists.newArrayList(mutObj, "a", Lists.newArrayList(1, 2));

        mutObj.setField("foo", list, Object.class);

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        list.set(0, res);

        assertNotSame(list, res.foo);
        assertEquals(list, res.foo);
    }

    /**
     *
     */
    @Test
    public void testArrayListModification() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Lists.newArrayList("a", "b", "c");

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        List<String> list = mutObj.getField("foo");

        list.add("!"); // "a", "b", "c", "!"
        list.add(0, "_"); // "_", "a", "b", "c", "!"

        String s = list.remove(1); // "_", "b", "c", "!"
        assertEquals("a", s);

        assertEquals(Arrays.asList("c", "!"), list.subList(2, 4));
        assertEquals(1, list.indexOf("b"));
        assertEquals(1, list.lastIndexOf("b"));

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        assertTrue(res.foo instanceof ArrayList);
        assertEquals(Arrays.asList("_", "b", "c", "!"), res.foo);
    }

    /**
     *
     */
    @Test
    public void testArrayListClear() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Lists.newArrayList("a", "b", "c");

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        List<String> list = mutObj.getField("foo");

        list.clear();

        Assert.assertEquals(Collections.emptyList(), mutObj.build().<GridBinaryTestClasses.TestObjectContainer>deserialize().foo);
    }

    /**
     *
     */
    @Test
    public void testArrayListWriteUnmodifiable() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        ArrayList<Object> src = Lists.newArrayList(obj, "a", "b", "c");

        obj.foo = src;

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        GridBinaryTestClasses.TestObjectContainer deserialized = mutObj.build().deserialize();

        List<Object> res = (List<Object>)deserialized.foo;

        src.set(0, deserialized);

        assertEquals(src, res);
    }

    /**
     *
     */
    @Test
    public void testLinkedListRead() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Lists.newLinkedList(Arrays.asList(obj, "a"));

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        List<Object> list = mutObj.getField("foo");

        assert list.equals(Lists.newLinkedList(Arrays.asList(mutObj, "a")));
    }

    /**
     *
     */
    @Test
    public void testLinkedListOverride() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        List<Object> list = Lists.newLinkedList(Arrays.asList(mutObj, "a", Lists.newLinkedList(Arrays.asList(1, 2))));

        mutObj.setField("foo", list, Object.class);

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        list.set(0, res);

        assertNotSame(list, res.foo);
        assertEquals(list, res.foo);
    }

    /**
     *
     */
    @Test
    public void testLinkedListModification() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        obj.foo = Lists.newLinkedList(Arrays.asList("a", "b", "c"));

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        List<String> list = mutObj.getField("foo");

        list.add("!"); // "a", "b", "c", "!"
        list.add(0, "_"); // "_", "a", "b", "c", "!"

        String s = list.remove(1); // "_", "b", "c", "!"
        assertEquals("a", s);

        assertEquals(Arrays.asList("c", "!"), list.subList(2, 4));
        assertEquals(1, list.indexOf("b"));
        assertEquals(1, list.lastIndexOf("b"));

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        assertTrue(res.foo instanceof LinkedList);
        assertEquals(Arrays.asList("_", "b", "c", "!"), res.foo);
    }

    /**
     *
     */
    @Test
    public void testLinkedListWriteUnmodifiable() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        LinkedList<Object> src = Lists.newLinkedList(Arrays.asList(obj, "a", "b", "c"));

        obj.foo = src;

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        GridBinaryTestClasses.TestObjectContainer deserialized = mutObj.build().deserialize();

        List<Object> res = (List<Object>)deserialized.foo;

        src.set(0, deserialized);

        assertEquals(src, res);
    }

    /**
     *
     */
    @Test
    public void testHashSetRead() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Sets.newHashSet(obj, "a");

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Set<Object> set = mutObj.getField("foo");

        assert set.equals(Sets.newHashSet(mutObj, "a"));
    }

    /**
     *
     */
    @Test
    public void testHashSetOverride() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Set<Object> c = Sets.newHashSet(mutObj, "a", Sets.newHashSet(1, 2));

        mutObj.setField("foo", c, Object.class);

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        c.remove(mutObj);
        c.add(res);

        assertNotSame(c, res.foo);
        assertEquals(c, res.foo);
    }

    /**
     *
     */
    @Test
    public void testHashSetModification() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Sets.newHashSet("a", "b", "c");

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Set<String> set = mutObj.getField("foo");

        set.remove("b");
        set.add("!");

        assertEquals(Sets.newHashSet("a", "!", "c"), set);
        assertTrue(set.contains("a"));
        assertTrue(set.contains("!"));

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        assertTrue(res.foo instanceof HashSet);
        assertEquals(Sets.newHashSet("a", "!", "c"), res.foo);
    }

    /**
     *
     */
    @Test
    public void testHashSetWriteUnmodifiable() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        Set<Object> src = Sets.newHashSet(obj, "a", "b", "c");

        obj.foo = src;

        GridBinaryTestClasses.TestObjectContainer deserialized = wrap(obj).build().deserialize();

        Set<Object> res = (Set<Object>)deserialized.foo;

        src.remove(obj);
        src.add(deserialized);

        assertEquals(src, res);
    }

    /**
     *
     */
    @Test
    public void testMapRead() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Maps.newHashMap(ImmutableMap.of(obj, "a", "b", obj));

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Map<Object, Object> map = mutObj.getField("foo");

        assert map.equals(ImmutableMap.of(mutObj, "a", "b", mutObj));
    }

    /**
     *
     */
    @Test
    public void testMapOverride() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Map<Object, Object> map = Maps.newHashMap(ImmutableMap.of(mutObj, "a", "b", mutObj));

        mutObj.setField("foo", map, Object.class);

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        assertEquals(ImmutableMap.of(res, "a", "b", res), res.foo);
    }

    /**
     *
     */
    @Test
    public void testMapModification() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Maps.newHashMap(ImmutableMap.of(1, "a", 2, "b"));

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        Map<Object, Object> map = mutObj.getField("foo");

        map.put(3, mutObj);
        Object rmv = map.remove(1);

        assertEquals("a", rmv);

        GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize();

        assertEquals(ImmutableMap.of(2, "b", 3, res), res.foo);
    }

    /**
     *
     */
    @Test
    public void testEnumArrayModification() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();

        obj.enumArr = new GridBinaryTestClasses.TestObjectEnum[] {GridBinaryTestClasses.TestObjectEnum.A, GridBinaryTestClasses.TestObjectEnum.B};

        BinaryObjectBuilderImpl mutObj = wrap(obj);

        BinaryBuilderEnum[] arr = mutObj.getField("enumArr");
        arr[0] = new BinaryBuilderEnum(mutObj.typeId(), GridBinaryTestClasses.TestObjectEnum.B);

        GridBinaryTestClasses.TestObjectAllTypes res = mutObj.build().deserialize();

        Assert.assertArrayEquals(new GridBinaryTestClasses.TestObjectEnum[] {GridBinaryTestClasses.TestObjectEnum.A, GridBinaryTestClasses.TestObjectEnum.B}, res.enumArr);
    }

    /**
     *
     */
    @Test
    public void testEditObjectWithRawData() {
        GridBinaryMarshalerAwareTestClass obj = new GridBinaryMarshalerAwareTestClass();

        obj.s = "a";
        obj.sRaw = "aa";

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        mutableObj.setField("s", "z");

        GridBinaryMarshalerAwareTestClass res = mutableObj.build().deserialize();
        assertEquals("z", res.s);
        assertEquals("aa", res.sRaw);
    }

    /**
     *
     */
    @Test
    public void testHashCode() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        BinaryObject bo = mutableObj.build();

        assertEquals(BinaryArrayIdentityResolver.instance().hashCode(bo), bo.hashCode());
    }

    /**
     *
     */
    @Test
    public void testCollectionsInCollection() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();
        obj.foo = Lists.newArrayList(
            Lists.newArrayList(1, 2),
            Lists.newLinkedList(Arrays.asList(1, 2)),
            Sets.newHashSet("a", "b"),
            Sets.newLinkedHashSet(Arrays.asList("a", "b")),
            Maps.newHashMap(ImmutableMap.of(1, "a", 2, "b")));

        GridBinaryTestClasses.TestObjectContainer deserialized = wrap(obj).build().deserialize();

        assertEquals(obj.foo, deserialized.foo);
    }

    /**
     *
     */
    @Test
    public void testMapEntryOverride() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        mutableObj.setField("foo", new GridMapEntry<>(1, "a"));

        GridBinaryTestClasses.TestObjectContainer res = mutableObj.build().deserialize();

        assertEquals(new GridMapEntry<>(1, "a"), res.foo);
    }

    /**
     *
     */
    @Test
    public void testMetadataChangingDoublePut() {
        BinaryObjectBuilderImpl mutableObj = wrap(new GridBinaryTestClasses.TestObjectContainer());

        mutableObj.setField("xx567", "a");
        mutableObj.setField("xx567", "b");

        mutableObj.build();

        BinaryType metadata = binaries().type(GridBinaryTestClasses.TestObjectContainer.class);

        assertEquals("String", metadata.fieldTypeName("xx567"));
    }

    /**
     *
     */
    @Test
    public void testMetadataChangingDoublePut2() {
        BinaryObjectBuilderImpl mutableObj = wrap(new GridBinaryTestClasses.TestObjectContainer());

        mutableObj.setField("xx567", "a");
        mutableObj.setField("xx567", "b");

        mutableObj.build();

        BinaryType metadata = binaries().type(GridBinaryTestClasses.TestObjectContainer.class);

        assertEquals("String", metadata.fieldTypeName("xx567"));
    }

    /**
     *
     */
    @Test
    public void testMetadataChanging() {
        GridBinaryTestClasses.TestObjectContainer c = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutableObj = wrap(c);

        mutableObj.setField("intField", 1);
        mutableObj.setField("intArrField", new int[] {1});
        mutableObj.setField("arrField", new String[] {"1"});
        mutableObj.setField("strField", "1");
        mutableObj.setField("colField", Lists.newArrayList("1"));
        mutableObj.setField("mapField", Maps.newHashMap(ImmutableMap.of(1, "1")));
        mutableObj.setField("enumField", GridBinaryTestClasses.TestObjectEnum.A);
        mutableObj.setField("enumArrField", new Enum[] {GridBinaryTestClasses.TestObjectEnum.A});

        mutableObj.build();

        BinaryType metadata = binaries().type(c.getClass());

        assertTrue(metadata.fieldNames().containsAll(Arrays.asList("intField", "intArrField", "arrField", "strField",
            "colField", "mapField", "enumField", "enumArrField")));

        assertEquals("int", metadata.fieldTypeName("intField"));
        assertEquals("int[]", metadata.fieldTypeName("intArrField"));
        assertEquals("String[]", metadata.fieldTypeName("arrField"));
        assertEquals("String", metadata.fieldTypeName("strField"));
        assertEquals("Collection", metadata.fieldTypeName("colField"));
        assertEquals("Map", metadata.fieldTypeName("mapField"));
        assertEquals("Enum", metadata.fieldTypeName("enumField"));
        assertEquals("Enum[]", metadata.fieldTypeName("enumArrField"));
    }

    /**
     *
     */
    @Test
    public void testWrongMetadataNullField() {
        BinaryObjectBuilder builder = binaries().builder("SomeType");

        builder.setField("dateField", null);

        builder.setField("objectField", null, Integer.class);

        builder.build();

        try {
            builder = binaries().builder("SomeType");

            builder.setField("dateField", new Date());

            builder.build();
        }
        catch (BinaryObjectException ex) {
            assertTrue(ex.getMessage().startsWith("Wrong value has been set"));
        }

        builder = binaries().builder("SomeType");

        try {
            builder.setField("objectField", new GridBinaryTestClasses.Company());

            builder.build();

            fail("BinaryObjectBuilder accepted wrong metadata");
        }
        catch (BinaryObjectException ex) {
            assertTrue(ex.getMessage().startsWith("Wrong value has been set"));
        }
    }

    /**
     *
     */
    @Test
    public void testWrongMetadataNullField2() {
        BinaryObjectBuilder builder = binaries().builder("SomeType1");

        builder.setField("dateField", null);

        builder.setField("objectField", null, Integer.class);

        BinaryObject obj = builder.build();

        try {
            builder = binaries().builder(obj);

            builder.setField("dateField", new Date());

            builder.build();
        }
        catch (BinaryObjectException ex) {
            assertTrue(ex.getMessage().startsWith("Wrong value has been set"));
        }

        builder = binaries().builder(obj);

        try {
            builder.setField("objectField", new GridBinaryTestClasses.Company());

            builder.build();

            fail("BinaryObjectBuilder accepted wrong metadata");
        }
        catch (BinaryObjectException ex) {
            assertTrue(ex.getMessage().startsWith("Wrong value has been set"));
        }
    }

    /**
     *
     */
    @Test
    public void testCorrectMetadataNullField() {
        BinaryObjectBuilder builder = binaries().builder("SomeType2");

        builder.setField("dateField", null, Date.class);

        builder.setField("objectField", null, GridBinaryTestClasses.Company.class);

        builder.build();

        builder = binaries().builder("SomeType2");

        builder.setField("dateField", new Date());

        builder.setField("objectField", new GridBinaryTestClasses.Company());

        builder.build();

    }

    /**
     *
     */
    @Test
    public void testCorrectMetadataNullField2() {
        BinaryObjectBuilder builder = binaries().builder("SomeType3");

        builder.setField("dateField", null, Date.class);

        builder.setField("objectField", null, GridBinaryTestClasses.Company.class);

        BinaryObject obj = builder.build();

        builder = binaries().builder(obj);

        builder.setField("dateField", new Date());

        builder.setField("objectField", new GridBinaryTestClasses.Company());

        builder.build();
    }

    /**
     *
     */
    @Test
    public void testDateInObjectField() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        obj.foo = new Date();

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        assertEquals(Date.class, mutableObj.getField("foo").getClass());
    }

    /**
     *
     */
    @Test
    public void testTimestampInObjectField() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        obj.foo = new Timestamp(100020003);

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        assertEquals(Timestamp.class, mutableObj.getField("foo").getClass());
    }

    /**
     *
     */
    @Test
    public void testDateInCollection() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        obj.foo = Lists.newArrayList(new Date());

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        assertEquals(Date.class, ((List<?>)mutableObj.getField("foo")).get(0).getClass());
    }

    /**
     *
     */
    @Test
    public void testTimestampInCollection() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        obj.foo = Lists.newArrayList(new Timestamp(100020003));

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        assertEquals(Timestamp.class, ((List<?>)mutableObj.getField("foo")).get(0).getClass());
    }

    /**
     *
     */
    @Test
    public void testDateArrayOverride() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        Date[] arr = {new Date()};

        mutableObj.setField("foo", arr, Object.class);

        GridBinaryTestClasses.TestObjectContainer res = mutableObj.build().deserialize();

        assertEquals(Date[].class, res.foo.getClass());
        assertTrue(Objects.deepEquals(arr, res.foo));
    }

    /**
     *
     */
    @Test
    public void testTimestampArrayOverride() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl mutableObj = wrap(obj);

        Timestamp[] arr = {new Timestamp(100020003)};

        mutableObj.setField("foo", arr, Object.class);

        GridBinaryTestClasses.TestObjectContainer res = mutableObj.build().deserialize();

        assertEquals(Timestamp[].class, res.foo.getClass());
        assertTrue(Objects.deepEquals(arr, res.foo));
    }

    /**
     *
     */
    @Test
    public void testChangeMap() {
        GridBinaryTestClasses.Addresses addrs = new GridBinaryTestClasses.Addresses();

        addrs.addCompany(new GridBinaryTestClasses.Company(1, "Google inc", 100,
            new GridBinaryTestClasses.Address("Saint-Petersburg", "Torzhkovskya", 1, 53), "occupation"));

        addrs.addCompany(new GridBinaryTestClasses.Company(2, "Apple inc", 100,
            new GridBinaryTestClasses.Address("Saint-Petersburg", "Torzhkovskya", 1, 54), "occupation"));

        addrs.addCompany(new GridBinaryTestClasses.Company(3, "Microsoft", 100,
            new GridBinaryTestClasses.Address("Saint-Petersburg", "Torzhkovskya", 1, 55), "occupation"));

        addrs.addCompany(new GridBinaryTestClasses.Company(4, "Oracle", 100,
            new GridBinaryTestClasses.Address("Saint-Petersburg", "Nevskiy", 1, 1), "occupation"));

        BinaryObjectBuilderImpl binaryAddres = wrap(addrs);

        Map<String, BinaryObjectBuilderImpl> map = binaryAddres.getField("companyByStreet");

        BinaryObjectBuilderImpl binaryCompanies = map.get("Torzhkovskya");

        List<BinaryObjectBuilderImpl> binaryCompaniesList = binaryCompanies.getField("companies");

        BinaryObjectBuilderImpl company = binaryCompaniesList.get(0);

        assert "Google inc".equals(company.<String>getField("name"));

        binaryCompaniesList.remove(0);

        GridBinaryTestClasses.Addresses res = binaryAddres.build().deserialize();

        assertEquals(Arrays.asList("Nevskiy", "Torzhkovskya"), new ArrayList<>(res.getCompanyByStreet().keySet()));

        GridBinaryTestClasses.Companies torzhkovskyaCompanies = res.getCompanyByStreet().get("Torzhkovskya");

        assertEquals(2, torzhkovskyaCompanies.size());
        assertEquals("Apple inc", torzhkovskyaCompanies.get(0).name);
    }

    /**
     *
     */
    @Test
    public void testSavingObjectWithNotZeroStart() {
        GridBinaryTestClasses.TestObjectOuter out = new GridBinaryTestClasses.TestObjectOuter();
        GridBinaryTestClasses.TestObjectInner inner = new GridBinaryTestClasses.TestObjectInner();

        out.inner = inner;
        inner.outer = out;

        BinaryObjectBuilderImpl builder = wrap(out);

        BinaryObjectBuilderImpl innerBuilder = builder.getField("inner");

        GridBinaryTestClasses.TestObjectInner res = innerBuilder.build().deserialize();

        assertSame(res, res.outer.inner);
    }

    /**
     *
     */
    @Test
    public void testBinaryObjectField() {
        GridBinaryTestClasses.TestObjectContainer container = new GridBinaryTestClasses.TestObjectContainer(toBinary(new GridBinaryTestClasses.TestObjectArrayList()));

        BinaryObjectBuilderImpl wrapper = wrap(container);

        assertTrue(wrapper.getField("foo") instanceof BinaryObject);

        GridBinaryTestClasses.TestObjectContainer deserialized = wrapper.build().deserialize();
        assertTrue(deserialized.foo instanceof BinaryObject);
    }

    /**
     *
     */
    @Test
    public void testAssignBinaryObject() {
        GridBinaryTestClasses.TestObjectContainer container = new GridBinaryTestClasses.TestObjectContainer();

        BinaryObjectBuilderImpl wrapper = wrap(container);

        wrapper.setField("foo", toBinary(new GridBinaryTestClasses.TestObjectArrayList()));

        GridBinaryTestClasses.TestObjectContainer deserialized = wrapper.build().deserialize();
        assertTrue(deserialized.foo instanceof GridBinaryTestClasses.TestObjectArrayList);
    }

    /**
     *
     */
    @Test
    public void testRemoveFromNewObject() {
        BinaryObjectBuilderImpl wrapper = newWrapper(GridBinaryTestClasses.TestObjectAllTypes.class);

        wrapper.setField("str", "a");

        wrapper.removeField("str");

        Assert.assertNull(wrapper.build().<GridBinaryTestClasses.TestObjectAllTypes>deserialize().str);
    }

    /**
     *
     */
    @Test
    public void testRemoveFromExistingObject() {
        GridBinaryTestClasses.TestObjectAllTypes obj = new GridBinaryTestClasses.TestObjectAllTypes();
        obj.setDefaultData();

        BinaryObjectBuilderImpl wrapper = wrap(toBinary(obj));

        wrapper.removeField("str");

        Assert.assertNull(wrapper.build().<GridBinaryTestClasses.TestObjectAllTypes>deserialize().str);
    }

    /**
     *
     */
    @Test
    public void testCyclicArrays() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        Object[] arr1 = new Object[1];
        Object[] arr2 = new Object[] {arr1};

        arr1[0] = arr2;

        obj.foo = arr1;

        GridBinaryTestClasses.TestObjectContainer res = toBinary(obj).deserialize();

        Object[] resArr = (Object[])res.foo;

        assertSame(((Object[])resArr[0])[0], resArr);
    }

    /**
     *
     */
    @SuppressWarnings("TypeMayBeWeakened")
    @Test
    public void testCyclicArrayList() {
        GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer();

        List<Object> arr1 = new ArrayList<>();
        List<Object> arr2 = new ArrayList<>();

        arr1.add(arr2);
        arr2.add(arr1);

        obj.foo = arr1;

        GridBinaryTestClasses.TestObjectContainer res = toBinary(obj).deserialize();

        List<?> resArr = (List<?>)res.foo;

        assertSame(((List<Object>)resArr.get(0)).get(0), resArr);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testSameBinaryKey() throws Exception {
        IgniteCache<BinaryObject, BinaryObject> replicatedCache =
            jcache(0).withKeepBinary();

        IgniteCache<BinaryObject, BinaryObject> partitionedCache =
            jcache(0, "partitioned").withKeepBinary();

        BinaryObjectBuilder keyBuilder = ignite(0).binary().builder("keyType")
            .setField("F1", "V1");

        BinaryObjectBuilder valBuilder = ignite(0).binary().builder("valueType")
            .setField("F2", "V2")
            .setField("F3", "V3");

        BinaryObject key = keyBuilder.build();
        BinaryObject val = valBuilder.build();

        replicatedCache.put(key, val);
        partitionedCache.put(key, val);

        assertNotNull(replicatedCache.get(key));
        assertNotNull(partitionedCache.get(key));
    }

    /**
     * Ensure that object w/o schema can be re-built.
     */
    @Test
    public void testBuildFromObjectWithoutSchema() {
        BinaryObjectBuilderImpl binBuilder = wrap(new GridBinaryTestClass2());

        BinaryObject binObj = binBuilder.build();

        BinaryObjectBuilderImpl binBuilder2 = wrap(binObj);

        binBuilder2.build();
    }

    /**
     * @param obj Object.
     * @return Object in binary format.
     */
    private BinaryObject toBinary(Object obj) {
        return binaries().toBinary(obj);
    }

    /**
     * @param obj Object.
     * @return GridMutableBinaryObject.
     */
    private BinaryObjectBuilderImpl wrap(Object obj) {
        return BinaryObjectBuilderImpl.wrap(toBinary(obj));
    }

    /**
     * @param aCls Class.
     * @return Wrapper.
     */
    private BinaryObjectBuilderImpl newWrapper(Class<?> aCls) {
        return newWrapper(aCls.getName());
    }

    /**
     * @param typeName Type name.
     * @return Wrapper.
     */
    private BinaryObjectBuilderImpl newWrapper(String typeName) {
        CacheObjectBinaryProcessorImpl processor = (CacheObjectBinaryProcessorImpl)(
            (IgniteBinaryImpl)binaries()).processor();

        return new BinaryObjectBuilderImpl(processor.binaryContext(), processor.typeId(typeName),
            processor.binaryContext().userTypeName(typeName));
    }

    /** */
    private void clearBinaryMeta() {
        BinaryContext binCtx = ((CacheObjectBinaryProcessorImpl)((IgniteBinaryImpl)binaries()).processor()).binaryContext();

        binCtx.unregisterBinarySchemas();
        binCtx.unregisterUserTypeDescriptors();
    }

    /**
     * Check that correct type is stored in binary object.
     */
    @Test
    public void testCollectionsSerialization() {
        final BinaryObjectBuilder root = newWrapper(BigInteger.class);

        final List<Integer> arrList = new ArrayList<>();

        arrList.add(Integer.MAX_VALUE);

        final List<Integer> linkedList = new LinkedList<>();

        linkedList.add(Integer.MAX_VALUE);

        final Set<Integer> hashSet = new HashSet<>();

        hashSet.add(Integer.MAX_VALUE);

        final Set<Integer> linkedHashSet = new LinkedHashSet<>();

        linkedHashSet.add(Integer.MAX_VALUE);

        final Map<String, String> hashMap = new HashMap<>();

        hashMap.put("key", "val");

        final Map<String, String> linkedHashMap = new LinkedHashMap<>();

        linkedHashMap.put("key", "val");

        // collections
        root.setField("arrayList", arrList);
        root.setField("linkedList", linkedList);
        root.setField("hashSet", hashSet);
        root.setField("linkedHashSet", linkedHashSet);

        root.setField("singletonList", Collections.singletonList(Integer.MAX_VALUE), Collection.class);
        root.setField("singletonSet", Collections.singleton(Integer.MAX_VALUE), Collection.class);

        // maps
        root.setField("hashMap", hashMap);
        root.setField("linkedHashMap", linkedHashMap);

        root.setField("singletonMap", Collections.singletonMap("key", "val"), Map.class);

        // objects
        root.setField("asList", Collections.singletonList(Integer.MAX_VALUE));
        root.setField("asSet", Collections.singleton(Integer.MAX_VALUE));
        root.setField("asMap", Collections.singletonMap("key", "val"));
        root.setField("asListHint", Collections.singletonList(Integer.MAX_VALUE), List.class);
        root.setField("asSetHint", Collections.singleton(Integer.MAX_VALUE), Set.class);
        root.setField("asMapHint", (AbstractMap)Collections.singletonMap("key", "val"), AbstractMap.class);

        BinaryObject binaryObj = root.build();

        final String COL = "Collection";
        final String MAP = "Map";
        final String OBJ = "Object";

        assert COL.equals(binaryObj.type().fieldTypeName("arrayList"));
        assert COL.equals(binaryObj.type().fieldTypeName("linkedList"));
        assert COL.equals(binaryObj.type().fieldTypeName("hashSet"));
        assert COL.equals(binaryObj.type().fieldTypeName("linkedHashSet"));
        assert COL.equals(binaryObj.type().fieldTypeName("linkedHashSet"));
        assert COL.equals(binaryObj.type().fieldTypeName("linkedHashSet"));

        assert COL.equals(binaryObj.type().fieldTypeName("singletonList"));
        assert COL.equals(binaryObj.type().fieldTypeName("singletonSet"));

        assert MAP.equals(binaryObj.type().fieldTypeName("singletonMap"));

        assert COL.equals(binaryObj.type().fieldTypeName("asList"));
        assert OBJ.equals(binaryObj.type().fieldTypeName("asSet"));
        assert OBJ.equals(binaryObj.type().fieldTypeName("asMap"));
        assert OBJ.equals(binaryObj.type().fieldTypeName("asListHint"));
        assert OBJ.equals(binaryObj.type().fieldTypeName("asSetHint"));
        assert OBJ.equals(binaryObj.type().fieldTypeName("asMapHint"));
    }

    /**
     * Checks that externalizable value is correctly serialized/deserialized.
     *
     * @throws Exception If failed.
     */
    @Test
    public void testBuilderExternalizable() throws Exception {
        BinaryObjectBuilder builder = newWrapper("TestType");

        final TestObjectExternalizable exp = new TestObjectExternalizable("test");
        final TestObjectExternalizable[] expArr = new TestObjectExternalizable[]{
            new TestObjectExternalizable("test1"), new TestObjectExternalizable("test2")};

        BinaryObject extObj = builder.setField("extVal", exp).setField("extArr", expArr).build();

        assertEquals(exp, extObj.field("extVal"));
        Assert.assertArrayEquals(expArr, (Object[])extObj.field("extArr"));

        builder = extObj.toBuilder();

        extObj = builder.setField("intVal", 10).build();

        assertEquals(exp, extObj.field("extVal"));
        Assert.assertArrayEquals(expArr, (Object[])extObj.field("extArr"));
        assertEquals(Integer.valueOf(10), extObj.field("intVal"));

        builder = extObj.toBuilder();

        extObj = builder.setField("strVal", "some string").build();

        assertEquals(exp, extObj.field("extVal"));
        Assert.assertArrayEquals(expArr, (Object[])extObj.field("extArr"));
        assertEquals(Integer.valueOf(10), extObj.field("intVal"));
        assertEquals("some string", extObj.field("strVal"));
    }

    /**
     * Checks correct serialization/deserialization of enums in builder.
     */
    @Test
    public void testEnum() {
        try {
            BinaryObjectBuilder builder = newWrapper(TestClsWithEnum.class.getName());

            TestEnum[] expArr = {TestEnum.A, TestEnum.B};

            BinaryObject enumObj = builder
                .setField("testEnumA", TestEnum.A)
                .setField("testEnumB", TestEnum.B)
                .setField("testEnumArr", expArr)
                .build();

            Assert.assertSame(TestEnum.A, ((BinaryObject)enumObj.field("testEnumA")).deserialize());
            Assert.assertSame(TestEnum.B, ((BinaryObject)enumObj.field("testEnumB")).deserialize());
            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));

            Assert.assertSame(TestEnum.A, ((TestClsWithEnum)enumObj.deserialize()).testEnumA);
            Assert.assertSame(TestEnum.B, ((TestClsWithEnum)enumObj.deserialize()).testEnumB);
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);

            builder = newWrapper(enumObj.type().typeName());

            enumObj = builder
                .setField("testEnumA", (Object)enumObj.field("testEnumA"))
                .setField("testEnumB", (Object)enumObj.field("testEnumB"))
                .setField("testEnumArr", (Object)enumObj.field("testEnumArr"))
                .build();

            Assert.assertSame(TestEnum.A, ((BinaryObject)enumObj.field("testEnumA")).deserialize());
            Assert.assertSame(TestEnum.B, ((BinaryObject)enumObj.field("testEnumB")).deserialize());
            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));

            Assert.assertSame(TestEnum.A, ((TestClsWithEnum)enumObj.deserialize()).testEnumA);
            Assert.assertSame(TestEnum.B, ((TestClsWithEnum)enumObj.deserialize()).testEnumB);
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);

            builder = newWrapper(enumObj.type().typeName());

            expArr = new TestEnum[0];

            enumObj = builder.setField("testEnumArr", expArr).build();

            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);

            enumObj = builder.setField("testEnumArr", (Object)enumObj.field("testEnumArr")).build();

            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
        }
        finally {
            clearBinaryMeta();
        }
    }

    /** */
    @Test
    public void testEnum2() {
        try {
            BinaryObjectBuilder builder = newWrapper(TestClsWithEnum.class.getName());

            Object[] expArr = new TestEnum[0];

            BinaryObject enumObj = builder.setField("testEnumArr", expArr).build();

            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);

            builder = newWrapper(enumObj.type().typeName());

            enumObj = builder.setField("testEnumArr", (Object)enumObj.field("testEnumArr")).build();

            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);

            expArr = new TestEnum[] {TestEnum.A, TestEnum.B};

            builder = newWrapper(enumObj.type().typeName());

            enumObj = builder.setField("testEnumArr", expArr).build();

            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);

            builder = newWrapper(enumObj.type().typeName());

            enumObj = builder.setField("testEnumArr", (Object)enumObj.field("testEnumArr")).build();

            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
        }
        finally {
            clearBinaryMeta();
        }
    }

    /**
     * Test {@link BinaryObjectBuilder#build()} adds type mapping to the binary marshaller's cache.
     */
    @Test
    public void testMarshallerMappings() throws IgniteCheckedException, ClassNotFoundException {
        String typeName = "TestType";

        int typeId = BinaryContext.defaultIdMapper().typeId(typeName);

        BinaryObjectBuilder builder = newWrapper(typeName);

        builder.build();

        MarshallerContext marshCtx = grid(0).context().marshallerContext();

        String actualTypeName = marshCtx.getClassName(MarshallerPlatformIds.JAVA_ID, typeId);

        assertEquals(typeName, actualTypeName);
    }

    /**
     * @param obj BinaryObject array.
     * @return Deserialized enums.
     */
    private TestEnum[] deserializeEnumBinaryArray(Object obj) {
        Object[] arr = (Object[])obj;

        final TestEnum[] res = new TestEnum[arr.length];

        for (int i = 0; i < arr.length; i++)
            res[i] = ((BinaryObject)arr[i]).deserialize();

        return res;
    }

    /**
     * @throws Exception If fails
     */
    @Test
    public void testBuilderReusage() throws Exception {
        // Check: rewrite null field value.
        BinaryObjectBuilder builder = newWrapper("SimpleCls1");

        builder.setField("f1", null, Object.class);
        assertNull(builder.build().field("f1"));

        builder.setField("f1", "val1");
        assertEquals("val1", builder.build().field("f1"));

        // Check: rewrite non-null field value to null and back.
        builder = newWrapper("SimpleCls2");

        builder.setField("f1", "val1", String.class);
        assertEquals("val1", builder.build().field("f1"));

        builder.setField("f1", null);
        assertNull(builder.build().field("f1"));

        builder.setField("f1", "val2");
        assertEquals("val2", builder.build().field("f1"));
    }

    /**
     *
     */
    private static class TestObjectExternalizable implements Externalizable {
        /** */
        private String val;

        /**
         *
         */
        public TestObjectExternalizable() {
        }

        /**
         * @param val Value.
         */
        public TestObjectExternalizable(final String val) {
            this.val = val;
        }

        /** {@inheritDoc} */
        @Override public void writeExternal(final ObjectOutput out) throws IOException {
            out.writeUTF(val);
        }

        /** {@inheritDoc} */
        @Override public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
            val = in.readUTF();
        }

        /** {@inheritDoc} */
        @Override public boolean equals(final Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;

            final TestObjectExternalizable that = (TestObjectExternalizable)o;

            return val != null ? val.equals(that.val) : that.val == null;
        }

        /** {@inheritDoc} */
        @Override public int hashCode() {
            return val != null ? val.hashCode() : 0;
        }

        /** {@inheritDoc} */
        @Override public String toString() {
            return "TestObjectExternalizable{" +
                "val='" + val + '\'' +
                '}';
        }
    }

    /** Test class with enum and array of enums. */
    public static class TestClsWithEnum {
        /** */
        private final TestEnum testEnumA;

        /** */
        private final TestEnum testEnumB;

        /** */
        private final TestEnum[] testEnumArr;

        /** */
        public TestClsWithEnum(TestEnum testEnumA, TestEnum testEnumB, TestEnum[] testEnumArr) {
            this.testEnumA = testEnumA;
            this.testEnumB = testEnumB;
            this.testEnumArr = testEnumArr;
        }
    }

    /**
     *
     */
    private enum TestEnum {
        /** */
        A {
            /**
             * An empty function is needed so that {@link TestEnum#A}
             * becomes a subclass.
             */
            public void foo() {

            }
        },

        /** */
        B
    }
}