Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 7E90D200C65 for ; Fri, 14 Apr 2017 17:13:24 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 7D272160B80; Fri, 14 Apr 2017 15:13:24 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 29824160BCF for ; Fri, 14 Apr 2017 17:13:20 +0200 (CEST) Received: (qmail 61600 invoked by uid 500); 14 Apr 2017 15:13:19 -0000 Mailing-List: contact commits-help@ignite.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@ignite.apache.org Delivered-To: mailing list commits@ignite.apache.org Received: (qmail 60784 invoked by uid 99); 14 Apr 2017 15:13:19 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 14 Apr 2017 15:13:19 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id D7DF9E04FA; Fri, 14 Apr 2017 15:13:18 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit From: agura@apache.org To: commits@ignite.apache.org Date: Fri, 14 Apr 2017 15:13:58 -0000 Message-Id: <1499edfccde74c379861f88bd9eb2e45@git.apache.org> In-Reply-To: <16dfbc567383453393a9f4c479744750@git.apache.org> References: <16dfbc567383453393a9f4c479744750@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [41/50] [abbrv] ignite git commit: IGNITE-4938: Moved OptimizedMarshaller to private package. This closes #1793. archived-at: Fri, 14 Apr 2017 15:13:24 -0000 http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/OptimizedObjectStreamSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/OptimizedObjectStreamSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/OptimizedObjectStreamSelfTest.java new file mode 100644 index 0000000..5f72c29 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/OptimizedObjectStreamSelfTest.java @@ -0,0 +1,2162 @@ +/* + * 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.marshaller.optimized; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.NotActiveException; +import java.io.NotSerializableException; +import java.io.ObjectInput; +import java.io.ObjectInputStream; +import java.io.ObjectOutput; +import java.io.ObjectOutputStream; +import java.io.ObjectStreamException; +import java.io.Serializable; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.Inet4Address; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.text.SimpleDateFormat; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Hashtable; +import java.util.IdentityHashMap; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.PriorityQueue; +import java.util.Properties; +import java.util.Queue; +import java.util.TreeMap; +import java.util.TreeSet; +import java.util.UUID; +import java.util.Vector; +import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentMap; +import org.apache.ignite.IgniteCheckedException; +import org.apache.ignite.internal.marshaller.optimized.OptimizedClassDescriptor; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedObjectInputStream; +import org.apache.ignite.internal.marshaller.optimized.OptimizedObjectOutputStream; +import org.apache.ignite.internal.marshaller.optimized.OptimizedObjectStreamRegistry; +import org.apache.ignite.internal.util.io.GridUnsafeDataInput; +import org.apache.ignite.internal.util.typedef.F; +import org.apache.ignite.internal.util.typedef.internal.U; +import org.apache.ignite.marshaller.MarshallerContext; +import org.apache.ignite.marshaller.MarshallerContextTestImpl; +import org.apache.ignite.marshaller.MarshallerExclusions; +import org.apache.ignite.testframework.GridTestUtils; +import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; +import org.jetbrains.annotations.Nullable; +import org.jsr166.ConcurrentHashMap8; + +import static org.junit.Assert.assertArrayEquals; + +/** + * Test for optimized object streams. + */ +public class OptimizedObjectStreamSelfTest extends GridCommonAbstractTest { + /** */ + private static final MarshallerContext CTX = new MarshallerContextTestImpl(); + + /** */ + private ConcurrentMap clsMap = new ConcurrentHashMap8<>(); + + /** + * @throws Exception If failed. + */ + public void testNull() throws Exception { + assertNull(marshalUnmarshal(null)); + } + + /** + * @throws Exception If failed. + */ + public void testByte() throws Exception { + byte val = 10; + + assertEquals(new Byte(val), marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testShort() throws Exception { + short val = 100; + + assertEquals(new Short(val), marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testInteger() throws Exception { + int val = 100; + + assertEquals(new Integer(val), marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testLong() throws Exception { + long val = 1000L; + + assertEquals(new Long(val), marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testFloat() throws Exception { + float val = 10.0f; + + assertEquals(val, marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testDouble() throws Exception { + double val = 100.0d; + + assertEquals(val, marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testBoolean() throws Exception { + boolean val = true; + + assertEquals(new Boolean(val), marshalUnmarshal(val)); + + val = false; + + assertEquals(new Boolean(val), marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testChar() throws Exception { + char val = 10; + + assertEquals(new Character(val), marshalUnmarshal(val)); + } + + /** + * @throws Exception If failed. + */ + public void testByteArray() throws Exception { + byte[] arr = marshalUnmarshal(new byte[] {1, 2}); + + assertArrayEquals(new byte[] {1, 2}, arr); + } + + /** + * @throws Exception If failed. + */ + public void testShortArray() throws Exception { + short[] arr = marshalUnmarshal(new short[] {1, 2}); + + assertArrayEquals(new short[] {1, 2}, arr); + } + + /** + * @throws Exception If failed. + */ + public void testIntArray() throws Exception { + int[] arr = marshalUnmarshal(new int[] {1, 2}); + + assertArrayEquals(new int[] {1, 2}, arr); + } + + /** + * @throws Exception If failed. + */ + public void testLongArray() throws Exception { + long[] arr = marshalUnmarshal(new long[] {1L, 2L}); + + assertArrayEquals(new long[] {1, 2}, arr); + } + + /** + * @throws Exception If failed. + */ + public void testFloatArray() throws Exception { + float[] arr = marshalUnmarshal(new float[] {1.0f, 2.0f}); + + assertArrayEquals(new float[] {1.0f, 2.0f}, arr, 0.1f); + } + + /** + * @throws Exception If failed. + */ + public void testDoubleArray() throws Exception { + double[] arr = marshalUnmarshal(new double[] {1.0d, 2.0d}); + + assertArrayEquals(new double[] {1.0d, 2.0d}, arr, 0.1d); + } + + /** + * @throws Exception If failed. + */ + public void testBooleanArray() throws Exception { + boolean[] arr = marshalUnmarshal(new boolean[] {true, false, false}); + + assertEquals(3, arr.length); + assertEquals(true, arr[0]); + assertEquals(false, arr[1]); + assertEquals(false, arr[2]); + } + + /** + * @throws Exception If failed. + */ + public void testCharArray() throws Exception { + char[] arr = marshalUnmarshal(new char[] {1, 2}); + + assertArrayEquals(new char[] {1, 2}, arr); + } + + /** + * @throws Exception If failed. + */ + public void testObject() throws Exception { + TestObject obj = new TestObject(); + + obj.longVal = 100L; + obj.doubleVal = 100.0d; + obj.longArr = new Long[] {200L, 300L}; + obj.doubleArr = new Double[] {200.0d, 300.0d}; + + assertEquals(obj, marshalUnmarshal(obj)); + } + + /** + * @throws Exception If failed. + */ + public void testRequireSerializable() throws Exception { + try { + OptimizedMarshaller marsh = new OptimizedMarshaller(true); + + marsh.setContext(CTX); + + marsh.marshal(new Object()); + + assert false : "Exception not thrown."; + } + catch (IgniteCheckedException e) { + NotSerializableException serEx = e.getCause(NotSerializableException.class); + + if (serEx == null) + throw e; + } + } + + /** + * @throws Exception If failed. + */ + public void testPool() throws Exception { + final TestObject obj = new TestObject(); + + obj.longVal = 100L; + obj.doubleVal = 100.0d; + obj.longArr = new Long[100 * 1024]; + obj.doubleArr = new Double[100 * 1024]; + + Arrays.fill(obj.longArr, 100L); + Arrays.fill(obj.doubleArr, 100.0d); + + final OptimizedMarshaller marsh = new OptimizedMarshaller(); + + marsh.setContext(CTX); + + marsh.setPoolSize(5); + + try { + multithreaded(new Callable() { + @Override public Object call() throws Exception { + for (int i = 0; i < 50; i++) + assertEquals(obj, marsh.unmarshal(marsh.marshal(obj), null)); + + return null; + } + }, 20); + } + finally { + marsh.setPoolSize(0); + } + } + + /** + * @throws Exception If failed. + */ + public void testObjectWithNulls() throws Exception { + TestObject obj = new TestObject(); + + obj.longVal = 100L; + obj.longArr = new Long[] {200L, 300L}; + + assertEquals(obj, marshalUnmarshal(obj)); + } + + /** + * @throws Exception If failed. + */ + public void testObjectArray() throws Exception { + TestObject obj1 = new TestObject(); + + obj1.longVal = 100L; + obj1.doubleVal = 100.0d; + obj1.longArr = new Long[] {200L, 300L}; + obj1.doubleArr = new Double[] {200.0d, 300.0d}; + + TestObject obj2 = new TestObject(); + + obj2.longVal = 400L; + obj2.doubleVal = 400.0d; + obj2.longArr = new Long[] {500L, 600L}; + obj2.doubleArr = new Double[] {500.0d, 600.0d}; + + TestObject[] arr = {obj1, obj2}; + + assertArrayEquals(arr, (Object[])marshalUnmarshal(arr)); + + String[] strArr = {"str1", "str2"}; + + assertArrayEquals(strArr, (String[])marshalUnmarshal(strArr)); + } + + /** + * @throws Exception If failed. + */ + public void testExternalizable() throws Exception { + ExternalizableTestObject1 obj = new ExternalizableTestObject1(); + + obj.longVal = 100L; + obj.doubleVal = 100.0d; + obj.longArr = new Long[] {200L, 300L}; + obj.doubleArr = new Double[] {200.0d, 300.0d}; + + assertEquals(obj, marshalUnmarshal(obj)); + } + + /** + * @throws Exception If failed. + */ + public void testExternalizableWithNulls() throws Exception { + ExternalizableTestObject2 obj = new ExternalizableTestObject2(); + + obj.longVal = 100L; + obj.doubleVal = 100.0d; + obj.longArr = new Long[] {200L, 300L}; + obj.doubleArr = new Double[] {200.0d, 300.0d}; + + obj = marshalUnmarshal(obj); + + assertEquals(100L, obj.longVal.longValue()); + assertNull(obj.doubleVal); + assertArrayEquals(new Long[] {200L, 300L}, obj.longArr); + assertNull(obj.doubleArr); + } + + /** + * @throws Exception If failed. + */ + public void testLink() throws Exception { + for (int i = 0; i < 20; i++) { + LinkTestObject1 obj1 = new LinkTestObject1(); + LinkTestObject2 obj2 = new LinkTestObject2(); + LinkTestObject2 obj3 = new LinkTestObject2(); + + obj1.val = 100; + obj2.ref = obj1; + obj3.ref = obj1; + + LinkTestObject2[] arr = new LinkTestObject2[] {obj2, obj3}; + + assertArrayEquals(arr, (Object[])marshalUnmarshal(arr)); + } + } + + /** + * @throws Exception If failed. + */ + public void testCycleLink() throws Exception { + for (int i = 0; i < 20; i++) { + CycleLinkTestObject obj = new CycleLinkTestObject(); + + obj.val = 100; + obj.ref = obj; + + assertEquals(obj, marshalUnmarshal(obj)); + } + } + + /** + * @throws Exception If failed. + */ + public void testNoDefaultConstructor() throws Exception { + NoDefaultConstructorTestObject obj = new NoDefaultConstructorTestObject(100); + + assertEquals(obj, marshalUnmarshal(obj)); + } + + /** + * @throws Exception If failed. + */ + public void testEnum() throws Exception { + assertEquals(TestEnum.B, marshalUnmarshal(TestEnum.B)); + + TestEnum[] arr = new TestEnum[] {TestEnum.C, TestEnum.A, TestEnum.B, TestEnum.A}; + + assertArrayEquals(arr, (Object[])marshalUnmarshal(arr)); + } + + /** + * @throws Exception If failed. + */ + public void testCollection() throws Exception { + TestObject obj1 = new TestObject(); + + obj1.longVal = 100L; + obj1.doubleVal = 100.0d; + obj1.longArr = new Long[] {200L, 300L}; + obj1.doubleArr = new Double[] {200.0d, 300.0d}; + + TestObject obj2 = new TestObject(); + + obj2.longVal = 400L; + obj2.doubleVal = 400.0d; + obj2.longArr = new Long[] {500L, 600L}; + obj2.doubleArr = new Double[] {500.0d, 600.0d}; + + Collection col = F.asList(obj1, obj2); + + assertEquals(col, marshalUnmarshal(col)); + } + + /** + * @throws Exception If failed. + */ + public void testMap() throws Exception { + TestObject obj1 = new TestObject(); + + obj1.longVal = 100L; + obj1.doubleVal = 100.0d; + obj1.longArr = new Long[] {200L, 300L}; + obj1.doubleArr = new Double[] {200.0d, 300.0d}; + + TestObject obj2 = new TestObject(); + + obj2.longVal = 400L; + obj2.doubleVal = 400.0d; + obj2.longArr = new Long[] {500L, 600L}; + obj2.doubleArr = new Double[] {500.0d, 600.0d}; + + Map map = F.asMap(1, obj1, 2, obj2); + + assertEquals(map, marshalUnmarshal(map)); + } + + /** + * @throws Exception If failed. + */ + public void testUuid() throws Exception { + UUID uuid = UUID.randomUUID(); + + assertEquals(uuid, marshalUnmarshal(uuid)); + } + + /** + * @throws Exception If failed. + */ + public void testDate() throws Exception { + Date date = new Date(); + + assertEquals(date, marshalUnmarshal(date)); + } + + /** + * @throws Exception If failed. + */ + public void testTransient() throws Exception { + TransientTestObject obj = marshalUnmarshal(new TransientTestObject(100, 200, "str1", "str2")); + + assertEquals(100, obj.val1); + assertEquals(0, obj.val2); + assertEquals("str1", obj.str1); + assertNull(obj.str2); + } + + /** + * @throws Exception If failed. + */ + public void testWriteReadObject() throws Exception { + WriteReadTestObject obj = marshalUnmarshal(new WriteReadTestObject(100, "str")); + + assertEquals(100, obj.val); + assertEquals("Optional data", obj.str); + } + + /** + * @throws Exception If failed. + */ + public void testWriteReplace() throws Exception { + ReplaceTestObject obj = marshalUnmarshal(new ReplaceTestObject(100)); + + assertEquals(200, obj.value()); + } + + /** + * @throws Exception If failed. + */ + public void testWriteReplaceNull() throws Exception { + ReplaceNullTestObject obj = marshalUnmarshal(new ReplaceNullTestObject()); + + assertNull(obj); + } + + /** + * @throws Exception If failed. + */ + public void testReadResolve() throws Exception { + ResolveTestObject obj = marshalUnmarshal(new ResolveTestObject(100)); + + assertEquals(200, obj.value()); + } + + /** + * @throws Exception If failed. + */ + public void testArrayDeque() throws Exception { + Queue queue = new ArrayDeque<>(); + + for (int i = 0; i < 100; i++) + queue.add(i); + + Queue newQueue = marshalUnmarshal(queue); + + assertEquals(queue.size(), newQueue.size()); + + Integer i; + + while ((i = newQueue.poll()) != null) + assertEquals(queue.poll(), i); + } + + /** + * @throws Exception If failed. + */ + public void testArrayList() throws Exception { + Collection list = new ArrayList<>(); + + for (int i = 0; i < 100; i++) + list.add(i); + + assertEquals(list, marshalUnmarshal(list)); + } + + /** + * @throws Exception If failed. + */ + public void testHashMap() throws Exception { + Map map = new HashMap<>(); + + for (int i = 0; i < 100; i++) + map.put(i, i); + + assertEquals(map, marshalUnmarshal(map)); + } + + /** + * @throws Exception If failed. + */ + public void testHashSet() throws Exception { + Collection set = new HashSet<>(); + + for (int i = 0; i < 100; i++) + set.add(i); + + assertEquals(set, marshalUnmarshal(set)); + } + + /** + * @throws Exception If failed. + */ + @SuppressWarnings("UseOfObsoleteCollectionType") + public void testHashtable() throws Exception { + Map map = new Hashtable<>(); + + for (int i = 0; i < 100; i++) + map.put(i, i); + + assertEquals(map, marshalUnmarshal(map)); + } + + /** + * @throws Exception If failed. + */ + public void testIdentityHashMap() throws Exception { + Map map = new IdentityHashMap<>(); + + for (int i = 0; i < 100; i++) + map.put(i, i); + + assertEquals(map, marshalUnmarshal(map)); + } + + /** + * @throws Exception If failed. + */ + public void testLinkedHashMap() throws Exception { + Map map = new LinkedHashMap<>(); + + for (int i = 0; i < 100; i++) + map.put(i, i); + + assertEquals(map, marshalUnmarshal(map)); + } + + /** + * @throws Exception If failed. + */ + public void testLinkedHashSet() throws Exception { + Collection set = new LinkedHashSet<>(); + + for (int i = 0; i < 100; i++) + set.add(i); + + assertEquals(set, marshalUnmarshal(set)); + } + + /** + * @throws Exception If failed. + */ + public void testLinkedList() throws Exception { + Collection list = new LinkedList<>(); + + for (int i = 0; i < 100; i++) + list.add(i); + + assertEquals(list, marshalUnmarshal(list)); + } + + /** + * @throws Exception If failed. + */ + public void testPriorityQueue() throws Exception { + Queue queue = new PriorityQueue<>(); + + for (int i = 0; i < 100; i++) + queue.add(i); + + Queue newQueue = marshalUnmarshal(queue); + + assertEquals(queue.size(), newQueue.size()); + + Integer i; + + while ((i = newQueue.poll()) != null) + assertEquals(queue.poll(), i); + } + + /** + * @throws Exception If failed. + */ + public void testProperties() throws Exception { + Properties dflts = new Properties(); + + dflts.setProperty("key1", "val1"); + dflts.setProperty("key2", "wrong"); + + Properties props = new Properties(dflts); + + props.setProperty("key2", "val2"); + + Properties newProps = marshalUnmarshal(props); + + assertEquals("val1", newProps.getProperty("key1")); + assertEquals("val2", newProps.getProperty("key2")); + } + + /** + * @throws Exception If failed. + */ + public void testTreeMap() throws Exception { + Map map = new TreeMap<>(); + + for (int i = 0; i < 100; i++) + map.put(i, i); + + assertEquals(map, marshalUnmarshal(map)); + } + + /** + * @throws Exception If failed. + */ + public void testTreeSet() throws Exception { + Collection set = new TreeSet<>(); + + for (int i = 0; i < 100; i++) + set.add(i); + + assertEquals(set, marshalUnmarshal(set)); + } + + /** + * @throws Exception If failed. + */ + @SuppressWarnings("UseOfObsoleteCollectionType") + public void testVector() throws Exception { + Collection vector = new Vector<>(); + + for (int i = 0; i < 100; i++) + vector.add(i); + + assertEquals(vector, marshalUnmarshal(vector)); + } + + /** + * @throws Exception If failed. + */ + public void testString() throws Exception { + assertEquals("Latin", marshalUnmarshal("Latin")); + assertEquals("Кириллица", marshalUnmarshal("Кириллица")); + assertEquals("中国的", marshalUnmarshal("中国的")); + } + + /** + * @throws Exception If failed. + */ + public void testReadLine() throws Exception { + OptimizedObjectInputStream in = new OptimizedObjectInputStream(new GridUnsafeDataInput()); + + byte[] bytes = "line1\nline2\r\nli\rne3\nline4".getBytes(); + + in.in().bytes(bytes, bytes.length); + + assertEquals("line1", in.readLine()); + assertEquals("line2", in.readLine()); + assertEquals("line3", in.readLine()); + assertEquals("line4", in.readLine()); + } + + /** + * @throws Exception If failed. + */ + public void testHierarchy() throws Exception { + C c = new C(100, "str", 200, "str", 300, "str"); + + C newC = marshalUnmarshal(c); + + assertEquals(100, newC.valueA()); + assertEquals("Optional data", newC.stringA()); + assertEquals(200, newC.valueB()); + assertNull(newC.stringB()); + assertEquals(0, newC.valueC()); + assertEquals("Optional data", newC.stringC()); + } + + /** + * @throws Exception If failed. + */ + public void testInet4Address() throws Exception { + Inet4Address addr = (Inet4Address)InetAddress.getByName("localhost"); + + assertEquals(addr, marshalUnmarshal(addr)); + } + + /** + * @throws Exception If failed. + */ + public void testClass() throws Exception { + assertEquals(int.class, marshalUnmarshal(int.class)); + assertEquals(Long.class, marshalUnmarshal(Long.class)); + assertEquals(TestObject.class, marshalUnmarshal(TestObject.class)); + } + + /** + * @throws Exception If failed. + */ + public void testWriteReadFields() throws Exception { + WriteReadFieldsTestObject obj = marshalUnmarshal(new WriteReadFieldsTestObject(100, "str")); + + assertEquals(100, obj.val); + assertEquals("Optional data", obj.str); + } + + /** + * @throws Exception If failed. + */ + public void testWriteFields() throws Exception { + WriteFieldsTestObject obj = marshalUnmarshal(new WriteFieldsTestObject(100, "str")); + + assertEquals(100, obj.val); + assertEquals("Optional data", obj.str); + } + + /** + * @throws Exception If failed. + */ + public void testBigInteger() throws Exception { + BigInteger b = new BigInteger("54654865468745468465321414646834562346475457488"); + + assertEquals(b, marshalUnmarshal(b)); + } + + /** + * @throws Exception If failed. + */ + public void testBigDecimal() throws Exception { + BigDecimal b = new BigDecimal("849572389457208934572093574.123512938654126458542145"); + + assertEquals(b, marshalUnmarshal(b)); + } + + /** + * @throws Exception If failed. + */ + public void testSimpleDateFormat() throws Exception { + SimpleDateFormat f = new SimpleDateFormat("MM/dd/yyyy"); + + assertEquals(f, marshalUnmarshal(f)); + } + + /** + * @throws Exception If failed. + */ + public void testComplexObject() throws Exception { + ComplexTestObject obj = new ComplexTestObject(); + + assertEquals(obj, marshalUnmarshal(obj)); + + ExternalizableTestObject1 extObj1 = new ExternalizableTestObject1(); + + extObj1.longVal = 1000L; + extObj1.doubleVal = 1000.0d; + extObj1.longArr = new Long[] {1000L, 2000L, 3000L}; + extObj1.doubleArr = new Double[] {1000.0d, 2000.0d, 3000.0d}; + + ExternalizableTestObject1 extObj2 = new ExternalizableTestObject1(); + + extObj2.longVal = 2000L; + extObj2.doubleVal = 2000.0d; + extObj2.longArr = new Long[] {4000L, 5000L, 6000L}; + extObj2.doubleArr = new Double[] {4000.0d, 5000.0d, 6000.0d}; + + Properties props = new Properties(); + + props.setProperty("name", "value"); + + Collection col = F.asList(10, 20, 30); + + Map map = F.asMap(10, "str1", 20, "str2", 30, "str3"); + + obj = new ComplexTestObject( + (byte)1, + (short)10, + 100, + 1000L, + 100.0f, + 1000.0d, + 'a', + false, + (byte)2, + (short)20, + 200, + 2000L, + 200.0f, + 2000.0d, + 'b', + true, + new byte[] {1, 2, 3}, + new short[] {10, 20, 30}, + new int[] {100, 200, 300}, + new long[] {1000, 2000, 3000}, + new float[] {100.0f, 200.0f, 300.0f}, + new double[] {1000.0d, 2000.0d, 3000.0d}, + new char[] {'a', 'b', 'c'}, + new boolean[] {false, true}, + new ExternalizableTestObject1[] {extObj1, extObj2}, + "String", + TestEnum.A, + UUID.randomUUID(), + props, + new ArrayList<>(col), + new HashMap<>(map), + new HashSet<>(col), + new LinkedList<>(col), + new LinkedHashMap<>(map), + new LinkedHashSet<>(col), + new Date(), + ExternalizableTestObject2.class + ); + + assertEquals(obj, marshalUnmarshal(obj)); + } + + /** + * @throws Exception If failed. + */ + public void testReadToArray() throws Exception { + OptimizedObjectInputStream in = OptimizedObjectStreamRegistry.in(); + + try { + byte[] arr = new byte[50]; + + for (int i = 0; i < arr.length; i++) + arr[i] = (byte)i; + + in.in().bytes(arr, arr.length); + + byte[] buf = new byte[10]; + + assertEquals(10, in.read(buf)); + + for (int i = 0; i < buf.length; i++) + assertEquals(i, buf[i]); + + buf = new byte[30]; + + assertEquals(20, in.read(buf, 0, 20)); + + for (int i = 0; i < buf.length; i++) + assertEquals(i < 20 ? 10 + i : 0, buf[i]); + + buf = new byte[30]; + + assertEquals(10, in.read(buf, 10, 10)); + + for (int i = 0; i < buf.length; i++) + assertEquals(i >= 10 && i < 20 ? 30 + (i - 10) : 0, buf[i]); + + buf = new byte[20]; + + assertEquals(10, in.read(buf)); + + for (int i = 0; i < buf.length; i++) + assertEquals(i < 10 ? 40 + i : 0, buf[i]); + } + finally { + OptimizedObjectStreamRegistry.closeIn(in); + } + } + + /** + * @throws Exception If failed. + */ + public void testHandleTableGrow() throws Exception { + List c = new ArrayList<>(); + + for (int i = 0; i < 29; i++) + c.add("str"); + + String str = c.get(28); + + c.add("str"); + c.add(str); + + List c0 = marshalUnmarshal(c); + + assertTrue(c0.get(28) == c0.get(30)); + } + + /** + * @throws Exception If failed. + */ + public void testIncorrectExternalizable() throws Exception { + GridTestUtils.assertThrows( + log, + new Callable() { + @Override public Object call() throws Exception { + return marshalUnmarshal(new IncorrectExternalizable()); + } + }, + IOException.class, + null); + } + + /** + * @throws Exception If failed. + */ + public void testExcludedClass() throws Exception { + Class[] exclClasses = U.staticField(MarshallerExclusions.class, "EXCL_CLASSES"); + + assertFalse(F.isEmpty(exclClasses)); + + for (Class cls : exclClasses) + assertEquals(cls, marshalUnmarshal(cls)); + } + + /** + * @throws Exception If failed. + */ + public void testInet6Address() throws Exception { + final InetAddress address = Inet6Address.getByAddress(new byte[16]); + + assertEquals(address, marshalUnmarshal(address)); + } + + /** + * @throws Exception If failed. + */ + @SuppressWarnings("ThrowableResultOfMethodCallIgnored") + public void testPutFieldsWithDefaultWriteObject() throws Exception { + try { + marshalUnmarshal(new CustomWriteObjectMethodObject("test")); + } + catch (IOException e) { + assert e.getCause() instanceof NotActiveException; + } + } + + /** + * @throws Exception If failed. + */ + @SuppressWarnings("ThrowableInstanceNeverThrown") + public void testThrowable() throws Exception { + Throwable t = new Throwable("Throwable"); + + assertEquals(t.getMessage(), ((Throwable)marshalUnmarshal(t)).getMessage()); + } + + /** + * Marshals and unmarshals object. + * + * @param obj Original object. + * @return Object after marshalling and unmarshalling. + * @throws Exception In case of error. + */ + private T marshalUnmarshal(@Nullable Object obj) throws Exception { + OptimizedObjectOutputStream out = null; + OptimizedObjectInputStream in = null; + + try { + out = OptimizedObjectStreamRegistry.out(); + + out.context(clsMap, CTX, null, true); + + out.writeObject(obj); + + byte[] arr = out.out().array(); + + in = OptimizedObjectStreamRegistry.in(); + + in.context(clsMap, CTX, null, getClass().getClassLoader()); + + in.in().bytes(arr, arr.length); + + Object obj0 = in.readObject(); + + checkHandles(out, in); + + return (T)obj0; + } + finally { + OptimizedObjectStreamRegistry.closeOut(out); + OptimizedObjectStreamRegistry.closeIn(in); + } + } + + /** + * Checks that handles are equal in output and input streams. + * + * @param out Output stream. + * @param in Input stream. + * @throws Exception If failed. + */ + private void checkHandles(OptimizedObjectOutputStream out, OptimizedObjectInputStream in) + throws Exception { + Object[] outHandles = out.handledObjects(); + Object[] inHandles = in.handledObjects(); + + assertEquals(outHandles.length, inHandles.length); + + for (int i = 0; i < outHandles.length; i++) { + if (outHandles[i] == null) + assertTrue(inHandles[i] == null); + else { + assertFalse(inHandles[i] == null); + + assertTrue(outHandles[i].getClass() == inHandles[i].getClass()); + } + } + } + + /** */ + private static class IncorrectExternalizable implements Externalizable { + /** + * Required by {@link Externalizable}. + */ + public IncorrectExternalizable() { + // No-op. + } + + /** {@inheritDoc} */ + @Override public void writeExternal(ObjectOutput out) throws IOException { + out.writeInt(0); + out.writeInt(200); + out.writeObject("str"); + } + + /** {@inheritDoc} */ + @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + in.readInt(); + in.readObject(); + } + } + + /** + * Test object. + */ + private static class TestObject implements Serializable { + /** */ + private Long longVal; + + /** */ + private Double doubleVal; + + /** */ + private Long[] longArr; + + /** */ + private Double[] doubleArr; + + /** {@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 longVal != null ? longVal.equals(obj.longVal) : obj.longVal == null && + doubleVal != null ? doubleVal.equals(obj.doubleVal) : obj.doubleVal == null && + Arrays.equals(longArr, obj.longArr) && + Arrays.equals(doubleArr, obj.doubleArr); + } + } + + /** + * Externalizable test object. + */ + private static class ExternalizableTestObject1 implements Externalizable { + /** */ + private Long longVal; + + /** */ + private Double doubleVal; + + /** */ + private Long[] longArr; + + /** */ + private Double[] doubleArr; + + /** + * Required by {@link Externalizable}. + */ + public ExternalizableTestObject1() { + // No-op. + } + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + ExternalizableTestObject1 obj = (ExternalizableTestObject1)o; + + return longVal != null ? longVal.equals(obj.longVal) : obj.longVal == null && + doubleVal != null ? doubleVal.equals(obj.doubleVal) : obj.doubleVal == null && + Arrays.equals(longArr, obj.longArr) && + Arrays.equals(doubleArr, obj.doubleArr); + } + + /** {@inheritDoc} */ + @Override public void writeExternal(ObjectOutput out) throws IOException { + out.writeLong(longVal); + out.writeDouble(doubleVal); + U.writeArray(out, longArr); + U.writeArray(out, doubleArr); + } + + /** {@inheritDoc} */ + @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + longVal = in.readLong(); + doubleVal = in.readDouble(); + + Object[] arr = U.readArray(in); + + longArr = Arrays.copyOf(arr, arr.length, Long[].class); + + arr = U.readArray(in); + + doubleArr = Arrays.copyOf(arr, arr.length, Double[].class); + } + } + + /** + * Externalizable test object. + */ + private static class ExternalizableTestObject2 implements Externalizable { + /** */ + private Long longVal; + + /** */ + private Double doubleVal; + + /** */ + private Long[] longArr; + + /** */ + private Double[] doubleArr; + + /** + * Required by {@link Externalizable}. + */ + public ExternalizableTestObject2() { + // No-op. + } + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + ExternalizableTestObject2 obj = (ExternalizableTestObject2)o; + + return longVal != null ? longVal.equals(obj.longVal) : obj.longVal == null && + doubleVal != null ? doubleVal.equals(obj.doubleVal) : obj.doubleVal == null && + Arrays.equals(longArr, obj.longArr) && + Arrays.equals(doubleArr, obj.doubleArr); + } + + /** {@inheritDoc} */ + @Override public void writeExternal(ObjectOutput out) throws IOException { + out.writeLong(longVal); + U.writeArray(out, longArr); + } + + /** {@inheritDoc} */ + @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + longVal = in.readLong(); + + Object[] arr = U.readArray(in); + + longArr = Arrays.copyOf(arr, arr.length, Long[].class); + } + } + + /** + * Test object. + */ + private static class LinkTestObject1 implements Serializable { + /** */ + private int val; + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + LinkTestObject1 obj = (LinkTestObject1)o; + + return val == obj.val; + } + } + + /** + * Test object. + */ + private static class LinkTestObject2 implements Serializable { + /** */ + private LinkTestObject1 ref; + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + LinkTestObject2 obj = (LinkTestObject2)o; + + return ref != null ? ref.equals(obj.ref) : obj.ref == null; + } + } + + /** + * Cycle link test object. + */ + private static class CycleLinkTestObject implements Serializable { + /** */ + private int val; + + /** */ + private CycleLinkTestObject ref; + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + CycleLinkTestObject obj = (CycleLinkTestObject)o; + + return val == obj.val && ref != null ? ref.val == val : obj.ref == null; + } + } + + /** + * Test object without default constructor. + */ + private static class NoDefaultConstructorTestObject implements Serializable { + /** */ + private int val; + + /** + * @param val Value. + */ + private NoDefaultConstructorTestObject(int val) { + this.val = val; + } + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + NoDefaultConstructorTestObject obj = (NoDefaultConstructorTestObject)o; + + return val == obj.val; + } + } + + /** + * Test object with transient fields. + */ + @SuppressWarnings("TransientFieldNotInitialized") + private static class TransientTestObject implements Serializable { + /** */ + private int val1; + + /** */ + private transient int val2; + + /** */ + private String str1; + + /** */ + private transient String str2; + + /** + * @param val1 Value 1. + * @param val2 Value 2. + * @param str1 String 1. + * @param str2 String 2. + */ + private TransientTestObject(int val1, int val2, String str1, String str2) { + this.val1 = val1; + this.val2 = val2; + this.str1 = str1; + this.str2 = str2; + } + } + + /** + * Test object with {@code writeObject} and {@code readObject} methods. + */ + @SuppressWarnings("TransientFieldNotInitialized") + private static class WriteReadTestObject implements Serializable { + /** */ + private int val; + + /** */ + private transient String str; + + /** + * @param val Value. + * @param str String. + */ + private WriteReadTestObject(int val, String str) { + this.val = val; + this.str = str; + } + + /** + * @param out Output stream. + * @throws IOException In case of error. + */ + private void writeObject(ObjectOutputStream out) throws IOException { + out.defaultWriteObject(); + + out.writeUTF("Optional data"); + } + + /** + * @param in Input stream. + * @throws IOException In case of error. + * @throws ClassNotFoundException If class not found. + */ + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + + str = in.readUTF(); + } + } + + /** + * Test object that uses {@code writeFields} and {@code readFields} methods. + */ + private static class WriteReadFieldsTestObject implements Serializable { + /** */ + private int val; + + /** */ + private String str; + + /** + * @param val Value. + * @param str String. + */ + private WriteReadFieldsTestObject(int val, String str) { + this.val = val; + this.str = str; + } + + /** + * @param out Output stream. + * @throws IOException In case of error. + */ + private void writeObject(ObjectOutputStream out) throws IOException { + ObjectOutputStream.PutField fields = out.putFields(); + + fields.put("val", val); + fields.put("str", "Optional data"); + + out.writeFields(); + } + + /** + * @param in Input stream. + * @throws IOException In case of error. + * @throws ClassNotFoundException If class not found. + */ + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + ObjectInputStream.GetField fields = in.readFields(); + + val = fields.get("val", 0); + str = (String)fields.get("str", null); + } + } + + /** + * Test object that uses {@code writeFields} and {@code readFields} methods. + */ + private static class WriteFieldsTestObject implements Serializable { + /** */ + private int val; + + /** */ + @SuppressWarnings("UnusedDeclaration") + private String str; + + /** + * @param val Value. + * @param str String. + */ + private WriteFieldsTestObject(int val, String str) { + this.val = val; + this.str = str; + } + + /** + * @param out Output stream. + * @throws IOException In case of error. + */ + private void writeObject(ObjectOutputStream out) throws IOException { + ObjectOutputStream.PutField fields = out.putFields(); + + fields.put("val", val); + fields.put("str", "Optional data"); + + out.writeFields(); + } + } + + /** + * Base object with {@code writeReplace} method. + */ + private abstract static class ReplaceTestBaseObject implements Serializable { + /** */ + private int val; + + /** + * @param val Value. + */ + private ReplaceTestBaseObject(int val) { + this.val = val; + } + + /** + * @return Value. + */ + public int value() { + return val; + } + + /** + * @return Replaced object. + * @throws ObjectStreamException In case of error. + */ + protected Object writeReplace() throws ObjectStreamException { + return new ReplaceTestObject(val * 2); + } + } + + /** + * Test object for {@code writeReplace} method. + */ + private static class ReplaceTestObject extends ReplaceTestBaseObject { + /** + * @param val Value. + */ + private ReplaceTestObject(int val) { + super(val); + } + } + + /** + * Test object with {@code writeReplace} method. + */ + private static class ReplaceNullTestObject implements Serializable { + /** + * @return Replaced object. + * @throws ObjectStreamException In case of error. + */ + protected Object writeReplace() throws ObjectStreamException { + return null; + } + } + + /** + * Base object with {@code readResolve} method. + */ + private abstract static class ResolveTestBaseObject implements Serializable { + /** */ + private int val; + + /** + * @param val Value. + */ + private ResolveTestBaseObject(int val) { + this.val = val; + } + + /** + * @return Value. + */ + public int value() { + return val; + } + + /** + * @return Replaced object. + * @throws ObjectStreamException In case of error. + */ + protected Object readResolve() throws ObjectStreamException { + return new ResolveTestObject(val * 2); + } + } + + /** + * Test object for {@code readResolve} method. + */ + private static class ResolveTestObject extends ResolveTestBaseObject { + /** + * @param val Value. + */ + private ResolveTestObject(int val) { + super(val); + } + } + + /** + * Class A. + */ + private static class A implements Serializable { + /** */ + private int valA; + + /** */ + private transient String strA; + + /** + * @param valA Value A. + * @param strA String A. + */ + A(int valA, String strA) { + this.valA = valA; + this.strA = strA; + } + + /** + * @return Value. + */ + int valueA() { + return valA; + } + + /** + * @return String. + */ + String stringA() { + return strA; + } + + /** + * @param out Output stream. + * @throws IOException In case of error. + */ + private void writeObject(ObjectOutputStream out) throws IOException { + out.defaultWriteObject(); + + out.writeUTF("Optional data"); + } + + /** + * @param in Input stream. + * @throws IOException In case of error. + * @throws ClassNotFoundException If class not found. + */ + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + + strA = in.readUTF(); + } + } + + /** + * Class B. + */ + private static class B extends A { + /** */ + private int valB; + + /** */ + @SuppressWarnings("TransientFieldNotInitialized") + private transient String strB; + + /** + * @param valA Value A. + * @param strA String A. + * @param valB Value B. + * @param strB String B. + */ + B(int valA, String strA, int valB, String strB) { + super(valA, strA); + + this.valB = valB; + this.strB = strB; + } + + /** + * @return Value. + */ + int valueB() { + return valB; + } + + /** + * @return String. + */ + String stringB() { + return strB; + } + } + + /** + * Class C. + */ + @SuppressWarnings("MethodOverridesPrivateMethodOfSuperclass") + private static class C extends B { + /** */ + @SuppressWarnings("InstanceVariableMayNotBeInitializedByReadObject") + private int valC; + + /** */ + private transient String strC; + + /** + * @param valA Value A. + * @param strA String A. + * @param valB Value B. + * @param strB String B. + * @param valC Value C. + * @param strC String C. + */ + C(int valA, String strA, int valB, String strB, int valC, String strC) { + super(valA, strA, valB, strB); + + this.valC = valC; + this.strC = strC; + } + + /** + * @return Value. + */ + int valueC() { + return valC; + } + + /** + * @return String. + */ + String stringC() { + return strC; + } + + /** + * @param out Output stream. + * @throws IOException In case of error. + */ + private void writeObject(ObjectOutputStream out) throws IOException { + out.writeUTF("Optional data"); + } + + /** + * @param in Input stream. + * @throws IOException In case of error. + * @throws ClassNotFoundException If class not found. + */ + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + strC = in.readUTF(); + } + } + + /** + * Complex test object. + */ + private static class ComplexTestObject implements Serializable { + /** */ + private byte byteVal1; + + /** */ + private short shortVal1; + + /** */ + private int intVal1; + + /** */ + private long longVal1; + + /** */ + private float floatVal1; + + /** */ + private double doubleVal1; + + /** */ + private char cVal1; + + /** */ + private boolean boolVal1; + + /** */ + private Byte byteVal2; + + /** */ + private Short shortVal2; + + /** */ + private Integer intVal2; + + /** */ + private Long longVal2; + + /** */ + private Float floatVal2; + + /** */ + private Double doubleVal2; + + /** */ + private Character cVal2; + + /** */ + private Boolean boolVal2; + + /** */ + private byte[] byteArr; + + /** */ + private short[] shortArr; + + /** */ + private int[] intArr; + + /** */ + private long[] longArr; + + /** */ + private float[] floatArr; + + /** */ + private double[] doubleArr; + + /** */ + private char[] cArr; + + /** */ + private boolean[] boolArr; + + /** */ + private ExternalizableTestObject1[] objArr; + + /** */ + private String str; + + /** */ + private TestEnum enumVal; + + /** */ + private UUID uuid; + + /** */ + private Properties props; + + /** */ + private ArrayList arrList; + + /** */ + private HashMap hashMap; + + /** */ + private HashSet hashSet; + + /** */ + private LinkedList linkedList; + + /** */ + private LinkedHashMap linkedHashMap; + + /** */ + private LinkedHashSet linkedHashSet; + + /** */ + private Date date; + + /** */ + private Class cls; + + /** */ + private ComplexTestObject self; + + /** */ + private ComplexTestObject() { + self = this; + } + + /** + * @param byteVal1 Byte value. + * @param shortVal1 Short value. + * @param intVal1 Integer value. + * @param longVal1 Long value. + * @param floatVal1 Float value. + * @param doubleVal1 Double value. + * @param cVal1 Char value. + * @param boolVal1 Boolean value. + * @param byteVal2 Byte value. + * @param shortVal2 Short value. + * @param intVal2 Integer value. + * @param longVal2 Long value. + * @param floatVal2 Float value. + * @param doubleVal2 Double value. + * @param cVal2 Char value. + * @param boolVal2 Boolean value. + * @param byteArr Bytes array. + * @param shortArr Shorts array. + * @param intArr Integers array. + * @param longArr Longs array. + * @param floatArr Floats array. + * @param doubleArr Doubles array. + * @param cArr Chars array. + * @param boolArr Booleans array. + * @param objArr Objects array. + * @param str String. + * @param enumVal Enum. + * @param uuid UUID. + * @param props Properties. + * @param arrList ArrayList. + * @param hashMap HashMap. + * @param hashSet HashSet. + * @param linkedList LinkedList. + * @param linkedHashMap LinkedHashMap. + * @param linkedHashSet LinkedHashSet. + * @param date Date. + * @param cls Class. + */ + private ComplexTestObject(byte byteVal1, short shortVal1, int intVal1, long longVal1, float floatVal1, + double doubleVal1, char cVal1, boolean boolVal1, Byte byteVal2, Short shortVal2, Integer intVal2, + Long longVal2, Float floatVal2, Double doubleVal2, Character cVal2, Boolean boolVal2, byte[] byteArr, + short[] shortArr, int[] intArr, long[] longArr, float[] floatArr, double[] doubleArr, char[] cArr, + boolean[] boolArr, ExternalizableTestObject1[] objArr, String str, TestEnum enumVal, UUID uuid, + Properties props, ArrayList arrList, HashMap hashMap, HashSet hashSet, + LinkedList linkedList, LinkedHashMap linkedHashMap, + LinkedHashSet linkedHashSet, Date date, Class cls) { + this.byteVal1 = byteVal1; + this.shortVal1 = shortVal1; + this.intVal1 = intVal1; + this.longVal1 = longVal1; + this.floatVal1 = floatVal1; + this.doubleVal1 = doubleVal1; + this.cVal1 = cVal1; + this.boolVal1 = boolVal1; + this.byteVal2 = byteVal2; + this.shortVal2 = shortVal2; + this.intVal2 = intVal2; + this.longVal2 = longVal2; + this.floatVal2 = floatVal2; + this.doubleVal2 = doubleVal2; + this.cVal2 = cVal2; + this.boolVal2 = boolVal2; + this.byteArr = byteArr; + this.shortArr = shortArr; + this.intArr = intArr; + this.longArr = longArr; + this.floatArr = floatArr; + this.doubleArr = doubleArr; + this.cArr = cArr; + this.boolArr = boolArr; + this.objArr = objArr; + this.str = str; + this.enumVal = enumVal; + this.uuid = uuid; + this.props = props; + this.arrList = arrList; + this.hashMap = hashMap; + this.hashSet = hashSet; + this.linkedList = linkedList; + this.linkedHashMap = linkedHashMap; + this.linkedHashSet = linkedHashSet; + this.date = date; + this.cls = cls; + + self = this; + } + + /** {@inheritDoc} */ + @SuppressWarnings("RedundantIfStatement") + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + ComplexTestObject obj = (ComplexTestObject)o; + + if (boolVal1 != obj.boolVal1) + return false; + + if (byteVal1 != obj.byteVal1) + return false; + + if (cVal1 != obj.cVal1) + return false; + + if (Double.compare(obj.doubleVal1, doubleVal1) != 0) + return false; + + if (Float.compare(obj.floatVal1, floatVal1) != 0) + return false; + + if (intVal1 != obj.intVal1) + return false; + + if (longVal1 != obj.longVal1) + return false; + + if (shortVal1 != obj.shortVal1) + return false; + + if (arrList != null ? !arrList.equals(obj.arrList) : obj.arrList != null) + return false; + + if (!Arrays.equals(boolArr, obj.boolArr)) + return false; + + if (boolVal2 != null ? !boolVal2.equals(obj.boolVal2) : obj.boolVal2 != null) + return false; + + if (!Arrays.equals(byteArr, obj.byteArr)) + return false; + + if (byteVal2 != null ? !byteVal2.equals(obj.byteVal2) : obj.byteVal2 != null) + return false; + + if (!Arrays.equals(cArr, obj.cArr)) + return false; + + if (cVal2 != null ? !cVal2.equals(obj.cVal2) : obj.cVal2 != null) + return false; + + if (cls != null ? !cls.equals(obj.cls) : obj.cls != null) + return false; + + if (date != null ? !date.equals(obj.date) : obj.date != null) + return false; + + if (!Arrays.equals(doubleArr, obj.doubleArr)) + return false; + + if (doubleVal2 != null ? !doubleVal2.equals(obj.doubleVal2) : obj.doubleVal2 != null) + return false; + + if (enumVal != obj.enumVal) + return false; + + if (!Arrays.equals(floatArr, obj.floatArr)) + return false; + + if (floatVal2 != null ? !floatVal2.equals(obj.floatVal2) : obj.floatVal2 != null) + return false; + + if (hashMap != null ? !hashMap.equals(obj.hashMap) : obj.hashMap != null) + return false; + + if (hashSet != null ? !hashSet.equals(obj.hashSet) : obj.hashSet != null) + return false; + + if (!Arrays.equals(intArr, obj.intArr)) + return false; + + if (intVal2 != null ? !intVal2.equals(obj.intVal2) : obj.intVal2 != null) + return false; + + if (linkedHashMap != null ? !linkedHashMap.equals(obj.linkedHashMap) : obj.linkedHashMap != null) + return false; + + if (linkedHashSet != null ? !linkedHashSet.equals(obj.linkedHashSet) : obj.linkedHashSet != null) + return false; + + if (linkedList != null ? !linkedList.equals(obj.linkedList) : obj.linkedList != null) + return false; + + if (!Arrays.equals(longArr, obj.longArr)) + return false; + + if (longVal2 != null ? !longVal2.equals(obj.longVal2) : obj.longVal2 != null) + return false; + + if (!Arrays.equals(objArr, obj.objArr)) + return false; + + if (props != null ? !props.equals(obj.props) : obj.props != null) + return false; + + if (!Arrays.equals(shortArr, obj.shortArr)) + return false; + + if (shortVal2 != null ? !shortVal2.equals(obj.shortVal2) : obj.shortVal2 != null) + return false; + + if (str != null ? !str.equals(obj.str) : obj.str != null) + return false; + + if (uuid != null ? !uuid.equals(obj.uuid) : obj.uuid != null) + return false; + + if (self != this) + return false; + + return true; + } + } + + /** + * Test enum. + */ + @SuppressWarnings("JavaDoc") + private enum TestEnum { + /** */ + A, + + /** */ + B, + + /** */ + C + } + + /** + * Class with custom serialization method which at the beginning invokes + * {@link ObjectOutputStream#defaultWriteObject()} and {@link ObjectOutputStream#putFields()} then. + */ + public static class CustomWriteObjectMethodObject implements Serializable { + /** */ + private final String name; + + /** + * Creates new instance. + * @param name Object name. + */ + public CustomWriteObjectMethodObject(String name) { + this.name = name; + } + + /** {@inheritDoc} */ + private void writeObject(ObjectOutputStream stream) throws IOException { + stream.defaultWriteObject(); + + ObjectOutputStream.PutField fields = stream.putFields(); + fields.put("name", "test"); + + stream.writeFields(); + } + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/TestTcpDiscoveryIpFinderAdapter.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/TestTcpDiscoveryIpFinderAdapter.java b/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/TestTcpDiscoveryIpFinderAdapter.java new file mode 100644 index 0000000..fcf1750 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/marshaller/optimized/TestTcpDiscoveryIpFinderAdapter.java @@ -0,0 +1,43 @@ +/* + * 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.marshaller.optimized; + +import java.net.InetSocketAddress; +import java.util.Collection; +import org.apache.ignite.spi.IgniteSpiException; +import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinderAdapter; + +/** + * Test TCP discovery IP finder adapter. + */ +public class TestTcpDiscoveryIpFinderAdapter extends TcpDiscoveryIpFinderAdapter { + /** {@inheritDoc} */ + @Override public Collection getRegisteredAddresses() throws IgniteSpiException { + return null; + } + + /** {@inheritDoc} */ + @Override public void registerAddresses(Collection addrs) throws IgniteSpiException { + // No-op. + } + + /** {@inheritDoc} */ + @Override public void unregisterAddresses(Collection addrs) throws IgniteSpiException { + // No-op. + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheStartupInDeploymentModesTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheStartupInDeploymentModesTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheStartupInDeploymentModesTest.java index 6f65545..d065890 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheStartupInDeploymentModesTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheStartupInDeploymentModesTest.java @@ -24,7 +24,7 @@ import org.apache.ignite.configuration.DeploymentMode; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.binary.BinaryMarshaller; import org.apache.ignite.marshaller.Marshaller; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; /** http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheEntryMemorySizeSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheEntryMemorySizeSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheEntryMemorySizeSelfTest.java index 7c05b36..3ff302d 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheEntryMemorySizeSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheEntryMemorySizeSelfTest.java @@ -33,7 +33,7 @@ import org.apache.ignite.internal.processors.cache.distributed.near.GridNearCach import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.marshaller.Marshaller; import org.apache.ignite.marshaller.MarshallerContext; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheStoreManagerDeserializationTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheStoreManagerDeserializationTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheStoreManagerDeserializationTest.java index 38f9d97..ee1c9e5 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheStoreManagerDeserializationTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheStoreManagerDeserializationTest.java @@ -38,7 +38,7 @@ import org.apache.ignite.internal.binary.BinaryMarshaller; import org.apache.ignite.internal.processors.cache.extras.GridCacheObsoleteEntryExtras; import org.apache.ignite.internal.processors.cache.store.CacheLocalStore; import org.apache.ignite.internal.processors.cache.version.GridCacheVersion; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheVersionSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheVersionSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheVersionSelfTest.java index 8179dc5..9bf1c43 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheVersionSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheVersionSelfTest.java @@ -21,7 +21,7 @@ import java.util.concurrent.Callable; import org.apache.ignite.internal.processors.cache.version.GridCacheVersion; import org.apache.ignite.internal.processors.cache.version.GridCacheVersionEx; import org.apache.ignite.marshaller.MarshallerContextTestImpl; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.testframework.GridTestUtils; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheAffinityEarlyTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheAffinityEarlyTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheAffinityEarlyTest.java index d4e4269..051ca00 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheAffinityEarlyTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheAffinityEarlyTest.java @@ -29,7 +29,7 @@ import org.apache.ignite.cache.CacheMode; import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteInternalFuture; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheGetFutureHangsSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheGetFutureHangsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheGetFutureHangsSelfTest.java index 78cb817..9ee8d69 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheGetFutureHangsSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheGetFutureHangsSelfTest.java @@ -32,7 +32,7 @@ import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.T2; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutMultiNodeSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutMultiNodeSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutMultiNodeSelfTest.java index 0ba2228..3b7fa4f 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutMultiNodeSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutMultiNodeSelfTest.java @@ -29,7 +29,7 @@ import org.apache.ignite.cache.CacheMode; import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteInternalFuture; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutTest.java index 97bd202..40440e0 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/IgniteCacheCreatePutTest.java @@ -27,7 +27,7 @@ import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.util.typedef.internal.U; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearTxForceKeyTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearTxForceKeyTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearTxForceKeyTest.java index f5b7635..be8f1bc 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearTxForceKeyTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearTxForceKeyTest.java @@ -22,7 +22,6 @@ import org.apache.ignite.IgniteCache; import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.configuration.NearCacheConfiguration; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheEntryProcessorNonSerializableTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheEntryProcessorNonSerializableTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheEntryProcessorNonSerializableTest.java index b462417..b29f2bb 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheEntryProcessorNonSerializableTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheEntryProcessorNonSerializableTest.java @@ -30,7 +30,7 @@ import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.configuration.NearCacheConfiguration; import org.apache.ignite.internal.IgniteEx; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsAbstractBaseSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsAbstractBaseSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsAbstractBaseSelfTest.java index 724bacb..47a768e 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsAbstractBaseSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsAbstractBaseSelfTest.java @@ -53,7 +53,7 @@ import org.apache.ignite.internal.util.typedef.G; import org.apache.ignite.internal.util.typedef.X; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.lang.IgniteUuid; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.discovery.tcp.ipfinder.TcpDiscoveryIpFinder; import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsFileInfoSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsFileInfoSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsFileInfoSelfTest.java index b2b87dc..47af49b 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsFileInfoSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/igfs/IgfsFileInfoSelfTest.java @@ -21,7 +21,7 @@ import org.apache.ignite.IgniteCheckedException; import org.apache.ignite.lang.IgniteUuid; import org.apache.ignite.marshaller.Marshaller; import org.apache.ignite.marshaller.MarshallerContextTestImpl; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.jetbrains.annotations.Nullable; import java.io.Externalizable; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/service/ClosureServiceClientsNodesTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/service/ClosureServiceClientsNodesTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/service/ClosureServiceClientsNodesTest.java index 3119f2d..68f68b1 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/service/ClosureServiceClientsNodesTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/service/ClosureServiceClientsNodesTest.java @@ -30,7 +30,7 @@ import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.util.lang.GridAbsPredicate; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.lang.IgniteCallable; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.resources.IgniteInstanceResource; import org.apache.ignite.resources.LoggerResource; import org.apache.ignite.services.Service; http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeployment2ClassLoadersOptimizedMarshallerTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeployment2ClassLoadersOptimizedMarshallerTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeployment2ClassLoadersOptimizedMarshallerTest.java index f2988cc..23a36d1 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeployment2ClassLoadersOptimizedMarshallerTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeployment2ClassLoadersOptimizedMarshallerTest.java @@ -17,7 +17,7 @@ package org.apache.ignite.internal.processors.service; import org.apache.ignite.marshaller.Marshaller; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; /** * Tests that not all nodes in cluster need user's service definition (only nodes according to filter). http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeploymentClassLoadingOptimizedMarshallerTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeploymentClassLoadingOptimizedMarshallerTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeploymentClassLoadingOptimizedMarshallerTest.java index cb0c911..930c6ed 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeploymentClassLoadingOptimizedMarshallerTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/service/IgniteServiceDeploymentClassLoadingOptimizedMarshallerTest.java @@ -17,7 +17,7 @@ package org.apache.ignite.internal.processors.service; import org.apache.ignite.marshaller.Marshaller; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; /** * Tests that not all nodes in cluster need user's service definition (only nodes according to filter). http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/marshaller/DynamicProxySerializationMultiJvmSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/DynamicProxySerializationMultiJvmSelfTest.java b/modules/core/src/test/java/org/apache/ignite/marshaller/DynamicProxySerializationMultiJvmSelfTest.java index f75af03..3e1e6f7 100644 --- a/modules/core/src/test/java/org/apache/ignite/marshaller/DynamicProxySerializationMultiJvmSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/marshaller/DynamicProxySerializationMultiJvmSelfTest.java @@ -26,7 +26,7 @@ import org.apache.ignite.binary.BinaryObject; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.binary.BinaryMarshaller; import org.apache.ignite.lang.IgniteCallable; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; /** http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerPerformanceTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerPerformanceTest.java b/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerPerformanceTest.java index a9d0f66..3b45977 100644 --- a/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerPerformanceTest.java +++ b/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerPerformanceTest.java @@ -43,7 +43,7 @@ import org.apache.ignite.internal.util.typedef.COX; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.lang.IgniteInClosure; import org.apache.ignite.lang.IgniteOutClosure; -import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; +import org.apache.ignite.internal.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; /** http://git-wip-us.apache.org/repos/asf/ignite/blob/a1b5b8c3/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/OptimizedMarshallerEnumSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/OptimizedMarshallerEnumSelfTest.java b/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/OptimizedMarshallerEnumSelfTest.java deleted file mode 100644 index c072170..0000000 --- a/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/OptimizedMarshallerEnumSelfTest.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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.marshaller.optimized; - -import junit.framework.TestCase; -import org.apache.ignite.IgniteCheckedException; -import org.apache.ignite.IgniteLogger; -import org.apache.ignite.configuration.IgniteConfiguration; -import org.apache.ignite.internal.GridKernalContext; -import org.apache.ignite.marshaller.MarshallerContextTestImpl; -import org.apache.ignite.testframework.junits.GridTestKernalContext; -import org.apache.ignite.testframework.junits.logger.GridTestLog4jLogger; - -/** - * - */ -public class OptimizedMarshallerEnumSelfTest extends TestCase { - - private String igniteHome = System.getProperty("user.dir"); - - private final IgniteLogger rootLog = new GridTestLog4jLogger(false); - /** - * @throws Exception If failed. - */ - public void testEnumSerialisation() throws Exception { - OptimizedMarshaller marsh = new OptimizedMarshaller(); - - MarshallerContextTestImpl context = new MarshallerContextTestImpl(); - - context.onMarshallerProcessorStarted(newContext(), null); - - marsh.setContext(context); - - byte[] bytes = marsh.marshal(TestEnum.Bond); - - TestEnum unmarshalled = marsh.unmarshal(bytes, Thread.currentThread().getContextClassLoader()); - - assertEquals(TestEnum.Bond, unmarshalled); - assertEquals(TestEnum.Bond.desc, unmarshalled.desc); - } - - private GridKernalContext newContext() throws IgniteCheckedException { - IgniteConfiguration cfg = new IgniteConfiguration(); - - cfg.setIgniteHome(igniteHome); - cfg.setClientMode(false); - - return new GridTestKernalContext(rootLog.getLogger(OptimizedMarshallerEnumSelfTest.class), cfg); - } - - private enum TestEnum { - Equity("Equity") { - @Override public String getTestString() { - return "eee"; - } - }, - - Bond("Bond") { - @Override public String getTestString() { - return "qqq"; - } - }; - - public final String desc; - - TestEnum(String desc) { - this.desc = desc; - } - - public abstract String getTestString(); - } -} \ No newline at end of file