ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [28/53] [abbrv] incubator-ignite git commit: # gg-9470-rename
Date Thu, 04 Dec 2014 23:24:20 GMT
# gg-9470-rename


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/40cf54f6
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/40cf54f6
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/40cf54f6

Branch: refs/heads/master
Commit: 40cf54f6819e381aa16a30b9dfe11bc1d14ccaf2
Parents: 3edf39e
Author: sboikov <sboikov@gridgain.com>
Authored: Thu Dec 4 21:59:54 2014 +0300
Committer: sboikov <sboikov@gridgain.com>
Committed: Thu Dec 4 21:59:54 2014 +0300

----------------------------------------------------------------------
 .../GridOptimizedMarshallerEnumSelfTest.java    |   55 +
 .../GridOptimizedMarshallerSelfTest.java        |  437 ++++
 .../optimized/GridOptimizedMarshallerTest.java  |  815 +++++++
 .../GridOptimizedObjectStreamSelfTest.java      | 2086 ++++++++++++++++++
 .../GridTestTcpDiscoveryIpFinderAdapter.java    |   36 +
 .../ignite/marshaller/optimized/package.html    |   15 +
 .../GridOptimizedMarshallerEnumSelfTest.java    |   55 -
 .../GridOptimizedMarshallerSelfTest.java        |  437 ----
 .../optimized/GridOptimizedMarshallerTest.java  |  816 -------
 .../GridOptimizedObjectStreamSelfTest.java      | 2086 ------------------
 .../GridTestTcpDiscoveryIpFinderAdapter.java    |   36 -
 .../grid/marshaller/optimized/package.html      |   15 -
 .../testsuites/GridMarshallerSelfTestSuite.java |    2 +-
 13 files changed, 3445 insertions(+), 3446 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/40cf54f6/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerEnumSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerEnumSelfTest.java
b/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerEnumSelfTest.java
new file mode 100644
index 0000000..4bf911e
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerEnumSelfTest.java
@@ -0,0 +1,55 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.apache.ignite.marshaller.optimized;
+
+import junit.framework.*;
+import org.apache.ignite.marshaller.optimized.*;
+
+/**
+ *
+ */
+public class GridOptimizedMarshallerEnumSelfTest extends TestCase {
+    /**
+     * @throws Exception If failed.
+     */
+    public void testEnumSerialisation() throws Exception {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        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 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();
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/40cf54f6/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerSelfTest.java
b/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerSelfTest.java
new file mode 100644
index 0000000..aa018b4
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerSelfTest.java
@@ -0,0 +1,437 @@
+package org.apache.ignite.marshaller.optimized;
+
+import org.apache.ignite.lang.*;
+import org.apache.ignite.marshaller.*;
+import org.apache.ignite.marshaller.optimized.*;
+import org.gridgain.grid.*;
+import org.gridgain.grid.marshaller.*;
+import org.gridgain.grid.util.typedef.*;
+import org.gridgain.testframework.*;
+import org.gridgain.testframework.junits.common.*;
+
+import java.io.*;
+import java.util.concurrent.*;
+
+/**
+ * Optimized marshaller self test.
+ */
+@GridCommonTest(group = "Marshaller")
+public class GridOptimizedMarshallerSelfTest extends GridMarshallerAbstractTest {
+    /** {@inheritDoc} */
+    @Override protected GridMarshaller createMarshaller() {
+        GridOptimizedMarshaller m = new GridOptimizedMarshaller();
+
+        m.setRequireSerializable(false);
+        m.setClassNames(F.asList(GoodMarshallable.class.getName(), NoMarshallable.class.getName()));
+
+        return m;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testTestMarshalling() throws Exception {
+        final String msg = "PASSED";
+
+        assert msg != null;
+
+        byte[] buf = marshal(new IgniteRunnable() {
+            @Override public void run() {
+                c1.apply(msg);
+                c2.apply(msg);
+
+                c3.apply();
+                c4.reduce();
+
+                System.out.println("Test message: " + msg);
+            }
+        });
+
+        Runnable r = unmarshal(buf);
+
+        assertNotNull(r);
+
+        r.run();
+    }
+
+    /**
+     * Tests marshal self-linked object.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testMarshallingSelfLink() throws GridException {
+        SelfLink sl = new SelfLink("a string 1");
+
+        sl.link(sl);
+
+        SelfLink sl1 = unmarshal(marshal(sl));
+
+        assert sl1.link() == sl1;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testInvalid() throws Exception {
+        GridTestUtils.assertThrows(
+            log,
+            new Callable<Object>() {
+                @Override public Object call() throws Exception {
+                    unmarshal(new byte[10]);
+
+                    return null;
+                }
+            },
+            GridException.class,
+            null
+        );
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testNested() throws Exception {
+        NestedTestObject obj = new NestedTestObject("String", 100);
+
+        NestedTestObject newObj = unmarshal(marshal(obj));
+
+        assertEquals("String", newObj.str);
+        assertEquals(100, newObj.val);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testGoodMarshallable() throws Exception {
+        GoodMarshallable obj = new GoodMarshallable("String", 100);
+
+        GoodMarshallable newObj = unmarshal(marshal(obj));
+
+        assertEquals("String", newObj.getString());
+        assertEquals(100, newObj.getInt());
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testBadMarshallable() throws Exception {
+        BadMarshallable obj = new BadMarshallable("String", 100);
+
+        try {
+            System.out.println(unmarshal(marshal(obj)));
+
+            assert false;
+        }
+        catch (GridException e) {
+            assert e.getCause() instanceof IOException;
+            assert e.getCause().getMessage().contains("must return the value of the field");
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void checkPerformance() throws Exception {
+        final int cnt = 5_000_000;
+
+        for (int j = 0; j < 5; j++) {
+            long start = System.nanoTime();
+
+            for (int i = 0; i < cnt; i++) {
+                String s = "string-" + i;
+
+                NoMarshallable obj = new NoMarshallable(s, i);
+
+                NoMarshallable newObj = unmarshal(marshal(obj));
+
+                assertEquals(s, newObj.getString());
+            }
+
+            X.println("Marshalling NoMarshallable duration: " + ((System.nanoTime() - start)
/ 1_000_000) + "ms");
+        }
+
+
+        for (int j = 0; j < 5; j++) {
+            long start = System.nanoTime();
+
+            for (int i = 0; i < cnt; i++) {
+                String s = "string-" + i;
+
+                GoodMarshallable obj = new GoodMarshallable(s, i);
+
+                GoodMarshallable newObj = unmarshal(marshal(obj));
+
+                assertEquals(s, newObj.getString());
+            }
+
+            X.println("Marshalling Marshallable duration: " + ((System.nanoTime() - start)
/ 1_000_000) + "ms");
+        }
+    }
+
+    /**
+     * Class for nested execution test.
+     */
+    private static class NestedTestObject implements Serializable {
+        /** */
+        private String str;
+
+        /** */
+        private int val;
+
+        /**
+         * @param str String.
+         * @param val Value.
+         */
+        private NestedTestObject(String str, int val) {
+            this.str = str;
+            this.val = val;
+        }
+
+        /** {@inheritDoc} */
+        private void writeObject(ObjectOutputStream out) throws IOException {
+            try {
+                byte[] arr = marshal(str);
+
+                out.writeInt(arr.length);
+                out.write(arr);
+
+                out.writeInt(val);
+            }
+            catch (GridException e) {
+                throw new IOException(e);
+            }
+        }
+
+        /** {@inheritDoc} */
+        @SuppressWarnings("UnusedParameters")
+        private void readObject(ObjectInputStream in) throws IOException {
+            try {
+                byte[] arr = new byte[in.readInt()];
+
+                in.read(arr);
+
+                str = unmarshal(arr);
+
+                val = in.readInt();
+            }
+            catch (GridException e) {
+                throw new IOException(e);
+            }
+        }
+    }
+
+    /** */
+    private static class TestObject2 {
+        /** */
+        private final int i;
+
+        /**
+         * Constructor for TestObject2 instances.
+         *
+         * @param i Integer value to hold.
+         */
+        private TestObject2(int i) {
+            this.i = i;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object o) {
+            return i == ((TestObject2)o).i;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return i;
+        }
+    }
+
+    /**
+     * Static nested class.
+     */
+    private static class TestObject {
+        /** */
+        private final TestObject2 o2;
+
+        /** The only meaningful field in the class, used for {@link #equals(Object o)} and
{@link #hashCode()}. */
+        private final String str;
+
+        /**
+         * @param str String to hold.
+         * @param i Integer.
+         */
+        TestObject(String str, int i) {
+            this.str = str;
+
+            o2 = new TestObject2(i);
+        }
+
+        /**
+         * Method for accessing value of the hold string after the object is created.
+         *
+         * @return Wrapped string.
+         */
+        public String string() {
+            return str;
+        }
+
+        /**
+         * @return Object held in this wrapped.
+         */
+        public TestObject2 obj() {
+            return o2;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return 31 * o2.hashCode() + str.hashCode();
+        }
+
+        /** {@inheritDoc} */
+        @SuppressWarnings("RedundantIfStatement")
+        @Override public boolean equals(Object o) {
+            if (this == o)
+                return true;
+
+            if (o == null || getClass() != o.getClass())
+                return false;
+
+            TestObject obj = (TestObject)o;
+
+            if (o2 != null ? !o2.equals(obj.o2) : obj.o2 != null)
+                return false;
+
+            if (str != null ? !str.equals(obj.str) : obj.str != null)
+                return false;
+
+            return true;
+        }
+    }
+
+    /**
+     * Static nested class.
+     */
+    private static class SelfLink extends TestObject {
+        /** */
+        private SelfLink link;
+
+        /**
+         * @param str String to hold.
+         */
+        SelfLink(String str) {
+            super(str, 1);
+        }
+
+        /**
+         * @return The object this link points to,.
+         */
+        public SelfLink link() {
+            return link;
+        }
+
+        /**
+         * @param link The object this link should points to,
+         */
+        public void link(SelfLink link) {
+            this.link = link;
+        }
+    }
+
+    /**
+     *
+     */
+    public static class GoodMarshallable implements GridOptimizedMarshallable, Serializable
{
+        /** Class ID required by {@link GridOptimizedMarshallable}. */
+        @SuppressWarnings({"NonConstantFieldWithUpperCaseName", "AbbreviationUsage", "UnusedDeclaration"})
+        private static Object GG_CLASS_ID;
+
+        /** */
+        private String str;
+
+        /** */
+        private int i;
+
+        /**
+         * @param str String.
+         * @param i Integer.
+         */
+        public GoodMarshallable(String str, int i) {
+            this.str = str;
+            this.i = i;
+        }
+
+        /**
+         * @return Int value.
+         */
+        private int getInt() {
+            return i;
+        }
+
+        /**
+         * @return String value
+         */
+        private String getString() {
+            return str;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Object ggClassId() {
+            return GG_CLASS_ID;
+        }
+    }
+
+    /**
+     *
+     */
+    public static class NoMarshallable implements Serializable {
+        /** */
+        private String str;
+
+        /** */
+        private int i;
+
+        /**
+         * @param str String.
+         * @param i Integer.
+         */
+        public NoMarshallable(String str, int i) {
+            this.str = str;
+            this.i = i;
+        }
+
+        /**
+         * @return Int value.
+         */
+        private int getInt() {
+            return i;
+        }
+
+        /**
+         * @return String value
+         */
+        private String getString() {
+            return str;
+        }
+    }
+
+    /**
+     *
+     */
+    private static class BadMarshallable extends TestObject implements GridOptimizedMarshallable
{
+        /** Class ID required by {@link GridOptimizedMarshallable}. */
+        @SuppressWarnings({"NonConstantFieldWithUpperCaseName", "AbbreviationUsage", "UnusedDeclaration"})
+        private static Object GG_CLASS_ID;
+
+        /**
+         * @param str String.
+         * @param i Integer.
+         */
+        private BadMarshallable(String str, int i) {
+            super(str, i);
+        }
+
+        /** {@inheritDoc} */
+        @Override public Object ggClassId() {
+            return new Object();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/40cf54f6/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerTest.java
b/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerTest.java
new file mode 100644
index 0000000..d394039
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/marshaller/optimized/GridOptimizedMarshallerTest.java
@@ -0,0 +1,815 @@
+package org.apache.ignite.marshaller.optimized;
+
+import org.apache.ignite.*;
+import org.apache.ignite.compute.*;
+import org.apache.ignite.marshaller.*;
+import org.gridgain.grid.*;
+import org.gridgain.grid.marshaller.*;
+import org.gridgain.grid.spi.discovery.tcp.ipfinder.*;
+import org.gridgain.grid.spi.discovery.tcp.ipfinder.vm.*;
+import org.gridgain.grid.util.typedef.internal.*;
+import org.gridgain.testframework.junits.common.*;
+import org.jetbrains.annotations.*;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.lang.reflect.Proxy;
+import java.net.*;
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ *
+ */
+public class GridOptimizedMarshallerTest extends GridCommonAbstractTest {
+    /**
+     * Tests ability to marshal non-serializable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testNonSerializable() throws GridException {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        marsh.setRequireSerializable(false);
+
+        NonSerializable outObj = marsh.unmarshal(marsh.marshal(new NonSerializable(null)),
null);
+
+        outObj.checkAfterUnmarshalled();
+    }
+
+    /**
+     * Tests ability to marshal non-serializable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testNonSerializable1() throws GridException {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        marsh.setRequireSerializable(false);
+
+        byte[] bytes = marsh.marshal(new GridTcpDiscoveryVmIpFinder());
+
+        GridTcpDiscoveryIpFinder ipFinder = marsh.unmarshal(bytes, null);
+
+        assertFalse(ipFinder.isShared());
+
+        ipFinder = marsh.unmarshal(marsh.marshal(new GridTcpDiscoveryVmIpFinder(true)), null);
+
+        assertTrue(ipFinder.isShared());
+    }
+
+    /**
+     * Tests ability to marshal non-serializable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testNonSerializable2() throws GridException {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        marsh.setRequireSerializable(false);
+
+        GridTcpDiscoveryIpFinderAdapter ipFinder = new GridTcpDiscoveryIpFinderAdapter()
{
+            @Override public Collection<InetSocketAddress> getRegisteredAddresses()
{
+                return null;
+            }
+
+            @Override public void registerAddresses(Collection<InetSocketAddress> addrs)
{
+                //No-op.
+            }
+
+            @Override public void unregisterAddresses(Collection<InetSocketAddress>
addrs) {
+                //No-op.
+            }
+        };
+
+        ipFinder.setShared(false);
+
+        byte[] bytes = marsh.marshal(ipFinder);
+
+        ipFinder = marsh.unmarshal(bytes, null);
+
+        assertFalse(ipFinder.isShared());
+    }
+
+    /**
+     * Tests ability to marshal non-serializable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testNonSerializable3() throws GridException {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        marsh.setRequireSerializable(false);
+
+        byte[] bytes = marsh.marshal(new GridTestTcpDiscoveryIpFinderAdapter());
+
+        GridTcpDiscoveryIpFinder ipFinder = marsh.unmarshal(bytes, null);
+
+        assertFalse(ipFinder.isShared());
+    }
+
+     /**
+     * Tests ability to marshal non-serializable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testNonSerializable4() throws GridException {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        marsh.setRequireSerializable(false);
+
+        byte[] bytes = marsh.marshal(new GridMarshallerTestInheritedBean());
+
+        info(Arrays.toString(bytes));
+
+        GridMarshallerTestInheritedBean bean = marsh.unmarshal(bytes, null);
+
+        assertTrue(bean.isFlag());
+    }
+
+     /**
+     * Tests ability to marshal non-serializable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testNonSerializable5() throws GridException {
+        GridMarshaller marsh = new GridOptimizedMarshaller();
+
+        byte[] bytes = marsh.marshal(true);
+
+        Boolean val = marsh.unmarshal(bytes, null);
+
+        assertTrue(val);
+    }
+
+    /**
+     * Tests ability to marshal serializable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testSerializable() throws GridException {
+        GridMarshaller marsh = new GridOptimizedMarshaller();
+
+        SomeSerializable outObj = marsh.unmarshal(marsh.marshal(new SomeSerializable(null)),
null);
+
+        outObj.checkAfterUnmarshalled();
+    }
+
+    /**
+     * @throws GridException If failed.
+     */
+    public void testSerializableAfterChangingValue() throws GridException {
+        GridMarshaller marsh = new GridOptimizedMarshaller();
+
+        SomeSimpleSerializable newObj = new SomeSimpleSerializable();
+
+        assert(newObj.flag);
+
+        newObj.setFlagValue(false);
+
+        assert(! newObj.flag);
+
+        SomeSimpleSerializable outObj = marsh.unmarshal(marsh.marshal(newObj), null);
+
+        assert (! outObj.flag);
+    }
+
+    /**
+     * Tests ability to marshal externalizable objects.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testExternalizable() throws GridException {
+        GridMarshaller marsh = new GridOptimizedMarshaller();
+
+        ExternalizableA outObj = marsh.unmarshal(marsh.marshal(new ExternalizableA(null,
true)), null);
+        ExternalizableA outObj1 = marsh.unmarshal(marsh.marshal(new ExternalizableA(null,
false)), null);
+
+        assertNotNull(outObj);
+        assertNotNull(outObj1);
+    }
+
+    /**
+     * Tests {@link GridOptimizedMarshaller#setRequireSerializable(boolean)}.
+     */
+    public void testRequireSerializable() {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        marsh.setRequireSerializable(true);
+
+        try {
+            marsh.marshal(new NonSerializable(null));
+
+            fail();
+        }
+        catch (GridException ignore) {
+            // No-op.
+        }
+    }
+
+    /**
+     * Tests {@link GridOptimizedMarshaller#setClassNames(List)}.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testUserPreregisteredNames() throws GridException {
+        Object obj = new SomeSerializable(null);
+
+        // Clear caches.
+        ((Map)U.staticField(GridOptimizedMarshallerUtils.class, "CLS_DESC_CACHE")).clear();
+        GridOptimizedClassResolver.userClasses(null, null);
+
+        GridMarshaller marsh = new GridOptimizedMarshaller();
+
+        int size1 = marsh.marshal(obj).length;
+
+        // Clear caches.
+        ((Map)U.staticField(GridOptimizedMarshallerUtils.class, "CLS_DESC_CACHE")).clear();
+        GridOptimizedClassResolver.userClasses(null, null);
+
+        GridOptimizedMarshaller marshPreregistered = new GridOptimizedMarshaller();
+
+        marshPreregistered.setClassNames(Arrays.asList(SomeSerializable.class.getName()));
+
+        int size2 = marshPreregistered.marshal(obj).length;
+
+        assertTrue(size1 > size2);
+    }
+
+    /**
+     * Tests {@link GridOptimizedMarshaller#setClassNames(List)}.
+     *
+     * @throws GridException If marshalling failed.
+     * @throws IOException If an I/O error occurs.
+     */
+    public void testUserPreregisteredNamesPath() throws GridException, IOException {
+        Object obj = new SomeSerializable(null);
+
+        // Clear caches.
+        ((Map)U.staticField(GridOptimizedMarshallerUtils.class, "CLS_DESC_CACHE")).clear();
+        GridOptimizedClassResolver.userClasses(null, null);
+
+        GridMarshaller marsh = new GridOptimizedMarshaller();
+
+        int size1 = marsh.marshal(obj).length;
+
+        // Clear caches.
+        ((Map)U.staticField(GridOptimizedMarshallerUtils.class, "CLS_DESC_CACHE")).clear();
+        GridOptimizedClassResolver.userClasses(null, null);
+
+        GridOptimizedMarshaller marshPreregistered = new GridOptimizedMarshaller();
+
+        File namesFile = File.createTempFile("gg-", null);
+
+        U.writeStringToFile(namesFile, SomeSerializable.class.getName(), "UTF-8");
+
+        marshPreregistered.setClassNamesPath(namesFile.getAbsolutePath());
+
+        int size2 = marshPreregistered.marshal(obj).length;
+
+        assertTrue(size1 > size2);
+    }
+
+    /**
+     * Tests {@link Proxy}.
+     *
+     * @throws GridException If marshalling failed.
+     */
+    public void testProxy() throws GridException {
+        GridOptimizedMarshaller marsh = new GridOptimizedMarshaller();
+
+        marsh.setRequireSerializable(false);
+
+        SomeItf inItf = (SomeItf)Proxy.newProxyInstance(
+            GridOptimizedMarshallerTest.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 {
+                    obj.checkAfterUnmarshalled();
+
+                    return 17;
+                }
+            }
+        );
+
+        SomeItf outItf = marsh.unmarshal(marsh.marshal(inItf), null);
+
+        assertEquals(outItf.checkAfterUnmarshalled(), 17);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testDescriptorCache() throws Exception {
+        try {
+            Ignite ignite = startGridsMultiThreaded(2);
+
+            String taskClsName = "org.gridgain.grid.tests.p2p.GridSingleSplitTestTask";
+            String jobClsName = "org.gridgain.grid.tests.p2p.GridSingleSplitTestTask$GridSingleSplitTestJob";
+
+            ClassLoader ldr = getExternalClassLoader();
+
+            Class<? extends ComputeTask<?, ?>> taskCls = (Class<? extends
ComputeTask<?, ?>>)ldr.loadClass(taskClsName);
+            Class<? extends ComputeTask<?, ?>> jobCls = (Class<? extends ComputeTask<?,
?>>)ldr.loadClass(jobClsName);
+
+            ignite.compute().localDeployTask(taskCls, ldr);
+
+            ignite.compute().execute(taskClsName, 2);
+
+            ConcurrentMap<Class<?>, GridOptimizedClassDescriptor> cache =
+                U.staticField(GridOptimizedMarshallerUtils.class, "CLS_DESC_CACHE");
+
+            assertTrue(cache.containsKey(jobCls));
+
+            ignite.compute().undeployTask(taskClsName);
+
+            // Wait for undeploy.
+            Thread.sleep(1000);
+
+            assertFalse(cache.containsKey(jobCls));
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPerformance() throws Exception {
+        System.gc();
+
+        checkPerformance(10000, 4);
+    }
+
+    /**
+     * @param cnt Number of marshalling attempts.
+     * @param tries Number of retries.
+     * @throws Exception If failed.
+     */
+    private void checkPerformance(int cnt, int tries) throws Exception {
+        GridMarshaller marsh = new GridOptimizedMarshaller();
+
+        for (int j = 0; j < tries; j++) {
+            System.gc();
+
+            long start = System.currentTimeMillis();
+
+            for (int i = 0; i < cnt; i++) {
+                TestCacheKey key = new TestCacheKey("key", "id");
+
+                TestCacheKey outKey = marsh.unmarshal(marsh.marshal(key), null);
+
+                assert key.equals(outKey);
+                assert key.hashCode() == outKey.hashCode();
+            }
+
+            info("Time non-serializable: " + (System.currentTimeMillis() - start));
+
+            System.gc();
+
+            start = System.currentTimeMillis();
+
+            for (int i = 0; i < cnt; i++) {
+                TestCacheKeySerializable key1 = new TestCacheKeySerializable("key", "id");
+
+                TestCacheKeySerializable outKey = marsh.unmarshal(marsh.marshal(key1), null);
+
+                assert key1.equals(outKey);
+                assert key1.hashCode() == outKey.hashCode();
+            }
+
+            info("Time serializable: " + (System.currentTimeMillis() - start));
+
+            System.gc();
+
+            start = System.currentTimeMillis();
+
+            for (int i = 0; i < cnt; i++) {
+                TestCacheKeyExternalizable key2 = new TestCacheKeyExternalizable("key", "id");
+
+                TestCacheKeyExternalizable outKey = marsh.unmarshal(marsh.marshal(key2),
null);
+
+                assert key2.equals(outKey);
+                assert key2.hashCode() == outKey.hashCode();
+            }
+
+            info("Time externalizable: " + (System.currentTimeMillis() - start));
+
+            info(">>>");
+        }
+
+        info(">>> Finished performance check <<<");
+    }
+
+    /**
+     * 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.
+         */
+        @SuppressWarnings( {"UnusedDeclaration"})
+        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(intVal, 0);
+
+            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 shortVal = 0x1122;
+
+        /** */
+        public long longVal = 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(shortVal.shortValue(), 0x1122);
+
+            assertEquals(longVal, 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.
+         */
+        @SuppressWarnings( {"UnusedDeclaration"})
+        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);
+        }
+    }
+
+    /**
+     * Some serializable class.
+     */
+    @SuppressWarnings( {"PublicField","TransientFieldInNonSerializableClass","PackageVisibleInnerClass"})
+    static class ForSerializableB {
+        /** */
+        public Short shortVal = 0x1122;
+
+        /** */
+        public long longVal = 0x8877665544332211L;
+
+        /** */
+        private transient NonSerializableA[] aArr;
+
+        /** */
+        private transient String strVal = "abc";
+
+        /** */
+        protected Double doubleVal = 123.456;
+
+        /**
+         */
+        protected void init() {
+            shortVal = 0x1122;
+
+            longVal = 0x8877665544332211L;
+
+            aArr = new NonSerializableA[] {
+                new NonSerializableA(null, null),
+                new NonSerializableA(null, null),
+                new NonSerializableA(null, null)
+            };
+        }
+
+        /**
+         * Checks correctness of the state after unmarshalling.
+         */
+        void checkAfterUnmarshalled() {
+            assertEquals(shortVal.shortValue(), 0x1122);
+
+            assertEquals(longVal, 0x8877665544332211L);
+
+            assertNull(aArr);
+
+            assertNull(strVal);
+
+            assertEquals(doubleVal, 123.456);
+        }
+    }
+
+    /**
+     * Some serializable class.
+     */
+    private static class SomeSimpleSerializable extends ComputeJobAdapter {
+        /** */
+        private boolean flag = true;
+
+        /**
+         * @param newFlagVal - The new value of flag field.
+         */
+        public void setFlagValue(boolean newFlagVal) {
+            flag = newFlagVal;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Object execute() throws GridException {
+            assert false;
+
+            return null;
+        }
+    }
+    /**
+     * Some serializable class.
+     */
+    private static class SomeSerializable extends ForSerializableB implements Serializable
{
+        /**
+         * Just to eliminate the default constructor.
+         *
+         * @param id Unused.
+         */
+        @SuppressWarnings( {"UnusedDeclaration"})
+        private SomeSerializable(Long id) {
+            init();
+        }
+    }
+
+    /**
+     */
+    private static interface SomeItf {
+        /**
+         * @return Check result.
+         */
+        int checkAfterUnmarshalled();
+    }
+
+    /**
+     * Some externalizable class.
+     */
+    @SuppressWarnings( {"UnusedDeclaration", "PublicField"})
+    private static class ExternalizableA implements Externalizable {
+        /** */
+        private boolean boolVal;
+
+        /** */
+        public String[] strArr;
+
+        /** No-arg constructor is required by externalization.  */
+        public ExternalizableA() {
+            // No-op.
+        }
+
+        /**
+         *
+         * @param strArr String array.
+         * @param boolVal Boolean value.
+         */
+        private ExternalizableA(String[] strArr, boolean boolVal) {
+            this.strArr = strArr;
+            this.boolVal = boolVal;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void writeExternal(ObjectOutput out) throws IOException {
+            out.writeBoolean(false);
+            out.writeBoolean(false);
+            out.writeBoolean(false);
+            out.writeBoolean(false);
+            out.writeBoolean(false);
+            out.writeBoolean(false);
+        }
+
+        /** {@inheritDoc} */
+        @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
+            boolVal = in.readBoolean();
+            in.readBoolean();
+            in.readBoolean();
+            in.readBoolean();
+            in.readBoolean();
+            in.readBoolean();
+        }
+    }
+
+    /**
+     *
+     */
+    private static class TestCacheKey implements Serializable {
+        /** */
+        private String key;
+
+        /** */
+        @SuppressWarnings({"UnusedDeclaration"})
+        private String terminalId;
+
+        /**
+         * @param key Key.
+         * @param terminalId Some ID.
+         */
+        TestCacheKey(String key, String terminalId) {
+            this.key = key;
+            this.terminalId = terminalId;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return key.hashCode();
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object obj) {
+            return obj instanceof TestCacheKey && key.equals(((TestCacheKey)obj).key);
+        }
+    }
+
+    /**
+     *
+     */
+    private static class TestCacheKeySerializable implements Serializable {
+        /** */
+        private String key;
+
+        /** */
+        @SuppressWarnings({"UnusedDeclaration"})
+        private String terminalId;
+
+        /**
+         * @param key Key.
+         * @param terminalId Some ID.
+         */
+        TestCacheKeySerializable(String key, String terminalId) {
+            this.key = key;
+            this.terminalId = terminalId;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return key.hashCode();
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object obj) {
+            return obj instanceof TestCacheKeySerializable && key.equals(((TestCacheKeySerializable)obj).key);
+        }
+    }
+
+    /**
+     *
+     */
+    private static class TestCacheKeyExternalizable implements Externalizable {
+        /** */
+        private String key;
+
+        /** */
+        private String terminalId;
+
+        /**
+         *
+         */
+        public TestCacheKeyExternalizable() {
+            // No-op.
+        }
+
+        /**
+         * @param key Key.
+         * @param terminalId Some ID.
+         */
+        TestCacheKeyExternalizable(String key, String terminalId) {
+            this.key = key;
+            this.terminalId = terminalId;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return key.hashCode();
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object obj) {
+            return obj instanceof TestCacheKeyExternalizable && key.equals(((TestCacheKeyExternalizable)obj).key);
+        }
+
+        /** {@inheritDoc} */
+        @Override public void writeExternal(ObjectOutput out) throws IOException {
+            U.writeString(out, key);
+            U.writeString(out, terminalId);
+        }
+
+        /** {@inheritDoc} */
+        @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
+            key = U.readString(in);
+            terminalId = U.readString(in);
+        }
+    }
+}


Mime
View raw message