| /* |
| * 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 java.io.Externalizable; |
| import java.io.IOException; |
| import java.io.ObjectInput; |
| import java.io.ObjectOutput; |
| import java.io.Serializable; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationHandler; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Proxy; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.math.RoundingMode; |
| import java.net.InetSocketAddress; |
| import java.sql.Time; |
| import java.sql.Timestamp; |
| import java.util.AbstractQueue; |
| 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.Iterator; |
| 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.Queue; |
| import java.util.TreeMap; |
| import java.util.TreeSet; |
| import java.util.UUID; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentSkipListSet; |
| import java.util.function.Function; |
| import java.util.stream.Collectors; |
| import java.util.stream.IntStream; |
| import com.google.common.collect.ImmutableList; |
| import org.apache.ignite.IgniteCheckedException; |
| import org.apache.ignite.IgniteException; |
| import org.apache.ignite.IgniteSystemProperties; |
| import org.apache.ignite.binary.BinaryBasicIdMapper; |
| import org.apache.ignite.binary.BinaryBasicNameMapper; |
| import org.apache.ignite.binary.BinaryCollectionFactory; |
| import org.apache.ignite.binary.BinaryField; |
| import org.apache.ignite.binary.BinaryIdMapper; |
| import org.apache.ignite.binary.BinaryMapFactory; |
| import org.apache.ignite.binary.BinaryNameMapper; |
| import org.apache.ignite.binary.BinaryObject; |
| import org.apache.ignite.binary.BinaryObjectBuilder; |
| import org.apache.ignite.binary.BinaryObjectException; |
| import org.apache.ignite.binary.BinaryRawReader; |
| import org.apache.ignite.binary.BinaryRawWriter; |
| import org.apache.ignite.binary.BinaryReader; |
| import org.apache.ignite.binary.BinarySerializer; |
| import org.apache.ignite.binary.BinaryType; |
| import org.apache.ignite.binary.BinaryTypeConfiguration; |
| import org.apache.ignite.binary.BinaryWriter; |
| import org.apache.ignite.binary.Binarylizable; |
| import org.apache.ignite.configuration.BinaryConfiguration; |
| import org.apache.ignite.configuration.IgniteConfiguration; |
| import org.apache.ignite.internal.binary.builder.BinaryObjectBuilderImpl; |
| import org.apache.ignite.internal.binary.streams.BinaryHeapInputStream; |
| import org.apache.ignite.internal.binary.streams.BinaryHeapOutputStream; |
| import org.apache.ignite.internal.managers.discovery.GridDiscoveryManager; |
| import org.apache.ignite.internal.managers.systemview.GridSystemViewManager; |
| import org.apache.ignite.internal.managers.systemview.JmxSystemViewExporterSpi; |
| import org.apache.ignite.internal.processors.cache.CacheObjectContext; |
| import org.apache.ignite.internal.processors.platform.utils.PlatformUtils; |
| import org.apache.ignite.internal.util.GridUnsafe; |
| import org.apache.ignite.internal.util.lang.GridMapEntry; |
| import org.apache.ignite.internal.util.lang.IgnitePair; |
| import org.apache.ignite.internal.util.lang.IgniteThrowableConsumer; |
| import org.apache.ignite.internal.util.typedef.F; |
| import org.apache.ignite.internal.util.typedef.T2; |
| import org.apache.ignite.internal.util.typedef.internal.S; |
| import org.apache.ignite.internal.util.typedef.internal.U; |
| import org.apache.ignite.lang.IgniteUuid; |
| import org.apache.ignite.logger.NullLogger; |
| import org.apache.ignite.marshaller.MarshallerContextTestImpl; |
| import org.apache.ignite.spi.discovery.DiscoverySpiCustomMessage; |
| import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; |
| import org.apache.ignite.testframework.GridTestUtils; |
| import org.apache.ignite.testframework.junits.GridTestKernalContext; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| import org.junit.Assert; |
| import org.junit.Test; |
| |
| import static java.nio.charset.StandardCharsets.UTF_8; |
| import static org.apache.ignite.internal.binary.streams.BinaryMemoryAllocator.THREAD_LOCAL; |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertNotEquals; |
| |
| /** |
| * Binary marshaller tests. |
| */ |
| @SuppressWarnings({"OverlyStrongTypeCast", "ConstantConditions"}) |
| public class BinaryMarshallerSelfTest extends AbstractBinaryArraysTest { |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testNull() throws Exception { |
| assertNull(marshalUnmarshal(null)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testByte() throws Exception { |
| assertEquals((byte)100, marshalUnmarshal((byte)100).byteValue()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testShort() throws Exception { |
| assertEquals((short)100, marshalUnmarshal((short)100).shortValue()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testInt() throws Exception { |
| assertEquals(100, marshalUnmarshal(100).intValue()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testLong() throws Exception { |
| assertEquals(100L, marshalUnmarshal(100L).longValue()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testFloat() throws Exception { |
| assertEquals(100.001f, marshalUnmarshal(100.001f), 0); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDouble() throws Exception { |
| assertEquals(100.001d, marshalUnmarshal(100.001d), 0); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testChar() throws Exception { |
| assertEquals((char)100, marshalUnmarshal((char)100).charValue()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBoolean() throws Exception { |
| assertEquals(true, marshalUnmarshal(true).booleanValue()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDecimal() throws Exception { |
| BigDecimal val; |
| |
| assertEquals((val = BigDecimal.ZERO), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MAX_VALUE, 0)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MIN_VALUE, 0)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MAX_VALUE, 8)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MIN_VALUE, 8)), marshalUnmarshal(val)); |
| |
| assertEquals((val = new BigDecimal(new BigInteger("-79228162514264337593543950336"))), marshalUnmarshal(val)); |
| } |
| |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testNegativeScaleDecimal() throws Exception { |
| BigDecimal val; |
| |
| assertEquals((val = BigDecimal.valueOf(Long.MAX_VALUE, -1)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MIN_VALUE, -2)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MAX_VALUE, -3)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MIN_VALUE, -4)), marshalUnmarshal(val)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testNegativeScaleRoundingModeDecimal() throws Exception { |
| BigDecimal val; |
| |
| assertEquals((val = BigDecimal.ZERO.setScale(-1, RoundingMode.HALF_UP)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MAX_VALUE).setScale(-3, RoundingMode.HALF_DOWN)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Long.MIN_VALUE).setScale(-5, RoundingMode.HALF_EVEN)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Integer.MAX_VALUE).setScale(-8, RoundingMode.UP)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Integer.MIN_VALUE).setScale(-10, RoundingMode.DOWN)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Double.MAX_VALUE).setScale(-12, RoundingMode.CEILING)), marshalUnmarshal(val)); |
| assertEquals((val = BigDecimal.valueOf(Double.MIN_VALUE).setScale(-15, RoundingMode.FLOOR)), marshalUnmarshal(val)); |
| } |
| |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testStringVer1() throws Exception { |
| doTestString(false); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testStringVer2() throws Exception { |
| doTestString(true); |
| } |
| |
| /** |
| * @throws Exception If failed |
| */ |
| private void doTestString(boolean ver2) throws Exception { |
| // Ascii check. |
| String str = "ascii0123456789"; |
| assertEquals(str, marshalUnmarshal(str)); |
| |
| byte[] bytes = str.getBytes(UTF_8); |
| assertEquals(str, BinaryUtils.utf8BytesToStr(bytes, 0, bytes.length)); |
| |
| bytes = BinaryUtils.strToUtf8Bytes(str); |
| assertEquals(str, new String(bytes, UTF_8)); |
| |
| // Extended symbols set check set. |
| str = "的的abcdкириллица"; |
| assertEquals(str, marshalUnmarshal(str)); |
| |
| bytes = str.getBytes(UTF_8); |
| assertEquals(str, BinaryUtils.utf8BytesToStr(bytes, 0, bytes.length)); |
| |
| bytes = BinaryUtils.strToUtf8Bytes(str); |
| assertEquals(str, new String(bytes, UTF_8)); |
| |
| // Special symbols check. |
| str = new String(new char[] {0xD800, 'çš„', 0xD800, 0xD800, 0xDC00, 0xDFFF}); |
| if (ver2) { |
| bytes = BinaryUtils.strToUtf8Bytes(str); |
| assertEquals(str, BinaryUtils.utf8BytesToStr(bytes, 0, bytes.length)); |
| } |
| else |
| assertNotEquals(str, marshalUnmarshal(str)); |
| |
| str = new String(new char[] {55296}); |
| if (ver2) { |
| bytes = BinaryUtils.strToUtf8Bytes(str); |
| assertEquals(str, BinaryUtils.utf8BytesToStr(bytes, 0, bytes.length)); |
| } |
| else |
| assertNotEquals(str, marshalUnmarshal(str)); |
| |
| bytes = str.getBytes(UTF_8); |
| assertNotEquals(str, new String(bytes, UTF_8)); |
| |
| bytes = str.getBytes(UTF_8); |
| assertNotEquals(str, BinaryUtils.utf8BytesToStr(bytes, 0, bytes.length)); |
| |
| str = new String(new char[] {0xD801, 0xDC37}); |
| assertEquals(str, marshalUnmarshal(str)); |
| |
| bytes = str.getBytes(UTF_8); |
| assertEquals(str, new String(bytes, UTF_8)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testUuid() throws Exception { |
| UUID uuid = UUID.randomUUID(); |
| |
| assertEquals(uuid, marshalUnmarshal(uuid)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testIgniteUuid() throws Exception { |
| IgniteUuid uuid = IgniteUuid.randomUuid(); |
| |
| assertEquals(uuid, marshalUnmarshal(uuid)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDate() throws Exception { |
| Date date = new Date(); |
| |
| Date val = marshalUnmarshal(date); |
| |
| assertEquals(date, val); |
| assertEquals(Date.class, val.getClass()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testTimestamp() throws Exception { |
| Timestamp ts = new Timestamp(System.currentTimeMillis()); |
| |
| ts.setNanos(999999999); |
| |
| assertEquals(ts, marshalUnmarshal(ts)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testTime() throws Exception { |
| Time time = new Time(System.currentTimeMillis()); |
| assertEquals(time, marshalUnmarshal(time)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testTimeArray() throws Exception { |
| Time[] times = new Time[]{new Time(System.currentTimeMillis()), new Time(123456789)}; |
| assertArrayEquals(times, marshalUnmarshal(times)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testByteArray() throws Exception { |
| byte[] arr = new byte[] {10, 20, 30}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testShortArray() throws Exception { |
| short[] arr = new short[] {10, 20, 30}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testIntArray() throws Exception { |
| int[] arr = new int[] {10, 20, 30}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testLongArray() throws Exception { |
| long[] arr = new long[] {10, 20, 30}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testFloatArray() throws Exception { |
| float[] arr = new float[] {10.1f, 20.1f, 30.1f}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr), 0); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDoubleArray() throws Exception { |
| double[] arr = new double[] {10.1d, 20.1d, 30.1d}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr), 0); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCharArray() throws Exception { |
| char[] arr = new char[] {10, 20, 30}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBooleanArray() throws Exception { |
| boolean[] arr = new boolean[] {true, false, true}; |
| |
| assertBooleanArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDecimalArray() throws Exception { |
| BigDecimal[] arr = new BigDecimal[] {BigDecimal.ZERO, BigDecimal.ONE, BigDecimal.TEN}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testStringArray() throws Exception { |
| String[] arr = new String[] {"str1", "str2", "str3"}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testUuidArray() throws Exception { |
| UUID[] arr = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDateArray() throws Exception { |
| Date[] arr = new Date[] {new Date(11111), new Date(22222), new Date(33333)}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testObjectArray() throws Exception { |
| Object[] arr = new Object[] {1, 2, 3}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| } |
| |
| /** */ |
| @Test |
| public void testBinaryArray() throws IgniteCheckedException { |
| TestClass1[] arr = new TestClass1[] {new TestClass1(), new TestClass1()}; |
| |
| assertArrayEquals(arr, marshalUnmarshal(arr)); |
| |
| Object[] arr1 = new Object[] {arr, arr}; |
| |
| Object[] arr2 = marshalUnmarshal(arr1); |
| |
| Assert.assertSame("Same array should be returned because of HANDLE usage", arr2[0], arr2[1]); |
| |
| assertArrayEquals(arr1, arr2); |
| |
| ArrayFieldClass o1 = new ArrayFieldClass(); |
| |
| o1.arr1 = arr; |
| o1.arr2 = arr; |
| |
| ArrayFieldClass o2 = marshalUnmarshal(o1); |
| |
| Assert.assertSame("Same array should be returned because of HANDLE usage", o2.arr1, o2.arr2); |
| |
| assertArrayEquals(o1.arr1, o2.arr1); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testException() throws Exception { |
| Exception ex = new RuntimeException(); |
| |
| // Checks that Optimize marshaller will be used, because Throwable has writeObject method. |
| // Exception's stacktrace equals to zero-length array by default and generates at Throwable's writeObject method. |
| assertNotEquals(0, marshalUnmarshal(ex).getStackTrace().length); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCollection() throws Exception { |
| testCollection(new ArrayList<Integer>(3)); |
| testCollection(new LinkedHashSet<Integer>()); |
| testCollection(new HashSet<Integer>()); |
| testCollection(new TreeSet<Integer>()); |
| testCollection(new ConcurrentSkipListSet<Integer>()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| private void testCollection(Collection<Integer> col) throws Exception { |
| col.add(1); |
| col.add(2); |
| col.add(3); |
| |
| assertEquals(col, marshalUnmarshal(col)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testMap() throws Exception { |
| testMap(new HashMap<Integer, String>()); |
| testMap(new LinkedHashMap<Integer, String>()); |
| testMap(new TreeMap<Integer, String>()); |
| testMap(new ConcurrentHashMap<Integer, String>()); |
| testMap(new ConcurrentHashMap<Integer, String>()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| private void testMap(Map<Integer, String> map) throws Exception { |
| map.put(1, "str1"); |
| map.put(2, "str2"); |
| map.put(3, "str3"); |
| |
| assertEquals(map, marshalUnmarshal(map)); |
| } |
| |
| /** |
| * Test serialization of custom collections. |
| * |
| * @throws Exception If failed. |
| */ |
| @SuppressWarnings("unchecked") |
| @Test |
| public void testCustomCollections() throws Exception { |
| CustomCollections cc = new CustomCollections(); |
| |
| cc.list.add(1); |
| cc.customList.add(new Value(1)); |
| |
| CustomCollections copiedCc = marshalUnmarshal(cc); |
| |
| assert copiedCc.customList.getClass().equals(CustomArrayList.class); |
| |
| assertEquals(cc.list.size(), copiedCc.list.size()); |
| assertEquals(cc.customList.size(), copiedCc.customList.size()); |
| |
| assertEquals(cc.list.get(0), copiedCc.list.get(0)); |
| assertEquals(cc.customList.get(0), copiedCc.customList.get(0)); |
| } |
| |
| /** |
| * Test serialization of custom collections. |
| * |
| * @throws Exception If failed. |
| */ |
| @SuppressWarnings("unchecked") |
| @Test |
| public void testCustomCollections2() throws Exception { |
| CustomArrayList arrList = new CustomArrayList(); |
| |
| arrList.add(1); |
| |
| Object cp = marshalUnmarshal(arrList); |
| |
| assert cp.getClass().equals(CustomArrayList.class); |
| |
| CustomArrayList customCp = (CustomArrayList)cp; |
| |
| assertEquals(customCp.size(), arrList.size()); |
| |
| assertEquals(customCp.get(0), arrList.get(0)); |
| } |
| |
| /** |
| * Test custom collections with factories. |
| * |
| * @throws Exception If failed. |
| */ |
| @SuppressWarnings("unchecked") |
| @Test |
| public void testCustomCollectionsWithFactory() throws Exception { |
| CustomCollectionsWithFactory cc = new CustomCollectionsWithFactory(); |
| |
| cc.list.add(new DummyHolder(1)); |
| cc.map.put(new DummyHolder(2), new DummyHolder(3)); |
| |
| CustomCollectionsWithFactory copiedCc = marshalUnmarshal(cc); |
| |
| assertEquals(cc.list.size(), copiedCc.list.size()); |
| assertEquals(cc.map.size(), copiedCc.map.size()); |
| |
| assertEquals(cc.list.get(0), copiedCc.list.get(0)); |
| assertEquals(cc.map.get(new DummyHolder(2)), copiedCc.map.get(new DummyHolder(2))); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testExternalizableInEnclosing() throws Exception { |
| SimpleEnclosingObject obj = new SimpleEnclosingObject(); |
| obj.simpl = new SimpleExternalizable("field"); |
| |
| SimpleEnclosingObject other = marshalUnmarshal(obj); |
| |
| assertEquals(((SimpleExternalizable)obj.simpl).field, ((SimpleExternalizable)other.simpl).field); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testMapEntry() throws Exception { |
| Map.Entry<Integer, String> e = new GridMapEntry<>(1, "str1"); |
| |
| assertEquals(e, marshalUnmarshal(e)); |
| |
| Map<Integer, String> map = new HashMap<>(1); |
| |
| map.put(2, "str2"); |
| |
| e = F.firstEntry(map); |
| |
| Map.Entry<Integer, String> e0 = marshalUnmarshal(e); |
| |
| assertEquals(2, e0.getKey().intValue()); |
| assertEquals("str2", e0.getValue()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryObject() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(new BinaryTypeConfiguration(SimpleObject.class.getName()))); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject po0 = marshalUnmarshal(po, marsh); |
| |
| assertTrue(po.hasField("b")); |
| assertTrue(po.hasField("s")); |
| assertTrue(po.hasField("i")); |
| assertTrue(po.hasField("l")); |
| assertTrue(po.hasField("f")); |
| assertTrue(po.hasField("d")); |
| assertTrue(po.hasField("c")); |
| assertTrue(po.hasField("bool")); |
| |
| assertFalse(po.hasField("no_such_field")); |
| |
| assertEquals(obj, po.deserialize()); |
| assertEquals(obj, po0.deserialize()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testEnum() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(new BinaryTypeConfiguration(TestEnum.class.getName()))); |
| |
| assertEquals(TestEnum.B, marshalUnmarshal(TestEnum.B, marsh)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDeclaredBodyEnum() throws Exception { |
| final MarshallerContextTestImpl ctx = new MarshallerContextTestImpl(); |
| ctx.registerClassName((byte)0, 1, EnumObject.class.getName(), false); |
| ctx.registerClassName((byte)0, 2, DeclaredBodyEnum.class.getName(), false); |
| |
| BinaryMarshaller marsh = binaryMarshaller(); |
| marsh.setContext(ctx); |
| |
| EnumObject obj = new EnumObject(1L, "test 1", DeclaredBodyEnum.TWO); |
| |
| final byte[] marshal = marsh.marshal(obj); |
| final Object restored = marsh.unmarshal(marshal, null); |
| |
| assertTrue(restored instanceof EnumObject); |
| |
| obj = (EnumObject)restored; |
| |
| assertEquals(1, obj.id); |
| assertEquals(DeclaredBodyEnum.TWO.ordinal(), obj.type.ordinal()); |
| assertEquals(DeclaredBodyEnum.TWO, obj.type); |
| assertTrue(obj.type == DeclaredBodyEnum.TWO); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDateAndTimestampInSingleObject() throws Exception { |
| BinaryTypeConfiguration cfg1 = new BinaryTypeConfiguration(DateClass1.class.getName()); |
| |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(cfg1)); |
| |
| Date date = new Date(); |
| Timestamp ts = new Timestamp(System.currentTimeMillis()); |
| Time time = new Time(System.currentTimeMillis()); |
| Time[] timeArr = new Time[]{time, new Time(date.getTime()), new Time(System.currentTimeMillis())}; |
| |
| DateClass1 obj1 = new DateClass1(); |
| obj1.date = date; |
| obj1.ts = ts; |
| obj1.time = time; |
| obj1.timeArr = timeArr; |
| |
| BinaryObject po1 = marshal(obj1, marsh); |
| |
| assertEquals(date, po1.field("date")); |
| assertEquals(Date.class, po1.field("date").getClass()); |
| assertEquals(ts, po1.field("ts")); |
| assertEquals(Timestamp.class, po1.field("ts").getClass()); |
| assertEquals(time, po1.field("time")); |
| assertEquals(Time.class, po1.field("time").getClass()); |
| assertArrayEquals(timeArr, (Object[])po1.field("timeArr")); |
| assertEquals(Time[].class, po1.field("timeArr").getClass()); |
| |
| obj1 = po1.deserialize(); |
| assertEquals(date, obj1.date); |
| assertEquals(ts, obj1.ts); |
| assertEquals(time, obj1.time); |
| assertArrayEquals(timeArr, obj1.timeArr); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testSimpleObject() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| assertEquals(obj, po.deserialize()); |
| |
| assertEquals(obj.b, (byte)po.field("b")); |
| assertEquals(obj.s, (short)po.field("s")); |
| assertEquals(obj.i, (int)po.field("i")); |
| assertEquals(obj.l, (long)po.field("l")); |
| assertEquals(obj.f, (float)po.field("f"), 0); |
| assertEquals(obj.d, (double)po.field("d"), 0); |
| assertEquals(obj.c, (char)po.field("c")); |
| assertEquals(obj.bool, (boolean)po.field("bool")); |
| assertEquals(obj.str, po.field("str")); |
| assertEquals(obj.uuid, po.field("uuid")); |
| assertEquals(obj.date, po.field("date")); |
| assertEquals(Date.class, obj.date.getClass()); |
| assertEquals(obj.ts, po.field("ts")); |
| assertArrayEquals(obj.bArr, (byte[])po.field("bArr")); |
| assertArrayEquals(obj.sArr, (short[])po.field("sArr")); |
| assertArrayEquals(obj.iArr, (int[])po.field("iArr")); |
| assertArrayEquals(obj.lArr, (long[])po.field("lArr")); |
| assertArrayEquals(obj.fArr, (float[])po.field("fArr"), 0); |
| assertArrayEquals(obj.dArr, (double[])po.field("dArr"), 0); |
| assertArrayEquals(obj.cArr, (char[])po.field("cArr")); |
| assertBooleanArrayEquals(obj.boolArr, (boolean[])po.field("boolArr")); |
| assertArrayEquals(obj.strArr, (String[])po.field("strArr")); |
| assertArrayEquals(obj.uuidArr, (UUID[])po.field("uuidArr")); |
| assertArrayEquals(obj.dateArr, (Date[])po.field("dateArr")); |
| assertArrayEquals( |
| obj.objArr, |
| useBinaryArrays ? po.<BinaryArray>field("objArr").array() : po.field("objArr") |
| ); |
| assertEquals(obj.col, po.field("col")); |
| assertEquals(obj.map, po.field("map")); |
| assertEquals(new Integer(obj.enumVal.ordinal()), new Integer(((BinaryObject)po.field("enumVal")).enumOrdinal())); |
| assertArrayEquals(ordinals(obj.enumArr), binaryOrdinals(po.field("enumArr"))); |
| assertNull(po.field("unknown")); |
| |
| BinaryObject innerPo = po.field("inner"); |
| |
| assertEquals(obj.inner, innerPo.deserialize()); |
| |
| assertEquals(obj.inner.b, (byte)innerPo.field("b")); |
| assertEquals(obj.inner.s, (short)innerPo.field("s")); |
| assertEquals(obj.inner.i, (int)innerPo.field("i")); |
| assertEquals(obj.inner.l, (long)innerPo.field("l")); |
| assertEquals(obj.inner.f, (float)innerPo.field("f"), 0); |
| assertEquals(obj.inner.d, (double)innerPo.field("d"), 0); |
| assertEquals(obj.inner.c, (char)innerPo.field("c")); |
| assertEquals(obj.inner.bool, (boolean)innerPo.field("bool")); |
| assertEquals(obj.inner.str, innerPo.field("str")); |
| assertEquals(obj.inner.uuid, innerPo.field("uuid")); |
| assertEquals(obj.inner.date, innerPo.field("date")); |
| assertEquals(Date.class, obj.inner.date.getClass()); |
| assertEquals(obj.inner.ts, innerPo.field("ts")); |
| assertArrayEquals(obj.inner.bArr, (byte[])innerPo.field("bArr")); |
| assertArrayEquals(obj.inner.sArr, (short[])innerPo.field("sArr")); |
| assertArrayEquals(obj.inner.iArr, (int[])innerPo.field("iArr")); |
| assertArrayEquals(obj.inner.lArr, (long[])innerPo.field("lArr")); |
| assertArrayEquals(obj.inner.fArr, (float[])innerPo.field("fArr"), 0); |
| assertArrayEquals(obj.inner.dArr, (double[])innerPo.field("dArr"), 0); |
| assertArrayEquals(obj.inner.cArr, (char[])innerPo.field("cArr")); |
| assertBooleanArrayEquals(obj.inner.boolArr, (boolean[])innerPo.field("boolArr")); |
| assertArrayEquals(obj.inner.strArr, (String[])innerPo.field("strArr")); |
| assertArrayEquals(obj.inner.uuidArr, (UUID[])innerPo.field("uuidArr")); |
| assertArrayEquals(obj.inner.dateArr, (Date[])innerPo.field("dateArr")); |
| assertArrayEquals( |
| obj.inner.objArr, |
| useBinaryArrays ? innerPo.<BinaryArray>field("objArr").array() : innerPo.field("objArr") |
| ); |
| assertEquals(obj.inner.col, innerPo.field("col")); |
| assertEquals(obj.inner.map, innerPo.field("map")); |
| assertEquals(new Integer(obj.inner.enumVal.ordinal()), |
| new Integer(((BinaryObject)innerPo.field("enumVal")).enumOrdinal())); |
| assertArrayEquals(ordinals(obj.inner.enumArr), binaryOrdinals(innerPo.field("enumArr"))); |
| assertNull(innerPo.field("inner")); |
| assertNull(innerPo.field("unknown")); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinary() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()), |
| new BinaryTypeConfiguration(TestBinary.class.getName()) |
| )); |
| |
| TestBinary obj = binaryObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| assertEquals(obj, po.deserialize()); |
| |
| assertEquals(obj.b, (byte)po.field("_b")); |
| assertEquals(obj.s, (short)po.field("_s")); |
| assertEquals(obj.i, (int)po.field("_i")); |
| assertEquals(obj.l, (long)po.field("_l")); |
| assertEquals(obj.f, (float)po.field("_f"), 0); |
| assertEquals(obj.d, (double)po.field("_d"), 0); |
| assertEquals(obj.c, (char)po.field("_c")); |
| assertEquals(obj.bool, (boolean)po.field("_bool")); |
| assertEquals(obj.str, po.field("_str")); |
| assertEquals(obj.uuid, po.field("_uuid")); |
| assertEquals(obj.date, po.field("_date")); |
| assertEquals(obj.ts, po.field("_ts")); |
| assertArrayEquals(obj.bArr, (byte[])po.field("_bArr")); |
| assertArrayEquals(obj.sArr, (short[])po.field("_sArr")); |
| assertArrayEquals(obj.iArr, (int[])po.field("_iArr")); |
| assertArrayEquals(obj.lArr, (long[])po.field("_lArr")); |
| assertArrayEquals(obj.fArr, (float[])po.field("_fArr"), 0); |
| assertArrayEquals(obj.dArr, (double[])po.field("_dArr"), 0); |
| assertArrayEquals(obj.cArr, (char[])po.field("_cArr")); |
| assertBooleanArrayEquals(obj.boolArr, (boolean[])po.field("_boolArr")); |
| assertArrayEquals(obj.strArr, (String[])po.field("_strArr")); |
| assertArrayEquals(obj.uuidArr, (UUID[])po.field("_uuidArr")); |
| assertArrayEquals(obj.dateArr, (Date[])po.field("_dateArr")); |
| assertArrayEquals( |
| obj.objArr, |
| useBinaryArrays ? po.<BinaryArray>field("_objArr").array() : po.field("_objArr") |
| ); |
| assertEquals(obj.col, po.field("_col")); |
| assertEquals(obj.map, po.field("_map")); |
| assertEquals(new Integer(obj.enumVal.ordinal()), new Integer(((BinaryObject)po.field("_enumVal")).enumOrdinal())); |
| assertArrayEquals(ordinals(obj.enumArr), binaryOrdinals(po.field("_enumArr"))); |
| assertNull(po.field("unknown")); |
| |
| BinaryObject simplePo = po.field("_simple"); |
| |
| assertEquals(obj.simple, simplePo.deserialize()); |
| |
| assertEquals(obj.simple.b, (byte)simplePo.field("b")); |
| assertEquals(obj.simple.s, (short)simplePo.field("s")); |
| assertEquals(obj.simple.i, (int)simplePo.field("i")); |
| assertEquals(obj.simple.l, (long)simplePo.field("l")); |
| assertEquals(obj.simple.f, (float)simplePo.field("f"), 0); |
| assertEquals(obj.simple.d, (double)simplePo.field("d"), 0); |
| assertEquals(obj.simple.c, (char)simplePo.field("c")); |
| assertEquals(obj.simple.bool, (boolean)simplePo.field("bool")); |
| assertEquals(obj.simple.str, simplePo.field("str")); |
| assertEquals(obj.simple.uuid, simplePo.field("uuid")); |
| assertEquals(obj.simple.date, simplePo.field("date")); |
| assertEquals(Date.class, obj.simple.date.getClass()); |
| assertEquals(obj.simple.ts, simplePo.field("ts")); |
| assertArrayEquals(obj.simple.bArr, (byte[])simplePo.field("bArr")); |
| assertArrayEquals(obj.simple.sArr, (short[])simplePo.field("sArr")); |
| assertArrayEquals(obj.simple.iArr, (int[])simplePo.field("iArr")); |
| assertArrayEquals(obj.simple.lArr, (long[])simplePo.field("lArr")); |
| assertArrayEquals(obj.simple.fArr, (float[])simplePo.field("fArr"), 0); |
| assertArrayEquals(obj.simple.dArr, (double[])simplePo.field("dArr"), 0); |
| assertArrayEquals(obj.simple.cArr, (char[])simplePo.field("cArr")); |
| assertBooleanArrayEquals(obj.simple.boolArr, (boolean[])simplePo.field("boolArr")); |
| assertArrayEquals(obj.simple.strArr, (String[])simplePo.field("strArr")); |
| assertArrayEquals(obj.simple.uuidArr, (UUID[])simplePo.field("uuidArr")); |
| assertArrayEquals(obj.simple.dateArr, (Date[])simplePo.field("dateArr")); |
| assertArrayEquals( |
| obj.simple.objArr, |
| useBinaryArrays ? simplePo.<BinaryArray>field("objArr").array() : simplePo.field("objArr") |
| ); |
| assertEquals(obj.simple.col, simplePo.field("col")); |
| assertEquals(obj.simple.map, simplePo.field("map")); |
| assertEquals(new Integer(obj.simple.enumVal.ordinal()), |
| new Integer(((BinaryObject)simplePo.field("enumVal")).enumOrdinal())); |
| assertArrayEquals(ordinals(obj.simple.enumArr), binaryOrdinals(simplePo.field("enumArr"))); |
| assertNull(simplePo.field("simple")); |
| assertNull(simplePo.field("binary")); |
| assertNull(simplePo.field("unknown")); |
| |
| BinaryObject binaryPo = po.field("_binary"); |
| |
| assertEquals(obj.binary, binaryPo.deserialize()); |
| |
| assertEquals(obj.binary.b, (byte)binaryPo.field("_b")); |
| assertEquals(obj.binary.s, (short)binaryPo.field("_s")); |
| assertEquals(obj.binary.i, (int)binaryPo.field("_i")); |
| assertEquals(obj.binary.l, (long)binaryPo.field("_l")); |
| assertEquals(obj.binary.f, (float)binaryPo.field("_f"), 0); |
| assertEquals(obj.binary.d, (double)binaryPo.field("_d"), 0); |
| assertEquals(obj.binary.c, (char)binaryPo.field("_c")); |
| assertEquals(obj.binary.bool, (boolean)binaryPo.field("_bool")); |
| assertEquals(obj.binary.str, binaryPo.field("_str")); |
| assertEquals(obj.binary.uuid, binaryPo.field("_uuid")); |
| assertEquals(obj.binary.date, binaryPo.field("_date")); |
| assertEquals(obj.binary.ts, binaryPo.field("_ts")); |
| assertArrayEquals(obj.binary.bArr, (byte[])binaryPo.field("_bArr")); |
| assertArrayEquals(obj.binary.sArr, (short[])binaryPo.field("_sArr")); |
| assertArrayEquals(obj.binary.iArr, (int[])binaryPo.field("_iArr")); |
| assertArrayEquals(obj.binary.lArr, (long[])binaryPo.field("_lArr")); |
| assertArrayEquals(obj.binary.fArr, (float[])binaryPo.field("_fArr"), 0); |
| assertArrayEquals(obj.binary.dArr, (double[])binaryPo.field("_dArr"), 0); |
| assertArrayEquals(obj.binary.cArr, (char[])binaryPo.field("_cArr")); |
| assertBooleanArrayEquals(obj.binary.boolArr, (boolean[])binaryPo.field("_boolArr")); |
| assertArrayEquals(obj.binary.strArr, (String[])binaryPo.field("_strArr")); |
| assertArrayEquals(obj.binary.uuidArr, (UUID[])binaryPo.field("_uuidArr")); |
| assertArrayEquals(obj.binary.dateArr, (Date[])binaryPo.field("_dateArr")); |
| assertArrayEquals( |
| obj.binary.objArr, |
| useBinaryArrays ? binaryPo.<BinaryArray>field("_objArr").array() : binaryPo.field("_objArr") |
| ); |
| assertEquals(obj.binary.col, binaryPo.field("_col")); |
| assertEquals(obj.binary.map, binaryPo.field("_map")); |
| assertEquals(new Integer(obj.binary.enumVal.ordinal()), |
| new Integer(((BinaryObject)binaryPo.field("_enumVal")).enumOrdinal())); |
| assertArrayEquals(ordinals(obj.binary.enumArr), binaryOrdinals(binaryPo.field("_enumArr"))); |
| assertNull(binaryPo.field("_simple")); |
| assertNull(binaryPo.field("_binary")); |
| assertNull(binaryPo.field("unknown")); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testObjectFieldOfExternalizableCollection() throws Exception { |
| EnclosingObj obj = new EnclosingObj(); |
| |
| obj.queue = new TestQueue("test"); |
| |
| assertEquals(obj, marshalUnmarshal(obj)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testVoid() throws Exception { |
| Class clazz = Void.class; |
| |
| assertEquals(clazz, marshalUnmarshal(clazz)); |
| |
| clazz = Void.TYPE; |
| |
| assertEquals(clazz, marshalUnmarshal(clazz)); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testWriteReplacePrivate() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Collections.singleton( |
| new BinaryTypeConfiguration(TestObject.class.getName()) |
| )); |
| |
| TestObject obj = new TestObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| assertEquals(obj, po.deserialize()); |
| |
| assertEquals(obj.val, ((BinaryObject)po.field("val")).deserialize()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testWriteReplaceInheritable() throws Exception { |
| ImmutableList<String> obj = ImmutableList.of("This is a test"); |
| |
| BinaryMarshaller marsh = binaryMarshaller(Collections.singleton( |
| new BinaryTypeConfiguration(obj.getClass().getName()) |
| )); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| Object des = po.deserialize(); |
| |
| assertEquals(obj, des); |
| } |
| |
| /** |
| * Checks {@link BinaryBuilderReader#parseValue()} for object that contains handles to collection. |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void handleToCollection() throws Exception { |
| final IgnitePair<String>[] fieldsColAndHandle = new IgnitePair[] { |
| new IgnitePair<>("lst", "hndLst"), |
| new IgnitePair<>("linkedLst", "hndLinkedLst"), |
| new IgnitePair<>("map", "hndMap"), |
| new IgnitePair<>("linkedMap", "hndLinkedMap") |
| }; |
| BinaryMarshaller m = binaryMarshaller(); |
| |
| HandleToCollections obj = new HandleToCollections(); |
| |
| BinaryObject bo = marshal(obj, m); |
| |
| for (int i = 0; i < 10; ++i) { |
| BinaryObjectBuilder bob = bo.toBuilder(); |
| |
| if (i > 0) |
| assertEquals(i - 1, (int)bo.field("a")); |
| |
| bob.setField("a", i); |
| |
| for (IgnitePair<String> flds : fieldsColAndHandle) { |
| // Different orders to read collection and handle to collection. |
| Object col; |
| Object colHnd; |
| |
| if (i % 2 == 0) { |
| col = bob.getField(flds.get1()); |
| colHnd = bob.getField(flds.get2()); |
| } |
| else { |
| colHnd = bob.getField(flds.get2()); |
| col = bob.getField(flds.get1()); |
| } |
| |
| // Must be assertSame but now BinaryObjectBuilder doesn't support handle to collection. |
| // Now we check only that BinaryObjectBuilder#getField doesn't crash and returns valid collection. |
| assertEquals("Check: " + flds, col, colHnd); |
| } |
| |
| bo = bob.build(); |
| } |
| } |
| |
| /** */ |
| @Test |
| public void rebuildWithHandleToCollection() throws Exception { |
| BinaryMarshaller m = binaryMarshaller(); |
| |
| HandleToCollections obj = new HandleToCollections(); |
| |
| BinaryObjectImpl bo = marshal(obj, m); |
| |
| for (int i = 0; i < 10; ++i) { |
| BinaryObjectBuilder bob = bo.toBuilder(); |
| |
| bob.setField("a", i); |
| |
| bo = (BinaryObjectImpl)bob.build(); |
| |
| // Check unmarshal is OK. |
| HandleToCollections modified = unmarshal(bo, m); |
| |
| assertEquals(i, modified.a); |
| assertEquals(obj.lst, modified.lst); |
| assertEquals(obj.hndLst, modified.hndLst); |
| assertEquals(obj.linkedLst, modified.linkedLst); |
| assertEquals(obj.hndLinkedLst, modified.hndLinkedLst); |
| assertEquals(obj.map, modified.map); |
| assertEquals(obj.hndMap, modified.hndMap); |
| } |
| } |
| |
| /** */ |
| @Test |
| public void rebuildObjectWithCollections() throws Exception { |
| BinaryMarshaller m = binaryMarshaller(); |
| |
| TwoCollections obj = new TwoCollections(); |
| |
| BinaryObjectImpl bo = marshal(obj, m); |
| |
| for (int i = 0; i < 10; ++i) { |
| BinaryObjectBuilder bob = bo.toBuilder(); |
| |
| bob.setField("a", i); |
| |
| bo = (BinaryObjectImpl)bob.build(); |
| |
| // Check unmarshal is OK. |
| TwoCollections modified = unmarshal(bo, m); |
| |
| assertEquals(i, modified.a); |
| assertEquals(obj.lst0, modified.lst0); |
| assertEquals(obj.lst1, modified.lst1); |
| } |
| } |
| |
| /** */ |
| @Test |
| public void emptyObjectBuilder() throws IgniteCheckedException { |
| BinaryObject emptyBinObj = builder("test_type").build(); |
| |
| BinaryObjectBuilder bob2 = emptyBinObj.toBuilder(); |
| |
| // Check any field is null at the empty object. |
| assertNull(bob2.getField("a")); |
| |
| // Modify empty object: add field. |
| BinaryObjectImpl o1 = (BinaryObjectImpl)bob2.setField("a", 1).build(); |
| BinaryObjectImpl o2 = (BinaryObjectImpl)builder("test_type").setField("a", 1).build(); |
| |
| // Check that modified empty object and the new object with the sanme field are equals. |
| assertEquals(o1.schemaId(), o2.schemaId()); |
| assertEquals(o1, o2); |
| } |
| |
| /** */ |
| @Test |
| public void emptyObjectBinarylizable() throws IgniteCheckedException { |
| BinaryMarshaller m = binaryMarshaller(); |
| |
| BinaryObjectBuilder bob = marshal(new ObjectRaw(), m).toBuilder(); |
| |
| // Check any field is null at the empty object. |
| assertNull(bob.getField("a")); |
| } |
| |
| /** |
| * |
| */ |
| private static class EnclosingObj implements Serializable { |
| /** Queue. */ |
| Queue<Integer> queue = new TestQueue("test"); |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| |
| EnclosingObj obj = (EnclosingObj)o; |
| |
| return Objects.equals(queue, obj.queue); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int hashCode() { |
| return Objects.hash(queue); |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class TestQueue extends AbstractQueue<Integer> implements Externalizable { |
| /** Name. */ |
| private String name; |
| |
| /** |
| * {@link Externalizable} support. |
| */ |
| public TestQueue() { |
| // No-op. |
| } |
| |
| /** |
| * @param name Name. |
| */ |
| public TestQueue(String name) { |
| this.name = name; |
| } |
| |
| /** {@inheritDoc} */ |
| @NotNull @Override public Iterator<Integer> iterator() { |
| return Collections.emptyIterator(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int size() { |
| return 0; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeExternal(ObjectOutput out) throws IOException { |
| out.writeObject(name); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { |
| name = (String)in.readObject(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean offer(Integer integer) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public Integer poll() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public Integer peek() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| |
| TestQueue integers = (TestQueue)o; |
| |
| return Objects.equals(name, integers.name); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int hashCode() { |
| return Objects.hash(name); |
| } |
| } |
| |
| /** |
| * @param obj Simple object. |
| * @param po Binary object. |
| */ |
| private void checkSimpleObjectData(SimpleObject obj, BinaryObject po) { |
| assertEquals(obj.b, (byte)po.field("b")); |
| assertEquals(obj.s, (short)po.field("s")); |
| assertEquals(obj.i, (int)po.field("i")); |
| assertEquals(obj.l, (long)po.field("l")); |
| assertEquals(obj.f, (float)po.field("f"), 0); |
| assertEquals(obj.d, (double)po.field("d"), 0); |
| assertEquals(obj.c, (char)po.field("c")); |
| assertEquals(obj.bool, (boolean)po.field("bool")); |
| assertEquals(obj.str, po.field("str")); |
| assertEquals(obj.uuid, po.field("uuid")); |
| assertEquals(obj.date, po.field("date")); |
| assertEquals(Date.class, obj.date.getClass()); |
| assertEquals(obj.ts, po.field("ts")); |
| assertArrayEquals(obj.bArr, (byte[])po.field("bArr")); |
| assertArrayEquals(obj.sArr, (short[])po.field("sArr")); |
| assertArrayEquals(obj.iArr, (int[])po.field("iArr")); |
| assertArrayEquals(obj.lArr, (long[])po.field("lArr")); |
| assertArrayEquals(obj.fArr, (float[])po.field("fArr"), 0); |
| assertArrayEquals(obj.dArr, (double[])po.field("dArr"), 0); |
| assertArrayEquals(obj.cArr, (char[])po.field("cArr")); |
| assertBooleanArrayEquals(obj.boolArr, (boolean[])po.field("boolArr")); |
| assertArrayEquals(obj.strArr, (String[])po.field("strArr")); |
| assertArrayEquals(obj.uuidArr, (UUID[])po.field("uuidArr")); |
| assertArrayEquals(obj.dateArr, (Date[])po.field("dateArr")); |
| assertArrayEquals( |
| obj.objArr, |
| useBinaryArrays ? po.<BinaryArray>field("objArr").array() : po.field("objArr") |
| ); |
| assertEquals(obj.col, po.field("col")); |
| assertEquals(obj.map, po.field("map")); |
| assertEquals(new Integer(obj.enumVal.ordinal()), new Integer(((BinaryObject)po.field("enumVal")).enumOrdinal())); |
| assertArrayEquals(ordinals(obj.enumArr), binaryOrdinals(po.field("enumArr"))); |
| assertNull(po.field("unknown")); |
| |
| assertEquals(obj, po.deserialize()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testClassWithoutPublicConstructor() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(NoPublicConstructor.class.getName()), |
| new BinaryTypeConfiguration(NoPublicDefaultConstructor.class.getName()), |
| new BinaryTypeConfiguration(ProtectedConstructor.class.getName())) |
| ); |
| |
| NoPublicConstructor npc = new NoPublicConstructor(); |
| BinaryObject npc2 = marshal(npc, marsh); |
| |
| assertEquals("test", npc2.<NoPublicConstructor>deserialize().val); |
| |
| NoPublicDefaultConstructor npdc = new NoPublicDefaultConstructor(239); |
| BinaryObject npdc2 = marshal(npdc, marsh); |
| |
| assertEquals(239, npdc2.<NoPublicDefaultConstructor>deserialize().val); |
| |
| ProtectedConstructor pc = new ProtectedConstructor(); |
| BinaryObject pc2 = marshal(pc, marsh); |
| |
| assertEquals(ProtectedConstructor.class, pc2.<ProtectedConstructor>deserialize().getClass()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCustomSerializer() throws Exception { |
| BinaryTypeConfiguration type = |
| new BinaryTypeConfiguration(CustomSerializedObject1.class.getName()); |
| |
| type.setSerializer(new CustomSerializer1()); |
| |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(type)); |
| |
| CustomSerializedObject1 obj1 = new CustomSerializedObject1(10); |
| |
| BinaryObject po1 = marshal(obj1, marsh); |
| |
| assertEquals(20, po1.<CustomSerializedObject1>deserialize().val); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCustomSerializerWithGlobal() throws Exception { |
| BinaryTypeConfiguration type1 = |
| new BinaryTypeConfiguration(CustomSerializedObject1.class.getName()); |
| BinaryTypeConfiguration type2 = |
| new BinaryTypeConfiguration(CustomSerializedObject2.class.getName()); |
| |
| type2.setSerializer(new CustomSerializer2()); |
| |
| BinaryMarshaller marsh = binaryMarshaller(new CustomSerializer1(), Arrays.asList(type1, type2)); |
| |
| CustomSerializedObject1 obj1 = new CustomSerializedObject1(10); |
| |
| BinaryObject po1 = marshal(obj1, marsh); |
| |
| assertEquals(20, po1.<CustomSerializedObject1>deserialize().val); |
| |
| CustomSerializedObject2 obj2 = new CustomSerializedObject2(10); |
| |
| BinaryObject po2 = marshal(obj2, marsh); |
| |
| assertEquals(30, po2.<CustomSerializedObject2>deserialize().val); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCustomIdMapper() throws Exception { |
| BinaryTypeConfiguration type = |
| new BinaryTypeConfiguration(CustomMappedObject1.class.getName()); |
| |
| type.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 11111; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| assert typeId == 11111; |
| |
| if ("val1".equals(fieldName)) |
| return 22222; |
| else if ("val2".equals(fieldName)) |
| return 33333; |
| |
| assert false : "Unknown field: " + fieldName; |
| |
| return 0; |
| } |
| }); |
| |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(type)); |
| |
| CustomMappedObject1 obj1 = new CustomMappedObject1(10, "str"); |
| |
| BinaryObjectExImpl po1 = marshal(obj1, marsh); |
| |
| assertEquals(11111, po1.type().typeId()); |
| assertEquals((Integer)10, po1.field(22222)); |
| assertEquals("str", po1.field(33333)); |
| |
| assertEquals(10, po1.<CustomMappedObject1>deserialize().val1); |
| assertEquals("str", po1.<CustomMappedObject1>deserialize().val2); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCustomIdMapperWithGlobal() throws Exception { |
| BinaryTypeConfiguration type1 = |
| new BinaryTypeConfiguration(CustomMappedObject1.class.getName()); |
| BinaryTypeConfiguration type2 = |
| new BinaryTypeConfiguration(CustomMappedObject2.class.getName()); |
| |
| type2.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 44444; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| assert typeId == 44444; |
| |
| if ("val1".equals(fieldName)) |
| return 55555; |
| else if ("val2".equals(fieldName)) |
| return 66666; |
| |
| assert false : "Unknown field: " + fieldName; |
| |
| return 0; |
| } |
| }); |
| |
| BinaryMarshaller marsh = binaryMarshaller(null, new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 11111; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| assert typeId == 11111; |
| |
| if ("val1".equals(fieldName)) |
| return 22222; |
| else if ("val2".equals(fieldName)) |
| return 33333; |
| |
| assert false : "Unknown field: " + fieldName; |
| |
| return 0; |
| } |
| }, Arrays.asList(type1, type2)); |
| |
| CustomMappedObject1 obj1 = new CustomMappedObject1(10, "str1"); |
| |
| BinaryObjectExImpl po1 = marshal(obj1, marsh); |
| |
| assertEquals(11111, po1.type().typeId()); |
| assertEquals((Integer)10, po1.field(22222)); |
| assertEquals("str1", po1.field(33333)); |
| |
| assertEquals(10, po1.<CustomMappedObject1>deserialize().val1); |
| assertEquals("str1", po1.<CustomMappedObject1>deserialize().val2); |
| |
| CustomMappedObject2 obj2 = new CustomMappedObject2(20, "str2"); |
| |
| BinaryObjectExImpl po2 = marshal(obj2, marsh); |
| |
| assertEquals(44444, po2.type().typeId()); |
| assertEquals((Integer)20, po2.field(55555)); |
| assertEquals("str2", po2.field(66666)); |
| |
| assertEquals(20, po2.<CustomMappedObject2>deserialize().val1); |
| assertEquals("str2", po2.<CustomMappedObject2>deserialize().val2); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testSimpleNameLowerCaseMappers() throws Exception { |
| BinaryTypeConfiguration innerClassType = new BinaryTypeConfiguration(InnerMappedObject.class.getName()); |
| BinaryTypeConfiguration publicClassType = new BinaryTypeConfiguration(TestMappedObject.class.getName()); |
| BinaryTypeConfiguration typeWithCustomMapper = new BinaryTypeConfiguration(CustomMappedObject2.class.getName()); |
| |
| typeWithCustomMapper.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 44444; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| assert typeId == 44444; |
| |
| if ("val1".equals(fieldName)) |
| return 55555; |
| else if ("val2".equals(fieldName)) |
| return 66666; |
| |
| assert false : "Unknown field: " + fieldName; |
| |
| return 0; |
| } |
| }); |
| |
| BinaryMarshaller marsh = binaryMarshaller(new BinaryBasicNameMapper(true), new BinaryBasicIdMapper(true), |
| Arrays.asList(innerClassType, publicClassType, typeWithCustomMapper)); |
| |
| InnerMappedObject innerObj = new InnerMappedObject(10, "str1"); |
| |
| BinaryObjectExImpl innerBo = marshal(innerObj, marsh); |
| |
| assertEquals("InnerMappedObject".toLowerCase().hashCode(), innerBo.type().typeId()); |
| |
| assertEquals(10, innerBo.<CustomMappedObject1>deserialize().val1); |
| assertEquals("str1", innerBo.<CustomMappedObject1>deserialize().val2); |
| |
| TestMappedObject publicObj = new TestMappedObject(); |
| |
| BinaryObjectExImpl publicBo = marshal(publicObj, marsh); |
| |
| assertEquals("TestMappedObject".toLowerCase().hashCode(), publicBo.type().typeId()); |
| |
| CustomMappedObject2 obj2 = new CustomMappedObject2(20, "str2"); |
| |
| BinaryObjectExImpl po2 = marshal(obj2, marsh); |
| |
| assertEquals(44444, po2.type().typeId()); |
| assertEquals((Integer)20, po2.field(55555)); |
| assertEquals("str2", po2.field(66666)); |
| |
| assertEquals(20, po2.<CustomMappedObject2>deserialize().val1); |
| assertEquals("str2", po2.<CustomMappedObject2>deserialize().val2); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDynamicObject() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(DynamicObject.class.getName()) |
| )); |
| |
| BinaryObject po1 = marshal(new DynamicObject(0, 10, 20, 30), marsh); |
| |
| assertEquals(new Integer(10), po1.field("val1")); |
| assertEquals(null, po1.field("val2")); |
| assertEquals(null, po1.field("val3")); |
| |
| DynamicObject do1 = po1.deserialize(); |
| |
| assertEquals(10, do1.val1); |
| assertEquals(0, do1.val2); |
| assertEquals(0, do1.val3); |
| |
| BinaryObject po2 = marshal(new DynamicObject(1, 10, 20, 30), marsh); |
| |
| assertEquals(new Integer(10), po2.field("val1")); |
| assertEquals(new Integer(20), po2.field("val2")); |
| assertEquals(null, po2.field("val3")); |
| |
| DynamicObject do2 = po2.deserialize(); |
| |
| assertEquals(10, do2.val1); |
| assertEquals(20, do2.val2); |
| assertEquals(0, do2.val3); |
| |
| BinaryObject po3 = marshal(new DynamicObject(2, 10, 20, 30), marsh); |
| |
| assertEquals(new Integer(10), po3.field("val1")); |
| assertEquals(new Integer(20), po3.field("val2")); |
| assertEquals(new Integer(30), po3.field("val3")); |
| |
| DynamicObject do3 = po3.deserialize(); |
| |
| assertEquals(10, do3.val1); |
| assertEquals(20, do3.val2); |
| assertEquals(30, do3.val3); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCycleLink() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(CycleLinkObject.class.getName()) |
| )); |
| |
| CycleLinkObject obj = new CycleLinkObject(); |
| |
| obj.self = obj; |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| CycleLinkObject obj0 = po.deserialize(); |
| |
| assert obj0.self == obj0; |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDetached() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(DetachedTestObject.class.getName()), |
| new BinaryTypeConfiguration(DetachedInnerTestObject.class.getName()) |
| )); |
| |
| UUID id = UUID.randomUUID(); |
| |
| DetachedTestObject obj = marshal(new DetachedTestObject( |
| new DetachedInnerTestObject(null, id)), marsh).deserialize(); |
| |
| assertEquals(id, obj.inner1.id); |
| assertEquals(id, obj.inner4.id); |
| |
| assert obj.inner1 == obj.inner4; |
| |
| BinaryObjectImpl innerPo = (BinaryObjectImpl)obj.inner2; |
| |
| assert innerPo.detached(); |
| |
| DetachedInnerTestObject inner = innerPo.deserialize(); |
| |
| assertEquals(id, inner.id); |
| |
| BinaryObjectImpl detachedPo = (BinaryObjectImpl)innerPo.detach(); |
| |
| assert detachedPo.detached(); |
| |
| inner = detachedPo.deserialize(); |
| |
| assertEquals(id, inner.id); |
| |
| innerPo = (BinaryObjectImpl)obj.inner3; |
| |
| assert innerPo.detached(); |
| |
| inner = innerPo.deserialize(); |
| |
| assertEquals(id, inner.id); |
| assertNotNull(inner.inner); |
| |
| detachedPo = (BinaryObjectImpl)innerPo.detach(); |
| |
| assert detachedPo.detached(); |
| |
| inner = innerPo.deserialize(); |
| |
| assertEquals(id, inner.id); |
| assertNotNull(inner.inner); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCollectionFields() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(CollectionFieldsObject.class.getName()), |
| new BinaryTypeConfiguration(Key.class.getName()), |
| new BinaryTypeConfiguration(Value.class.getName()) |
| )); |
| |
| Object[] arr = new Object[] {new Value(1), new Value(2), new Value(3)}; |
| Collection<Value> col = new ArrayList<>(Arrays.asList(new Value(4), new Value(5), new Value(6))); |
| Map<Key, Value> map = new HashMap<>(F.asMap(new Key(10), new Value(10), new Key(20), new Value(20), new Key(30), new Value(30))); |
| |
| CollectionFieldsObject obj = new CollectionFieldsObject(arr, col, map); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| Object[] arr0 = useBinaryArrays ? po.<BinaryArray>field("arr").array() : po.field("arr"); |
| |
| assertEquals(3, arr0.length); |
| |
| int i = 1; |
| |
| for (Object valPo : arr0) |
| assertEquals(i++, ((BinaryObject)valPo).<Value>deserialize().val); |
| |
| Collection<BinaryObject> col0 = po.field("col"); |
| |
| i = 4; |
| |
| for (BinaryObject valPo : col0) |
| assertEquals(i++, valPo.<Value>deserialize().val); |
| |
| Map<BinaryObject, BinaryObject> map0 = po.field("map"); |
| |
| for (Map.Entry<BinaryObject, BinaryObject> e : map0.entrySet()) |
| assertEquals(e.getKey().<Key>deserialize().key, e.getValue().<Value>deserialize().val); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDefaultMapping() throws Exception { |
| BinaryTypeConfiguration customMappingType = |
| new BinaryTypeConfiguration(TestBinary.class.getName()); |
| |
| customMappingType.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| String typeName = BinaryContext.SIMPLE_NAME_LOWER_CASE_MAPPER.typeName(clsName); |
| |
| return typeName.toLowerCase().hashCode(); |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return fieldName.toLowerCase().hashCode(); |
| } |
| }); |
| |
| BinaryMarshaller marsh1 = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()), |
| customMappingType |
| )); |
| |
| TestBinary obj = binaryObject(); |
| |
| BinaryObjectImpl po = marshal(obj, marsh1); |
| |
| BinaryMarshaller marsh2 = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()), |
| new BinaryTypeConfiguration(TestBinary.class.getName()) |
| )); |
| |
| po = marshal(obj, marsh2); |
| |
| assertEquals(obj, po.deserialize()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testTypeNamesSimpleNameMapper() throws Exception { |
| BinaryTypeConfiguration customType1 = new BinaryTypeConfiguration(Value.class.getName()); |
| |
| customType1.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 300; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType2 = new BinaryTypeConfiguration("org.gridgain.NonExistentClass1"); |
| |
| customType2.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 400; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType3 = new BinaryTypeConfiguration("NonExistentClass2"); |
| |
| customType3.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 500; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType4 = new BinaryTypeConfiguration("NonExistentClass0"); |
| |
| customType4.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 0; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryMarshaller marsh = binaryMarshaller(new BinaryBasicNameMapper(true), new BinaryBasicIdMapper(true), |
| Arrays.asList( |
| new BinaryTypeConfiguration(Key.class.getName()), |
| new BinaryTypeConfiguration("org.gridgain.NonExistentClass3"), |
| new BinaryTypeConfiguration("NonExistentClass4"), |
| customType1, |
| customType2, |
| customType3, |
| customType4 |
| )); |
| |
| BinaryContext ctx = binaryContext(marsh); |
| |
| // Full name hashCode. |
| assertEquals("notconfiguredclass".hashCode(), ctx.typeId("NotConfiguredClass")); |
| assertEquals("key".hashCode(), ctx.typeId(Key.class.getName())); |
| assertEquals("nonexistentclass3".hashCode(), ctx.typeId("org.gridgain.NonExistentClass3")); |
| assertEquals("nonexistentclass4".hashCode(), ctx.typeId("NonExistentClass4")); |
| assertEquals(300, ctx.typeId(Value.class.getName())); |
| assertEquals(400, ctx.typeId("org.gridgain.NonExistentClass1")); |
| assertEquals(500, ctx.typeId("NonExistentClass2")); |
| |
| // BinaryIdMapper.typeId() contract. |
| assertEquals("nonexistentclass0".hashCode(), ctx.typeId("NonExistentClass0")); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testTypeNamesFullNameMappers() throws Exception { |
| BinaryTypeConfiguration customType1 = new BinaryTypeConfiguration(Value.class.getName()); |
| |
| customType1.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 300; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType2 = new BinaryTypeConfiguration("org.gridgain.NonExistentClass1"); |
| |
| customType2.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 400; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType3 = new BinaryTypeConfiguration("NonExistentClass2"); |
| |
| customType3.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 500; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType4 = new BinaryTypeConfiguration("NonExistentClass0"); |
| |
| customType4.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 0; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryMarshaller marsh = binaryMarshaller(new BinaryBasicNameMapper(false), new BinaryBasicIdMapper(false), |
| Arrays.asList( |
| new BinaryTypeConfiguration(Key.class.getName()), |
| new BinaryTypeConfiguration("org.gridgain.NonExistentClass3"), |
| new BinaryTypeConfiguration("NonExistentClass4"), |
| customType1, |
| customType2, |
| customType3, |
| customType4 |
| )); |
| |
| BinaryContext ctx = binaryContext(marsh); |
| |
| // Full name hashCode. |
| assertEquals("NotConfiguredClass".hashCode(), ctx.typeId("NotConfiguredClass")); |
| assertEquals(Key.class.getName().hashCode(), ctx.typeId(Key.class.getName())); |
| assertEquals("org.gridgain.NonExistentClass3".hashCode(), ctx.typeId("org.gridgain.NonExistentClass3")); |
| assertEquals("NonExistentClass4".hashCode(), ctx.typeId("NonExistentClass4")); |
| assertEquals(300, ctx.typeId(Value.class.getName())); |
| assertEquals(400, ctx.typeId("org.gridgain.NonExistentClass1")); |
| assertEquals(500, ctx.typeId("NonExistentClass2")); |
| |
| // BinaryIdMapper.typeId() contract. |
| assertEquals("nonexistentclass0".hashCode(), ctx.typeId("NonExistentClass0")); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testTypeNamesSimpleNameMappers() throws Exception { |
| BinaryTypeConfiguration customType1 = new BinaryTypeConfiguration(Value.class.getName()); |
| |
| customType1.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 300; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType2 = new BinaryTypeConfiguration("org.gridgain.NonExistentClass1"); |
| |
| customType2.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 400; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType3 = new BinaryTypeConfiguration("NonExistentClass2"); |
| |
| customType3.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 500; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType4 = new BinaryTypeConfiguration("NonExistentClass0"); |
| |
| customType4.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 0; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType5 = new BinaryTypeConfiguration(DateClass1.class.getName()); |
| |
| customType5.setNameMapper(new BinaryBasicNameMapper(false)); |
| customType5.setIdMapper(new BinaryBasicIdMapper(false)); |
| |
| BinaryMarshaller marsh = binaryMarshaller(new BinaryBasicNameMapper(true), new BinaryBasicIdMapper(true), |
| Arrays.asList( |
| new BinaryTypeConfiguration(Key.class.getName()), |
| new BinaryTypeConfiguration("org.gridgain.NonExistentClass3"), |
| new BinaryTypeConfiguration("NonExistentClass4"), |
| customType1, |
| customType2, |
| customType3, |
| customType4, |
| customType5 |
| )); |
| |
| BinaryContext ctx = binaryContext(marsh); |
| |
| assertEquals("notconfiguredclass".hashCode(), ctx.typeId("NotConfiguredClass")); |
| assertEquals("notconfiguredclass".hashCode(), ctx.typeId("org.blabla.NotConfiguredClass")); |
| assertEquals("key".hashCode(), ctx.typeId(Key.class.getName())); |
| assertEquals("nonexistentclass3".hashCode(), ctx.typeId("org.gridgain.NonExistentClass3")); |
| assertEquals("nonexistentclass4".hashCode(), ctx.typeId("NonExistentClass4")); |
| |
| assertEquals(300, ctx.typeId(Value.class.getName())); |
| assertEquals(400, ctx.typeId("org.gridgain.NonExistentClass1")); |
| assertEquals(500, ctx.typeId("NonExistentClass2")); |
| |
| assertEquals(DateClass1.class.getName().hashCode(), ctx.typeId(DateClass1.class.getName())); |
| |
| // BinaryIdMapper.typeId() contract. |
| assertEquals("nonexistentclass0".hashCode(), ctx.typeId("NonExistentClass0")); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testTypeNamesCustomIdMapper() throws Exception { |
| BinaryTypeConfiguration customType1 = new BinaryTypeConfiguration(Value.class.getName()); |
| |
| customType1.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 300; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType2 = new BinaryTypeConfiguration("org.gridgain.NonExistentClass1"); |
| |
| customType2.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 400; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType3 = new BinaryTypeConfiguration("NonExistentClass2"); |
| |
| customType3.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 500; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType4 = new BinaryTypeConfiguration("NonExistentClass0"); |
| |
| customType4.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 0; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType5 = new BinaryTypeConfiguration(DateClass1.class.getName()); |
| |
| customType5.setIdMapper(new BinaryBasicIdMapper(false)); |
| |
| BinaryTypeConfiguration customType6 = new BinaryTypeConfiguration(MyTestClass.class.getName()); |
| |
| customType6.setIdMapper(new BinaryBasicIdMapper(true)); |
| customType6.setNameMapper(new BinaryBasicNameMapper(true)); |
| |
| BinaryMarshaller marsh = binaryMarshaller(new BinaryBasicNameMapper(false), new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| if ("org.blabla.NotConfiguredSpecialClass".equals(clsName)) |
| return 0; |
| else if (Key.class.getName().equals(clsName)) |
| return 991; |
| else if ("org.gridgain.NonExistentClass3".equals(clsName)) |
| return 992; |
| else if ("NonExistentClass4".equals(clsName)) |
| return 993; |
| |
| return 999; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }, Arrays.asList( |
| new BinaryTypeConfiguration(Key.class.getName()), |
| new BinaryTypeConfiguration("org.gridgain.NonExistentClass3"), |
| new BinaryTypeConfiguration("NonExistentClass4"), |
| customType1, |
| customType2, |
| customType3, |
| customType4, |
| customType5, |
| customType6 |
| )); |
| |
| BinaryContext ctx = binaryContext(marsh); |
| |
| assertEquals(999, ctx.typeId("NotConfiguredClass")); |
| assertEquals(999, ctx.typeId("org.blabla.NotConfiguredClass")); |
| |
| // BinaryIdMapper.typeId() contract. |
| assertEquals("notconfiguredspecialclass".hashCode(), ctx.typeId("org.blabla.NotConfiguredSpecialClass")); |
| |
| assertEquals(991, ctx.typeId(Key.class.getName())); |
| assertEquals(992, ctx.typeId("org.gridgain.NonExistentClass3")); |
| assertEquals(993, ctx.typeId("NonExistentClass4")); |
| |
| // Custom types. |
| assertEquals(300, ctx.typeId(Value.class.getName())); |
| assertEquals(400, ctx.typeId("org.gridgain.NonExistentClass1")); |
| assertEquals(500, ctx.typeId("NonExistentClass2")); |
| |
| // BinaryIdMapper.typeId() contract. |
| assertEquals("nonexistentclass0".hashCode(), ctx.typeId("NonExistentClass0")); |
| |
| assertEquals(DateClass1.class.getName().hashCode(), ctx.typeId(DateClass1.class.getName())); |
| assertEquals("mytestclass".hashCode(), ctx.typeId(MyTestClass.class.getName())); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testCustomTypeRegistration() throws Exception { |
| BinaryTypeConfiguration customType = new BinaryTypeConfiguration(Value.class.getName()); |
| |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(customType)); |
| |
| BinaryContext ctx = binaryContext(marsh); |
| |
| int typeId = ctx.typeId(Value.class.getName()); |
| |
| BinaryClassDescriptor descriptor = ctx.descriptorForTypeId(true, typeId, null, true); |
| |
| assertEquals(Value.class, descriptor.describedClass()); |
| assertEquals(true, descriptor.registered()); |
| assertEquals(true, descriptor.userType()); |
| |
| // Custom explicit types must be registered in 'predefinedTypes' in order not to break the interoperability. |
| Field field = ctx.getClass().getDeclaredField("predefinedTypes"); |
| |
| field.setAccessible(true); |
| |
| Map<Integer, BinaryClassDescriptor> map = (Map<Integer, BinaryClassDescriptor>)field.get(ctx); |
| |
| assertTrue(!map.isEmpty()); |
| |
| assertNotNull(map.get(typeId)); |
| |
| // Custom explicit types must NOT be registered in 'predefinedTypeNames'. |
| field = ctx.getClass().getDeclaredField("predefinedTypeNames"); |
| |
| field.setAccessible(true); |
| |
| Map<String, Integer> map2 = (Map<String, Integer>)field.get(ctx); |
| |
| assertTrue(!map2.isEmpty()); |
| |
| assertNull(map2.get(ctx.userTypeName(Value.class.getName()))); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testFieldIdMapping() throws Exception { |
| BinaryTypeConfiguration customType1 = new BinaryTypeConfiguration(Value.class.getName()); |
| |
| customType1.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 300; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| switch (fieldName) { |
| case "val1": |
| return 301; |
| |
| case "val2": |
| return 302; |
| |
| default: |
| return 0; |
| } |
| } |
| }); |
| |
| BinaryTypeConfiguration customType2 = new BinaryTypeConfiguration("NonExistentClass1"); |
| |
| customType2.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 400; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| switch (fieldName) { |
| case "val1": |
| return 401; |
| |
| case "val2": |
| return 402; |
| |
| default: |
| return 0; |
| } |
| } |
| }); |
| |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(new BinaryTypeConfiguration(Key.class.getName()), |
| new BinaryTypeConfiguration("NonExistentClass2"), |
| customType1, |
| customType2)); |
| |
| BinaryContext ctx = binaryContext(marsh); |
| |
| assertEquals("val".hashCode(), ctx.fieldId("key".hashCode(), "val")); |
| assertEquals("val".hashCode(), ctx.fieldId("nonexistentclass2".hashCode(), "val")); |
| assertEquals("val".hashCode(), ctx.fieldId("notconfiguredclass".hashCode(), "val")); |
| assertEquals(301, ctx.fieldId(300, "val1")); |
| assertEquals(302, ctx.fieldId(300, "val2")); |
| assertEquals("val3".hashCode(), ctx.fieldId(300, "val3")); |
| assertEquals(401, ctx.fieldId(400, "val1")); |
| assertEquals(402, ctx.fieldId(400, "val2")); |
| assertEquals("val3".hashCode(), ctx.fieldId(400, "val3")); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDuplicateTypeId() throws Exception { |
| BinaryTypeConfiguration customType1 = new BinaryTypeConfiguration("org.gridgain.Class1"); |
| |
| customType1.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 100; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| BinaryTypeConfiguration customType2 = new BinaryTypeConfiguration("org.gridgain.Class2"); |
| |
| customType2.setIdMapper(new BinaryIdMapper() { |
| @Override public int typeId(String clsName) { |
| return 100; |
| } |
| |
| @Override public int fieldId(int typeId, String fieldName) { |
| return 0; |
| } |
| }); |
| |
| try { |
| binaryMarshaller(Arrays.asList(customType1, customType2)); |
| } |
| catch (BinaryObjectException e) { |
| assertEquals("Duplicate type ID [clsName=org.gridgain.Class2, id=100]", e.getMessage()); |
| |
| return; |
| } |
| |
| assert false; |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopy() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| final BinaryObject po = marshal(obj, marsh); |
| |
| assertEquals(obj, po.deserialize()); |
| |
| BinaryObject copy = copy(po, null); |
| |
| assertEquals(obj, copy.deserialize()); |
| |
| copy = copy(po, new HashMap<String, Object>()); |
| |
| assertEquals(obj, copy.deserialize()); |
| |
| Map<String, Object> map = new HashMap<>(1, 1.0f); |
| |
| map.put("i", 3); |
| |
| copy = copy(po, map); |
| |
| assertEquals((byte)2, copy.<Byte>field("b").byteValue()); |
| assertEquals((short)2, copy.<Short>field("s").shortValue()); |
| assertEquals(3, copy.<Integer>field("i").intValue()); |
| assertEquals(2L, copy.<Long>field("l").longValue()); |
| assertEquals(2.2f, copy.<Float>field("f").floatValue(), 0); |
| assertEquals(2.2d, copy.<Double>field("d").doubleValue(), 0); |
| assertEquals((char)2, copy.<Character>field("c").charValue()); |
| assertEquals(false, copy.<Boolean>field("bool").booleanValue()); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertEquals((byte)2, obj0.b); |
| assertEquals((short)2, obj0.s); |
| assertEquals(3, obj0.i); |
| assertEquals(2L, obj0.l); |
| assertEquals(2.2f, obj0.f, 0); |
| assertEquals(2.2d, obj0.d, 0); |
| assertEquals((char)2, obj0.c); |
| assertEquals(false, obj0.bool); |
| |
| map = new HashMap<>(3, 1.0f); |
| |
| map.put("b", (byte)3); |
| map.put("l", 3L); |
| map.put("bool", true); |
| |
| copy = copy(po, map); |
| |
| assertEquals((byte)3, copy.<Byte>field("b").byteValue()); |
| assertEquals((short)2, copy.<Short>field("s").shortValue()); |
| assertEquals(2, copy.<Integer>field("i").intValue()); |
| assertEquals(3L, copy.<Long>field("l").longValue()); |
| assertEquals(2.2f, copy.<Float>field("f").floatValue(), 0); |
| assertEquals(2.2d, copy.<Double>field("d").doubleValue(), 0); |
| assertEquals((char)2, copy.<Character>field("c").charValue()); |
| assertEquals(true, copy.<Boolean>field("bool").booleanValue()); |
| |
| obj0 = copy.deserialize(); |
| |
| assertEquals((byte)3, obj0.b); |
| assertEquals((short)2, obj0.s); |
| assertEquals(2, obj0.i); |
| assertEquals(3L, obj0.l); |
| assertEquals(2.2f, obj0.f, 0); |
| assertEquals(2.2d, obj0.d, 0); |
| assertEquals((char)2, obj0.c); |
| assertEquals(true, obj0.bool); |
| |
| map = new HashMap<>(8, 1.0f); |
| |
| map.put("b", (byte)3); |
| map.put("s", (short)3); |
| map.put("i", 3); |
| map.put("l", 3L); |
| map.put("f", 3.3f); |
| map.put("d", 3.3d); |
| map.put("c", (char)3); |
| map.put("bool", true); |
| |
| copy = copy(po, map); |
| |
| assertEquals((byte)3, copy.<Byte>field("b").byteValue()); |
| assertEquals((short)3, copy.<Short>field("s").shortValue()); |
| assertEquals(3, copy.<Integer>field("i").intValue()); |
| assertEquals(3L, copy.<Long>field("l").longValue()); |
| assertEquals(3.3f, copy.<Float>field("f").floatValue(), 0); |
| assertEquals(3.3d, copy.<Double>field("d").doubleValue(), 0); |
| assertEquals((char)3, copy.<Character>field("c").charValue()); |
| assertEquals(true, copy.<Boolean>field("bool").booleanValue()); |
| |
| obj0 = copy.deserialize(); |
| |
| assertEquals((byte)3, obj0.b); |
| assertEquals((short)3, obj0.s); |
| assertEquals(3, obj0.i); |
| assertEquals(3L, obj0.l); |
| assertEquals(3.3f, obj0.f, 0); |
| assertEquals(3.3d, obj0.d, 0); |
| assertEquals((char)3, obj0.c); |
| assertEquals(true, obj0.bool); |
| |
| // GridTestUtils.assertThrows( |
| // log, |
| // new Callable<Object>() { |
| // @Override public Object call() throws Exception { |
| // po.copy(F.<String, Object>asMap("i", false)); |
| // |
| // return null; |
| // } |
| // }, |
| // BinaryException.class, |
| // "Invalid value type for field: i" |
| // ); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyString() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("str", "str3")); |
| |
| assertEquals("str3", copy.<String>field("str")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertEquals("str3", obj0.str); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyUuid() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| UUID uuid = UUID.randomUUID(); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("uuid", uuid)); |
| |
| assertEquals(uuid, copy.<UUID>field("uuid")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertEquals(uuid, obj0.uuid); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyByteArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("bArr", new byte[] {1, 2, 3})); |
| |
| assertArrayEquals(new byte[] {1, 2, 3}, copy.<byte[]>field("bArr")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new byte[] {1, 2, 3}, obj0.bArr); |
| } |
| |
| /** |
| * @param po Binary object. |
| * @param fields Fields. |
| * @return Copy. |
| */ |
| private BinaryObject copy(BinaryObject po, Map<String, Object> fields) { |
| BinaryObjectBuilder builder = BinaryObjectBuilderImpl.wrap(po); |
| |
| if (fields != null) { |
| for (Map.Entry<String, Object> e : fields.entrySet()) |
| builder.setField(e.getKey(), e.getValue()); |
| } |
| |
| return builder.build(); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyShortArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("sArr", new short[] {1, 2, 3})); |
| |
| assertArrayEquals(new short[] {1, 2, 3}, copy.<short[]>field("sArr")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new short[] {1, 2, 3}, obj0.sArr); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyIntArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("iArr", new int[] {1, 2, 3})); |
| |
| assertArrayEquals(new int[] {1, 2, 3}, copy.<int[]>field("iArr")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new int[] {1, 2, 3}, obj0.iArr); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyLongArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("lArr", new long[] {1, 2, 3})); |
| |
| assertArrayEquals(new long[] {1, 2, 3}, copy.<long[]>field("lArr")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new long[] {1, 2, 3}, obj0.lArr); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyFloatArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("fArr", new float[] {1, 2, 3})); |
| |
| assertArrayEquals(new float[] {1, 2, 3}, copy.<float[]>field("fArr"), 0); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new float[] {1, 2, 3}, obj0.fArr, 0); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyDoubleArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("dArr", new double[] {1, 2, 3})); |
| |
| assertArrayEquals(new double[] {1, 2, 3}, copy.<double[]>field("dArr"), 0); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new double[] {1, 2, 3}, obj0.dArr, 0); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyCharArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("cArr", new char[] {1, 2, 3})); |
| |
| assertArrayEquals(new char[] {1, 2, 3}, copy.<char[]>field("cArr")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new char[] {1, 2, 3}, obj0.cArr); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyStringArray() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("strArr", new String[] {"str1", "str2"})); |
| |
| assertArrayEquals(new String[] {"str1", "str2"}, copy.<String[]>field("strArr")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertArrayEquals(new String[] {"str1", "str2"}, obj0.strArr); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyObject() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| SimpleObject newObj = new SimpleObject(); |
| |
| newObj.i = 12345; |
| newObj.fArr = new float[] {5, 8, 0}; |
| newObj.str = "newStr"; |
| |
| BinaryObject copy = copy(po, F.<String, Object>asMap("inner", newObj)); |
| |
| assertEquals(newObj, copy.<BinaryObject>field("inner").deserialize()); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertEquals(newObj, obj0.inner); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyNonPrimitives() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(SimpleObject.class.getName()) |
| )); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| Map<String, Object> map = new HashMap<>(3, 1.0f); |
| |
| SimpleObject newObj = new SimpleObject(); |
| |
| newObj.i = 12345; |
| newObj.fArr = new float[] {5, 8, 0}; |
| newObj.str = "newStr"; |
| |
| map.put("str", "str555"); |
| map.put("inner", newObj); |
| map.put("bArr", new byte[] {6, 7, 9}); |
| |
| BinaryObject copy = copy(po, map); |
| |
| assertEquals("str555", copy.<String>field("str")); |
| assertEquals(newObj, copy.<BinaryObject>field("inner").deserialize()); |
| assertArrayEquals(new byte[] {6, 7, 9}, copy.<byte[]>field("bArr")); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertEquals("str555", obj0.str); |
| assertEquals(newObj, obj0.inner); |
| assertArrayEquals(new byte[] {6, 7, 9}, obj0.bArr); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryCopyMixed() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(new BinaryTypeConfiguration(SimpleObject.class.getName()))); |
| |
| SimpleObject obj = simpleObject(); |
| |
| BinaryObject po = marshal(obj, marsh); |
| |
| Map<String, Object> map = new HashMap<>(3, 1.0f); |
| |
| SimpleObject newObj = new SimpleObject(); |
| |
| newObj.i = 12345; |
| newObj.fArr = new float[] {5, 8, 0}; |
| newObj.str = "newStr"; |
| |
| map.put("i", 1234); |
| map.put("str", "str555"); |
| map.put("inner", newObj); |
| map.put("s", (short)2323); |
| map.put("bArr", new byte[] {6, 7, 9}); |
| map.put("b", (byte)111); |
| |
| BinaryObject copy = copy(po, map); |
| |
| assertEquals(1234, copy.<Integer>field("i").intValue()); |
| assertEquals("str555", copy.<String>field("str")); |
| assertEquals(newObj, copy.<BinaryObject>field("inner").deserialize()); |
| assertEquals((short)2323, copy.<Short>field("s").shortValue()); |
| assertArrayEquals(new byte[] {6, 7, 9}, copy.<byte[]>field("bArr")); |
| assertEquals((byte)111, copy.<Byte>field("b").byteValue()); |
| |
| SimpleObject obj0 = copy.deserialize(); |
| |
| assertEquals(1234, obj0.i); |
| assertEquals("str555", obj0.str); |
| assertEquals(newObj, obj0.inner); |
| assertEquals((short)2323, obj0.s); |
| assertArrayEquals(new byte[] {6, 7, 9}, obj0.bArr); |
| assertEquals((byte)111, obj0.b); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testKeepDeserialized() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(new BinaryTypeConfiguration(SimpleObject.class.getName()))); |
| |
| BinaryObjectImpl po = marshal(simpleObject(), marsh); |
| |
| CacheObjectContext coCtx = new CacheObjectContext(newContext(), null, null, false, false, true, false, false); |
| |
| assert po.value(coCtx, false) == po.value(coCtx, false); |
| |
| po = marshal(simpleObject(), marsh); |
| |
| assert po.deserialize() != po.deserialize(); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testOffheapBinary() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(new BinaryTypeConfiguration(SimpleObject.class.getName()))); |
| |
| BinaryContext ctx = binaryContext(marsh); |
| |
| SimpleObject simpleObj = simpleObject(); |
| |
| BinaryObjectImpl obj = marshal(simpleObj, marsh); |
| |
| long ptr = 0; |
| |
| long ptr1 = 0; |
| |
| long ptr2 = 0; |
| |
| try { |
| ptr = copyOffheap(obj); |
| |
| BinaryObjectOffheapImpl offheapObj = new BinaryObjectOffheapImpl(ctx, |
| ptr, |
| 0, |
| obj.array().length); |
| |
| assertTrue(offheapObj.equals(offheapObj)); |
| assertEquals(offheapObj.size(), obj.size()); |
| assertFalse(offheapObj.equals(null)); |
| assertFalse(offheapObj.equals("str")); |
| assertTrue(offheapObj.equals(obj)); |
| assertTrue(obj.equals(offheapObj)); |
| |
| ptr1 = copyOffheap(obj); |
| |
| BinaryObjectOffheapImpl offheapObj1 = new BinaryObjectOffheapImpl(ctx, |
| ptr1, |
| 0, |
| obj.array().length); |
| |
| assertTrue(offheapObj.equals(offheapObj1)); |
| assertTrue(offheapObj1.equals(offheapObj)); |
| |
| assertEquals(obj.type().typeId(), offheapObj.type().typeId()); |
| assertEquals(obj.hashCode(), offheapObj.hashCode()); |
| |
| checkSimpleObjectData(simpleObj, offheapObj); |
| |
| BinaryObjectOffheapImpl innerOffheapObj = offheapObj.field("inner"); |
| |
| assertNotNull(innerOffheapObj); |
| |
| checkSimpleObjectData(simpleObj.inner, innerOffheapObj); |
| |
| obj = (BinaryObjectImpl)offheapObj.heapCopy(); |
| |
| assertEquals(obj.type().typeId(), offheapObj.type().typeId()); |
| assertEquals(obj.hashCode(), offheapObj.hashCode()); |
| |
| checkSimpleObjectData(simpleObj, obj); |
| |
| BinaryObjectImpl innerObj = obj.field("inner"); |
| |
| assertNotNull(innerObj); |
| |
| checkSimpleObjectData(simpleObj.inner, innerObj); |
| |
| simpleObj.d = 0; |
| |
| obj = marshal(simpleObj, marsh); |
| |
| assertFalse(offheapObj.equals(obj)); |
| assertFalse(obj.equals(offheapObj)); |
| |
| ptr2 = copyOffheap(obj); |
| |
| BinaryObjectOffheapImpl offheapObj2 = new BinaryObjectOffheapImpl(ctx, |
| ptr2, |
| 0, |
| obj.array().length); |
| |
| assertFalse(offheapObj.equals(offheapObj2)); |
| assertFalse(offheapObj2.equals(offheapObj)); |
| } |
| finally { |
| GridUnsafe.freeMemory(ptr); |
| |
| if (ptr1 > 0) |
| GridUnsafe.freeMemory(ptr1); |
| |
| if (ptr2 > 0) |
| GridUnsafe.freeMemory(ptr2); |
| } |
| } |
| |
| /** |
| * |
| */ |
| @Test |
| public void testReadResolve() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( |
| new BinaryTypeConfiguration(MySingleton.class.getName()), |
| new BinaryTypeConfiguration(SingletonMarker.class.getName()))); |
| |
| BinaryObjectImpl binaryObj = marshal(MySingleton.INSTANCE, marsh); |
| |
| assertTrue(binaryObj.array().length <= 1024); // Check that big string was not serialized. |
| |
| MySingleton singleton = binaryObj.deserialize(); |
| |
| assertSame(MySingleton.INSTANCE, singleton); |
| } |
| |
| /** |
| * |
| */ |
| @Test |
| public void testReadResolveOnBinaryAware() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(Collections.singletonList( |
| new BinaryTypeConfiguration(MyTestClass.class.getName()))); |
| |
| BinaryObjectImpl binaryObj = marshal(new MyTestClass(), marsh); |
| |
| MyTestClass obj = binaryObj.deserialize(); |
| |
| assertEquals("readResolve", obj.s); |
| } |
| |
| /** |
| * |
| */ |
| @Test |
| public void testDecimalFields() throws Exception { |
| Collection<BinaryTypeConfiguration> clsNames = new ArrayList<>(); |
| |
| clsNames.add(new BinaryTypeConfiguration(DecimalReflective.class.getName())); |
| clsNames.add(new BinaryTypeConfiguration(DecimalMarshalAware.class.getName())); |
| |
| BinaryMarshaller marsh = binaryMarshaller(clsNames); |
| |
| // 1. Test reflective stuff. |
| DecimalReflective obj1 = new DecimalReflective(); |
| |
| BigDecimal valArr[] = new BigDecimal[] {BigDecimal.ONE, BigDecimal.TEN, new BigDecimal("-100.5"), |
| BigDecimal.valueOf(Long.MAX_VALUE, 0), BigDecimal.valueOf(Long.MIN_VALUE, 0), |
| BigDecimal.valueOf(Long.MAX_VALUE, 8), BigDecimal.valueOf(Long.MIN_VALUE, 8)}; |
| |
| obj1.val = BigDecimal.ZERO; |
| obj1.valArr = valArr; |
| BinaryObjectImpl portObj = marshal(obj1, marsh); |
| |
| assertArrayEquals(obj1.valArr, portObj.<BigDecimal[]>field("valArr")); |
| assertArrayEquals(obj1.valArr, portObj.<DecimalReflective>deserialize().valArr); |
| assertArrayEquals(obj1.valArr, (BigDecimal[])portObj.type().field("valArr").value(portObj)); |
| |
| obj1.valArr = null; |
| |
| for (BigDecimal v: valArr) { |
| obj1.val = v; |
| |
| portObj = marshal(obj1, marsh); |
| |
| assertEquals(obj1.val, portObj.field("val")); |
| assertEquals(obj1.val, portObj.<DecimalReflective>deserialize().val); |
| assertEquals(obj1.val, portObj.type().field("val").value(portObj)); |
| } |
| |
| // 2. Test marshal aware stuff. |
| DecimalMarshalAware obj2 = new DecimalMarshalAware(); |
| |
| obj2.val = BigDecimal.ZERO; |
| obj2.valArr = new BigDecimal[] {BigDecimal.ONE, BigDecimal.TEN.negate()}; |
| obj2.rawVal = BigDecimal.TEN; |
| obj2.rawValArr = new BigDecimal[] {BigDecimal.ZERO, BigDecimal.ONE}; |
| |
| portObj = marshal(obj2, marsh); |
| |
| assertEquals(obj2.val, portObj.field("val")); |
| assertArrayEquals(obj2.valArr, portObj.<BigDecimal[]>field("valArr")); |
| |
| assertEquals(obj2.val, portObj.<DecimalMarshalAware>deserialize().val); |
| assertArrayEquals(obj2.valArr, portObj.<DecimalMarshalAware>deserialize().valArr); |
| assertEquals(obj2.rawVal, portObj.<DecimalMarshalAware>deserialize().rawVal); |
| assertArrayEquals(obj2.rawValArr, portObj.<DecimalMarshalAware>deserialize().rawValArr); |
| |
| assertEquals(obj2.val, portObj.type().field("val").value(portObj)); |
| assertArrayEquals(obj2.valArr, (BigDecimal[])portObj.type().field("valArr").value(portObj)); |
| |
| for (BigDecimal v: valArr) { |
| obj2.val = v; |
| |
| portObj = marshal(obj2, marsh); |
| |
| assertEquals(obj2.val, portObj.field("val")); |
| assertEquals(obj2.val, portObj.<DecimalMarshalAware>deserialize().val); |
| assertEquals(obj2.val, portObj.type().field("val").value(portObj)); |
| } |
| } |
| |
| /** |
| * @throws IgniteCheckedException If failed. |
| */ |
| @Test |
| public void testFinalField() throws IgniteCheckedException { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| SimpleObjectWithFinal obj = new SimpleObjectWithFinal(); |
| |
| SimpleObjectWithFinal po0 = marshalUnmarshal(obj, marsh); |
| |
| assertEquals(obj.time, po0.time); |
| } |
| |
| /** |
| * @throws IgniteCheckedException If failed. |
| */ |
| @Test |
| public void testThreadLocalArrayReleased() throws Exception { |
| // Checking the writer directly. |
| assertEquals(false, THREAD_LOCAL.isAcquired()); |
| |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| try (BinaryWriterExImpl writer = new BinaryWriterExImpl(binaryContext(marsh))) { |
| assertEquals(true, THREAD_LOCAL.isAcquired()); |
| |
| writer.writeString("Thread local test"); |
| |
| writer.array(); |
| |
| assertEquals(true, THREAD_LOCAL.isAcquired()); |
| } |
| |
| // Checking the binary marshaller. |
| assertEquals(false, THREAD_LOCAL.isAcquired()); |
| |
| marsh = binaryMarshaller(); |
| |
| marsh.marshal(new SimpleObject()); |
| |
| assertEquals(false, THREAD_LOCAL.isAcquired()); |
| |
| marsh = binaryMarshaller(); |
| |
| // Checking the builder. |
| BinaryObjectBuilder builder = new BinaryObjectBuilderImpl(binaryContext(marsh), |
| "org.gridgain.foo.bar.TestClass"); |
| |
| builder.setField("a", "1"); |
| |
| BinaryObject binaryObj = builder.build(); |
| |
| assertEquals(false, THREAD_LOCAL.isAcquired()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDuplicateNameSimpleNameMapper() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(new BinaryBasicNameMapper(true), |
| new BinaryBasicIdMapper(true), null, null, null); |
| |
| Test1.Job job1 = new Test1().new Job(); |
| Test2.Job job2 = new Test2().new Job(); |
| |
| marsh.marshal(job1); |
| |
| try { |
| marsh.marshal(job2); |
| } |
| catch (BinaryObjectException e) { |
| assertEquals(true, e.getMessage().contains("Failed to register class")); |
| |
| return; |
| } |
| |
| assert false; |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDuplicateNameFullNameMapper() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(new BinaryBasicNameMapper(false), |
| new BinaryBasicIdMapper(false), null, null, null); |
| |
| Test1.Job job1 = new Test1().new Job(); |
| Test2.Job job2 = new Test2().new Job(); |
| |
| marsh.marshal(job1); |
| |
| marsh.marshal(job2); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testClass() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| Class cls = BinaryMarshallerSelfTest.class; |
| |
| Class unmarshalledCls = marshalUnmarshal(cls, marsh); |
| |
| Assert.assertEquals(cls, unmarshalledCls); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testClassFieldsMarshalling() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| ObjectWithClassFields obj = new ObjectWithClassFields(); |
| obj.cls1 = BinaryMarshallerSelfTest.class; |
| |
| byte[] marshal = marsh.marshal(obj); |
| |
| ObjectWithClassFields obj2 = marsh.unmarshal(marshal, null); |
| |
| assertEquals(obj.cls1, obj2.cls1); |
| assertNull(obj2.cls2); |
| |
| BinaryObject portObj = marshal(obj, marsh); |
| |
| Class cls1 = portObj.field("cls1"); |
| |
| assertEquals(obj.cls1, cls1); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testReadDetachedMap() throws Exception { |
| Map<Key, Value> map = IntStream.range(0, 1000).mapToObj(i -> new T2<>(new Key(i), new Value(i))) |
| .collect(Collectors.toMap(T2::getKey, T2::getValue)); |
| |
| testReadDetachObjectProperly(map, obj -> { |
| Map<BinaryObject, BinaryObject> desMap = (Map<BinaryObject, BinaryObject>)obj; |
| |
| assertEquals(map.size(), desMap.size()); |
| |
| desMap.forEach((k, v) -> { |
| Key key = new Key(k.field("key")); |
| Value val = new Value(v.field("val")); |
| |
| assertTrue(map.containsKey(key)); |
| assertEquals(val, map.get(key)); |
| }); |
| }, false); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testReadDetachedCollection() throws Exception { |
| Collection<Value> col = IntStream.range(0, 1000).mapToObj(Value::new).collect(Collectors.toSet()); |
| |
| testReadDetachObjectProperly(col, obj -> { |
| Collection<BinaryObject> desCol = (Collection<BinaryObject>)obj; |
| |
| assertEquals(col.size(), desCol.size()); |
| |
| desCol.forEach(v -> { |
| Value val = new Value(v.field("val")); |
| |
| assertTrue(col.contains(val)); |
| }); |
| }, false); |
| } |
| |
| /** @throws Exception If failed. */ |
| @Test |
| public void testReadDetachedTypedArray() throws Exception { |
| Value[] arr = IntStream.range(0, 1000).mapToObj(Value::new).toArray(Value[]::new); |
| |
| testReadDetachObjectProperly(arr, obj -> { |
| assertArrayEquals(arr, (Value[])obj); |
| |
| Object[] args = new Object[] {obj}; |
| |
| assertTrue(args[0] instanceof Value[]); |
| |
| args = PlatformUtils.unwrapBinariesInArray(args); |
| |
| assertTrue(args[0] instanceof Value[]); |
| assertArrayEquals(arr, (Value[])args[0]); |
| }, true); |
| } |
| |
| /** @throws Exception If failed. */ |
| @Test |
| public void testReadArrayOfCollections() throws Exception { |
| Collection[] arr = new Collection[] { Arrays.asList(new Value(1), new Value(2), new Value(3)) }; |
| testReadDetachObjectProperly(arr, obj -> { |
| assertArrayEquals(arr, (Collection[])obj); |
| |
| Object[] args = new Object[] {obj}; |
| |
| assertTrue(args[0] instanceof Collection[]); |
| |
| args = PlatformUtils.unwrapBinariesInArray(args); |
| |
| assertTrue(args[0] instanceof Collection[]); |
| assertArrayEquals(arr, (Collection[])args[0]); |
| }, true); |
| } |
| |
| |
| /** @throws Exception If failed. */ |
| @Test |
| public void testReadArrayOfBinaryCollections() throws Exception { |
| Collection[] arr = new Collection[] { new ArrayList<>(Arrays.asList(new Value(1), new Value(2), new Value(3))) }; |
| |
| testReadDetachObjectProperly(arr, obj -> { |
| Object[] args = PlatformUtils.unwrapBinariesInArray(new Object[] {obj}); |
| |
| Collection deserVals = (Collection)((Object[])args[0])[0]; |
| |
| assertEqualsCollections(arr[0], deserVals); |
| }, false); |
| } |
| |
| /** |
| * Perform action on binary object after unmarshalling from offheap data, when offheap memory chunk cleared. |
| * |
| * @param obj Object to marshal-unmarshal. |
| * @param action Action to perform on object. |
| * @throws Exception If failed. |
| */ |
| private void testReadDetachObjectProperly(Object obj, IgniteThrowableConsumer<Object> action, boolean deserialize) throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| BinaryHeapOutputStream os = new BinaryHeapOutputStream(1024); |
| |
| BinaryWriterExImpl writer = marsh.binaryMarshaller().writer(os); |
| |
| writer.writeObject(obj); |
| |
| BinaryHeapInputStream is = new BinaryHeapInputStream(os.array()); |
| |
| BinaryReaderExImpl reader = marsh.binaryMarshaller().reader(is); |
| |
| Object bObj = reader.readObjectDetached(deserialize); |
| |
| Arrays.fill(os.array(), (byte)0); |
| |
| action.accept(bObj); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testMarshallingThroughJdk() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| InetSocketAddress addr = new InetSocketAddress("192.168.0.2", 4545); |
| |
| byte[] arr = marsh.marshal(addr); |
| |
| InetSocketAddress addr2 = marsh.unmarshal(arr, null); |
| |
| assertEquals(addr.getHostString(), addr2.getHostString()); |
| assertEquals(addr.getPort(), addr2.getPort()); |
| |
| TestAddress testAddr = new TestAddress(); |
| testAddr.addr = addr; |
| testAddr.str1 = "Hello World"; |
| |
| SimpleObject simpleObj = new SimpleObject(); |
| simpleObj.c = 'g'; |
| simpleObj.date = new Date(); |
| |
| testAddr.obj = simpleObj; |
| |
| arr = marsh.marshal(testAddr); |
| |
| TestAddress testAddr2 = marsh.unmarshal(arr, null); |
| |
| assertEquals(testAddr.addr.getHostString(), testAddr2.addr.getHostString()); |
| assertEquals(testAddr.addr.getPort(), testAddr2.addr.getPort()); |
| assertEquals(testAddr.str1, testAddr2.str1); |
| assertEquals(testAddr.obj.c, testAddr2.obj.c); |
| assertEquals(testAddr.obj.date, testAddr2.obj.date); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testPredefinedTypeIds() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| BinaryContext bCtx = binaryContext(marsh); |
| |
| Field field = bCtx.getClass().getDeclaredField("predefinedTypeNames"); |
| |
| field.setAccessible(true); |
| |
| Map<String, Integer> map = (Map<String, Integer>)field.get(bCtx); |
| |
| assertTrue(!map.isEmpty()); |
| |
| for (Map.Entry<String, Integer> entry : map.entrySet()) { |
| int id = entry.getValue(); |
| |
| if (id == GridBinaryMarshaller.UNREGISTERED_TYPE_ID) |
| continue; |
| |
| BinaryClassDescriptor desc = bCtx.descriptorForTypeId(false, entry.getValue(), null, true); |
| |
| assertEquals(desc.typeId(), bCtx.typeId(desc.describedClass().getName())); |
| } |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testProxy() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| SomeItf inItf = (SomeItf)Proxy.newProxyInstance( |
| BinaryMarshallerSelfTest.class.getClassLoader(), new Class[] {SomeItf.class}, |
| new InvocationHandler() { |
| private NonSerializable obj = new NonSerializable(null); |
| |
| @Override public Object invoke(Object proxy, Method mtd, Object[] args) throws Throwable { |
| if ("hashCode".equals(mtd.getName())) |
| return obj.hashCode(); |
| |
| obj.checkAfterUnmarshalled(); |
| |
| return 17; |
| } |
| } |
| ); |
| |
| SomeItf outItf = marsh.unmarshal(marsh.marshal(inItf), null); |
| |
| assertEquals(outItf.checkAfterUnmarshalled(), 17); |
| } |
| |
| /** |
| * Test object with {@link Proxy} field. |
| * |
| * @throws Exception If fails. |
| */ |
| @Test |
| public void testObjectContainingProxy() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| SomeItf inItf = (SomeItf)Proxy.newProxyInstance( |
| BinaryMarshallerSelfTest.class.getClassLoader(), new Class[] {SomeItf.class}, |
| new InvocationHandler() { |
| private NonSerializable obj = new NonSerializable(null); |
| |
| @Override public Object invoke(Object proxy, Method mtd, Object[] args) throws Throwable { |
| if ("hashCode".equals(mtd.getName())) |
| return obj.hashCode(); |
| |
| obj.checkAfterUnmarshalled(); |
| |
| return 17; |
| } |
| } |
| ); |
| |
| SomeItf outItf = marsh.unmarshal(marsh.marshal(inItf), null); |
| |
| assertEquals(outItf.checkAfterUnmarshalled(), 17); |
| } |
| |
| /** |
| * Test duplicate fields. |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDuplicateFields() throws Exception { |
| BinaryMarshaller marsh = binaryMarshaller(); |
| |
| DuplicateFieldsB obj = new DuplicateFieldsB(1, 2); |
| |
| BinaryObjectImpl objBin = marshal(obj, marsh); |
| |
| String fieldName = "x"; |
| String fieldNameA = DuplicateFieldsA.class.getName() + "." + fieldName; |
| String fieldNameB = DuplicateFieldsB.class.getName() + "." + fieldName; |
| |
| // Check "hasField". |
| assert !objBin.hasField(fieldName); |
| assert objBin.hasField(fieldNameA); |
| assert objBin.hasField(fieldNameB); |
| |
| // Check direct field access. |
| assertNull(objBin.field(fieldName)); |
| assertEquals(Integer.valueOf(1), objBin.field(fieldNameA)); |
| assertEquals(Integer.valueOf(2), objBin.field(fieldNameB)); |
| |
| // Check metadata. |
| BinaryType type = objBin.type(); |
| |
| Collection<String> fieldNames = type.fieldNames(); |
| |
| assertEquals(2, fieldNames.size()); |
| |
| assert !fieldNames.contains(fieldName); |
| assert fieldNames.contains(fieldNameA); |
| assert fieldNames.contains(fieldNameB); |
| |
| // Check field access through type. |
| BinaryField field = type.field(fieldName); |
| BinaryField fieldA = type.field(fieldNameA); |
| BinaryField fieldB = type.field(fieldNameB); |
| |
| assert !field.exists(objBin); |
| assert fieldA.exists(objBin); |
| assert fieldB.exists(objBin); |
| |
| assertNull(field.value(objBin)); |
| assertEquals(Integer.valueOf(1), fieldA.value(objBin)); |
| assertEquals(Integer.valueOf(2), fieldB.value(objBin)); |
| |
| // Check object deserialization. |
| DuplicateFieldsB deserialized = objBin.deserialize(); |
| |
| assertEquals(obj.xA(), deserialized.xA()); |
| assertEquals(obj.xB(), deserialized.xB()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testSingleHandle() throws Exception { |
| SingleHandleA a = new SingleHandleA(new SingleHandleB()); |
| |
| BinaryObjectImpl bo = marshal(a, binaryMarshaller()); |
| |
| Map<String, BinaryObject> map = bo.field("map"); |
| |
| BinaryObject innerBo = map.get("key"); |
| |
| assertEquals(SingleHandleB.class, innerBo.deserialize().getClass()); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testUnregisteredClass() throws Exception { |
| BinaryMarshaller m = binaryMarshaller(null, Collections.singletonList(Value.class.getName())); |
| |
| ClassFieldObject res = m.unmarshal(m.marshal(new ClassFieldObject(Value.class)), null); |
| |
| assertEquals(Value.class, res.cls); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testMixedRawCollections() throws Exception { |
| Collection<String> excludedClasses = Arrays.asList( |
| ObjectRaw.class.getName(), |
| ObjectWithRaw.class.getName(), |
| Value.class.getName()); |
| |
| BinaryMarshaller m0 = binaryMarshaller(null, excludedClasses); |
| BinaryMarshaller m1 = binaryMarshaller(); |
| |
| Value obj = new Value(27); |
| ObjectWithRaw objectWithRaw = new ObjectWithRaw(27, 13); |
| ObjectRaw objectRaw = new ObjectRaw(27, 13); |
| |
| Value objOther = new Value(26); |
| ObjectWithRaw objectWithRawOther = new ObjectWithRaw(26, 13); |
| ObjectRaw objectRawOther = new ObjectRaw(26, 13); |
| |
| ArrayList collection = new ArrayList(Arrays.asList( |
| obj, objectWithRawOther, objectRaw, objectWithRaw, objectRawOther, objOther)); |
| |
| marshalUnmarshal(collection, m0); |
| marshalUnmarshal(collection, m1); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryEquals() throws Exception { |
| Collection<String> excludedClasses = Arrays.asList( |
| ObjectRaw.class.getName(), |
| ObjectWithRaw.class.getName(), |
| Value.class.getName()); |
| |
| BinaryMarshaller m0 = binaryMarshaller(null, excludedClasses); |
| BinaryMarshaller m1 = binaryMarshaller(); |
| |
| Value obj = new Value(27); |
| ObjectWithRaw objectWithRaw = new ObjectWithRaw(27, 13); |
| ObjectRaw objectRaw = new ObjectRaw(27, 13); |
| |
| Value objOther = new Value(26); |
| ObjectWithRaw objectWithRawOther = new ObjectWithRaw(26, 13); |
| ObjectRaw objectRawOther = new ObjectRaw(26, 13); |
| |
| BinaryObjectImpl binObj0 = marshal(obj, m0); |
| BinaryObjectImpl binObj1 = marshal(obj, m1); |
| BinaryObjectImpl binObjWithRaw0 = marshal(objectWithRaw, m0); |
| BinaryObjectImpl binObjWithRaw1 = marshal(objectWithRaw, m1); |
| BinaryObjectImpl binObjRaw0 = marshal(objectRaw, m0); |
| BinaryObjectImpl binObjRaw1 = marshal(objectRaw, m1); |
| |
| assertNotEquals(binObj0.array().length, binObj1.array().length); |
| assertNotEquals(binObjWithRaw0.array().length, binObjWithRaw1.array().length); |
| assertNotEquals(binObjRaw0.array().length, binObjRaw1.array().length); |
| |
| checkEquals(binObj0, binObj1); |
| |
| checkEquals(binObjWithRaw0, binObjWithRaw1); |
| |
| checkEquals(binObjRaw0, binObjRaw1); |
| |
| BinaryObjectOffheapImpl binObjOffheap0 = null; |
| BinaryObjectOffheapImpl binObjOffheap1 = null; |
| BinaryObjectOffheapImpl binObjWithRawOffheap0 = null; |
| BinaryObjectOffheapImpl binObjWithRawOffheap1 = null; |
| BinaryObjectOffheapImpl binObjRawOffheap0 = null; |
| BinaryObjectOffheapImpl binObjRawOffheap1 = null; |
| |
| BinaryObjectImpl binObjOther0 = marshal(objOther, m0); |
| BinaryObjectImpl binObjOther1 = marshal(objOther, m1); |
| BinaryObjectImpl binObjWithRawOther0 = marshal(objectWithRawOther, m0); |
| BinaryObjectImpl binObjWithRawOther1 = marshal(objectWithRawOther, m1); |
| BinaryObjectImpl binObjRawOther0 = marshal(objectRawOther, m0); |
| BinaryObjectImpl binObjRawOther1 = marshal(objectRawOther, m1); |
| |
| assertEquals(binObjOther0.length(), binObj0.length()); |
| assertEquals(binObjOther1.length(), binObj1.length()); |
| assertEquals(binObjWithRawOther0.length(), binObjWithRaw0.length()); |
| assertEquals(binObjWithRawOther1.length(), binObjWithRaw1.length()); |
| assertEquals(binObjRawOther0.length(), binObjRaw0.length()); |
| assertEquals(binObjRawOther1.length(), binObjRaw1.length()); |
| |
| assertNotEquals(binObjOther0, binObj0); |
| assertNotEquals(binObjOther1, binObj1); |
| assertNotEquals(binObjWithRawOther0, binObjWithRaw0); |
| assertNotEquals(binObjWithRawOther1, binObjWithRaw1); |
| assertNotEquals(binObjRawOther0, binObjRaw0); |
| assertNotEquals(binObjRawOther1, binObjRaw1); |
| |
| try { |
| binObjOffheap0 = marshalOffHeap(binObj0, m0); |
| binObjOffheap1 = marshalOffHeap(binObj1, m1); |
| binObjWithRawOffheap0 = marshalOffHeap(binObjWithRaw0, m0); |
| binObjWithRawOffheap1 = marshalOffHeap(binObjWithRaw1, m1); |
| binObjRawOffheap0 = marshalOffHeap(binObjRaw0, m0); |
| binObjRawOffheap1 = marshalOffHeap(binObjRaw1, m1); |
| |
| checkEquals(binObj0, binObjOffheap0); |
| checkEquals(binObj1, binObjOffheap0); |
| checkEquals(binObj0, binObjOffheap1); |
| checkEquals(binObj1, binObjOffheap1); |
| checkEquals(binObjOffheap0, binObjOffheap1); |
| |
| checkEquals(binObjWithRaw0, binObjWithRawOffheap0); |
| checkEquals(binObjWithRaw0, binObjWithRawOffheap1); |
| checkEquals(binObjWithRaw1, binObjWithRawOffheap0); |
| checkEquals(binObjWithRaw1, binObjWithRawOffheap1); |
| checkEquals(binObjWithRawOffheap0, binObjWithRawOffheap1); |
| |
| checkEquals(binObjRaw0, binObjRawOffheap0); |
| checkEquals(binObjRaw1, binObjRawOffheap0); |
| checkEquals(binObjRaw0, binObjRawOffheap1); |
| checkEquals(binObjRaw1, binObjRawOffheap1); |
| checkEquals(binObjRawOffheap0, binObjRawOffheap1); |
| } |
| finally { |
| if (binObjOffheap0 != null) { |
| GridUnsafe.freeMemory(binObjOffheap0.offheapAddress()); |
| binObjOffheap0 = null; |
| } |
| |
| if (binObjOffheap1 != null) { |
| GridUnsafe.freeMemory(binObjOffheap1.offheapAddress()); |
| binObjOffheap1 = null; |
| } |
| |
| if (binObjWithRawOffheap0 != null) { |
| GridUnsafe.freeMemory(binObjWithRawOffheap0.offheapAddress()); |
| binObjOffheap1 = null; |
| } |
| |
| if (binObjWithRawOffheap1 != null) { |
| GridUnsafe.freeMemory(binObjWithRawOffheap1.offheapAddress()); |
| binObjOffheap1 = null; |
| } |
| |
| if (binObjRawOffheap0 != null) { |
| GridUnsafe.freeMemory(binObjRawOffheap0.offheapAddress()); |
| binObjOffheap1 = null; |
| } |
| |
| if (binObjRawOffheap1 != null) { |
| GridUnsafe.freeMemory(binObjRawOffheap1.offheapAddress()); |
| binObjOffheap1 = null; |
| } |
| } |
| } |
| |
| /** |
| * @param binObj0 Object #0. |
| * @param binObj1 Object #1. |
| */ |
| private void checkEquals(Object binObj0, Object binObj1) { |
| assertEquals(binObj0, binObj1); |
| assertEquals(binObj1, binObj0); |
| assertEquals(binObj0, binObj0); |
| assertEquals(binObj1, binObj1); |
| } |
| |
| /** |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testBinaryEqualsComplexObject() throws Exception { |
| List<String> excludedClasses = Arrays.asList( |
| TestClass0.class.getName(), |
| TestClass1.class.getName(), |
| TestClass2.class.getName()); |
| |
| BinaryMarshaller m0 = binaryMarshaller(null, excludedClasses); |
| BinaryMarshaller m1 = binaryMarshaller(null); |
| |
| TestClass0 obj0 = new TestClass0(); |
| TestClass1 obj1 = new TestClass1(); |
| TestClass2 obj2 = new TestClass2(); |
| |
| BinaryObjectImpl binObj00 = marshal(obj0, m0); |
| BinaryObjectImpl binObj01 = marshal(obj1, m0); |
| BinaryObjectImpl binObj02 = marshal(obj2, m0); |
| |
| // The length of array must be equal. Object are different only by the class. |
| assertEquals(binObj00.array().length, binObj01.array().length); |
| assertEquals(binObj00.array().length, binObj02.array().length); |
| |
| BinaryObjectImpl binObj10 = marshal(obj0, m1); |
| BinaryObjectImpl binObj11 = marshal(obj1, m1); |
| BinaryObjectImpl binObj12 = marshal(obj2, m1); |
| |
| // The length of array must be equal. Object are different only by the class. |
| assertEquals(binObj10.array().length, binObj11.array().length); |
| assertEquals(binObj10.array().length, binObj12.array().length); |
| |
| assertNotEquals(binObj10.array().length, binObj00.array().length); |
| |
| assertEquals(binObj00, binObj10); |
| assertEquals(binObj01, binObj11); |
| assertEquals(binObj02, binObj12); |
| |
| assertNotEquals(binObj00, binObj01); |
| assertNotEquals(binObj00, binObj02); |
| assertNotEquals(binObj00, binObj11); |
| assertNotEquals(binObj00, binObj12); |
| |
| assertNotEquals(binObj01, binObj00); |
| assertNotEquals(binObj01, binObj02); |
| assertNotEquals(binObj01, binObj10); |
| assertNotEquals(binObj01, binObj12); |
| |
| assertNotEquals(binObj02, binObj00); |
| assertNotEquals(binObj02, binObj01); |
| assertNotEquals(binObj02, binObj00); |
| assertNotEquals(binObj02, binObj11); |
| } |
| |
| |
| /** |
| * The test must be refactored after {@link IgniteSystemProperties#IGNITE_BINARY_SORT_OBJECT_FIELDS} |
| * is removed. |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testFieldOrder() throws Exception { |
| if (BinaryUtils.FIELDS_SORTED_ORDER) |
| return; |
| |
| BinaryMarshaller m = binaryMarshaller(); |
| |
| BinaryObjectImpl binObj = marshal(simpleObject(), m); |
| |
| Collection<String> fieldsBin = binObj.type().fieldNames(); |
| |
| Field[] fields = SimpleObject.class.getDeclaredFields(); |
| |
| assertEquals(fields.length, fieldsBin.size()); |
| |
| int i = 0; |
| |
| for (String fieldName : fieldsBin) { |
| assertEquals(fields[i].getName(), fieldName); |
| |
| ++i; |
| } |
| } |
| |
| /** |
| * The test must be refactored after {@link IgniteSystemProperties#IGNITE_BINARY_SORT_OBJECT_FIELDS} |
| * is removed. |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testFieldOrderByBuilder() throws Exception { |
| if (BinaryUtils.FIELDS_SORTED_ORDER) |
| return; |
| |
| BinaryMarshaller m = binaryMarshaller(); |
| |
| BinaryObjectBuilder builder = new BinaryObjectBuilderImpl(binaryContext(m), "MyFakeClass"); |
| |
| String[] fieldNames = {"field9", "field8", "field0", "field1", "field2"}; |
| |
| for (String fieldName : fieldNames) |
| builder.setField(fieldName, 0); |
| |
| BinaryObject binObj = builder.build(); |
| |
| Collection<String> fieldsBin = binObj.type().fieldNames(); |
| |
| assertEquals(fieldNames.length, fieldsBin.size()); |
| |
| int i = 0; |
| |
| for (String fieldName : fieldsBin) { |
| assertEquals(fieldNames[i], fieldName); |
| |
| ++i; |
| } |
| } |
| |
| /** |
| * @param obj Instance of the BinaryObjectImpl to offheap marshalling. |
| * @param marsh Binary marshaller. |
| * @return Instance of BinaryObjectOffheapImpl. |
| */ |
| private BinaryObjectOffheapImpl marshalOffHeap(BinaryObjectImpl obj, BinaryMarshaller marsh) { |
| long ptr = copyOffheap(obj); |
| |
| return new BinaryObjectOffheapImpl(binaryContext(marsh), |
| ptr, |
| 0, |
| obj.array().length); |
| } |
| |
| /** |
| * |
| */ |
| private static interface SomeItf { |
| /** |
| * @return Check result. |
| */ |
| int checkAfterUnmarshalled(); |
| } |
| |
| /** |
| * Some non-serializable class. |
| */ |
| @SuppressWarnings({"PublicField", "TransientFieldInNonSerializableClass", "FieldMayBeStatic"}) |
| private static class NonSerializableA { |
| /** */ |
| private final long longVal = 0x33445566778899AAL; |
| |
| /** */ |
| protected Short shortVal = (short)0xAABB; |
| |
| /** */ |
| public String[] strArr = {"AA", "BB"}; |
| |
| /** */ |
| public boolean flag1 = true; |
| |
| /** */ |
| public boolean flag2; |
| |
| /** */ |
| public Boolean flag3; |
| |
| /** */ |
| public Boolean flag4 = true; |
| |
| /** */ |
| public Boolean flag5 = false; |
| |
| /** */ |
| private transient int intVal = 0xAABBCCDD; |
| |
| /** |
| * @param strArr Array. |
| * @param shortVal Short value. |
| */ |
| private NonSerializableA(@Nullable String[] strArr, @Nullable Short shortVal) { |
| // No-op. |
| } |
| |
| /** |
| * Checks correctness of the state after unmarshalling. |
| */ |
| void checkAfterUnmarshalled() { |
| assertEquals(longVal, 0x33445566778899AAL); |
| |
| assertEquals(shortVal.shortValue(), (short)0xAABB); |
| |
| assertTrue(Arrays.equals(strArr, new String[] {"AA", "BB"})); |
| |
| assertEquals(0, intVal); |
| |
| assertTrue(flag1); |
| assertFalse(flag2); |
| assertNull(flag3); |
| assertTrue(flag4); |
| assertFalse(flag5); |
| } |
| } |
| |
| /** |
| * Some non-serializable class. |
| */ |
| @SuppressWarnings({"PublicField", "TransientFieldInNonSerializableClass", "PackageVisibleInnerClass"}) |
| static class NonSerializableB extends NonSerializableA { |
| /** */ |
| public Short shortValue = 0x1122; |
| |
| /** */ |
| public long longValue = 0x8877665544332211L; |
| |
| /** */ |
| private transient NonSerializableA[] aArr = { |
| new NonSerializableA(null, null), |
| new NonSerializableA(null, null), |
| new NonSerializableA(null, null) |
| }; |
| |
| /** */ |
| protected Double doubleVal = 123.456; |
| |
| /** |
| * Just to eliminate the default constructor. |
| */ |
| private NonSerializableB() { |
| super(null, null); |
| } |
| |
| /** |
| * Checks correctness of the state after unmarshalling. |
| */ |
| @Override void checkAfterUnmarshalled() { |
| super.checkAfterUnmarshalled(); |
| |
| assertEquals(shortValue.shortValue(), 0x1122); |
| |
| assertEquals(longValue, 0x8877665544332211L); |
| |
| assertNull(aArr); |
| |
| assertEquals(doubleVal, 123.456); |
| } |
| } |
| |
| /** |
| * Some non-serializable class. |
| */ |
| @SuppressWarnings({"TransientFieldInNonSerializableClass", "PublicField"}) |
| private static class NonSerializable extends NonSerializableB { |
| /** */ |
| private int idVal = -17; |
| |
| /** */ |
| private final NonSerializableA aVal = new NonSerializableB(); |
| |
| /** */ |
| private transient NonSerializableB bVal = new NonSerializableB(); |
| |
| /** */ |
| private NonSerializableA[] bArr = new NonSerializableA[] { |
| new NonSerializableB(), |
| new NonSerializableA(null, null) |
| }; |
| |
| /** */ |
| public float floatVal = 567.89F; |
| |
| /** |
| * Just to eliminate the default constructor. |
| * |
| * @param aVal Unused. |
| */ |
| private NonSerializable(NonSerializableA aVal) { |
| } |
| |
| /** |
| * Checks correctness of the state after unmarshalling. |
| */ |
| @Override void checkAfterUnmarshalled() { |
| super.checkAfterUnmarshalled(); |
| |
| assertEquals(idVal, -17); |
| |
| aVal.checkAfterUnmarshalled(); |
| |
| assertNull(bVal); |
| |
| for (NonSerializableA a : bArr) |
| a.checkAfterUnmarshalled(); |
| |
| assertEquals(floatVal, 567.89F, 0); |
| } |
| } |
| |
| /** |
| * Object with class fields. |
| */ |
| private static class ObjectWithClassFields { |
| /** */ |
| private Class<?> cls1; |
| |
| /** */ |
| private Class<?> cls2; |
| } |
| |
| /** |
| * |
| */ |
| private static class TestAddress { |
| /** */ |
| private SimpleObject obj; |
| |
| /** */ |
| private InetSocketAddress addr; |
| |
| /** */ |
| private String str1; |
| } |
| |
| /** |
| * |
| */ |
| private static class Test1 { |
| /** |
| * |
| */ |
| private class Job { |
| |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class Test2 { |
| /** |
| * |
| */ |
| private class Job { |
| |
| } |
| } |
| |
| /** |
| * @param obj Object. |
| * @return Offheap address. |
| */ |
| private long copyOffheap(BinaryObjectImpl obj) { |
| byte[] arr = obj.array(); |
| |
| long ptr = GridUnsafe.allocateMemory(arr.length); |
| |
| GridUnsafe.copyHeapOffheap(arr, GridUnsafe.BYTE_ARR_OFF, ptr, arr.length); |
| |
| return ptr; |
| } |
| |
| /** |
| * @param enumArr Enum array. |
| * @return Ordinals. |
| */ |
| private <T extends Enum<?>> Integer[] ordinals(T[] enumArr) { |
| Integer[] ords = new Integer[enumArr.length]; |
| |
| for (int i = 0; i < enumArr.length; i++) |
| ords[i] = enumArr[i].ordinal(); |
| |
| return ords; |
| } |
| |
| /** |
| * @param fld Field value. |
| * @return Ordinals. |
| */ |
| private <T extends Enum<?>> Integer[] binaryOrdinals(Object fld) { |
| Object[] enumArr; |
| |
| if (useBinaryArrays) { |
| assertTrue(fld instanceof BinaryEnumArray); |
| |
| enumArr = ((BinaryEnumArray)fld).array(); |
| } |
| else { |
| assertTrue(fld instanceof BinaryObject[]); |
| |
| enumArr = (Object[])fld; |
| } |
| |
| Integer[] ords = new Integer[enumArr.length]; |
| |
| for (int i = 0; i < enumArr.length; i++) |
| ords[i] = ((BinaryObject)enumArr[i]).enumOrdinal(); |
| |
| return ords; |
| } |
| |
| /** |
| * @param po Binary object. |
| * @param off Offset. |
| * @return Value. |
| */ |
| private int intFromBinary(BinaryObject po, int off) { |
| byte[] arr = U.field(po, "arr"); |
| |
| return Integer.reverseBytes(U.bytesToInt(arr, off)); |
| } |
| |
| /** |
| * @param obj Original object. |
| * @return Result object. |
| */ |
| private <T> T marshalUnmarshal(T obj) throws IgniteCheckedException { |
| return marshalUnmarshal(obj, binaryMarshaller()); |
| } |
| |
| /** |
| * @param obj Original object. |
| * @param marsh Marshaller. |
| * @return Result object. |
| */ |
| private <T> T marshalUnmarshal(Object obj, BinaryMarshaller marsh) throws IgniteCheckedException { |
| byte[] bytes = marsh.marshal(obj); |
| |
| return marsh.unmarshal(bytes, null); |
| } |
| |
| /** |
| * @param bo Binary object to deserialize. |
| * @param marsh Marshaller. |
| * @return Result object. |
| */ |
| private <T> T unmarshal(BinaryObjectImpl bo, BinaryMarshaller marsh) throws IgniteCheckedException { |
| return marsh.unmarshal(bo.array(), null); |
| } |
| |
| /** |
| * @param obj Object. |
| * @param marsh Marshaller. |
| * @return Binary object. |
| */ |
| private <T> BinaryObjectImpl marshal(T obj, BinaryMarshaller marsh) throws IgniteCheckedException { |
| byte[] bytes = marsh.marshal(obj); |
| |
| return new BinaryObjectImpl(U.<GridBinaryMarshaller>field(marsh, "impl").context(), |
| bytes, 0); |
| } |
| |
| /** |
| * @return Whether to use compact footers or not. |
| */ |
| protected boolean compactFooter() { |
| return true; |
| } |
| |
| /** |
| * @param marsh Marshaller. |
| * @return Binary context. |
| */ |
| protected BinaryContext binaryContext(BinaryMarshaller marsh) { |
| GridBinaryMarshaller impl = U.field(marsh, "impl"); |
| |
| return impl.context(); |
| } |
| |
| /** |
| * |
| */ |
| protected BinaryMarshaller binaryMarshaller() throws IgniteCheckedException { |
| return binaryMarshaller(null, null, null, null, null); |
| } |
| |
| /** |
| * |
| */ |
| protected BinaryMarshaller binaryMarshaller(Collection<BinaryTypeConfiguration> cfgs) |
| throws IgniteCheckedException { |
| return binaryMarshaller(null, null, null, cfgs, null); |
| } |
| |
| /** |
| * |
| */ |
| protected BinaryMarshaller binaryMarshaller(Collection<BinaryTypeConfiguration> cfgs, |
| Collection<String> excludedClasses) throws IgniteCheckedException { |
| return binaryMarshaller(null, null, null, cfgs, excludedClasses); |
| } |
| |
| /** |
| * |
| */ |
| protected BinaryMarshaller binaryMarshaller(BinaryNameMapper nameMapper, BinaryIdMapper mapper, |
| Collection<BinaryTypeConfiguration> cfgs) |
| throws IgniteCheckedException { |
| return binaryMarshaller(nameMapper, mapper, null, cfgs, null); |
| } |
| |
| /** |
| * |
| */ |
| protected BinaryMarshaller binaryMarshaller(BinarySerializer serializer, Collection<BinaryTypeConfiguration> cfgs) |
| throws IgniteCheckedException { |
| return binaryMarshaller(null, null, serializer, cfgs, null); |
| } |
| |
| /** |
| * @return Binary marshaller. |
| */ |
| protected BinaryMarshaller binaryMarshaller( |
| BinaryNameMapper nameMapper, |
| BinaryIdMapper mapper, |
| BinarySerializer serializer, |
| Collection<BinaryTypeConfiguration> cfgs, |
| Collection<String> excludedClasses |
| ) throws IgniteCheckedException { |
| IgniteConfiguration iCfg = new IgniteConfiguration(); |
| |
| BinaryConfiguration bCfg = new BinaryConfiguration(); |
| |
| bCfg.setNameMapper(nameMapper); |
| bCfg.setIdMapper(mapper); |
| bCfg.setSerializer(serializer); |
| bCfg.setCompactFooter(compactFooter()); |
| |
| bCfg.setTypeConfigurations(cfgs); |
| |
| iCfg.setBinaryConfiguration(bCfg); |
| iCfg.setClientMode(false); |
| iCfg.setDiscoverySpi(new TcpDiscoverySpi() { |
| @Override public void sendCustomEvent(DiscoverySpiCustomMessage msg) throws IgniteException { |
| //No-op. |
| } |
| }); |
| iCfg.setSystemViewExporterSpi(new JmxSystemViewExporterSpi()); |
| |
| BinaryContext ctx = new BinaryContext(BinaryCachingMetadataHandler.create(), iCfg, new NullLogger()); |
| |
| BinaryMarshaller marsh = new BinaryMarshaller(); |
| |
| MarshallerContextTestImpl marshCtx = new MarshallerContextTestImpl(null, excludedClasses); |
| |
| GridTestKernalContext kernCtx = new GridTestKernalContext(log, iCfg); |
| |
| kernCtx.add(new GridSystemViewManager(kernCtx)); |
| kernCtx.add(new GridDiscoveryManager(kernCtx)); |
| |
| marshCtx.onMarshallerProcessorStarted(kernCtx, null); |
| |
| marsh.setContext(marshCtx); |
| |
| marsh.setBinaryContext(ctx, iCfg); |
| |
| return marsh; |
| } |
| |
| /** |
| * @return Binary object builder. |
| */ |
| protected BinaryObjectBuilder builder( |
| String typeName |
| ) throws IgniteCheckedException { |
| return builder(typeName, null, null, null, null, null); |
| } |
| |
| /** |
| * @return Binary object builder. |
| */ |
| protected BinaryObjectBuilder builder( |
| String typeName, |
| BinaryNameMapper nameMapper, |
| BinaryIdMapper mapper, |
| BinarySerializer serializer, |
| Collection<BinaryTypeConfiguration> cfgs, |
| Collection<String> excludedClasses |
| ) throws IgniteCheckedException { |
| IgniteConfiguration iCfg = new IgniteConfiguration(); |
| |
| BinaryConfiguration bCfg = new BinaryConfiguration(); |
| |
| bCfg.setNameMapper(nameMapper); |
| bCfg.setIdMapper(mapper); |
| bCfg.setSerializer(serializer); |
| bCfg.setCompactFooter(compactFooter()); |
| |
| bCfg.setTypeConfigurations(cfgs); |
| |
| iCfg.setBinaryConfiguration(bCfg); |
| iCfg.setClientMode(false); |
| iCfg.setDiscoverySpi(new TcpDiscoverySpi() { |
| @Override public void sendCustomEvent(DiscoverySpiCustomMessage msg) throws IgniteException { |
| //No-op. |
| } |
| }); |
| iCfg.setSystemViewExporterSpi(new JmxSystemViewExporterSpi()); |
| |
| BinaryContext ctx = new BinaryContext(BinaryCachingMetadataHandler.create(), iCfg, new NullLogger()); |
| |
| BinaryMarshaller marsh = new BinaryMarshaller(); |
| |
| MarshallerContextTestImpl marshCtx = new MarshallerContextTestImpl(null, excludedClasses); |
| |
| GridTestKernalContext kernCtx = new GridTestKernalContext(log, iCfg); |
| |
| kernCtx.add(new GridSystemViewManager(kernCtx)); |
| kernCtx.add(new GridDiscoveryManager(kernCtx)); |
| |
| marshCtx.onMarshallerProcessorStarted(kernCtx, null); |
| |
| marsh.setContext(marshCtx); |
| |
| marsh.setBinaryContext(ctx, iCfg); |
| |
| return new BinaryObjectBuilderImpl(ctx, typeName); |
| } |
| |
| /** |
| * @param exp Expected. |
| * @param act Actual. |
| */ |
| private void assertBooleanArrayEquals(boolean[] exp, boolean[] act) { |
| assertEquals(exp.length, act.length); |
| |
| for (int i = 0; i < act.length; i++) |
| assertEquals(exp[i], act[i]); |
| } |
| |
| /** |
| * |
| */ |
| private static class SimpleObjectWithFinal { |
| /** */ |
| private final long time = System.currentTimeMillis(); |
| } |
| |
| /** |
| * @return Simple object. |
| */ |
| private static SimpleObject simpleObject() { |
| SimpleObject inner = new SimpleObject(); |
| |
| inner.b = 1; |
| inner.s = 1; |
| inner.i = 1; |
| inner.l = 1; |
| inner.f = 1.1f; |
| inner.d = 1.1d; |
| inner.c = 1; |
| inner.bool = true; |
| inner.str = "str1"; |
| inner.uuid = UUID.randomUUID(); |
| inner.date = new Date(); |
| inner.ts = new Timestamp(System.currentTimeMillis()); |
| inner.bArr = new byte[] {1, 2, 3}; |
| inner.sArr = new short[] {1, 2, 3}; |
| inner.iArr = new int[] {1, 2, 3}; |
| inner.lArr = new long[] {1, 2, 3}; |
| inner.fArr = new float[] {1.1f, 2.2f, 3.3f}; |
| inner.dArr = new double[] {1.1d, 2.2d, 3.3d}; |
| inner.cArr = new char[] {1, 2, 3}; |
| inner.boolArr = new boolean[] {true, false, true}; |
| inner.strArr = new String[] {"str1", "str2", "str3"}; |
| inner.uuidArr = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| inner.dateArr = new Date[] {new Date(11111), new Date(22222), new Date(33333)}; |
| inner.objArr = new Object[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| inner.col = new ArrayList<>(); |
| inner.map = new HashMap<>(); |
| inner.enumVal = TestEnum.A; |
| inner.enumArr = new TestEnum[] {TestEnum.A, TestEnum.B}; |
| inner.bdArr = new BigDecimal[] {new BigDecimal(1000), BigDecimal.ONE}; |
| |
| inner.col.add("str1"); |
| inner.col.add("str2"); |
| inner.col.add("str3"); |
| |
| inner.map.put(1, "str1"); |
| inner.map.put(2, "str2"); |
| inner.map.put(3, "str3"); |
| |
| SimpleObject outer = new SimpleObject(); |
| |
| outer.b = 2; |
| outer.s = 2; |
| outer.i = 2; |
| outer.l = 2; |
| outer.f = 2.2f; |
| outer.d = 2.2d; |
| outer.c = 2; |
| outer.bool = false; |
| outer.str = "str2"; |
| outer.uuid = UUID.randomUUID(); |
| outer.date = new Date(); |
| outer.ts = new Timestamp(System.currentTimeMillis()); |
| outer.bArr = new byte[] {10, 20, 30}; |
| outer.sArr = new short[] {10, 20, 30}; |
| outer.iArr = new int[] {10, 20, 30}; |
| outer.lArr = new long[] {10, 20, 30}; |
| outer.fArr = new float[] {10.01f, 20.02f, 30.03f}; |
| outer.dArr = new double[] {10.01d, 20.02d, 30.03d}; |
| outer.cArr = new char[] {10, 20, 30}; |
| outer.boolArr = new boolean[] {false, true, false}; |
| outer.strArr = new String[] {"str10", "str20", "str30"}; |
| outer.uuidArr = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| outer.dateArr = new Date[] {new Date(44444), new Date(55555), new Date(66666)}; |
| outer.objArr = new Object[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| outer.col = new ArrayList<>(); |
| outer.map = new HashMap<>(); |
| outer.enumVal = TestEnum.B; |
| outer.enumArr = new TestEnum[] {TestEnum.B, TestEnum.C}; |
| outer.inner = inner; |
| outer.bdArr = new BigDecimal[] {new BigDecimal(5000), BigDecimal.TEN}; |
| |
| outer.col.add("str4"); |
| outer.col.add("str5"); |
| outer.col.add("str6"); |
| |
| outer.map.put(4, "str4"); |
| outer.map.put(5, "str5"); |
| outer.map.put(6, "str6"); |
| |
| return outer; |
| } |
| |
| /** |
| * @return Binary object. |
| */ |
| private TestBinary binaryObject() { |
| SimpleObject innerSimple = new SimpleObject(); |
| |
| innerSimple.b = 1; |
| innerSimple.s = 1; |
| innerSimple.i = 1; |
| innerSimple.l = 1; |
| innerSimple.f = 1.1f; |
| innerSimple.d = 1.1d; |
| innerSimple.c = 1; |
| innerSimple.bool = true; |
| innerSimple.str = "str1"; |
| innerSimple.uuid = UUID.randomUUID(); |
| innerSimple.date = new Date(); |
| innerSimple.ts = new Timestamp(System.currentTimeMillis()); |
| innerSimple.bArr = new byte[] {1, 2, 3}; |
| innerSimple.sArr = new short[] {1, 2, 3}; |
| innerSimple.iArr = new int[] {1, 2, 3}; |
| innerSimple.lArr = new long[] {1, 2, 3}; |
| innerSimple.fArr = new float[] {1.1f, 2.2f, 3.3f}; |
| innerSimple.dArr = new double[] {1.1d, 2.2d, 3.3d}; |
| innerSimple.cArr = new char[] {1, 2, 3}; |
| innerSimple.boolArr = new boolean[] {true, false, true}; |
| innerSimple.strArr = new String[] {"str1", "str2", "str3"}; |
| innerSimple.uuidArr = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| innerSimple.dateArr = new Date[] {new Date(11111), new Date(22222), new Date(33333)}; |
| innerSimple.objArr = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| innerSimple.col = new ArrayList<>(); |
| innerSimple.map = new HashMap<>(); |
| innerSimple.enumVal = TestEnum.A; |
| innerSimple.enumArr = new TestEnum[] {TestEnum.A, TestEnum.B}; |
| |
| innerSimple.col.add("str1"); |
| innerSimple.col.add("str2"); |
| innerSimple.col.add("str3"); |
| |
| innerSimple.map.put(1, "str1"); |
| innerSimple.map.put(2, "str2"); |
| innerSimple.map.put(3, "str3"); |
| |
| TestBinary innerBinary = new TestBinary(); |
| |
| innerBinary.b = 2; |
| innerBinary.s = 2; |
| innerBinary.i = 2; |
| innerBinary.l = 2; |
| innerBinary.f = 2.2f; |
| innerBinary.d = 2.2d; |
| innerBinary.c = 2; |
| innerBinary.bool = true; |
| innerBinary.str = "str2"; |
| innerBinary.uuid = UUID.randomUUID(); |
| innerBinary.date = new Date(); |
| innerBinary.ts = new Timestamp(System.currentTimeMillis()); |
| innerBinary.bArr = new byte[] {10, 20, 30}; |
| innerBinary.sArr = new short[] {10, 20, 30}; |
| innerBinary.iArr = new int[] {10, 20, 30}; |
| innerBinary.lArr = new long[] {10, 20, 30}; |
| innerBinary.fArr = new float[] {10.01f, 20.02f, 30.03f}; |
| innerBinary.dArr = new double[] {10.01d, 20.02d, 30.03d}; |
| innerBinary.cArr = new char[] {10, 20, 30}; |
| innerBinary.boolArr = new boolean[] {true, false, true}; |
| innerBinary.strArr = new String[] {"str10", "str20", "str30"}; |
| innerBinary.uuidArr = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| innerBinary.dateArr = new Date[] {new Date(44444), new Date(55555), new Date(66666)}; |
| innerBinary.objArr = new Object[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| innerBinary.bRaw = 3; |
| innerBinary.sRaw = 3; |
| innerBinary.iRaw = 3; |
| innerBinary.lRaw = 3; |
| innerBinary.fRaw = 3.3f; |
| innerBinary.dRaw = 3.3d; |
| innerBinary.cRaw = 3; |
| innerBinary.boolRaw = true; |
| innerBinary.strRaw = "str3"; |
| innerBinary.uuidRaw = UUID.randomUUID(); |
| innerBinary.dateRaw = new Date(); |
| innerBinary.tsRaw = new Timestamp(System.currentTimeMillis()); |
| innerBinary.bArrRaw = new byte[] {11, 21, 31}; |
| innerBinary.sArrRaw = new short[] {11, 21, 31}; |
| innerBinary.iArrRaw = new int[] {11, 21, 31}; |
| innerBinary.lArrRaw = new long[] {11, 21, 31}; |
| innerBinary.fArrRaw = new float[] {11.11f, 21.12f, 31.13f}; |
| innerBinary.dArrRaw = new double[] {11.11d, 21.12d, 31.13d}; |
| innerBinary.cArrRaw = new char[] {11, 21, 31}; |
| innerBinary.boolArrRaw = new boolean[] {true, false, true}; |
| innerBinary.strArrRaw = new String[] {"str11", "str21", "str31"}; |
| innerBinary.uuidArrRaw = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| innerBinary.dateArrRaw = new Date[] {new Date(77777), new Date(88888), new Date(99999)}; |
| innerBinary.objArrRaw = new Object[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| innerBinary.col = new ArrayList<>(); |
| innerBinary.colRaw = new ArrayList<>(); |
| innerBinary.map = new HashMap<>(); |
| innerBinary.mapRaw = new HashMap<>(); |
| innerBinary.enumVal = TestEnum.B; |
| innerBinary.enumValRaw = TestEnum.C; |
| innerBinary.enumArr = new TestEnum[] {TestEnum.B, TestEnum.C}; |
| innerBinary.enumArrRaw = new TestEnum[] {TestEnum.C, TestEnum.D}; |
| |
| innerBinary.col.add("str4"); |
| innerBinary.col.add("str5"); |
| innerBinary.col.add("str6"); |
| |
| innerBinary.map.put(4, "str4"); |
| innerBinary.map.put(5, "str5"); |
| innerBinary.map.put(6, "str6"); |
| |
| innerBinary.colRaw.add("str7"); |
| innerBinary.colRaw.add("str8"); |
| innerBinary.colRaw.add("str9"); |
| |
| innerBinary.mapRaw.put(7, "str7"); |
| innerBinary.mapRaw.put(8, "str8"); |
| innerBinary.mapRaw.put(9, "str9"); |
| |
| TestBinary outer = new TestBinary(); |
| |
| outer.b = 4; |
| outer.s = 4; |
| outer.i = 4; |
| outer.l = 4; |
| outer.f = 4.4f; |
| outer.d = 4.4d; |
| outer.c = 4; |
| outer.bool = true; |
| outer.str = "str4"; |
| outer.uuid = UUID.randomUUID(); |
| outer.date = new Date(); |
| outer.ts = new Timestamp(System.currentTimeMillis()); |
| outer.bArr = new byte[] {12, 22, 32}; |
| outer.sArr = new short[] {12, 22, 32}; |
| outer.iArr = new int[] {12, 22, 32}; |
| outer.lArr = new long[] {12, 22, 32}; |
| outer.fArr = new float[] {12.21f, 22.22f, 32.23f}; |
| outer.dArr = new double[] {12.21d, 22.22d, 32.23d}; |
| outer.cArr = new char[] {12, 22, 32}; |
| outer.boolArr = new boolean[] {true, false, true}; |
| outer.strArr = new String[] {"str12", "str22", "str32"}; |
| outer.uuidArr = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| outer.dateArr = new Date[] {new Date(10101), new Date(20202), new Date(30303)}; |
| outer.objArr = new Object[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| outer.simple = innerSimple; |
| outer.binary = innerBinary; |
| outer.bRaw = 5; |
| outer.sRaw = 5; |
| outer.iRaw = 5; |
| outer.lRaw = 5; |
| outer.fRaw = 5.5f; |
| outer.dRaw = 5.5d; |
| outer.cRaw = 5; |
| outer.boolRaw = true; |
| outer.strRaw = "str5"; |
| outer.uuidRaw = UUID.randomUUID(); |
| outer.dateRaw = new Date(); |
| outer.tsRaw = new Timestamp(System.currentTimeMillis()); |
| outer.bArrRaw = new byte[] {13, 23, 33}; |
| outer.sArrRaw = new short[] {13, 23, 33}; |
| outer.iArrRaw = new int[] {13, 23, 33}; |
| outer.lArrRaw = new long[] {13, 23, 33}; |
| outer.fArrRaw = new float[] {13.31f, 23.32f, 33.33f}; |
| outer.dArrRaw = new double[] {13.31d, 23.32d, 33.33d}; |
| outer.cArrRaw = new char[] {13, 23, 33}; |
| outer.boolArrRaw = new boolean[] {true, false, true}; |
| outer.strArrRaw = new String[] {"str13", "str23", "str33"}; |
| outer.uuidArrRaw = new UUID[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| outer.dateArr = new Date[] {new Date(40404), new Date(50505), new Date(60606)}; |
| outer.objArrRaw = new Object[] {UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID()}; |
| outer.col = new ArrayList<>(); |
| outer.colRaw = new ArrayList<>(); |
| outer.map = new HashMap<>(); |
| outer.mapRaw = new HashMap<>(); |
| outer.enumVal = TestEnum.D; |
| outer.enumValRaw = TestEnum.E; |
| outer.enumArr = new TestEnum[] {TestEnum.D, TestEnum.E}; |
| outer.enumArrRaw = new TestEnum[] {TestEnum.E, TestEnum.A}; |
| outer.simpleRaw = innerSimple; |
| outer.binaryRaw = innerBinary; |
| |
| outer.col.add("str10"); |
| outer.col.add("str11"); |
| outer.col.add("str12"); |
| |
| outer.map.put(10, "str10"); |
| outer.map.put(11, "str11"); |
| outer.map.put(12, "str12"); |
| |
| outer.colRaw.add("str13"); |
| outer.colRaw.add("str14"); |
| outer.colRaw.add("str15"); |
| |
| outer.mapRaw.put(16, "str16"); |
| outer.mapRaw.put(17, "str16"); |
| outer.mapRaw.put(18, "str17"); |
| |
| return outer; |
| } |
| |
| /** |
| */ |
| private enum TestEnum { |
| /** */ |
| A, |
| |
| /** */ |
| B, |
| |
| /** */ |
| C, |
| |
| /** */ |
| D, |
| |
| /** */ |
| E |
| } |
| |
| /** */ |
| public static class SimpleObject { |
| /** */ |
| private byte b; |
| |
| /** */ |
| private short s; |
| |
| /** */ |
| private int i; |
| |
| /** */ |
| private long l; |
| |
| /** */ |
| private float f; |
| |
| /** */ |
| private double d; |
| |
| /** */ |
| private char c; |
| |
| /** */ |
| private boolean bool; |
| |
| /** */ |
| private String str; |
| |
| /** */ |
| private UUID uuid; |
| |
| /** */ |
| private Date date; |
| |
| /** */ |
| private Timestamp ts; |
| |
| /** */ |
| private Time time; |
| |
| /** */ |
| private byte[] bArr; |
| |
| /** */ |
| private short[] sArr; |
| |
| /** */ |
| private int[] iArr; |
| |
| /** */ |
| private long[] lArr; |
| |
| /** */ |
| private float[] fArr; |
| |
| /** */ |
| private double[] dArr; |
| |
| /** */ |
| private char[] cArr; |
| |
| /** */ |
| private boolean[] boolArr; |
| |
| /** */ |
| private String[] strArr; |
| |
| /** */ |
| private UUID[] uuidArr; |
| |
| /** */ |
| private Date[] dateArr; |
| |
| /** */ |
| private Time[] timeArr; |
| |
| /** */ |
| private Object[] objArr; |
| |
| /** */ |
| private BigDecimal[] bdArr; |
| |
| /** */ |
| private Collection<String> col; |
| |
| /** */ |
| private Map<Integer, String> map; |
| |
| /** */ |
| private TestEnum enumVal; |
| |
| /** */ |
| private TestEnum[] enumArr; |
| |
| /** */ |
| private SimpleObject inner; |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object other) { |
| if (this == other) |
| return true; |
| |
| if (other == null || getClass() != other.getClass()) |
| return false; |
| |
| SimpleObject obj = (SimpleObject)other; |
| |
| return GridTestUtils.deepEquals(this, obj); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public String toString() { |
| return S.toString(SimpleObject.class, this); |
| } |
| } |
| |
| /** */ |
| private static class TestBinary implements Binarylizable { |
| /** */ |
| private byte b; |
| |
| /** */ |
| private byte bRaw; |
| |
| /** */ |
| private short s; |
| |
| /** */ |
| private short sRaw; |
| |
| /** */ |
| private int i; |
| |
| /** */ |
| private int iRaw; |
| |
| /** */ |
| private long l; |
| |
| /** */ |
| private long lRaw; |
| |
| /** */ |
| private float f; |
| |
| /** */ |
| private float fRaw; |
| |
| /** */ |
| private double d; |
| |
| /** */ |
| private double dRaw; |
| |
| /** */ |
| private char c; |
| |
| /** */ |
| private char cRaw; |
| |
| /** */ |
| private boolean bool; |
| |
| /** */ |
| private boolean boolRaw; |
| |
| /** */ |
| private String str; |
| |
| /** */ |
| private String strRaw; |
| |
| /** */ |
| private UUID uuid; |
| |
| /** */ |
| private UUID uuidRaw; |
| |
| /** */ |
| private Date date; |
| |
| /** */ |
| private Date dateRaw; |
| |
| /** */ |
| private Timestamp ts; |
| |
| /** */ |
| private Timestamp tsRaw; |
| |
| /** */ |
| private Time time; |
| |
| /** */ |
| private Time timeRaw; |
| |
| /** */ |
| private byte[] bArr; |
| |
| /** */ |
| private byte[] bArrRaw; |
| |
| /** */ |
| private short[] sArr; |
| |
| /** */ |
| private short[] sArrRaw; |
| |
| /** */ |
| private int[] iArr; |
| |
| /** */ |
| private int[] iArrRaw; |
| |
| /** */ |
| private long[] lArr; |
| |
| /** */ |
| private long[] lArrRaw; |
| |
| /** */ |
| private float[] fArr; |
| |
| /** */ |
| private float[] fArrRaw; |
| |
| /** */ |
| private double[] dArr; |
| |
| /** */ |
| private double[] dArrRaw; |
| |
| /** */ |
| private char[] cArr; |
| |
| /** */ |
| private char[] cArrRaw; |
| |
| /** */ |
| private boolean[] boolArr; |
| |
| /** */ |
| private boolean[] boolArrRaw; |
| |
| /** */ |
| private String[] strArr; |
| |
| /** */ |
| private String[] strArrRaw; |
| |
| /** */ |
| private UUID[] uuidArr; |
| |
| /** */ |
| private UUID[] uuidArrRaw; |
| |
| /** */ |
| private Date[] dateArr; |
| |
| /** */ |
| private Date[] dateArrRaw; |
| |
| /** */ |
| private Time[] timeArr; |
| |
| /** */ |
| private Time[] timeArrRaw; |
| |
| /** */ |
| private Object[] objArr; |
| |
| /** */ |
| private Object[] objArrRaw; |
| |
| /** */ |
| private Collection<String> col; |
| |
| /** */ |
| private Collection<String> colRaw; |
| |
| /** */ |
| private Map<Integer, String> map; |
| |
| /** */ |
| private Map<Integer, String> mapRaw; |
| |
| /** */ |
| private TestEnum enumVal; |
| |
| /** */ |
| private TestEnum enumValRaw; |
| |
| /** */ |
| private TestEnum[] enumArr; |
| |
| /** */ |
| private TestEnum[] enumArrRaw; |
| |
| /** */ |
| private SimpleObject simple; |
| |
| /** */ |
| private SimpleObject simpleRaw; |
| |
| /** */ |
| private TestBinary binary; |
| |
| /** */ |
| private TestBinary binaryRaw; |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| writer.writeByte("_b", b); |
| writer.writeShort("_s", s); |
| writer.writeInt("_i", i); |
| writer.writeLong("_l", l); |
| writer.writeFloat("_f", f); |
| writer.writeDouble("_d", d); |
| writer.writeChar("_c", c); |
| writer.writeBoolean("_bool", bool); |
| writer.writeString("_str", str); |
| writer.writeUuid("_uuid", uuid); |
| writer.writeDate("_date", date); |
| writer.writeTimestamp("_ts", ts); |
| writer.writeTime("_time", time); |
| writer.writeByteArray("_bArr", bArr); |
| writer.writeShortArray("_sArr", sArr); |
| writer.writeIntArray("_iArr", iArr); |
| writer.writeLongArray("_lArr", lArr); |
| writer.writeFloatArray("_fArr", fArr); |
| writer.writeDoubleArray("_dArr", dArr); |
| writer.writeCharArray("_cArr", cArr); |
| writer.writeBooleanArray("_boolArr", boolArr); |
| writer.writeStringArray("_strArr", strArr); |
| writer.writeUuidArray("_uuidArr", uuidArr); |
| writer.writeDateArray("_dateArr", dateArr); |
| writer.writeTimeArray("_timeArr", timeArr); |
| writer.writeObjectArray("_objArr", objArr); |
| writer.writeCollection("_col", col); |
| writer.writeMap("_map", map); |
| writer.writeEnum("_enumVal", enumVal); |
| writer.writeEnumArray("_enumArr", enumArr); |
| writer.writeObject("_simple", simple); |
| writer.writeObject("_binary", binary); |
| |
| BinaryRawWriter raw = writer.rawWriter(); |
| |
| raw.writeByte(bRaw); |
| raw.writeShort(sRaw); |
| raw.writeInt(iRaw); |
| raw.writeLong(lRaw); |
| raw.writeFloat(fRaw); |
| raw.writeDouble(dRaw); |
| raw.writeChar(cRaw); |
| raw.writeBoolean(boolRaw); |
| raw.writeString(strRaw); |
| raw.writeUuid(uuidRaw); |
| raw.writeDate(dateRaw); |
| raw.writeTimestamp(tsRaw); |
| raw.writeTime(timeRaw); |
| raw.writeByteArray(bArrRaw); |
| raw.writeShortArray(sArrRaw); |
| raw.writeIntArray(iArrRaw); |
| raw.writeLongArray(lArrRaw); |
| raw.writeFloatArray(fArrRaw); |
| raw.writeDoubleArray(dArrRaw); |
| raw.writeCharArray(cArrRaw); |
| raw.writeBooleanArray(boolArrRaw); |
| raw.writeStringArray(strArrRaw); |
| raw.writeUuidArray(uuidArrRaw); |
| raw.writeDateArray(dateArrRaw); |
| raw.writeTimeArray(timeArrRaw); |
| raw.writeObjectArray(objArrRaw); |
| raw.writeCollection(colRaw); |
| raw.writeMap(mapRaw); |
| raw.writeEnum(enumValRaw); |
| raw.writeEnumArray(enumArrRaw); |
| raw.writeObject(simpleRaw); |
| raw.writeObject(binaryRaw); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| b = reader.readByte("_b"); |
| s = reader.readShort("_s"); |
| i = reader.readInt("_i"); |
| l = reader.readLong("_l"); |
| f = reader.readFloat("_f"); |
| d = reader.readDouble("_d"); |
| c = reader.readChar("_c"); |
| bool = reader.readBoolean("_bool"); |
| str = reader.readString("_str"); |
| uuid = reader.readUuid("_uuid"); |
| date = reader.readDate("_date"); |
| ts = reader.readTimestamp("_ts"); |
| time = reader.readTime("_time"); |
| bArr = reader.readByteArray("_bArr"); |
| sArr = reader.readShortArray("_sArr"); |
| iArr = reader.readIntArray("_iArr"); |
| lArr = reader.readLongArray("_lArr"); |
| fArr = reader.readFloatArray("_fArr"); |
| dArr = reader.readDoubleArray("_dArr"); |
| cArr = reader.readCharArray("_cArr"); |
| boolArr = reader.readBooleanArray("_boolArr"); |
| strArr = reader.readStringArray("_strArr"); |
| uuidArr = reader.readUuidArray("_uuidArr"); |
| dateArr = reader.readDateArray("_dateArr"); |
| timeArr = reader.readTimeArray("_timeArr"); |
| objArr = reader.readObjectArray("_objArr"); |
| col = reader.readCollection("_col"); |
| map = reader.readMap("_map"); |
| enumVal = reader.readEnum("_enumVal"); |
| enumArr = reader.readEnumArray("_enumArr"); |
| simple = reader.readObject("_simple"); |
| binary = reader.readObject("_binary"); |
| |
| BinaryRawReader raw = reader.rawReader(); |
| |
| bRaw = raw.readByte(); |
| sRaw = raw.readShort(); |
| iRaw = raw.readInt(); |
| lRaw = raw.readLong(); |
| fRaw = raw.readFloat(); |
| dRaw = raw.readDouble(); |
| cRaw = raw.readChar(); |
| boolRaw = raw.readBoolean(); |
| strRaw = raw.readString(); |
| uuidRaw = raw.readUuid(); |
| dateRaw = raw.readDate(); |
| tsRaw = raw.readTimestamp(); |
| timeRaw = raw.readTime(); |
| bArrRaw = raw.readByteArray(); |
| sArrRaw = raw.readShortArray(); |
| iArrRaw = raw.readIntArray(); |
| lArrRaw = raw.readLongArray(); |
| fArrRaw = raw.readFloatArray(); |
| dArrRaw = raw.readDoubleArray(); |
| cArrRaw = raw.readCharArray(); |
| boolArrRaw = raw.readBooleanArray(); |
| strArrRaw = raw.readStringArray(); |
| uuidArrRaw = raw.readUuidArray(); |
| dateArrRaw = raw.readDateArray(); |
| timeArrRaw = raw.readTimeArray(); |
| objArrRaw = raw.readObjectArray(); |
| colRaw = raw.readCollection(); |
| mapRaw = raw.readMap(); |
| enumValRaw = raw.readEnum(); |
| enumArrRaw = raw.readEnumArray(); |
| simpleRaw = raw.readObject(); |
| binaryRaw = raw.readObject(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object other) { |
| if (this == other) |
| return true; |
| |
| if (other == null || getClass() != other.getClass()) |
| return false; |
| |
| TestBinary obj = (TestBinary)other; |
| |
| return GridTestUtils.deepEquals(this, obj); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public String toString() { |
| return S.toString(TestBinary.class, this); |
| } |
| } |
| |
| /** |
| */ |
| private static class CustomSerializedObject1 implements Binarylizable { |
| /** */ |
| private int val; |
| |
| /** |
| */ |
| private CustomSerializedObject1() { |
| // No-op. |
| } |
| |
| /** |
| * @param val Value. |
| */ |
| private CustomSerializedObject1(int val) { |
| this.val = val; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| // No-op. |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| // No-op. |
| } |
| } |
| |
| /** |
| */ |
| private static class CustomSerializedObject2 implements Binarylizable { |
| /** */ |
| private int val; |
| |
| /** |
| */ |
| private CustomSerializedObject2() { |
| // No-op. |
| } |
| |
| /** |
| * @param val Value. |
| */ |
| private CustomSerializedObject2(int val) { |
| this.val = val; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| // No-op. |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| // No-op. |
| } |
| } |
| |
| /** |
| */ |
| private static class CustomSerializer1 implements BinarySerializer { |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(Object obj, BinaryWriter writer) throws BinaryObjectException { |
| CustomSerializedObject1 o = (CustomSerializedObject1)obj; |
| |
| writer.writeInt("val", o.val * 2); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(Object obj, BinaryReader reader) throws BinaryObjectException { |
| CustomSerializedObject1 o = (CustomSerializedObject1)obj; |
| |
| o.val = reader.readInt("val"); |
| } |
| } |
| |
| /** |
| */ |
| private static class CustomSerializer2 implements BinarySerializer { |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(Object obj, BinaryWriter writer) throws BinaryObjectException { |
| CustomSerializedObject2 o = (CustomSerializedObject2)obj; |
| |
| writer.writeInt("val", o.val * 3); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(Object obj, BinaryReader reader) throws BinaryObjectException { |
| CustomSerializedObject2 o = (CustomSerializedObject2)obj; |
| |
| o.val = reader.readInt("val"); |
| } |
| } |
| |
| /** |
| */ |
| private static class CustomMappedObject1 { |
| /** */ |
| private int val1; |
| |
| /** */ |
| private String val2; |
| |
| /** |
| */ |
| private CustomMappedObject1() { |
| // No-op. |
| } |
| |
| /** |
| * @param val1 Value 1. |
| * @param val2 Value 2. |
| */ |
| private CustomMappedObject1(int val1, String val2) { |
| this.val1 = val1; |
| this.val2 = val2; |
| } |
| } |
| |
| /** |
| */ |
| private static class InnerMappedObject extends CustomMappedObject1 { |
| /** |
| * @param val1 Val1 |
| * @param val2 Val2 |
| */ |
| InnerMappedObject(int val1, String val2) { |
| super(val1, val2); |
| } |
| } |
| |
| /** |
| */ |
| private static class CustomMappedObject2 { |
| /** */ |
| private int val1; |
| |
| /** */ |
| private String val2; |
| |
| /** |
| */ |
| private CustomMappedObject2() { |
| // No-op. |
| } |
| |
| /** |
| * @param val1 Value 1. |
| * @param val2 Value 2. |
| */ |
| private CustomMappedObject2(int val1, String val2) { |
| this.val1 = val1; |
| this.val2 = val2; |
| } |
| } |
| |
| /** |
| */ |
| private static class DynamicObject implements Binarylizable { |
| /** */ |
| private int idx; |
| |
| /** */ |
| private int val1; |
| |
| /** */ |
| private int val2; |
| |
| /** */ |
| private int val3; |
| |
| /** |
| */ |
| private DynamicObject() { |
| // No-op. |
| } |
| |
| /** |
| * @param val1 Value 1. |
| * @param val2 Value 2. |
| * @param val3 Value 3. |
| */ |
| private DynamicObject(int idx, int val1, int val2, int val3) { |
| this.idx = idx; |
| this.val1 = val1; |
| this.val2 = val2; |
| this.val3 = val3; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| writer.writeInt("val1", val1); |
| |
| if (idx > 0) |
| writer.writeInt("val2", val2); |
| |
| if (idx > 1) |
| writer.writeInt("val3", val3); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| val1 = reader.readInt("val1"); |
| val2 = reader.readInt("val2"); |
| val3 = reader.readInt("val3"); |
| } |
| } |
| |
| /** |
| * Custom array list. |
| */ |
| private static class CustomArrayList extends ArrayList { |
| // No-op. |
| } |
| |
| /** |
| * Custom hash map. |
| */ |
| private static class CustomHashMap extends HashMap { |
| // No-op. |
| } |
| |
| /** |
| * Holder for non-stadard collections. |
| */ |
| private static class CustomCollections { |
| /** */ |
| public List list = new ArrayList(); |
| |
| /** */ |
| public List customList = new CustomArrayList(); |
| } |
| |
| /** */ |
| @SuppressWarnings("unchecked") |
| private static class CustomCollectionsWithFactory implements Binarylizable { |
| /** */ |
| public List list = new CustomArrayList(); |
| |
| /** */ |
| public Map map = new CustomHashMap(); |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| writer.writeCollection("list", list); |
| writer.writeMap("map", map); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| list = (List)reader.readCollection("list", new BinaryCollectionFactory<Object>() { |
| @Override public Collection<Object> create(int size) { |
| return new CustomArrayList(); |
| } |
| }); |
| |
| map = reader.readMap("map", new BinaryMapFactory<Object, Object>() { |
| @Override public Map<Object, Object> create(int size) { |
| return new CustomHashMap(); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Dummy value holder. |
| */ |
| private static class DummyHolder { |
| /** Value. */ |
| public int val; |
| |
| /** |
| * Constructor. |
| * |
| * @param val Value. |
| */ |
| public DummyHolder(int val) { |
| this.val = val; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| return o != null && o instanceof DummyHolder && ((DummyHolder)o).val == val; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int hashCode() { |
| return val; |
| } |
| } |
| |
| /** |
| */ |
| private static class CycleLinkObject { |
| /** */ |
| private CycleLinkObject self; |
| } |
| |
| /** |
| */ |
| private static class DetachedTestObject implements Binarylizable { |
| /** */ |
| private DetachedInnerTestObject inner1; |
| |
| /** */ |
| private Object inner2; |
| |
| /** */ |
| private Object inner3; |
| |
| /** */ |
| private DetachedInnerTestObject inner4; |
| |
| /** |
| */ |
| private DetachedTestObject() { |
| // No-op. |
| } |
| |
| /** |
| * @param inner Inner object. |
| */ |
| private DetachedTestObject(DetachedInnerTestObject inner) { |
| inner1 = inner; |
| inner2 = inner; |
| inner3 = new DetachedInnerTestObject(inner, inner.id); |
| inner4 = inner; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| BinaryRawWriterEx raw = (BinaryRawWriterEx)writer.rawWriter(); |
| |
| raw.writeObject(inner1); |
| raw.writeObjectDetached(inner2); |
| raw.writeObjectDetached(inner3); |
| raw.writeObject(inner4); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| BinaryRawReaderEx raw = (BinaryRawReaderEx)reader.rawReader(); |
| |
| inner1 = (DetachedInnerTestObject)raw.readObject(); |
| inner2 = raw.readObjectDetached(); |
| inner3 = raw.readObjectDetached(); |
| inner4 = (DetachedInnerTestObject)raw.readObject(); |
| } |
| } |
| |
| /** |
| */ |
| private static class DetachedInnerTestObject { |
| /** */ |
| private DetachedInnerTestObject inner; |
| |
| /** */ |
| private UUID id; |
| |
| /** |
| */ |
| private DetachedInnerTestObject() { |
| // No-op. |
| } |
| |
| /** |
| * @param inner Inner object. |
| * @param id ID. |
| */ |
| private DetachedInnerTestObject(DetachedInnerTestObject inner, UUID id) { |
| this.inner = inner; |
| this.id = id; |
| } |
| } |
| |
| /** |
| */ |
| private static class CollectionFieldsObject { |
| /** */ |
| private Object[] arr; |
| |
| /** */ |
| private Collection<Value> col; |
| |
| /** */ |
| private Map<Key, Value> map; |
| |
| /** |
| */ |
| private CollectionFieldsObject() { |
| // No-op. |
| } |
| |
| /** |
| * @param arr Array. |
| * @param col Collection. |
| * @param map Map. |
| */ |
| private CollectionFieldsObject(Object[] arr, Collection<Value> col, Map<Key, Value> map) { |
| this.arr = arr; |
| this.col = col; |
| this.map = map; |
| } |
| } |
| |
| /** |
| */ |
| private static class Key { |
| /** */ |
| private int key; |
| |
| /** |
| */ |
| private Key() { |
| // No-op. |
| } |
| |
| /** |
| * n |
| * |
| * @param key Key. |
| */ |
| private Key(int key) { |
| this.key = key; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| |
| Key key0 = (Key)o; |
| |
| return key == key0.key; |
| |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int hashCode() { |
| return key; |
| } |
| } |
| |
| /** |
| */ |
| private static class Value { |
| /** */ |
| private int val; |
| |
| /** |
| */ |
| private Value() { |
| // No-op. |
| } |
| |
| /** |
| * @param val Value. |
| */ |
| private Value(int val) { |
| this.val = val; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| |
| if (!(o instanceof Value)) |
| return false; |
| |
| Value value = (Value)o; |
| |
| return val == value.val; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int hashCode() { |
| return val; |
| } |
| } |
| |
| /** |
| */ |
| private static class DateClass1 { |
| /** */ |
| private Date date; |
| |
| /** */ |
| private Timestamp ts; |
| |
| /** */ |
| private Time time; |
| |
| /** */ |
| private Time[] timeArr; |
| } |
| |
| /** |
| * |
| */ |
| private static class NoPublicConstructor { |
| /** */ |
| private String val = "test"; |
| |
| /** |
| * @return Value. |
| */ |
| public String getVal() { |
| return val; |
| } |
| } |
| |
| /** |
| * |
| */ |
| @SuppressWarnings("PublicConstructorInNonPublicClass") |
| private static class NoPublicDefaultConstructor { |
| /** */ |
| private int val; |
| |
| /** |
| * @param val Value. |
| */ |
| public NoPublicDefaultConstructor(int val) { |
| this.val = val; |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class ProtectedConstructor { |
| /** |
| * Protected constructor. |
| */ |
| protected ProtectedConstructor() { |
| // No-op. |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class MyTestClass implements Binarylizable { |
| /** */ |
| private boolean readyToSerialize; |
| |
| /** */ |
| private String s; |
| |
| /** |
| * @return Object. |
| */ |
| Object writeReplace() { |
| readyToSerialize = true; |
| |
| return this; |
| } |
| |
| /** |
| * @return Object. |
| */ |
| Object readResolve() { |
| s = "readResolve"; |
| |
| return this; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| if (!readyToSerialize) |
| fail(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| s = "readBinary"; |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class MySingleton { |
| /** */ |
| public static final MySingleton INSTANCE = new MySingleton(); |
| |
| /** */ |
| private String s; |
| |
| /** Initializer. */ { |
| StringBuilder builder = new StringBuilder(); |
| |
| for (int i = 0; i < 10000; i++) { |
| builder.append("+"); |
| } |
| |
| s = builder.toString(); |
| } |
| |
| /** |
| * @return Object. |
| */ |
| Object writeReplace() { |
| return new SingletonMarker(); |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class SingletonMarker { |
| /** |
| * @return Object. |
| */ |
| Object readResolve() { |
| return MySingleton.INSTANCE; |
| } |
| } |
| |
| /** |
| * |
| */ |
| public static class SimpleEnclosingObject { |
| /** */ |
| private Object simpl; |
| } |
| |
| /** |
| * |
| */ |
| public static class SimpleExternalizable implements Externalizable { |
| /** */ |
| private String field; |
| |
| /** |
| * {@link Externalizable} support. |
| */ |
| public SimpleExternalizable() { |
| // No-op. |
| } |
| |
| /** |
| * @param field Field. |
| */ |
| public SimpleExternalizable(String field) { |
| this.field = field; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeExternal(ObjectOutput out) throws IOException { |
| U.writeString(out, field); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { |
| field = U.readString(in); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| |
| SimpleExternalizable that = (SimpleExternalizable)o; |
| |
| return field.equals(that.field); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int hashCode() { |
| return field.hashCode(); |
| } |
| } |
| |
| /** |
| * Class B for duplicate fields test. |
| */ |
| private static class DuplicateFieldsA { |
| /** Field. */ |
| int x; |
| |
| /** |
| * Constructor. |
| * |
| * @param x Field. |
| */ |
| protected DuplicateFieldsA(int x) { |
| this.x = x; |
| } |
| |
| /** |
| * @return A's field. |
| */ |
| public int xA() { |
| return x; |
| } |
| } |
| |
| /** |
| * Class B for duplicate fields test. |
| */ |
| private static class DuplicateFieldsB extends DuplicateFieldsA { |
| /** Field. */ |
| int x; |
| |
| /** |
| * Constructor. |
| * |
| * @param xA Field for parent class. |
| * @param xB Field for current class. |
| */ |
| public DuplicateFieldsB(int xA, int xB) { |
| super(xA); |
| |
| this.x = xB; |
| } |
| |
| /** |
| * @return B's field. |
| */ |
| public int xB() { |
| return x; |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class DecimalReflective { |
| /** */ |
| public BigDecimal val; |
| |
| /** */ |
| public BigDecimal[] valArr; |
| } |
| |
| /** |
| * |
| */ |
| private static class DecimalMarshalAware extends DecimalReflective implements Binarylizable { |
| /** */ |
| public BigDecimal rawVal; |
| |
| /** */ |
| public BigDecimal[] rawValArr; |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| writer.writeDecimal("val", val); |
| writer.writeDecimalArray("valArr", valArr); |
| |
| BinaryRawWriter rawWriter = writer.rawWriter(); |
| |
| rawWriter.writeDecimal(rawVal); |
| rawWriter.writeDecimalArray(rawValArr); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| val = reader.readDecimal("val"); |
| valArr = reader.readDecimalArray("valArr"); |
| |
| BinaryRawReader rawReader = reader.rawReader(); |
| |
| rawVal = rawReader.readDecimal(); |
| rawValArr = rawReader.readDecimalArray(); |
| } |
| } |
| |
| /** |
| */ |
| private static class SingleHandleA { |
| /** */ |
| private SingleHandleB b; |
| |
| /** */ |
| private Map<Object, SingleHandleB> map = new HashMap<>(); |
| |
| /** |
| * @param b B. |
| */ |
| SingleHandleA(SingleHandleB b) { |
| this.b = b; |
| |
| map.put("key", b); |
| } |
| } |
| |
| /** |
| */ |
| private static class SingleHandleB { |
| } |
| |
| /** |
| */ |
| private static class ClassFieldObject { |
| /** */ |
| private Class<?> cls; |
| |
| /** |
| * @param cls Class field. |
| */ |
| public ClassFieldObject(Class<?> cls) { |
| this.cls = cls; |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class TestClass0 { |
| /** */ |
| private int intVal = 33; |
| |
| /** */ |
| private String strVal = "Test string value"; |
| |
| /** */ |
| private SimpleObject obj = constSimpleObject(); |
| |
| /** |
| * @return Constant value of the SimpleObject. |
| */ |
| public static SimpleObject constSimpleObject() { |
| SimpleObject obj = simpleObject(); |
| |
| obj.uuid = null; |
| obj.date = new Date(33); |
| obj.ts = new Timestamp(22); |
| obj.uuidArr = new UUID[] {null, null, null}; |
| obj.dateArr = new Date[] {new Date(11111), new Date(22222), new Date(33333)}; |
| obj.objArr = new Object[] {null, null, null}; |
| |
| obj.inner.uuid = null; |
| obj.inner.date = new Date(33); |
| obj.inner.ts = new Timestamp(22); |
| obj.inner.uuidArr = new UUID[] {null, null, null}; |
| obj.inner.dateArr = new Date[] {new Date(11111), new Date(22222), new Date(33333)}; |
| obj.inner.objArr = new Object[] {null, null, null}; |
| |
| return obj; |
| } |
| } |
| |
| /** */ |
| public static class ArrayFieldClass { |
| /** */ |
| protected TestClass1[] arr1; |
| |
| /** */ |
| protected TestClass1[] arr2; |
| } |
| |
| /** |
| * |
| */ |
| public static class TestClass1 { |
| /** */ |
| private int intVal = 33; |
| |
| /** */ |
| private String strVal = "Test string value"; |
| |
| /** */ |
| private SimpleObject obj = TestClass0.constSimpleObject(); |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| TestClass1 class1 = (TestClass1)o; |
| return intVal == class1.intVal && Objects.equals(strVal, class1.strVal) && Objects.equals(obj, class1.obj); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int hashCode() { |
| return Objects.hash(intVal, strVal, obj); |
| } |
| } |
| |
| /** |
| * |
| */ |
| private static class TestClass2 extends TestClass0 { |
| } |
| |
| /** */ |
| private static class ObjectWithRaw implements Binarylizable { |
| /** */ |
| private int val; |
| |
| /** */ |
| private int rawVal; |
| |
| /** |
| * |
| */ |
| public ObjectWithRaw() { |
| } |
| |
| /** |
| * @param val Value. |
| * @param rawVal Raw value. |
| */ |
| public ObjectWithRaw(int val, int rawVal) { |
| this.val = val; |
| this.rawVal = rawVal; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| writer.writeInt("val", val); |
| |
| writer.rawWriter().writeInt(rawVal); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| val = reader.readInt("val"); |
| |
| rawVal = reader.rawReader().readInt(); |
| } |
| } |
| |
| /** */ |
| private static class ObjectRaw implements Binarylizable { |
| /** */ |
| private int val0; |
| |
| /** */ |
| private int val1; |
| |
| /** |
| * |
| */ |
| public ObjectRaw() { |
| } |
| |
| /** |
| * @param val0 Value. |
| * @param val1 Raw value. |
| */ |
| public ObjectRaw(int val0, int val1) { |
| this.val0 = val0; |
| this.val1 = val1; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { |
| writer.rawWriter().writeInt(val0); |
| writer.rawWriter().writeInt(val1); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { |
| BinaryRawReader rawReader = reader.rawReader(); |
| |
| val0 = rawReader.readInt(); |
| val1 = rawReader.readInt(); |
| } |
| } |
| |
| /** */ |
| private static class EnumObject implements Serializable { |
| /** */ |
| private long id; |
| |
| /** */ |
| private String name; |
| |
| /** */ |
| private DeclaredBodyEnum type; |
| |
| /** */ |
| EnumObject(final long id, final String name, final DeclaredBodyEnum type) { |
| this.id = id; |
| this.name = name; |
| this.type = type; |
| } |
| } |
| |
| /** */ |
| public enum DeclaredBodyEnum { |
| /** */ |
| ONE { |
| /** {@inheritDoc} */ |
| @Override boolean isSupported() { |
| return false; |
| } |
| }, |
| |
| /** */ |
| TWO { |
| /** {@inkheritDoc} */ |
| @Override boolean isSupported() { |
| return false; |
| } |
| }; |
| |
| /** */ |
| abstract boolean isSupported(); |
| } |
| |
| /** */ |
| interface Intf { |
| /** */ |
| long value(); |
| } |
| |
| /** */ |
| static class TestObject { |
| /** Value. */ |
| Intf val = new IntfImpl(); |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| |
| TestObject obj = (TestObject)o; |
| |
| return val.equals(obj.val); |
| } |
| } |
| |
| /** */ |
| static class IntfImpl extends Cls implements Intf { |
| /** {@inheritDoc} */ |
| @Override public long value() { |
| return longValue(); |
| } |
| } |
| |
| /** */ |
| static class Cls implements Serializable { |
| /** Value. */ |
| long val; |
| |
| /** */ |
| public long longValue() { |
| return val; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| |
| Cls cls = (Cls)o; |
| |
| return val == cls.val; |
| } |
| |
| /** */ |
| private Object writeReplace() { |
| return new SerializationProxy(this); |
| } |
| |
| /** */ |
| private static class SerializationProxy implements Serializable { |
| /** Value. */ |
| private final long val; |
| |
| /** */ |
| SerializationProxy(Cls a) { |
| val = a.longValue(); |
| } |
| |
| /** */ |
| private Object readResolve() { |
| Cls a = new Cls(); |
| |
| a.val = val; |
| |
| return a; |
| } |
| } |
| } |
| |
| /** */ |
| public static class HandleToCollections { |
| /** */ |
| int a; |
| |
| /** */ |
| List<Value> lst; |
| |
| /** */ |
| List<Value> hndLst; |
| |
| /** */ |
| List<Value> linkedLst; |
| |
| /** */ |
| List<Value> hndLinkedLst; |
| |
| /** */ |
| Map<Integer, Value> map; |
| |
| /** */ |
| Map<Integer, Value> hndMap; |
| |
| /** */ |
| Map<Integer, Value> linkedMap; |
| |
| /** */ |
| Map<Integer, Value> hndLinkedMap; |
| |
| /** */ |
| public HandleToCollections() { |
| lst = new ArrayList<>(Arrays.asList(new Value(0), new Value(1))); |
| hndLst = lst; |
| |
| linkedLst = new LinkedList<>(Arrays.asList(new Value(0), new Value(1))); |
| hndLinkedLst = linkedLst; |
| |
| map = IntStream.range(0, 1).boxed() |
| .collect(Collectors.toMap(Function.identity(), Value::new)); |
| hndMap = map; |
| |
| linkedMap = IntStream.range(0, 1).boxed() |
| .collect(Collectors.toMap(Function.identity(), Value::new, (a, b) -> a, LinkedHashMap::new)); |
| hndLinkedMap = linkedMap; |
| } |
| } |
| |
| /** */ |
| public static class TwoCollections { |
| /** */ |
| int a; |
| |
| /** */ |
| List<String> lst0; |
| |
| /** */ |
| List<String> lst1; |
| |
| /** */ |
| Value v; |
| |
| /** */ |
| public TwoCollections() { |
| a = 0; |
| |
| lst0 = new ArrayList<>(Arrays.asList("a", "b")); |
| lst1 = new ArrayList<>(Arrays.asList("c", "d"));; |
| |
| v = new Value(127); |
| } |
| } |
| } |