http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMarshallerCtxDisabledSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMarshallerCtxDisabledSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMarshallerCtxDisabledSelfTest.java new file mode 100644 index 0000000..a30d09f --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMarshallerCtxDisabledSelfTest.java @@ -0,0 +1,247 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary; + +import org.apache.ignite.IgniteCheckedException; +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.binary.BinaryReader; +import org.apache.ignite.binary.BinaryWriter; +import org.apache.ignite.binary.Binarylizable; +import org.apache.ignite.configuration.IgniteConfiguration; +import org.apache.ignite.internal.MarshallerContextAdapter; +import org.apache.ignite.internal.util.IgniteUtils; +import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.util.Arrays; + +/** + * + */ +public class GridPortableMarshallerCtxDisabledSelfTest extends GridCommonAbstractTest { + /** + * @throws Exception If failed. + */ + public void testObjectExchange() throws Exception { + BinaryMarshaller marsh = new BinaryMarshaller(); + marsh.setContext(new MarshallerContextWithNoStorage()); + + IgniteConfiguration cfg = new IgniteConfiguration(); + + PortableContext context = new PortableContext(BinaryCachingMetadataHandler.create(), cfg); + + IgniteUtils.invoke(BinaryMarshaller.class, marsh, "setPortableContext", context, cfg); + + SimpleObject simpleObj = new SimpleObject(); + + simpleObj.b = 2; + simpleObj.bArr = new byte[] {2, 3, 4, 5, 5}; + simpleObj.c = 'A'; + simpleObj.enumVal = TestEnum.D; + simpleObj.objArr = new Object[] {"hello", "world", "from", "me"}; + simpleObj.enumArr = new TestEnum[] {TestEnum.C, TestEnum.B}; + + SimpleObject otherObj = new SimpleObject(); + + otherObj.b = 3; + otherObj.bArr = new byte[] {5, 3, 4}; + + simpleObj.otherObj = otherObj; + + assertEquals(simpleObj, marsh.unmarshal(marsh.marshal(simpleObj), null)); + + SimpleBinary simplePortable = new SimpleBinary(); + + simplePortable.str = "portable"; + simplePortable.arr = new long[] {100, 200, 300}; + + assertEquals(simplePortable, marsh.unmarshal(marsh.marshal(simplePortable), null)); + + SimpleExternalizable simpleExtr = new SimpleExternalizable(); + + simpleExtr.str = "externalizable"; + simpleExtr.arr = new long[] {20000, 300000, 400000}; + + assertEquals(simpleExtr, marsh.unmarshal(marsh.marshal(simpleExtr), null)); + } + + /** + * Marshaller context with no storage. Platform has to work in such environment as well by marshalling class name of + * a portable object. + */ + private static class MarshallerContextWithNoStorage extends MarshallerContextAdapter { + /** */ + public MarshallerContextWithNoStorage() { + super(null); + } + + /** {@inheritDoc} */ + @Override protected boolean registerClassName(int id, String clsName) throws IgniteCheckedException { + return false; + } + + /** {@inheritDoc} */ + @Override protected String className(int id) throws IgniteCheckedException { + return null; + } + } + + /** + */ + private enum TestEnum { + A, B, C, D, E + } + + /** + */ + private static class SimpleObject { + /** */ + private byte b; + + /** */ + private char c; + + /** */ + private byte[] bArr; + + /** */ + private Object[] objArr; + + /** */ + private TestEnum enumVal; + + /** */ + private TestEnum[] enumArr; + + private SimpleObject otherObj; + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + SimpleObject object = (SimpleObject)o; + + if (b != object.b) + return false; + + if (c != object.c) + return false; + + if (!Arrays.equals(bArr, object.bArr)) + return false; + + // Probably incorrect - comparing Object[] arrays with Arrays.equals + if (!Arrays.equals(objArr, object.objArr)) + return false; + + if (enumVal != object.enumVal) + return false; + + // Probably incorrect - comparing Object[] arrays with Arrays.equals + if (!Arrays.equals(enumArr, object.enumArr)) + return false; + + return !(otherObj != null ? !otherObj.equals(object.otherObj) : object.otherObj != null); + } + } + + /** + * + */ + private static class SimpleBinary implements Binarylizable { + /** */ + private String str; + + /** */ + private long[] arr; + + /** {@inheritDoc} */ + @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { + writer.writeString("str", str); + writer.writeLongArray("longArr", arr); + } + + /** {@inheritDoc} */ + @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { + str = reader.readString("str"); + arr = reader.readLongArray("longArr"); + } + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + SimpleBinary that = (SimpleBinary)o; + + if (str != null ? !str.equals(that.str) : that.str != null) + return false; + + return Arrays.equals(arr, that.arr); + } + } + + /** + * + */ + private static class SimpleExternalizable implements Externalizable { + /** */ + private String str; + + /** */ + private long[] arr; + + /** {@inheritDoc} */ + @Override public void writeExternal(ObjectOutput out) throws IOException { + out.writeUTF(str); + out.writeObject(arr); + } + + /** {@inheritDoc} */ + @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + str = in.readUTF(); + arr = (long[])in.readObject(); + } + + /** {@inheritDoc} */ + @Override public boolean equals(Object o) { + if (this == o) + return true; + + if (o == null || getClass() != o.getClass()) + return false; + + SimpleExternalizable that = (SimpleExternalizable)o; + + if (str != null ? !str.equals(that.str) : that.str != null) + return false; + + return Arrays.equals(arr, that.arr); + } + } +}
http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMetaDataSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMetaDataSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMetaDataSelfTest.java new file mode 100644 index 0000000..5d74e12 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableMetaDataSelfTest.java @@ -0,0 +1,371 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import org.apache.ignite.IgniteBinary; +import org.apache.ignite.configuration.BinaryConfiguration; +import org.apache.ignite.configuration.CacheConfiguration; +import org.apache.ignite.configuration.IgniteConfiguration; +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.binary.Binarylizable; +import org.apache.ignite.binary.BinaryType; +import org.apache.ignite.binary.BinaryObject; +import org.apache.ignite.binary.BinaryRawWriter; +import org.apache.ignite.binary.BinaryReader; +import org.apache.ignite.binary.BinaryWriter; +import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; + +/** + * Portable meta data test. + */ +public class GridPortableMetaDataSelfTest extends GridCommonAbstractTest { + /** */ + private static int idx; + + /** {@inheritDoc} */ + @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception { + IgniteConfiguration cfg = super.getConfiguration(gridName); + + BinaryConfiguration bCfg = new BinaryConfiguration(); + + bCfg.setClassNames(Arrays.asList(TestObject1.class.getName(), TestObject2.class.getName())); + + cfg.setBinaryConfiguration(bCfg); + + cfg.setMarshaller(new BinaryMarshaller()); + + CacheConfiguration ccfg = new CacheConfiguration(); + + cfg.setCacheConfiguration(ccfg); + + return cfg; + } + + /** {@inheritDoc} */ + @Override protected void beforeTest() throws Exception { + idx = 0; + + startGrid(); + } + + /** {@inheritDoc} */ + @Override protected void afterTest() throws Exception { + stopGrid(); + } + + /** + * @return Portables API. + */ + protected IgniteBinary portables() { + return grid().binary(); + } + + /** + * @throws Exception If failed. + */ + public void testGetAll() throws Exception { + portables().toBinary(new TestObject2()); + + Collection<BinaryType> metas = portables().types(); + + assertEquals(2, metas.size()); + + for (BinaryType meta : metas) { + Collection<String> fields; + + switch (meta.typeName()) { + case "TestObject1": + fields = meta.fieldNames(); + + assertEquals(7, fields.size()); + + assertTrue(fields.contains("intVal")); + assertTrue(fields.contains("strVal")); + assertTrue(fields.contains("arrVal")); + assertTrue(fields.contains("obj1Val")); + assertTrue(fields.contains("obj2Val")); + assertTrue(fields.contains("decVal")); + assertTrue(fields.contains("decArrVal")); + + assertEquals("int", meta.fieldTypeName("intVal")); + assertEquals("String", meta.fieldTypeName("strVal")); + assertEquals("byte[]", meta.fieldTypeName("arrVal")); + assertEquals("Object", meta.fieldTypeName("obj1Val")); + assertEquals("Object", meta.fieldTypeName("obj2Val")); + assertEquals("decimal", meta.fieldTypeName("decVal")); + assertEquals("decimal[]", meta.fieldTypeName("decArrVal")); + + break; + + case "TestObject2": + fields = meta.fieldNames(); + + assertEquals(7, fields.size()); + + assertTrue(fields.contains("boolVal")); + assertTrue(fields.contains("dateVal")); + assertTrue(fields.contains("uuidArrVal")); + assertTrue(fields.contains("objVal")); + assertTrue(fields.contains("mapVal")); + assertTrue(fields.contains("decVal")); + assertTrue(fields.contains("decArrVal")); + + assertEquals("boolean", meta.fieldTypeName("boolVal")); + assertEquals("Date", meta.fieldTypeName("dateVal")); + assertEquals("UUID[]", meta.fieldTypeName("uuidArrVal")); + assertEquals("Object", meta.fieldTypeName("objVal")); + assertEquals("Map", meta.fieldTypeName("mapVal")); + assertEquals("decimal", meta.fieldTypeName("decVal")); + assertEquals("decimal[]", meta.fieldTypeName("decArrVal")); + + break; + + default: + assert false : meta.typeName(); + } + } + } + + /** + * @throws Exception If failed. + */ + public void testNoConfiguration() throws Exception { + portables().toBinary(new TestObject3()); + + assertNotNull(portables().type(TestObject3.class)); + } + + /** + * @throws Exception If failed. + */ + public void testReflection() throws Exception { + BinaryType meta = portables().type(TestObject1.class); + + assertNotNull(meta); + + assertEquals("TestObject1", meta.typeName()); + + Collection<String> fields = meta.fieldNames(); + + assertEquals(7, fields.size()); + + assertTrue(fields.contains("intVal")); + assertTrue(fields.contains("strVal")); + assertTrue(fields.contains("arrVal")); + assertTrue(fields.contains("obj1Val")); + assertTrue(fields.contains("obj2Val")); + assertTrue(fields.contains("decVal")); + assertTrue(fields.contains("decArrVal")); + + assertEquals("int", meta.fieldTypeName("intVal")); + assertEquals("String", meta.fieldTypeName("strVal")); + assertEquals("byte[]", meta.fieldTypeName("arrVal")); + assertEquals("Object", meta.fieldTypeName("obj1Val")); + assertEquals("Object", meta.fieldTypeName("obj2Val")); + assertEquals("decimal", meta.fieldTypeName("decVal")); + assertEquals("decimal[]", meta.fieldTypeName("decArrVal")); + } + + /** + * @throws Exception If failed. + */ + public void testPortableMarshalAware() throws Exception { + portables().toBinary(new TestObject2()); + + BinaryType meta = portables().type(TestObject2.class); + + assertNotNull(meta); + + assertEquals("TestObject2", meta.typeName()); + + Collection<String> fields = meta.fieldNames(); + + assertEquals(7, fields.size()); + + assertTrue(fields.contains("boolVal")); + assertTrue(fields.contains("dateVal")); + assertTrue(fields.contains("uuidArrVal")); + assertTrue(fields.contains("objVal")); + assertTrue(fields.contains("mapVal")); + assertTrue(fields.contains("decVal")); + assertTrue(fields.contains("decArrVal")); + + assertEquals("boolean", meta.fieldTypeName("boolVal")); + assertEquals("Date", meta.fieldTypeName("dateVal")); + assertEquals("UUID[]", meta.fieldTypeName("uuidArrVal")); + assertEquals("Object", meta.fieldTypeName("objVal")); + assertEquals("Map", meta.fieldTypeName("mapVal")); + assertEquals("decimal", meta.fieldTypeName("decVal")); + assertEquals("decimal[]", meta.fieldTypeName("decArrVal")); + } + + /** + * @throws Exception If failed. + */ + public void testMerge() throws Exception { + portables().toBinary(new TestObject2()); + + idx = 1; + + portables().toBinary(new TestObject2()); + + BinaryType meta = portables().type(TestObject2.class); + + assertNotNull(meta); + + assertEquals("TestObject2", meta.typeName()); + + Collection<String> fields = meta.fieldNames(); + + assertEquals(9, fields.size()); + + assertTrue(fields.contains("boolVal")); + assertTrue(fields.contains("dateVal")); + assertTrue(fields.contains("uuidArrVal")); + assertTrue(fields.contains("objVal")); + assertTrue(fields.contains("mapVal")); + assertTrue(fields.contains("charVal")); + assertTrue(fields.contains("colVal")); + assertTrue(fields.contains("decVal")); + assertTrue(fields.contains("decArrVal")); + + assertEquals("boolean", meta.fieldTypeName("boolVal")); + assertEquals("Date", meta.fieldTypeName("dateVal")); + assertEquals("UUID[]", meta.fieldTypeName("uuidArrVal")); + assertEquals("Object", meta.fieldTypeName("objVal")); + assertEquals("Map", meta.fieldTypeName("mapVal")); + assertEquals("char", meta.fieldTypeName("charVal")); + assertEquals("Collection", meta.fieldTypeName("colVal")); + assertEquals("decimal", meta.fieldTypeName("decVal")); + assertEquals("decimal[]", meta.fieldTypeName("decArrVal")); + } + + /** + * @throws Exception If failed. + */ + public void testSerializedObject() throws Exception { + TestObject1 obj = new TestObject1(); + + obj.intVal = 10; + obj.strVal = "str"; + obj.arrVal = new byte[] {2, 4, 6}; + obj.obj1Val = null; + obj.obj2Val = new TestObject2(); + obj.decVal = BigDecimal.ZERO; + obj.decArrVal = new BigDecimal[] { BigDecimal.ONE }; + + BinaryObject po = portables().toBinary(obj); + + info(po.toString()); + + BinaryType meta = po.type(); + + assertNotNull(meta); + + assertEquals("TestObject1", meta.typeName()); + + Collection<String> fields = meta.fieldNames(); + + assertEquals(7, fields.size()); + + assertTrue(fields.contains("intVal")); + assertTrue(fields.contains("strVal")); + assertTrue(fields.contains("arrVal")); + assertTrue(fields.contains("obj1Val")); + assertTrue(fields.contains("obj2Val")); + assertTrue(fields.contains("decVal")); + assertTrue(fields.contains("decArrVal")); + + assertEquals("int", meta.fieldTypeName("intVal")); + assertEquals("String", meta.fieldTypeName("strVal")); + assertEquals("byte[]", meta.fieldTypeName("arrVal")); + assertEquals("Object", meta.fieldTypeName("obj1Val")); + assertEquals("Object", meta.fieldTypeName("obj2Val")); + assertEquals("decimal", meta.fieldTypeName("decVal")); + assertEquals("decimal[]", meta.fieldTypeName("decArrVal")); + } + + /** + */ + @SuppressWarnings("UnusedDeclaration") + private static class TestObject1 { + /** */ + private int intVal; + + /** */ + private String strVal; + + /** */ + private byte[] arrVal; + + /** */ + private TestObject1 obj1Val; + + /** */ + private TestObject2 obj2Val; + + /** */ + private BigDecimal decVal; + + /** */ + private BigDecimal[] decArrVal; + } + + /** + */ + private static class TestObject2 implements Binarylizable { + /** {@inheritDoc} */ + @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { + writer.writeBoolean("boolVal", false); + writer.writeDate("dateVal", new Date()); + writer.writeUuidArray("uuidArrVal", null); + writer.writeObject("objVal", null); + writer.writeMap("mapVal", new HashMap<>()); + writer.writeDecimal("decVal", BigDecimal.ZERO); + writer.writeDecimalArray("decArrVal", new BigDecimal[] { BigDecimal.ONE }); + + if (idx == 1) { + writer.writeChar("charVal", (char)0); + writer.writeCollection("colVal", null); + } + + BinaryRawWriter raw = writer.rawWriter(); + + raw.writeChar((char)0); + raw.writeCollection(null); + } + + /** {@inheritDoc} */ + @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { + // No-op. + } + } + + /** + */ + @SuppressWarnings("UnusedDeclaration") + private static class TestObject3 { + /** */ + private int intVal; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableWildcardsSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableWildcardsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableWildcardsSelfTest.java new file mode 100644 index 0000000..a91e350 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/GridPortableWildcardsSelfTest.java @@ -0,0 +1,464 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary; + +import java.util.Collection; +import org.apache.ignite.IgniteCheckedException; +import org.apache.ignite.binary.BinaryIdMapper; +import org.apache.ignite.binary.BinarySerializer; +import org.apache.ignite.binary.BinaryTypeConfiguration; +import org.apache.ignite.configuration.BinaryConfiguration; +import org.apache.ignite.configuration.IgniteConfiguration; +import org.apache.ignite.internal.util.IgniteUtils; +import org.apache.ignite.internal.util.typedef.internal.U; +import org.apache.ignite.marshaller.MarshallerContextTestImpl; +import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; + +import java.util.Arrays; +import java.util.Map; + +/** + * Wildcards test. + */ +public class GridPortableWildcardsSelfTest extends GridCommonAbstractTest { + /** + * @throws Exception If failed. + */ + public void testClassNames() throws Exception { + BinaryMarshaller marsh = portableMarshaller(Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.internal.binary.test.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<Integer, Class> typeIds = U.field(ctx, "userTypes"); + + assertEquals(3, typeIds.size()); + + assertTrue(typeIds.containsKey("gridportabletestclass1".hashCode())); + assertTrue(typeIds.containsKey("gridportabletestclass2".hashCode())); + assertTrue(typeIds.containsKey("innerclass".hashCode())); + } + + /** + * @throws Exception If failed. + */ + public void testClassNamesWithMapper() throws Exception { + BinaryMarshaller marsh = portableMarshaller(new BinaryIdMapper() { + @SuppressWarnings("IfMayBeConditional") + @Override public int typeId(String clsName) { + if (clsName.endsWith("1")) + return 300; + else if (clsName.endsWith("2")) + return 400; + else if (clsName.endsWith("InnerClass")) + return 500; + else + return -500; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }, Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.internal.binary.test.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(3, typeMappers.size()); + + assertEquals(300, typeMappers.get("GridPortableTestClass1").typeId("GridPortableTestClass1")); + assertEquals(400, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + assertEquals(500, typeMappers.get("InnerClass").typeId("InnerClass")); + } + + /** + * @throws Exception If failed. + */ + public void testTypeConfigurations() throws Exception { + BinaryMarshaller marsh = portableMarshaller(Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.internal.binary.test.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<Integer, Class> typeIds = U.field(ctx, "userTypes"); + + assertEquals(3, typeIds.size()); + + assertTrue(typeIds.containsKey("gridportabletestclass1".hashCode())); + assertTrue(typeIds.containsKey("gridportabletestclass2".hashCode())); + assertTrue(typeIds.containsKey("innerclass".hashCode())); + } + + /** + * @throws Exception If failed. + */ + public void testTypeConfigurationsWithGlobalMapper() throws Exception { + BinaryMarshaller marsh = portableMarshaller(new BinaryIdMapper() { + @SuppressWarnings("IfMayBeConditional") + @Override public int typeId(String clsName) { + if (clsName.endsWith("1")) + return 300; + else if (clsName.endsWith("2")) + return 400; + else if (clsName.endsWith("InnerClass")) + return 500; + else + return -500; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }, Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.internal.binary.test.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(3, typeMappers.size()); + + assertEquals(300, typeMappers.get("GridPortableTestClass1").typeId("GridPortableTestClass1")); + assertEquals(400, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + assertEquals(500, typeMappers.get("InnerClass").typeId("InnerClass")); + } + + /** + * @throws Exception If failed. + */ + public void testTypeConfigurationsWithNonGlobalMapper() throws Exception { + BinaryMarshaller marsh = portableMarshaller(new BinaryIdMapper() { + @SuppressWarnings("IfMayBeConditional") + @Override public int typeId(String clsName) { + if (clsName.endsWith("1")) + return 300; + else if (clsName.endsWith("2")) + return 400; + else if (clsName.endsWith("InnerClass")) + return 500; + else + return -500; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }, Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.internal.binary.test.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(3, typeMappers.size()); + + assertEquals(300, typeMappers.get("GridPortableTestClass1").typeId("GridPortableTestClass1")); + assertEquals(400, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + assertEquals(500, typeMappers.get("InnerClass").typeId("InnerClass")); + } + + /** + * @throws Exception If failed. + */ + public void testOverride() throws Exception { + BinaryTypeConfiguration typeCfg = new BinaryTypeConfiguration(); + + typeCfg.setTypeName("GridPortableTestClass2"); + typeCfg.setIdMapper(new BinaryIdMapper() { + @Override public int typeId(String clsName) { + return 100; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }); + + BinaryMarshaller marsh = portableMarshaller(Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.internal.binary.test.*"), + typeCfg)); + + PortableContext ctx = portableContext(marsh); + + Map<Integer, Class> typeIds = U.field(ctx, "userTypes"); + + assertEquals(3, typeIds.size()); + + assertTrue(typeIds.containsKey("gridportabletestclass1".hashCode())); + assertTrue(typeIds.containsKey("innerclass".hashCode())); + assertFalse(typeIds.containsKey("gridportabletestclass2".hashCode())); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(100, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + } + + /** + * @throws Exception If failed. + */ + public void testClassNamesJar() throws Exception { + BinaryMarshaller marsh = portableMarshaller(Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.binary.testjar.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<Integer, Class> typeIds = U.field(ctx, "userTypes"); + + assertEquals(3, typeIds.size()); + + assertTrue(typeIds.containsKey("gridportabletestclass1".hashCode())); + assertTrue(typeIds.containsKey("gridportabletestclass2".hashCode())); + } + + /** + * @throws Exception If failed. + */ + public void testClassNamesWithMapperJar() throws Exception { + BinaryMarshaller marsh = portableMarshaller(new BinaryIdMapper() { + @SuppressWarnings("IfMayBeConditional") + @Override public int typeId(String clsName) { + if (clsName.endsWith("1")) + return 300; + else if (clsName.endsWith("2")) + return 400; + else + return -500; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }, Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.binary.testjar.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(3, typeMappers.size()); + + assertEquals(300, typeMappers.get("GridPortableTestClass1").typeId("GridPortableTestClass1")); + assertEquals(400, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + } + + /** + * @throws Exception If failed. + */ + public void testTypeConfigurationsJar() throws Exception { + BinaryMarshaller marsh = portableMarshaller(Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.binary.testjar.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<Integer, Class> typeIds = U.field(ctx, "userTypes"); + + assertEquals(3, typeIds.size()); + + assertTrue(typeIds.containsKey("gridportabletestclass1".hashCode())); + assertTrue(typeIds.containsKey("gridportabletestclass2".hashCode())); + } + + /** + * @throws Exception If failed. + */ + public void testTypeConfigurationsWithGlobalMapperJar() throws Exception { + BinaryMarshaller marsh = portableMarshaller(new BinaryIdMapper() { + @SuppressWarnings("IfMayBeConditional") + @Override public int typeId(String clsName) { + if (clsName.endsWith("1")) + return 300; + else if (clsName.endsWith("2")) + return 400; + else + return -500; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }, Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.binary.testjar.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(3, typeMappers.size()); + + assertEquals(300, typeMappers.get("GridPortableTestClass1").typeId("GridPortableTestClass1")); + assertEquals(400, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + } + + /** + * @throws Exception If failed. + */ + public void testTypeConfigurationsWithNonGlobalMapperJar() throws Exception { + BinaryMarshaller marsh = portableMarshaller(new BinaryIdMapper() { + @SuppressWarnings("IfMayBeConditional") + @Override public int typeId(String clsName) { + if (clsName.endsWith("1")) + return 300; + else if (clsName.endsWith("2")) + return 400; + else + return -500; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }, Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.binary.testjar.*"), + new BinaryTypeConfiguration("unknown.*") + )); + + PortableContext ctx = portableContext(marsh); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(3, typeMappers.size()); + + assertEquals(300, typeMappers.get("GridPortableTestClass1").typeId("GridPortableTestClass1")); + assertEquals(400, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + } + + /** + * @throws Exception If failed. + */ + public void testOverrideJar() throws Exception { + BinaryTypeConfiguration typeCfg = new BinaryTypeConfiguration( + "org.apache.ignite.binary.testjar.GridPortableTestClass2"); + + typeCfg.setIdMapper(new BinaryIdMapper() { + @Override public int typeId(String clsName) { + return 100; + } + + @Override public int fieldId(int typeId, String fieldName) { + return 0; + } + }); + + BinaryMarshaller marsh = portableMarshaller(Arrays.asList( + new BinaryTypeConfiguration("org.apache.ignite.binary.testjar.*"), + typeCfg)); + + PortableContext ctx = portableContext(marsh); + + Map<Integer, Class> typeIds = U.field(ctx, "userTypes"); + + assertEquals(3, typeIds.size()); + + assertTrue(typeIds.containsKey("gridportabletestclass1".hashCode())); + + Map<String, BinaryIdMapper> typeMappers = U.field(ctx, "typeMappers"); + + assertEquals(3, typeMappers.size()); + + assertEquals(100, typeMappers.get("GridPortableTestClass2").typeId("GridPortableTestClass2")); + } + + /** + * @param marsh Marshaller. + * @return Portable context. + */ + protected PortableContext portableContext(BinaryMarshaller marsh) { + GridPortableMarshaller impl = U.field(marsh, "impl"); + + return impl.context(); + } + + /** + * + */ + protected BinaryMarshaller portableMarshaller() + throws IgniteCheckedException { + return portableMarshaller(null, null, null); + } + + /** + * + */ + protected BinaryMarshaller portableMarshaller(Collection<BinaryTypeConfiguration> cfgs) + throws IgniteCheckedException { + return portableMarshaller(null, null, cfgs); + } + + /** + * + */ + protected BinaryMarshaller portableMarshaller(BinaryIdMapper mapper, Collection<BinaryTypeConfiguration> cfgs) + throws IgniteCheckedException { + return portableMarshaller(mapper, null, cfgs); + } + + /** + * + */ + protected BinaryMarshaller portableMarshaller(BinarySerializer serializer, Collection<BinaryTypeConfiguration> cfgs) + throws IgniteCheckedException { + return portableMarshaller(null, serializer, cfgs); + } + + protected BinaryMarshaller portableMarshaller( + BinaryIdMapper mapper, + BinarySerializer serializer, + Collection<BinaryTypeConfiguration> cfgs + ) throws IgniteCheckedException { + IgniteConfiguration iCfg = new IgniteConfiguration(); + + BinaryConfiguration bCfg = new BinaryConfiguration(); + + bCfg.setIdMapper(mapper); + bCfg.setSerializer(serializer); + + bCfg.setTypeConfigurations(cfgs); + + iCfg.setBinaryConfiguration(bCfg); + + PortableContext ctx = new PortableContext(BinaryNoopMetadataHandler.instance(), iCfg); + + BinaryMarshaller marsh = new BinaryMarshaller(); + + marsh.setContext(new MarshallerContextTestImpl(null)); + + IgniteUtils.invoke(BinaryMarshaller.class, marsh, "setPortableContext", ctx, iCfg); + + return marsh; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/TestCachingMetadataHandler.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/TestCachingMetadataHandler.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/TestCachingMetadataHandler.java new file mode 100644 index 0000000..0f48961 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/TestCachingMetadataHandler.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary; + +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.binary.BinaryType; + +import java.util.concurrent.ConcurrentHashMap; + +/** + * Test metadata handler. + */ +public class TestCachingMetadataHandler implements BinaryMetadataHandler { + /** Cached metadatas. */ + private final ConcurrentHashMap<Integer, BinaryType> metas = new ConcurrentHashMap<>(); + + /** {@inheritDoc} */ + @Override public void addMeta(int typeId, BinaryType meta) throws BinaryObjectException { + BinaryType otherType = metas.put(typeId, meta); + + if (otherType != null) + throw new IllegalStateException("Metadata replacement is not allowed in " + + TestCachingMetadataHandler.class.getSimpleName() + '.'); + } + + /** {@inheritDoc} */ + @Override public BinaryType metadata(int typeId) throws BinaryObjectException { + return metas.get(typeId); + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridBinaryMarshalerAwareTestClass.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridBinaryMarshalerAwareTestClass.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridBinaryMarshalerAwareTestClass.java new file mode 100644 index 0000000..f48bd1a --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridBinaryMarshalerAwareTestClass.java @@ -0,0 +1,67 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.mutabletest; + +import org.apache.ignite.internal.util.typedef.internal.S; +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.binary.Binarylizable; +import org.apache.ignite.binary.BinaryRawReader; +import org.apache.ignite.binary.BinaryRawWriter; +import org.apache.ignite.binary.BinaryReader; +import org.apache.ignite.binary.BinaryWriter; +import org.apache.ignite.testframework.GridTestUtils; + +/** + * + */ +public class GridBinaryMarshalerAwareTestClass implements Binarylizable { + /** */ + public String s; + + /** */ + public String sRaw; + + /** {@inheritDoc} */ + @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { + writer.writeString("s", s); + + BinaryRawWriter raw = writer.rawWriter(); + + raw.writeString(sRaw); + } + + /** {@inheritDoc} */ + @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { + s = reader.readString("s"); + + BinaryRawReader raw = reader.rawReader(); + + sRaw = raw.readString(); + } + + /** {@inheritDoc} */ + @SuppressWarnings("FloatingPointEquality") + @Override public boolean equals(Object other) { + return this == other || GridTestUtils.deepEquals(this, other); + } + + /** {@inheritDoc} */ + @Override public String toString() { + return S.toString(GridBinaryMarshalerAwareTestClass.class, this); + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridPortableTestClasses.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridPortableTestClasses.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridPortableTestClasses.java new file mode 100644 index 0000000..3a4a4b6 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/GridPortableTestClasses.java @@ -0,0 +1,484 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.mutabletest; + +import com.google.common.base.Throwables; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectOutput; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.math.BigDecimal; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +import java.util.UUID; + +import org.apache.ignite.binary.BinaryMapFactory; +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.binary.BinaryReader; +import org.apache.ignite.binary.BinaryWriter; +import org.apache.ignite.binary.Binarylizable; +import org.apache.ignite.internal.util.lang.GridMapEntry; +import org.apache.ignite.binary.BinaryObject; + +/** + * + */ +@SuppressWarnings({"PublicInnerClass", "PublicField"}) +public class GridPortableTestClasses { + /** + * + */ + public static class TestObjectContainer { + /** */ + public Object foo; + + /** + * + */ + public TestObjectContainer() { + // No-op. + } + + /** + * @param foo Object. + */ + public TestObjectContainer(Object foo) { + this.foo = foo; + } + } + + /** + * + */ + public static class TestObjectOuter { + /** */ + public TestObjectInner inner; + + /** */ + public String foo; + + /** + * + */ + public TestObjectOuter() { + + } + + /** + * @param inner Inner object. + */ + public TestObjectOuter(TestObjectInner inner) { + this.inner = inner; + } + } + + /** */ + public static class TestObjectInner { + /** */ + public Object foo; + + /** */ + public TestObjectOuter outer; + } + + /** */ + public static class TestObjectArrayList { + /** */ + public List<String> list = new ArrayList<>(); + } + + /** + * + */ + public static class TestObjectPlainPortable { + /** */ + public BinaryObject plainPortable; + + /** + * + */ + public TestObjectPlainPortable() { + // No-op. + } + + /** + * @param plainPortable Object. + */ + public TestObjectPlainPortable(BinaryObject plainPortable) { + this.plainPortable = plainPortable; + } + } + + /** + * + */ + public static class TestObjectAllTypes implements Serializable { + /** */ + public Byte b_; + + /** */ + public Short s_; + + /** */ + public Integer i_; + + /** */ + public Long l_; + + /** */ + public Float f_; + + /** */ + public Double d_; + + /** */ + public Character c_; + + /** */ + public Boolean z_; + + /** */ + public byte b; + + /** */ + public short s; + + /** */ + public int i; + + /** */ + public long l; + + /** */ + public float f; + + /** */ + public double d; + + /** */ + public char c; + + /** */ + public boolean z; + + /** */ + public String str; + + /** */ + public UUID uuid; + + /** */ + public Date date; + + /** */ + public Timestamp ts; + + /** */ + public byte[] bArr; + + /** */ + public short[] sArr; + + /** */ + public int[] iArr; + + /** */ + public long[] lArr; + + /** */ + public float[] fArr; + + /** */ + public double[] dArr; + + /** */ + public char[] cArr; + + /** */ + public boolean[] zArr; + + /** */ + public BigDecimal[] bdArr; + + /** */ + public String[] strArr; + + /** */ + public UUID[] uuidArr; + + /** */ + public Date[] dateArr; + + /** */ + public Timestamp[] tsArr; + + /** */ + public TestObjectEnum anEnum; + + /** */ + public TestObjectEnum[] enumArr; + + /** */ + public Map.Entry entry; + + /** + * @return Array. + */ + private byte[] serialize() { + ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + + try { + ObjectOutput out = new ObjectOutputStream(byteOut); + + out.writeObject(this); + + out.close(); + } + catch (IOException e) { + Throwables.propagate(e); + } + + return byteOut.toByteArray(); + } + + /** + * + */ + public void setDefaultData() { + b_ = 11; + s_ = 22; + i_ = 33; + l_ = 44L; + f_ = 55f; + d_ = 66d; + c_ = 'e'; + z_ = true; + + b = 1; + s = 2; + i = 3; + l = 4; + f = 5; + d = 6; + c = 7; + z = true; + + str = "abc"; + uuid = new UUID(1, 1); + date = new Date(1000000); + ts = new Timestamp(100020003); + + bArr = new byte[] {1, 2, 3}; + sArr = new short[] {1, 2, 3}; + iArr = new int[] {1, 2, 3}; + lArr = new long[] {1, 2, 3}; + fArr = new float[] {1, 2, 3}; + dArr = new double[] {1, 2, 3}; + cArr = new char[] {1, 2, 3}; + zArr = new boolean[] {true, false}; + + strArr = new String[] {"abc", "ab", "a"}; + uuidArr = new UUID[] {new UUID(1, 1), new UUID(2, 2)}; + bdArr = new BigDecimal[] {new BigDecimal(1000), BigDecimal.TEN}; + dateArr = new Date[] {new Date(1000000), new Date(200000)}; + tsArr = new Timestamp[] {new Timestamp(100020003), new Timestamp(200030004)}; + + anEnum = TestObjectEnum.A; + + enumArr = new TestObjectEnum[] {TestObjectEnum.B}; + + entry = new GridMapEntry<>(1, "a"); + } + } + + /** + * + */ + public enum TestObjectEnum { + A, B, C + } + + /** + * + */ + public static class Address implements Serializable { + /** SUID. */ + private static final long serialVersionUID = 0L; + + /** City. */ + public String city; + + /** Street. */ + public String street; + + /** Street number. */ + public int streetNumber; + + /** Flat number. */ + public int flatNumber; + + /** + * Default constructor. + */ + public Address() { + // No-op. + } + + /** + * Constructor. + * + * @param city City. + * @param street Street. + * @param streetNumber Street number. + * @param flatNumber Flat number. + */ + public Address(String city, String street, int streetNumber, int flatNumber) { + this.city = city; + this.street = street; + this.streetNumber = streetNumber; + this.flatNumber = flatNumber; + } + } + + /** + * + */ + public static class Company implements Serializable { + /** SUID. */ + private static final long serialVersionUID = 0L; + + /** ID. */ + public int id; + + /** Name. */ + public String name; + + /** Size. */ + public int size; + + /** Address. */ + public Address address; + + /** Occupation. */ + public String occupation; + + /** + * Default constructor. + */ + public Company() { + // No-op. + } + + /** + * Constructor. + * + * @param id ID. + * @param name Name. + * @param size Size. + * @param address Address. + * @param occupation Occupation. + */ + public Company(int id, String name, int size, Address address, String occupation) { + this.id = id; + this.name = name; + this.size = size; + this.address = address; + this.occupation = occupation; + } + } + + /** + * Companies. + */ + public static class Companies { + /** Companies. */ + private List<Company> companies = new ArrayList<>(); + + /** + * @param idx Index. + * @return Company. + */ + public Company get(int idx) { + return companies.get(idx); + } + + /** + * @param company Company. + */ + public void add(Company company) { + companies.add(company); + } + + /** + * @return Size. + */ + public int size() { + return companies.size(); + } + } + + /** + * + */ + public static class Addresses implements Binarylizable { + /** */ + private Map<String, Companies> companyByStreet = new TreeMap<>(); + + /** + * @param company Company. + */ + public void addCompany(Company company) { + Companies list = companyByStreet.get(company.address.street); + + if (list == null) { + list = new Companies(); + + companyByStreet.put(company.address.street, list); + } + + list.add(company); + } + + /** + * @return map + */ + public Map<String, Companies> getCompanyByStreet() { + return companyByStreet; + } + + /** {@inheritDoc} */ + @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { + writer.writeMap("companyByStreet", companyByStreet); + } + + /** {@inheritDoc} */ + @SuppressWarnings("unchecked") + @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { + companyByStreet = reader.readMap("companyByStreet", new BinaryMapFactory<String, Companies>() { + @Override public Map<String, Companies> create(int size) { + return new TreeMap<>(); + } + }); + } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/package-info.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/package-info.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/package-info.java new file mode 100644 index 0000000..fecf816 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/mutabletest/package-info.java @@ -0,0 +1,22 @@ +/* + * 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 description. --> + * Contains internal tests or test related classes and interfaces. + */ +package org.apache.ignite.internal.binary.mutabletest; http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsHeapNonCompactSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsHeapNonCompactSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsHeapNonCompactSelfTest.java new file mode 100644 index 0000000..7687f38 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsHeapNonCompactSelfTest.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.noncompact; + +import org.apache.ignite.internal.binary.BinaryFieldsHeapSelfTest; + +/** + * Field tests for heap-based portables with non-compact footer. + */ +public class BinaryFieldsHeapNonCompactSelfTest extends BinaryFieldsHeapSelfTest { + /** {@inheritDoc} */ + @Override protected boolean compactFooter() { + return false; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsOffheapNonCompactSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsOffheapNonCompactSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsOffheapNonCompactSelfTest.java new file mode 100644 index 0000000..52bccd8 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFieldsOffheapNonCompactSelfTest.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.noncompact; + +import org.apache.ignite.internal.binary.BinaryFieldsOffheapSelfTest; + +/** + * Field tests for offheap-based portables with non-compact footer. + */ +public class BinaryFieldsOffheapNonCompactSelfTest extends BinaryFieldsOffheapSelfTest { + /** {@inheritDoc} */ + @Override protected boolean compactFooter() { + return false; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsHeapNonCompactSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsHeapNonCompactSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsHeapNonCompactSelfTest.java new file mode 100644 index 0000000..279e4f0 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsHeapNonCompactSelfTest.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.noncompact; + +import org.apache.ignite.internal.binary.BinaryFooterOffsetsHeapSelfTest; + +/** + * Compact offsets tests for heap portable objects with non-compact footer. + */ +public class BinaryFooterOffsetsHeapNonCompactSelfTest extends BinaryFooterOffsetsHeapSelfTest { + /** {@inheritDoc} */ + @Override protected boolean compactFooter() { + return false; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsOffheapNonCompactSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsOffheapNonCompactSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsOffheapNonCompactSelfTest.java new file mode 100644 index 0000000..66a8d1a --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryFooterOffsetsOffheapNonCompactSelfTest.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.noncompact; + +import org.apache.ignite.internal.binary.BinaryFooterOffsetsOffheapSelfTest; + +/** + * Compact offsets tests for offheap portable objects with non-compact footer. + */ +public class BinaryFooterOffsetsOffheapNonCompactSelfTest extends BinaryFooterOffsetsOffheapSelfTest { + /** {@inheritDoc} */ + @Override protected boolean compactFooter() { + return false; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryMarshallerNonCompactSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryMarshallerNonCompactSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryMarshallerNonCompactSelfTest.java new file mode 100644 index 0000000..5cc228d --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryMarshallerNonCompactSelfTest.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.noncompact; + +import org.apache.ignite.internal.binary.BinaryMarshallerSelfTest; + +/** + * Basic marshaller test with non-compact footer. + */ +public class BinaryMarshallerNonCompactSelfTest extends BinaryMarshallerSelfTest { + /** {@inheritDoc} */ + @Override protected boolean compactFooter() { + return false; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderAdditionalNonCompactSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderAdditionalNonCompactSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderAdditionalNonCompactSelfTest.java new file mode 100644 index 0000000..fcf68c5 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderAdditionalNonCompactSelfTest.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.noncompact; + +import org.apache.ignite.internal.binary.BinaryObjectBuilderAdditionalSelfTest; + +/** + * + */ +public class BinaryObjectBuilderAdditionalNonCompactSelfTest extends BinaryObjectBuilderAdditionalSelfTest { + /** {@inheritDoc} */ + @Override protected boolean compactFooter() { + return false; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderNonCompactSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderNonCompactSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderNonCompactSelfTest.java new file mode 100644 index 0000000..1305b6e --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/noncompact/BinaryObjectBuilderNonCompactSelfTest.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.noncompact; + +import org.apache.ignite.internal.binary.BinaryObjectBuilderSelfTest; + +/** + * Portable builder test for objects with non-compact footer. + */ +public class BinaryObjectBuilderNonCompactSelfTest extends BinaryObjectBuilderSelfTest { + /** {@inheritDoc} */ + @Override protected boolean compactFooter() { + return false; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/package-info.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/package-info.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/package-info.java new file mode 100644 index 0000000..56abcfd --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/package-info.java @@ -0,0 +1,22 @@ +/* + * 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 description. --> + * Contains internal tests or test related classes and interfaces. + */ +package org.apache.ignite.internal.binary; http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass1.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass1.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass1.java new file mode 100644 index 0000000..887134a --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass1.java @@ -0,0 +1,28 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.test; + +/** + */ +public class GridPortableTestClass1 { + /** + */ + private static class InnerClass { + // No-op. + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass2.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass2.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass2.java new file mode 100644 index 0000000..3c1c506 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/GridPortableTestClass2.java @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.test; + +/** + */ +public class GridPortableTestClass2 { + // No-op. +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/test/package-info.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/test/package-info.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/package-info.java new file mode 100644 index 0000000..78009a6 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/package-info.java @@ -0,0 +1,22 @@ +/* + * 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 description. --> + * Contains internal tests or test related classes and interfaces. + */ +package org.apache.ignite.internal.binary.test; http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/GridPortableTestClass3.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/GridPortableTestClass3.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/GridPortableTestClass3.java new file mode 100644 index 0000000..a04b586 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/GridPortableTestClass3.java @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.binary.test.subpackage; + +/** + */ +public class GridPortableTestClass3 { + // No-op. +} http://git-wip-us.apache.org/repos/asf/ignite/blob/1dbf20e0/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/package-info.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/package-info.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/package-info.java new file mode 100644 index 0000000..f0e0b4c --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/test/subpackage/package-info.java @@ -0,0 +1,22 @@ +/* + * 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 description. --> + * Contains internal tests or test related classes and interfaces. + */ +package org.apache.ignite.internal.binary.test.subpackage;
