http://git-wip-us.apache.org/repos/asf/ignite/blob/ec58b87c/modules/platforms/cpp/core-test/src/portable_reader_writer_test.cpp ---------------------------------------------------------------------- diff --cc modules/platforms/cpp/core-test/src/portable_reader_writer_test.cpp index 0000000,0825ecc..1b7c319 mode 000000,100644..100644 --- a/modules/platforms/cpp/core-test/src/portable_reader_writer_test.cpp +++ b/modules/platforms/cpp/core-test/src/portable_reader_writer_test.cpp @@@ -1,0 -1,2016 +1,2017 @@@ + /* + * 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. + */ + + #ifndef _MSC_VER + #define BOOST_TEST_DYN_LINK + #endif + + #include <boost/test/unit_test.hpp> + + #include "ignite/impl/interop/interop.h" + #include "ignite/portable/portable.h" + + #include "ignite/portable_test_defs.h" + #include "ignite/portable_test_utils.h" + + using namespace ignite; + using namespace ignite::impl::interop; + using namespace ignite::impl::portable; + using namespace ignite::portable; + using namespace ignite_test::core::portable; + + template<typename T> + void CheckPrimitive(T val) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); - out.Position(18); ++ out.Position(19); + + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + + try + { + Write<T>(writer, NULL, val); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + Write<T>(writer, "test", val); + + out.Synchronize(); + + InteropInputStream in(&mem); + - in.Position(18); ++ in.Position(19); + + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100); + PortableReader reader(&readerImpl); + + try + { + Read<T>(reader, NULL); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + T readVal = Read<T>(reader, "test"); + + BOOST_REQUIRE(readVal == val); + } + + template<typename T> + void CheckPrimitiveArray(T dflt, T val1, T val2) + { + const char* fieldName = "test"; + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100); + PortableReader reader(&readerImpl); + - out.Position(18); ++ out.Position(19); + + try + { + T nullFieldArr[2]; + + nullFieldArr[0] = val1; + nullFieldArr[1] = val2; + + WriteArray<T>(writer, NULL, nullFieldArr, 2); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + // 1. Write NULL and see what happens. + WriteArray<T>(writer, fieldName, NULL, 0); + + out.Synchronize(); + in.Synchronize(); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 0) == -1); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 2) == -1); + + T arr1[2]; + arr1[0] = dflt; + arr1[1] = dflt; + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 1) == -1); + + BOOST_REQUIRE(arr1[0] == dflt); + BOOST_REQUIRE(arr1[1] == dflt); + + // 2. Write empty array. + T arr2[2]; + arr2[0] = val1; + arr2[1] = val2; + - out.Position(18); ++ out.Position(19); + + WriteArray<T>(writer, fieldName, arr2, 0); + + out.Synchronize(); + in.Synchronize(); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 0) == 0); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 2) == 0); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 0) == 0); + BOOST_REQUIRE(arr1[0] == dflt); + BOOST_REQUIRE(arr1[1] == dflt); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 2) == 0); + BOOST_REQUIRE(arr1[0] == dflt); + BOOST_REQUIRE(arr1[1] == dflt); + + // 3. Partial array write. - out.Position(18); ++ out.Position(19); + + WriteArray<T>(writer, fieldName, arr2, 1); + + out.Synchronize(); + in.Synchronize(); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 0) == 1); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 2) == 1); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 0) == 1); + BOOST_REQUIRE(arr1[0] == dflt); + BOOST_REQUIRE(arr1[1] == dflt); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 1) == 1); + BOOST_REQUIRE(arr1[0] == val1); + BOOST_REQUIRE(arr1[1] == dflt); + arr1[0] = dflt; + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 2) == 1); + BOOST_REQUIRE(arr1[0] == val1); + BOOST_REQUIRE(arr1[1] == dflt); + arr1[0] = dflt; + + // 4. Full array write. - out.Position(18); ++ out.Position(19); + + WriteArray<T>(writer, fieldName, arr2, 2); + + out.Synchronize(); + in.Synchronize(); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 0) == 2); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 2) == 2); + + try + { + ReadArray<T>(reader, NULL, arr1, 2); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 0) == 2); + BOOST_REQUIRE(arr1[0] == dflt); + BOOST_REQUIRE(arr1[1] == dflt); + + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 1) == 2); + BOOST_REQUIRE(arr1[0] == dflt); + BOOST_REQUIRE(arr1[1] == dflt); + + BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 2) == 2); + BOOST_REQUIRE(arr1[0] == val1); + BOOST_REQUIRE(arr1[1] == val2); + } + + void CheckWritesRestricted(PortableWriter& writer) + { + try + { + writer.WriteInt8("field", 1); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + int8_t arr[1]; + + writer.WriteInt8Array("field", arr, 1); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + Guid val(1, 1); + + writer.WriteGuid("field", val); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + writer.WriteString("field", "test"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + writer.WriteArray<int8_t>("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + writer.WriteCollection<int8_t>("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + writer.WriteMap<int8_t, int8_t>("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + } + + void CheckReadsRestricted(PortableReader& reader) + { + try + { + reader.ReadInt8("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + int8_t arr[1]; + + reader.ReadInt8Array("field", arr, 1); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + reader.ReadGuid("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + reader.ReadString("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + reader.ReadArray<int8_t>("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + reader.ReadCollection<int8_t>("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + reader.ReadMap<int8_t, int8_t>("field"); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + } + + void CheckCollectionEmpty(CollectionType* colType) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableCollectionWriter<PortableInner> colWriter = colType ? + writer.WriteCollection<PortableInner>("field1", *colType) : writer.WriteCollection<PortableInner>("field1"); + + CheckWritesRestricted(writer); + + colWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + colWriter.Write(1); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + colWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableCollectionReader<PortableInner> colReader = reader.ReadCollection<PortableInner>("field1"); + + if (colType) + BOOST_REQUIRE(colReader.GetType() == *colType); + else + BOOST_REQUIRE(colReader.GetType() == IGNITE_COLLECTION_UNDEFINED); + + BOOST_REQUIRE(colReader.GetSize() == 0); + BOOST_REQUIRE(!colReader.HasNext()); + BOOST_REQUIRE(!colReader.IsNull()); + + try + { + colReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + void CheckCollection(CollectionType* colType) + { + PortableInner writeVal1 = PortableInner(1); + PortableInner writeVal2 = PortableInner(0); + PortableInner writeVal3 = PortableInner(2); + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableCollectionWriter<PortableInner> colWriter = colType ? + writer.WriteCollection<PortableInner>("field1", *colType) : writer.WriteCollection<PortableInner>("field1"); + + colWriter.Write(writeVal1); + colWriter.Write(writeVal2); + colWriter.Write(writeVal3); + + CheckWritesRestricted(writer); + + colWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + colWriter.Write(1); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + colWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableCollectionReader<PortableInner> colReader = reader.ReadCollection<PortableInner>("field1"); + + CheckReadsRestricted(reader); + + if (colType) + BOOST_REQUIRE(colReader.GetType() == *colType); + else + BOOST_REQUIRE(colReader.GetType() == IGNITE_COLLECTION_UNDEFINED); + + BOOST_REQUIRE(colReader.GetSize() == 3); + BOOST_REQUIRE(!colReader.IsNull()); + + BOOST_REQUIRE(colReader.HasNext()); + BOOST_REQUIRE(colReader.GetNext().GetValue() == writeVal1.GetValue()); + + BOOST_REQUIRE(colReader.HasNext()); + BOOST_REQUIRE(colReader.GetNext().GetValue() == writeVal2.GetValue()); + + BOOST_REQUIRE(colReader.HasNext()); + BOOST_REQUIRE(colReader.GetNext().GetValue() == writeVal3.GetValue()); + + BOOST_REQUIRE(!colReader.HasNext()); + + try + { + colReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + void CheckCollectionIterators(CollectionType* colType) + { + typedef std::vector<PortableInner> PortableInnerVector; + PortableInnerVector writeValues; + + writeValues.push_back(1); + writeValues.push_back(0); + writeValues.push_back(2); + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + + out.Position(18); + + if (colType) + writer.WriteCollection("field1", writeValues.begin(), writeValues.end(), *colType); + else + writer.WriteCollection("field1", writeValues.begin(), writeValues.end()); + + writer.WriteInt8("field2", 1); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + + in.Position(18); + + BOOST_REQUIRE(reader.ReadCollectionSize("field1") == writeValues.size()); + + CollectionType expectedCollectionType = colType ? *colType : IGNITE_COLLECTION_UNDEFINED; + BOOST_REQUIRE(reader.ReadCollectionType("field1") == expectedCollectionType); + + PortableInnerVector readValues; + std::back_insert_iterator<PortableInnerVector> readInsertIterator(readValues); + + reader.ReadCollection<PortableInner>("field1", readInsertIterator); + + BOOST_REQUIRE(readValues.size() == 3); + + BOOST_REQUIRE(readValues[0].GetValue() == writeValues[0].GetValue()); + BOOST_REQUIRE(readValues[1].GetValue() == writeValues[1].GetValue()); + BOOST_REQUIRE(readValues[2].GetValue() == writeValues[2].GetValue()); + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + void CheckMapEmpty(MapType* mapType) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableMapWriter<int8_t, PortableInner> mapWriter = mapType ? + writer.WriteMap<int8_t, PortableInner>("field1", *mapType) : writer.WriteMap<int8_t, PortableInner>("field1"); + + CheckWritesRestricted(writer); + + mapWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + mapWriter.Write(1, PortableInner(1)); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + mapWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableMapReader<int8_t, PortableInner> mapReader = reader.ReadMap<int8_t, PortableInner>("field1"); + + if (mapType) + BOOST_REQUIRE(mapReader.GetType() == *mapType); + else + BOOST_REQUIRE(mapReader.GetType() == IGNITE_MAP_UNDEFINED); + + BOOST_REQUIRE(mapReader.GetSize() == 0); + BOOST_REQUIRE(!mapReader.HasNext()); + BOOST_REQUIRE(!mapReader.IsNull()); + + try + { + int8_t key; + PortableInner val; + + mapReader.GetNext(&key, &val); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + void CheckMap(MapType* mapType) + { + PortableInner writeVal1 = PortableInner(1); + PortableInner writeVal2 = PortableInner(0); + PortableInner writeVal3 = PortableInner(2); + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableMapWriter<int8_t, PortableInner> mapWriter = mapType ? + writer.WriteMap<int8_t, PortableInner>("field1", *mapType) : writer.WriteMap<int8_t, PortableInner>("field1"); + + mapWriter.Write(1, writeVal1); + mapWriter.Write(2, writeVal2); + mapWriter.Write(3, writeVal3); + + CheckWritesRestricted(writer); + + mapWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + mapWriter.Write(4, PortableInner(4)); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + mapWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableMapReader<int8_t, PortableInner> mapReader = reader.ReadMap<int8_t, PortableInner>("field1"); + + CheckReadsRestricted(reader); + + if (mapType) + BOOST_REQUIRE(mapReader.GetType() == *mapType); + else + BOOST_REQUIRE(mapReader.GetType() == IGNITE_MAP_UNDEFINED); + + BOOST_REQUIRE(mapReader.GetSize() == 3); + BOOST_REQUIRE(!mapReader.IsNull()); + + int8_t key; + PortableInner val; + + BOOST_REQUIRE(mapReader.HasNext()); + + mapReader.GetNext(&key, &val); + BOOST_REQUIRE(key == 1); + BOOST_REQUIRE(val.GetValue() == writeVal1.GetValue()); + + mapReader.GetNext(&key, &val); + BOOST_REQUIRE(key == 2); + BOOST_REQUIRE(val.GetValue() == writeVal2.GetValue()); + + mapReader.GetNext(&key, &val); + BOOST_REQUIRE(key == 3); + BOOST_REQUIRE(val.GetValue() == writeVal3.GetValue()); + + BOOST_REQUIRE(!mapReader.HasNext()); + + try + { + mapReader.GetNext(&key, &val); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_SUITE(PortableReaderWriterTestSuite) + + BOOST_AUTO_TEST_CASE(TestPrimitiveInt8) + { + CheckPrimitive<int8_t>(1); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveBool) + { + CheckPrimitive<bool>(true); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveInt16) + { + CheckPrimitive<int16_t>(1); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveUInt16) + { + CheckPrimitive<uint16_t>(1); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveInt32) + { + CheckPrimitive<int32_t>(1); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveInt64) + { + CheckPrimitive<int64_t>(1); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveFloat) + { + CheckPrimitive<float>(1.1f); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveDouble) + { + CheckPrimitive<double>(1.1); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveGuid) + { + Guid val(1, 2); + + CheckPrimitive<Guid>(val); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt8) + { + CheckPrimitiveArray<int8_t>(1, 2, 3); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayBool) + { + CheckPrimitiveArray<bool>(false, true, false); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt16) + { + CheckPrimitiveArray<int16_t>(1, 2, 3); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayUInt16) + { + CheckPrimitiveArray<uint16_t>(1, 2, 3); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt32) + { + CheckPrimitiveArray<int32_t>(1, 2, 3); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt64) + { + CheckPrimitiveArray<int64_t>(1, 2, 3); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayFloat) + { + CheckPrimitiveArray<float>(1.1f, 2.2f, 3.3f); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayDouble) + { + CheckPrimitiveArray<double>(1.1, 2.2, 3.3); + } + + BOOST_AUTO_TEST_CASE(TestPrimitiveArrayGuid) + { + Guid dflt(1, 2); + Guid val1(3, 4); + Guid val2(5, 6); + + CheckPrimitiveArray<Guid>(dflt, val1, val2); + } + + BOOST_AUTO_TEST_CASE(TestGuidNull) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + try + { + writer.WriteNull(NULL); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + writer.WriteNull("test"); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + try + { + reader.ReadGuid(NULL); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + Guid expVal; + Guid actualVal = reader.ReadGuid("test"); + + BOOST_REQUIRE(actualVal == expVal); + } + + BOOST_AUTO_TEST_CASE(TestString) { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + const char* writeVal1 = "testtest"; + const char* writeVal2 = "test"; + std::string writeVal3 = writeVal1; + + try + { + writer.WriteString(NULL, writeVal1); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + writer.WriteString(NULL, writeVal1, 4); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + writer.WriteString(NULL, writeVal3); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + writer.WriteString("field1", writeVal1); + writer.WriteString("field2", writeVal1, 4); + writer.WriteString("field3", writeVal3); + writer.WriteString("field4", NULL); + writer.WriteString("field5", NULL, 4); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + try + { + char nullCheckRes[9]; + + reader.ReadString(NULL, nullCheckRes, 9); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + reader.ReadString(NULL); + + BOOST_FAIL("Not restricted."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + char readVal1[9]; + char readVal2[5]; + + BOOST_REQUIRE(reader.ReadString("field1", NULL, 0) == 8); + BOOST_REQUIRE(reader.ReadString("field1", NULL, 8) == 8); + BOOST_REQUIRE(reader.ReadString("field1", readVal1, 0) == 8); + BOOST_REQUIRE(reader.ReadString("field1", readVal1, 4) == 8); + + BOOST_REQUIRE(reader.ReadString("field1", readVal1, 9) == 8); + std::string writeVal1Str = writeVal1; + std::string readVal1Str = readVal1; + BOOST_REQUIRE(readVal1Str.compare(writeVal1Str) == 0); + + BOOST_REQUIRE(reader.ReadString("field2", readVal2, 5) == 4); + std::string writeVal2Str = writeVal2; + std::string readVal2Str = readVal2; + BOOST_REQUIRE(readVal2Str.compare(writeVal2Str) == 0); + + std::string readVal3 = reader.ReadString("field3"); + BOOST_REQUIRE(readVal3.compare(writeVal3) == 0); + + BOOST_REQUIRE(reader.ReadString("field4", readVal1, 9) == -1); + BOOST_REQUIRE(reader.ReadString("field5", readVal1, 9) == -1); + } + + BOOST_AUTO_TEST_CASE(TestStringArrayNull) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + writer.WriteNull("field1"); + writer.WriteInt8("field2", 1); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableStringArrayReader arrReader = reader.ReadStringArray("field1"); + + BOOST_REQUIRE(arrReader.GetSize() == -1); + BOOST_REQUIRE(!arrReader.HasNext()); + BOOST_REQUIRE(arrReader.IsNull()); + + try + { + char res[100]; + + arrReader.GetNext(res, 100); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + arrReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestStringArrayEmpty) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableStringArrayWriter arrWriter = writer.WriteStringArray("field1"); + + CheckWritesRestricted(writer); + + arrWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + const char* val = "test"; + + arrWriter.Write(val, 4); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + const char* val = "test"; + + arrWriter.Write(val); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + std::string val = "test"; + + arrWriter.Write(val); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + arrWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableStringArrayReader arrReader = reader.ReadStringArray("field1"); + + BOOST_REQUIRE(arrReader.GetSize() == 0); + BOOST_REQUIRE(!arrReader.HasNext()); + BOOST_REQUIRE(!arrReader.IsNull()); + + try + { + char res[100]; + + arrReader.GetNext(res, 100); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + arrReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestStringArray) + { + const char* writeVal1 = "testtest"; + const char* writeVal2 = "test"; + std::string writeVal3 = "test2"; + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableStringArrayWriter arrWriter = writer.WriteStringArray("field1"); + + arrWriter.Write(writeVal1); + arrWriter.Write(writeVal1, 4); + arrWriter.Write(NULL); // NULL value. + arrWriter.Write(NULL, 100); // NULL value again. + arrWriter.Write(writeVal3); + + CheckWritesRestricted(writer); + + arrWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + const char* val = "test"; + + arrWriter.Write(val, 4); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + const char* val = "test"; + + arrWriter.Write(val); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + std::string val = "test"; + + arrWriter.Write(val); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + arrWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableStringArrayReader arrReader = reader.ReadStringArray("field1"); + + CheckReadsRestricted(reader); + + BOOST_REQUIRE(arrReader.GetSize() == 5); + BOOST_REQUIRE(!arrReader.IsNull()); + + // 1. Read first value. + BOOST_REQUIRE(arrReader.HasNext()); + + char readVal1[9]; + + BOOST_REQUIRE(arrReader.GetNext(NULL, 0) == 8); + BOOST_REQUIRE(arrReader.GetNext(NULL, 8) == 8); + BOOST_REQUIRE(arrReader.GetNext(readVal1, 0) == 8); + BOOST_REQUIRE(arrReader.GetNext(readVal1, 4) == 8); + + BOOST_REQUIRE(arrReader.GetNext(readVal1, 9) == 8); + std::string writeVal1Str = writeVal1; + std::string readVal1Str = readVal1; + BOOST_REQUIRE(readVal1Str.compare(writeVal1Str) == 0); + + // 2. Read second value. + BOOST_REQUIRE(arrReader.HasNext()); + + char readVal2[5]; + + BOOST_REQUIRE(arrReader.GetNext(readVal2, 5) == 4); + std::string writeVal2Str = writeVal2; + std::string readVal2Str = readVal2; + BOOST_REQUIRE(readVal2Str.compare(writeVal2Str) == 0); + + // 3. Read NULL. + BOOST_REQUIRE(arrReader.HasNext()); + + BOOST_REQUIRE(arrReader.GetNext(readVal1, 4) == -1); + readVal1Str = readVal1; + BOOST_REQUIRE(readVal1Str.compare(writeVal1Str) == 0); + + // 4. Read NULL again, this time through another method. + BOOST_REQUIRE(arrReader.HasNext()); + + std::string readNullVal = arrReader.GetNext(); + + BOOST_REQUIRE(readNullVal.length() == 0); + + // 5. Read third value. + BOOST_REQUIRE(arrReader.HasNext()); + + std::string readVal3 = arrReader.GetNext(); + BOOST_REQUIRE(readVal3.compare(writeVal3) == 0); + + BOOST_REQUIRE(!arrReader.HasNext()); + + try + { + char res[100]; + + arrReader.GetNext(res, 100); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + arrReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestObject) + { + PortableInner writeVal1(1); + PortableInner writeVal2(0); + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + writer.WriteObject("field1", writeVal1); + writer.WriteObject("field2", writeVal2); + writer.WriteNull("field3"); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableInner readVal1 = reader.ReadObject<PortableInner>("field1"); + BOOST_REQUIRE(writeVal1.GetValue() == readVal1.GetValue()); + + PortableInner readVal2 = reader.ReadObject<PortableInner>("field2"); + BOOST_REQUIRE(writeVal2.GetValue() == readVal2.GetValue()); + + PortableInner readVal3 = reader.ReadObject<PortableInner>("field3"); + BOOST_REQUIRE(0 == readVal3.GetValue()); + } + + BOOST_AUTO_TEST_CASE(TestNestedObject) + { + PortableOuter writeVal1(1, 2); + PortableOuter writeVal2(0, 0); + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + writer.WriteObject("field1", writeVal1); + writer.WriteObject("field2", writeVal2); + writer.WriteNull("field3"); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableOuter readVal1 = reader.ReadObject<PortableOuter>("field1"); + BOOST_REQUIRE(writeVal1.GetValue() == readVal1.GetValue()); + BOOST_REQUIRE(writeVal1.GetInner().GetValue() == readVal1.GetInner().GetValue()); + + PortableOuter readVal2 = reader.ReadObject<PortableOuter>("field2"); + BOOST_REQUIRE(writeVal2.GetValue() == readVal2.GetValue()); + BOOST_REQUIRE(writeVal2.GetInner().GetValue() == readVal2.GetInner().GetValue()); + + PortableOuter readVal3 = reader.ReadObject<PortableOuter>("field3"); + BOOST_REQUIRE(0 == readVal3.GetValue()); + BOOST_REQUIRE(0 == readVal3.GetInner().GetValue()); + } + + BOOST_AUTO_TEST_CASE(TestArrayNull) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + writer.WriteNull("field1"); + writer.WriteInt8("field2", 1); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableArrayReader<PortableInner> arrReader = reader.ReadArray<PortableInner>("field1"); + + BOOST_REQUIRE(arrReader.GetSize() == -1); + BOOST_REQUIRE(!arrReader.HasNext()); + BOOST_REQUIRE(arrReader.IsNull()); + + try + { + arrReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestArrayEmpty) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableArrayWriter<PortableInner> arrWriter = writer.WriteArray<PortableInner>("field1"); + + CheckWritesRestricted(writer); + + arrWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + arrWriter.Write(1); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + arrWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableArrayReader<PortableInner> arrReader = reader.ReadArray<PortableInner>("field1"); + + BOOST_REQUIRE(arrReader.GetSize() == 0); + BOOST_REQUIRE(!arrReader.HasNext()); + BOOST_REQUIRE(!arrReader.IsNull()); + + try + { + arrReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestArray) + { + PortableInner writeVal1 = PortableInner(1); + PortableInner writeVal2 = PortableInner(0); + PortableInner writeVal3 = PortableInner(2); + + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableArrayWriter<PortableInner> arrWriter = writer.WriteArray<PortableInner>("field1"); + + arrWriter.Write(writeVal1); + arrWriter.Write(writeVal2); + arrWriter.Write(writeVal3); + + CheckWritesRestricted(writer); + + arrWriter.Close(); + + writer.WriteInt8("field2", 1); + + try + { + arrWriter.Write(1); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + try + { + arrWriter.Close(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableArrayReader<PortableInner> arrReader = reader.ReadArray<PortableInner>("field1"); + + CheckReadsRestricted(reader); + + BOOST_REQUIRE(arrReader.GetSize() == 3); + BOOST_REQUIRE(!arrReader.IsNull()); + + BOOST_REQUIRE(arrReader.HasNext()); + BOOST_REQUIRE(arrReader.GetNext().GetValue() == writeVal1.GetValue()); + + BOOST_REQUIRE(arrReader.HasNext()); + BOOST_REQUIRE(arrReader.GetNext().GetValue() == writeVal2.GetValue()); + + BOOST_REQUIRE(arrReader.HasNext()); + BOOST_REQUIRE(arrReader.GetNext().GetValue() == writeVal3.GetValue()); + + BOOST_REQUIRE(!arrReader.HasNext()); + + try + { + arrReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestCollectionNull) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + writer.WriteNull("field1"); + writer.WriteInt8("field2", 1); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableCollectionReader<PortableInner> colReader = reader.ReadCollection<PortableInner>("field1"); + + BOOST_REQUIRE(colReader.GetType() == IGNITE_COLLECTION_UNDEFINED); + BOOST_REQUIRE(colReader.GetSize() == -1); + BOOST_REQUIRE(!colReader.HasNext()); + BOOST_REQUIRE(colReader.IsNull()); + + try + { + colReader.GetNext(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestCollectionEmpty) + { + CheckCollectionEmpty(NULL); + } + + BOOST_AUTO_TEST_CASE(TestCollectionEmptyTyped) + { + CollectionType typ = IGNITE_COLLECTION_CONCURRENT_SKIP_LIST_SET; + + CheckCollectionEmpty(&typ); + } + + BOOST_AUTO_TEST_CASE(TestCollection) + { + CheckCollection(NULL); + } + + BOOST_AUTO_TEST_CASE(testCollectionTyped) + { + CollectionType typ = IGNITE_COLLECTION_CONCURRENT_SKIP_LIST_SET; + + CheckCollection(&typ); + } + + BOOST_AUTO_TEST_CASE(TestCollectionIterators) + { + CheckCollectionIterators(NULL); + } + + BOOST_AUTO_TEST_CASE(TestCollectionIteratorsTyped) + { + CollectionType typ = IGNITE_COLLECTION_CONCURRENT_SKIP_LIST_SET; + + CheckCollectionIterators(&typ); + } + + BOOST_AUTO_TEST_CASE(TestMapNull) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + writer.WriteNull("field1"); + writer.WriteInt8("field2", 1); + + out.Synchronize(); + + InteropInputStream in(&mem); + PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 1000); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableMapReader<int8_t, PortableInner> mapReader = reader.ReadMap<int8_t, PortableInner>("field1"); + + BOOST_REQUIRE(mapReader.GetType() == IGNITE_MAP_UNDEFINED); + BOOST_REQUIRE(mapReader.GetSize() == -1); + BOOST_REQUIRE(!mapReader.HasNext()); + BOOST_REQUIRE(mapReader.IsNull()); + + try + { + int8_t key; + PortableInner val; + + mapReader.GetNext(&key, &val); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt8("field2") == 1); + } + + BOOST_AUTO_TEST_CASE(TestMapEmpty) + { + CheckMapEmpty(NULL); + } + + BOOST_AUTO_TEST_CASE(TestMapEmptyTyped) + { + MapType typ = IGNITE_MAP_CONCURRENT_HASH_MAP; + + CheckMapEmpty(&typ); + } + + BOOST_AUTO_TEST_CASE(TestMap) + { + CheckMap(NULL); + } + + BOOST_AUTO_TEST_CASE(TestMapTyped) + { + MapType typ = IGNITE_MAP_CONCURRENT_HASH_MAP; + + CheckMap(&typ); + } + + BOOST_AUTO_TEST_CASE(TestRawMode) + { + TemplatedPortableIdResolver<PortableDummy> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writerImpl(&out, &idRslvr, NULL, NULL); + PortableWriter writer(&writerImpl); + - out.Position(18); ++ out.Position(19); + + PortableRawWriter rawWriter = writer.RawWriter(); + + try + { + writer.RawWriter(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + rawWriter.WriteInt8(1); + + CheckWritesRestricted(writer); + + out.Synchronize(); + + InteropInputStream in(&mem); - PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 18); ++ PortableReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, 19); + PortableReader reader(&readerImpl); + - in.Position(18); ++ in.Position(19); + + PortableRawReader rawReader = reader.RawReader(); + + try + { + reader.RawReader(); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(rawReader.ReadInt8() == 1); + + CheckReadsRestricted(reader); + } + + BOOST_AUTO_TEST_CASE(TestFieldSeek) + { + TemplatedPortableIdResolver<PortableFields> idRslvr; + + InteropUnpooledMemory mem(1024); + + InteropOutputStream out(&mem); + PortableWriterImpl writer(&out, NULL); + + PortableFields writeVal(1, 2, 3, 4); + + writer.WriteTopObject<PortableFields>(writeVal); + + out.Synchronize(); + + InteropInputStream in(&mem); + + int32_t pos = in.Position(); + in.ReadInt8(); // We do not need a header here. ++ in.ReadInt8(); // We do not need proto ver here. + bool usrType = in.ReadBool(); + int32_t typeId = in.ReadInt32(); + int32_t hashCode = in.ReadInt32(); + int32_t len = in.ReadInt32(); + int32_t rawOff = in.ReadInt32(); + + PortableReaderImpl readerImpl(&in, &idRslvr, pos, usrType, typeId, hashCode, len, rawOff); + PortableReader reader(&readerImpl); + + // 1. Clockwise. + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + + // 2. Counter closkwise. - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + + // 3. Same field twice. - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + + // 4. Read missing field in between. - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + BOOST_REQUIRE(reader.ReadInt32("missing") == 0); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + BOOST_REQUIRE(reader.ReadInt32("missing") == 0); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + + // 5. Invalid field type. - in.Position(18); ++ in.Position(19); + BOOST_REQUIRE(reader.ReadInt32("val1") == 1); + + try + { + reader.ReadInt64("val2"); + + BOOST_FAIL("Error expected."); + } + catch (IgniteError& err) + { + BOOST_REQUIRE(err.GetCode() == IgniteError::IGNITE_ERR_PORTABLE); + } + + BOOST_REQUIRE(reader.ReadInt32("val2") == 2); + + // 6. Read missing primitive fields. + BOOST_REQUIRE(reader.ReadInt8("missing") == 0); + BOOST_REQUIRE(reader.ReadBool("missing") == false); + BOOST_REQUIRE(reader.ReadInt16("missing") == 0); + BOOST_REQUIRE(reader.ReadUInt16("missing") == 0); + BOOST_REQUIRE(reader.ReadInt32("missing") == 0); + BOOST_REQUIRE(reader.ReadInt64("missing") == 0); + BOOST_REQUIRE(reader.ReadFloat("missing") == 0); + BOOST_REQUIRE(reader.ReadDouble("missing") == 0); + + BOOST_REQUIRE(reader.ReadGuid("missing").GetMostSignificantBits() == 0); + BOOST_REQUIRE(reader.ReadGuid("missing").GetLeastSignificantBits() == 0); + + // 7. Read missing primitive array fields. + BOOST_REQUIRE(reader.ReadInt8Array("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadBoolArray("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadInt16Array("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadUInt16Array("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadInt32Array("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadInt64Array("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadFloatArray("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadDoubleArray("missing", NULL, 1) == -1); + + BOOST_REQUIRE(reader.ReadGuidArray("missing", NULL, 1) == -1); + + // 8. Read missing string fields. + BOOST_REQUIRE(reader.ReadString("missing", NULL, 1) == -1); + BOOST_REQUIRE(reader.ReadString("missing").length() == 0); + + // 9. Read missing object fields. + BOOST_REQUIRE(reader.ReadObject<PortableFields*>("missing") == NULL); + + // 10. Read missing container fields. + PortableStringArrayReader stringArrReader = reader.ReadStringArray("missing"); + BOOST_REQUIRE(stringArrReader.IsNull()); + + PortableArrayReader<PortableFields> arrReader = reader.ReadArray<PortableFields>("missing"); + BOOST_REQUIRE(arrReader.IsNull()); + + PortableCollectionReader<PortableFields> colReader = reader.ReadCollection<PortableFields>("missing"); + BOOST_REQUIRE(colReader.IsNull()); + + PortableMapReader<int32_t, PortableFields> mapReader = reader.ReadMap<int32_t, PortableFields>("missing"); + BOOST_REQUIRE(mapReader.IsNull()); + } + + BOOST_AUTO_TEST_SUITE_END()
http://git-wip-us.apache.org/repos/asf/ignite/blob/ec58b87c/modules/platforms/cpp/core/include/ignite/impl/portable/portable_common.h ---------------------------------------------------------------------- diff --cc modules/platforms/cpp/core/include/ignite/impl/portable/portable_common.h index 0000000,622cb54..9efaa28 mode 000000,100644..100644 --- a/modules/platforms/cpp/core/include/ignite/impl/portable/portable_common.h +++ b/modules/platforms/cpp/core/include/ignite/impl/portable/portable_common.h @@@ -1,0 -1,146 +1,155 @@@ + /* + * 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. + */ + + #ifndef _IGNITE_IMPL_PORTABLE_COMMON + #define _IGNITE_IMPL_PORTABLE_COMMON + + #include <stdint.h> + + namespace ignite + { + namespace impl + { + namespace portable + { + /** Header: null. */ + const int8_t IGNITE_HDR_NULL = 101; + + /** Header: handle. */ + const int8_t IGNITE_HDR_HND = 102; + + /** Header: fulle form. */ + const int8_t IGNITE_HDR_FULL = 103; + ++ /** Portable protocol version. */ ++ const int8_t IGNITE_PROTO_VER = 1; ++ + /** Full header length. */ - const int32_t IGNITE_FULL_HDR_LEN = 18; ++ const int32_t IGNITE_FULL_HDR_LEN = 19; ++ ++ /** Header offset: length. */ ++ const int32_t IGNITE_OFFSET_LEN = 11; ++ ++ /** Header offset: raw offset. */ ++ const int32_t IGNITE_OFFSET_RAW = 15; + + /** Type: object. */ + const int8_t IGNITE_TYPE_OBJECT = IGNITE_HDR_FULL; + + /** Type: unsigned byte. */ + const int8_t IGNITE_TYPE_BYTE = 1; + + /** Type: short. */ + const int8_t IGNITE_TYPE_SHORT = 2; + + /** Type: int. */ + const int8_t IGNITE_TYPE_INT = 3; + + /** Type: long. */ + const int8_t IGNITE_TYPE_LONG = 4; + + /** Type: float. */ + const int8_t IGNITE_TYPE_FLOAT = 5; + + /** Type: double. */ + const int8_t IGNITE_TYPE_DOUBLE = 6; + + /** Type: char. */ + const int8_t IGNITE_TYPE_CHAR = 7; + + /** Type: boolean. */ + const int8_t IGNITE_TYPE_BOOL = 8; + + /** Type: decimal. */ + const int8_t IGNITE_TYPE_DECIMAL = 30; + + /** Type: string. */ + const int8_t IGNITE_TYPE_STRING = 9; + + /** Type: UUID. */ + const int8_t IGNITE_TYPE_UUID = 10; + + /** Type: date. */ + const int8_t IGNITE_TYPE_DATE = 11; + + /** Type: unsigned byte array. */ + const int8_t IGNITE_TYPE_ARRAY_BYTE = 12; + + /** Type: short array. */ + const int8_t IGNITE_TYPE_ARRAY_SHORT = 13; + + /** Type: int array. */ + const int8_t IGNITE_TYPE_ARRAY_INT = 14; + + /** Type: long array. */ + const int8_t IGNITE_TYPE_ARRAY_LONG = 15; + + /** Type: float array. */ + const int8_t IGNITE_TYPE_ARRAY_FLOAT = 16; + + /** Type: double array. */ + const int8_t IGNITE_TYPE_ARRAY_DOUBLE = 17; + + /** Type: char array. */ + const int8_t IGNITE_TYPE_ARRAY_CHAR = 18; + + /** Type: boolean array. */ + const int8_t IGNITE_TYPE_ARRAY_BOOL = 19; + + /** Type: decimal array. */ + const int8_t IGNITE_TYPE_ARRAY_DECIMAL = 31; + + /** Type: string array. */ + const int8_t IGNITE_TYPE_ARRAY_STRING = 20; + + /** Type: UUID array. */ + const int8_t IGNITE_TYPE_ARRAY_UUID = 21; + + /** Type: date array. */ + const int8_t IGNITE_TYPE_ARRAY_DATE = 22; + + /** Type: object array. */ + const int8_t IGNITE_TYPE_ARRAY = 23; + + /** Type: collection. */ + const int8_t IGNITE_TYPE_COLLECTION = 24; + + /** Type: map. */ + const int8_t IGNITE_TYPE_MAP = 25; + + /** Type: map entry. */ + const int8_t IGNITE_TYPE_MAP_ENTRY = 26; + + /** Type: portable object. */ + const int8_t IGNITE_TYPE_PORTABLE = 27; + + /** Read/write single object. */ + const int32_t IGNITE_PORTABLE_MODE_SINGLE = 0; + + /** Read/write array. */ + const int32_t IGNITE_PORTABLE_MODE_ARRAY = 1; + + /** Read/write collection. */ + const int32_t IGNITE_PORTABLE_MODE_COL = 2; + + /** Read/write map. */ + const int32_t IGNITE_PORTABLE_MODE_MAP = 3; + } + } + } + + #endif
