| /* |
| * 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. |
| */ |
| |
| #include <memory> |
| |
| #include <boost/test/unit_test.hpp> |
| |
| #include "ignite/impl/interop/interop.h" |
| #include "ignite/binary/binary.h" |
| |
| #include "ignite/binary_test_defs.h" |
| #include "ignite/binary_test_utils.h" |
| |
| using namespace ignite; |
| using namespace ignite::impl::interop; |
| using namespace ignite::impl::binary; |
| using namespace ignite::binary; |
| using namespace ignite_test::core::binary; |
| |
| template<typename T> |
| void CheckPrimitive(T val) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| BOOST_CHECK_EXCEPTION(Write<T>(writer, NULL, val), IgniteError, IsBinaryError); |
| |
| Write<T>(writer, "test", val); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| in.Synchronize(); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| BOOST_CHECK_EXCEPTION(Read<T>(reader, NULL), IgniteError, IsBinaryError); |
| |
| 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"; |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| T nullFieldArr[2]; |
| |
| nullFieldArr[0] = val1; |
| nullFieldArr[1] = val2; |
| |
| BOOST_CHECK_EXCEPTION(WriteArray<T>(writer, NULL, nullFieldArr, 2), IgniteError, IsBinaryError); |
| |
| T arr1[2]; |
| arr1[0] = dflt; |
| arr1[1] = dflt; |
| |
| T arr2[2]; |
| arr2[0] = val1; |
| arr2[1] = val2; |
| |
| { |
| // 1. Write NULL and see what happens. |
| WriteArray<T>(writer, fieldName, NULL, 0); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| in.Synchronize(); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 0) == -1); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 2) == -1); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 1) == -1); |
| |
| BOOST_REQUIRE(arr1[0] == dflt); |
| BOOST_REQUIRE(arr1[1] == dflt); |
| } |
| |
| { |
| // 2. Write empty array. |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| WriteArray<T>(writer, fieldName, arr2, 0); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| in.Synchronize(); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 0) == 0); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 2) == 0); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 0) == 0); |
| BOOST_REQUIRE(arr1[0] == dflt); |
| BOOST_REQUIRE(arr1[1] == dflt); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| 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(IGNITE_DFLT_HDR_LEN); |
| |
| WriteArray<T>(writer, fieldName, arr2, 1); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| in.Synchronize(); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| 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(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, arr1, 1) == 1); |
| BOOST_REQUIRE(arr1[0] == val1); |
| BOOST_REQUIRE(arr1[1] == dflt); |
| arr1[0] = dflt; |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| 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(IGNITE_DFLT_HDR_LEN); |
| |
| WriteArray<T>(writer, fieldName, arr2, 2); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| in.Synchronize(); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 0) == 2); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(ReadArray<T>(reader, fieldName, NULL, 2) == 2); |
| |
| BOOST_CHECK_EXCEPTION(ReadArray<T>(reader, NULL, arr1, 2), IgniteError, IsBinaryError); |
| |
| 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(BinaryWriter& writer) |
| { |
| BOOST_CHECK_EXCEPTION(writer.WriteInt8("field", 1), IgniteError, IsBinaryError); |
| |
| int8_t arr[1]; |
| BOOST_CHECK_EXCEPTION(writer.WriteInt8Array("field", arr, 1), IgniteError, IsBinaryError); |
| |
| Guid guid(1, 1); |
| BOOST_CHECK_EXCEPTION(writer.WriteGuid("field", guid), IgniteError, IsBinaryError); |
| |
| Date date(1); |
| BOOST_CHECK_EXCEPTION(writer.WriteDate("field", date), IgniteError, IsBinaryError); |
| |
| Time time(1); |
| BOOST_CHECK_EXCEPTION(writer.WriteTime("field", time), IgniteError, IsBinaryError); |
| |
| Timestamp ts(1); |
| BOOST_CHECK_EXCEPTION(writer.WriteTimestamp("field", ts), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteString("field", "test"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteArray<int8_t>("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteCollection<int8_t>("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION((writer.WriteMap<int8_t, int8_t>("field")), IgniteError, IsBinaryError); |
| } |
| |
| void CheckReadsRestricted(BinaryReader& reader) |
| { |
| BOOST_CHECK_EXCEPTION(reader.ReadInt8("field"), IgniteError, IsBinaryError); |
| |
| int8_t arr[1]; |
| BOOST_CHECK_EXCEPTION(reader.ReadInt8Array("field", arr, 1), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadGuid("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadDate("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadTimestamp("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadString("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadArray<int8_t>("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadCollection<int8_t>("field"), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION((reader.ReadMap<int8_t, int8_t>("field")), IgniteError, IsBinaryError); |
| } |
| |
| void CheckCollectionEmpty(CollectionType::Type* colType) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryCollectionWriter<BinaryInner> colWriter = colType ? |
| writer.WriteCollection<BinaryInner>("field1", *colType) : writer.WriteCollection<BinaryInner>("field1"); |
| |
| CheckWritesRestricted(writer); |
| |
| colWriter.Close(); |
| |
| writer.WriteInt8("field2", 1); |
| |
| BOOST_CHECK_EXCEPTION(colWriter.Write(1), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(colWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryCollectionReader<BinaryInner> colReader = reader.ReadCollection<BinaryInner>("field1"); |
| |
| if (colType) |
| BOOST_REQUIRE(colReader.GetType() == *colType); |
| else |
| BOOST_REQUIRE(colReader.GetType() == CollectionType::UNDEFINED); |
| |
| BOOST_REQUIRE(colReader.GetSize() == 0); |
| BOOST_REQUIRE(!colReader.HasNext()); |
| BOOST_REQUIRE(!colReader.IsNull()); |
| |
| BOOST_CHECK_EXCEPTION(colReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| void CheckCollection(CollectionType::Type* colType) |
| { |
| BinaryInner writeVal1 = BinaryInner(1); |
| BinaryInner writeVal2 = BinaryInner(0); |
| BinaryInner writeVal3 = BinaryInner(2); |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryCollectionWriter<BinaryInner> colWriter = colType ? |
| writer.WriteCollection<BinaryInner>("field1", *colType) : writer.WriteCollection<BinaryInner>("field1"); |
| |
| colWriter.Write(writeVal1); |
| colWriter.Write(writeVal2); |
| colWriter.Write(writeVal3); |
| |
| CheckWritesRestricted(writer); |
| |
| colWriter.Close(); |
| |
| writer.WriteInt8("field2", 1); |
| |
| BOOST_CHECK_EXCEPTION(colWriter.Write(1), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(colWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryCollectionReader<BinaryInner> colReader = reader.ReadCollection<BinaryInner>("field1"); |
| |
| CheckReadsRestricted(reader); |
| |
| if (colType) |
| BOOST_REQUIRE(colReader.GetType() == *colType); |
| else |
| BOOST_REQUIRE(colReader.GetType() == CollectionType::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()); |
| |
| BOOST_CHECK_EXCEPTION(colReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| void CheckCollectionIterators(CollectionType::Type* colType) |
| { |
| typedef std::vector<BinaryInner> BinaryInnerVector; |
| BinaryInnerVector writeValues; |
| |
| writeValues.push_back(1); |
| writeValues.push_back(0); |
| writeValues.push_back(2); |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| if (colType) |
| writer.WriteCollection("field1", writeValues.begin(), writeValues.end(), *colType); |
| else |
| writer.WriteCollection("field1", writeValues.begin(), writeValues.end()); |
| |
| writer.WriteInt8("field2", 1); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_REQUIRE(reader.ReadCollectionSize("field1") == static_cast<int32_t>(writeValues.size())); |
| |
| CollectionType::Type expectedCollectionType = colType ? *colType : CollectionType::UNDEFINED; |
| BOOST_REQUIRE(reader.ReadCollectionType("field1") == expectedCollectionType); |
| |
| BinaryInnerVector readValues; |
| std::back_insert_iterator<BinaryInnerVector> readInsertIterator(readValues); |
| |
| reader.ReadCollection<BinaryInner>("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::Type* mapType) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryMapWriter<int8_t, BinaryInner> mapWriter = mapType ? |
| writer.WriteMap<int8_t, BinaryInner>("field1", *mapType) : writer.WriteMap<int8_t, BinaryInner>("field1"); |
| |
| CheckWritesRestricted(writer); |
| |
| mapWriter.Close(); |
| |
| writer.WriteInt8("field2", 1); |
| |
| BOOST_CHECK_EXCEPTION(mapWriter.Write(1, BinaryInner(1)), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(mapWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryMapReader<int8_t, BinaryInner> mapReader = reader.ReadMap<int8_t, BinaryInner>("field1"); |
| |
| if (mapType) |
| BOOST_REQUIRE(mapReader.GetType() == *mapType); |
| else |
| BOOST_REQUIRE(mapReader.GetType() == MapType::UNDEFINED); |
| |
| BOOST_REQUIRE(mapReader.GetSize() == 0); |
| BOOST_REQUIRE(!mapReader.HasNext()); |
| BOOST_REQUIRE(!mapReader.IsNull()); |
| |
| int8_t key; |
| BinaryInner val; |
| BOOST_CHECK_EXCEPTION(mapReader.GetNext(key, val), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| void CheckMap(MapType::Type* mapType) |
| { |
| BinaryInner writeVal1 = BinaryInner(1); |
| BinaryInner writeVal2 = BinaryInner(0); |
| BinaryInner writeVal3 = BinaryInner(2); |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryMapWriter<int8_t, BinaryInner> mapWriter = mapType ? |
| writer.WriteMap<int8_t, BinaryInner>("field1", *mapType) : writer.WriteMap<int8_t, BinaryInner>("field1"); |
| |
| mapWriter.Write(1, writeVal1); |
| mapWriter.Write(2, writeVal2); |
| mapWriter.Write(3, writeVal3); |
| |
| CheckWritesRestricted(writer); |
| |
| mapWriter.Close(); |
| |
| writer.WriteInt8("field2", 1); |
| |
| BOOST_CHECK_EXCEPTION(mapWriter.Write(4, BinaryInner(4)), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(mapWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryMapReader<int8_t, BinaryInner> mapReader = reader.ReadMap<int8_t, BinaryInner>("field1"); |
| |
| CheckReadsRestricted(reader); |
| |
| if (mapType) |
| BOOST_REQUIRE(mapReader.GetType() == *mapType); |
| else |
| BOOST_REQUIRE(mapReader.GetType() == MapType::UNDEFINED); |
| |
| BOOST_REQUIRE(mapReader.GetSize() == 3); |
| BOOST_REQUIRE(!mapReader.IsNull()); |
| |
| int8_t key; |
| BinaryInner 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()); |
| |
| BOOST_CHECK_EXCEPTION(mapReader.GetNext(key, val), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_SUITE(BinaryReaderWriterTestSuite) |
| |
| 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(TestPrimitiveDate) |
| { |
| Date val(time(NULL) * 1000); |
| |
| CheckPrimitive<Date>(val); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestPrimitiveTime) |
| { |
| Time val(time(NULL) * 1000); |
| |
| CheckPrimitive<Time>(val); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestPrimitiveTimestamp) |
| { |
| Timestamp val(time(NULL), 0); |
| |
| CheckPrimitive<Timestamp>(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(TestPrimitiveArrayDate) |
| { |
| Date dflt(1); |
| Date val1(2); |
| Date val2(3); |
| |
| CheckPrimitiveArray<Date>(dflt, val1, val2); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestPrimitiveArrayTime) |
| { |
| Time dflt(1); |
| Time val1(2); |
| Time val2(3); |
| |
| CheckPrimitiveArray<Time>(dflt, val1, val2); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestPrimitiveArrayTimestamp) |
| { |
| Timestamp dflt(1); |
| Timestamp val1(2); |
| Timestamp val2(3); |
| |
| CheckPrimitiveArray<Timestamp>(dflt, val1, val2); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestGuidNull) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteNull(NULL), IgniteError, IsBinaryError); |
| |
| writer.WriteNull("test"); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadGuid(NULL), IgniteError, IsBinaryError); |
| |
| Guid expVal; |
| Guid actualVal = reader.ReadGuid("test"); |
| |
| BOOST_REQUIRE(actualVal == expVal); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestDateNull) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteNull(NULL), IgniteError, IsBinaryError); |
| |
| writer.WriteNull("test"); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadDate(NULL), IgniteError, IsBinaryError); |
| |
| Date expVal; |
| Date actualVal = reader.ReadDate("test"); |
| |
| BOOST_REQUIRE(actualVal == expVal); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestTimeNull) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteNull(NULL), IgniteError, IsBinaryError); |
| |
| writer.WriteNull("test"); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadTime(NULL), IgniteError, IsBinaryError); |
| |
| Time expVal; |
| Time actualVal = reader.ReadTime("test"); |
| |
| BOOST_REQUIRE(actualVal == expVal); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestTimestampNull) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteNull(NULL), IgniteError, IsBinaryError); |
| |
| writer.WriteNull("test"); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadTimestamp(NULL), IgniteError, IsBinaryError); |
| |
| Timestamp expVal; |
| Timestamp actualVal = reader.ReadTimestamp("test"); |
| |
| BOOST_REQUIRE(actualVal == expVal); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestString) { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| const char* writeVal1 = "testtest"; |
| const char* writeVal2 = "test"; |
| std::string writeVal3 = writeVal1; |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteString(NULL, writeVal1), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteString(NULL, writeVal1, 4), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(writer.WriteString(NULL, writeVal3), IgniteError, IsBinaryError); |
| |
| writer.WriteString("field1", writeVal1); |
| writer.WriteString("field2", writeVal1, 4); |
| writer.WriteString("field3", writeVal3); |
| writer.WriteString("field4", NULL); |
| writer.WriteString("field5", NULL, 4); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 5; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| char nullCheckRes[9]; |
| BOOST_CHECK_EXCEPTION(reader.ReadString(NULL, nullCheckRes, 9), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadString(NULL), IgniteError, IsBinaryError); |
| |
| 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) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| writer.WriteNull("field1"); |
| writer.WriteInt8("field2", 1); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryStringArrayReader arrReader = reader.ReadStringArray("field1"); |
| |
| BOOST_REQUIRE(arrReader.GetSize() == -1); |
| BOOST_REQUIRE(!arrReader.HasNext()); |
| BOOST_REQUIRE(arrReader.IsNull()); |
| |
| char res[100]; |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(res, 100), IgniteError, IsBinaryError); |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestStringArrayEmpty) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryStringArrayWriter arrWriter = writer.WriteStringArray("field1"); |
| |
| CheckWritesRestricted(writer); |
| |
| arrWriter.Close(); |
| |
| writer.WriteInt8("field2", 1); |
| |
| const char* val1 = "test"; |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(val1, 4), IgniteError, IsBinaryError); |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(val1), IgniteError, IsBinaryError); |
| |
| std::string val2 = "test"; |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(val2), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(arrWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryStringArrayReader arrReader = reader.ReadStringArray("field1"); |
| |
| BOOST_REQUIRE(arrReader.GetSize() == 0); |
| BOOST_REQUIRE(!arrReader.HasNext()); |
| BOOST_REQUIRE(!arrReader.IsNull()); |
| |
| char res[100]; |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(res, 100), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestStringArray) |
| { |
| const char* writeVal1 = "testtest"; |
| const char* writeVal2 = "test"; |
| std::string writeVal3 = "test2"; |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryStringArrayWriter 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); |
| |
| const char* val1 = "test"; |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(val1, 4), IgniteError, IsBinaryError); |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(val1), IgniteError, IsBinaryError); |
| |
| std::string val2 = "test"; |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(val2), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(arrWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryStringArrayReader 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()); |
| |
| char res[100]; |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(res, 100), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestObject) |
| { |
| BinaryInner writeVal1(1); |
| BinaryInner writeVal2(0); |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| writer.WriteObject("field1", writeVal1); |
| writer.WriteObject("field2", writeVal2); |
| writer.WriteNull("field3"); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 3; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryInner readVal1 = reader.ReadObject<BinaryInner>("field1"); |
| |
| BOOST_REQUIRE(writeVal1.GetValue() == readVal1.GetValue()); |
| |
| BinaryInner readVal2 = reader.ReadObject<BinaryInner>("field2"); |
| BOOST_REQUIRE(writeVal2.GetValue() == readVal2.GetValue()); |
| |
| BinaryInner readVal3 = reader.ReadObject<BinaryInner>("field3"); |
| BOOST_REQUIRE(0 == readVal3.GetValue()); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestNestedObject) |
| { |
| BinaryOuter writeVal1(1, 2); |
| BinaryOuter writeVal2(0, 0); |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| writer.WriteObject("field1", writeVal1); |
| writer.WriteObject("field2", writeVal2); |
| writer.WriteNull("field3"); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 3; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryOuter readVal1 = reader.ReadObject<BinaryOuter>("field1"); |
| BOOST_REQUIRE(writeVal1.GetValue() == readVal1.GetValue()); |
| BOOST_REQUIRE(writeVal1.GetInner().GetValue() == readVal1.GetInner().GetValue()); |
| |
| BinaryOuter readVal2 = reader.ReadObject<BinaryOuter>("field2"); |
| BOOST_REQUIRE(writeVal2.GetValue() == readVal2.GetValue()); |
| BOOST_REQUIRE(writeVal2.GetInner().GetValue() == readVal2.GetInner().GetValue()); |
| |
| BinaryOuter readVal3 = reader.ReadObject<BinaryOuter>("field3"); |
| BOOST_REQUIRE(0 == readVal3.GetValue()); |
| BOOST_REQUIRE(0 == readVal3.GetInner().GetValue()); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestArrayNull) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| writer.WriteNull("field1"); |
| writer.WriteInt8("field2", 1); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryArrayReader<BinaryInner> arrReader = reader.ReadArray<BinaryInner>("field1"); |
| |
| BOOST_REQUIRE(arrReader.GetSize() == -1); |
| BOOST_REQUIRE(!arrReader.HasNext()); |
| BOOST_REQUIRE(arrReader.IsNull()); |
| |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestArrayEmpty) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryArrayWriter<BinaryInner> arrWriter = writer.WriteArray<BinaryInner>("field1"); |
| |
| CheckWritesRestricted(writer); |
| |
| arrWriter.Close(); |
| |
| writer.WriteInt8("field2", 1); |
| |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(1), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(arrWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryArrayReader<BinaryInner> arrReader = reader.ReadArray<BinaryInner>("field1"); |
| |
| BOOST_REQUIRE(arrReader.GetSize() == 0); |
| BOOST_REQUIRE(!arrReader.HasNext()); |
| BOOST_REQUIRE(!arrReader.IsNull()); |
| |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestArray) |
| { |
| BinaryInner writeVal1 = BinaryInner(1); |
| BinaryInner writeVal2 = BinaryInner(0); |
| BinaryInner writeVal3 = BinaryInner(2); |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryArrayWriter<BinaryInner> arrWriter = writer.WriteArray<BinaryInner>("field1"); |
| |
| arrWriter.Write(writeVal1); |
| arrWriter.Write(writeVal2); |
| arrWriter.Write(writeVal3); |
| |
| CheckWritesRestricted(writer); |
| |
| arrWriter.Close(); |
| |
| writer.WriteInt8("field2", 1); |
| |
| BOOST_CHECK_EXCEPTION(arrWriter.Write(1), IgniteError, IsBinaryError); |
| |
| BOOST_CHECK_EXCEPTION(arrWriter.Close(), IgniteError, IsBinaryError); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryArrayReader<BinaryInner> arrReader = reader.ReadArray<BinaryInner>("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()); |
| |
| BOOST_CHECK_EXCEPTION(arrReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestCollectionNull) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| writer.WriteNull("field1"); |
| writer.WriteInt8("field2", 1); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryCollectionReader<BinaryInner> colReader = reader.ReadCollection<BinaryInner>("field1"); |
| |
| BOOST_REQUIRE(colReader.GetType() == CollectionType::UNDEFINED); |
| BOOST_REQUIRE(colReader.GetSize() == -1); |
| BOOST_REQUIRE(!colReader.HasNext()); |
| BOOST_REQUIRE(colReader.IsNull()); |
| |
| BOOST_CHECK_EXCEPTION(colReader.GetNext(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestCollectionEmpty) |
| { |
| CheckCollectionEmpty(NULL); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestCollectionEmptyTyped) |
| { |
| CollectionType::Type typ = CollectionType::LINKED_HASH_SET; |
| |
| CheckCollectionEmpty(&typ); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestCollection) |
| { |
| CheckCollection(NULL); |
| } |
| |
| BOOST_AUTO_TEST_CASE(testCollectionTyped) |
| { |
| CollectionType::Type typ = CollectionType::LINKED_HASH_SET; |
| |
| CheckCollection(&typ); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestCollectionIterators) |
| { |
| CheckCollectionIterators(NULL); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestCollectionIteratorsTyped) |
| { |
| CollectionType::Type typ = CollectionType::LINKED_HASH_SET; |
| |
| CheckCollectionIterators(&typ); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestMapNull) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| writer.WriteNull("field1"); |
| writer.WriteInt8("field2", 1); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryMapReader<int8_t, BinaryInner> mapReader = reader.ReadMap<int8_t, BinaryInner>("field1"); |
| |
| BOOST_REQUIRE(mapReader.GetType() == MapType::UNDEFINED); |
| BOOST_REQUIRE(mapReader.GetSize() == -1); |
| BOOST_REQUIRE(!mapReader.HasNext()); |
| BOOST_REQUIRE(mapReader.IsNull()); |
| |
| int8_t key; |
| BinaryInner val; |
| BOOST_CHECK_EXCEPTION(mapReader.GetNext(key, val), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(reader.ReadInt8("field2") == 1); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestMapEmpty) |
| { |
| CheckMapEmpty(NULL); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestMapEmptyTyped) |
| { |
| MapType::Type typ = MapType::LINKED_HASH_MAP; |
| |
| CheckMapEmpty(&typ); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestMap) |
| { |
| CheckMap(NULL); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestMapTyped) |
| { |
| MapType::Type typ = MapType::LINKED_HASH_MAP; |
| |
| CheckMap(&typ); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestRawMode) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryRawWriter rawWriter = writer.RawWriter(); |
| |
| BOOST_CHECK_EXCEPTION(writer.RawWriter(), IgniteError, IsBinaryError); |
| |
| rawWriter.WriteInt8(1); |
| |
| CheckWritesRestricted(writer); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 1000, footerBegin, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BinaryRawReader rawReader = reader.RawReader(); |
| |
| BOOST_CHECK_EXCEPTION(reader.RawReader(), IgniteError, IsBinaryError); |
| |
| BOOST_REQUIRE(rawReader.ReadInt8() == 1); |
| |
| CheckReadsRestricted(reader); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestFieldSeek) |
| { |
| TemplatedBinaryIdResolver<BinaryFields> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writer(&out, NULL); |
| |
| BinaryFields writeVal(1, 2, 3, 4); |
| |
| writer.WriteTopObject<BinaryFields>(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. |
| |
| int16_t flags = in.ReadInt16(); |
| int32_t typeId = in.ReadInt32(); |
| int32_t hashCode = in.ReadInt32(); |
| int32_t len = in.ReadInt32(); |
| |
| in.ReadInt32(); // Ignoring Schema Id. |
| |
| int32_t schemaOrRawOff = in.ReadInt32(); |
| |
| int32_t rawOff; |
| int32_t footerBegin; |
| |
| if (flags & IGNITE_BINARY_FLAG_HAS_SCHEMA) |
| footerBegin = schemaOrRawOff; |
| else |
| footerBegin = len; |
| |
| int32_t trailingBytes = (len - footerBegin) % 8; |
| |
| int32_t footerEnd = len - trailingBytes; |
| |
| if (trailingBytes) |
| rawOff = in.ReadInt32(pos + len - 4); |
| else |
| rawOff = schemaOrRawOff; |
| |
| bool usrType = flags & IGNITE_BINARY_FLAG_USER_TYPE; |
| |
| footerBegin += pos; |
| footerEnd += pos; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, pos, usrType, |
| typeId, hashCode, len, rawOff, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| |
| BinaryReader 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(IGNITE_DFLT_HDR_LEN); |
| 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(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(reader.ReadInt32("val1") == 1); |
| BOOST_REQUIRE(reader.ReadInt32("val1") == 1); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(reader.ReadInt32("val2") == 2); |
| BOOST_REQUIRE(reader.ReadInt32("val2") == 2); |
| |
| // 4. Read missing field in between. |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(reader.ReadInt32("val1") == 1); |
| BOOST_REQUIRE(reader.ReadInt32("missing") == 0); |
| BOOST_REQUIRE(reader.ReadInt32("val2") == 2); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(reader.ReadInt32("val2") == 2); |
| BOOST_REQUIRE(reader.ReadInt32("missing") == 0); |
| BOOST_REQUIRE(reader.ReadInt32("val1") == 1); |
| |
| // 5. Invalid field type. |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| BOOST_REQUIRE(reader.ReadInt32("val1") == 1); |
| |
| BOOST_CHECK_EXCEPTION(reader.ReadInt64("val2"), IgniteError, IsBinaryError); |
| |
| 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<BinaryFields*>("missing") == NULL); |
| |
| // 10. Read missing container fields. |
| BinaryStringArrayReader stringArrReader = reader.ReadStringArray("missing"); |
| BOOST_REQUIRE(stringArrReader.IsNull()); |
| |
| BinaryArrayReader<BinaryFields> arrReader = reader.ReadArray<BinaryFields>("missing"); |
| BOOST_REQUIRE(arrReader.IsNull()); |
| |
| BinaryCollectionReader<BinaryFields> colReader = reader.ReadCollection<BinaryFields>("missing"); |
| BOOST_REQUIRE(colReader.IsNull()); |
| |
| BinaryMapReader<int32_t, BinaryFields> mapReader = reader.ReadMap<int32_t, BinaryFields>("missing"); |
| BOOST_REQUIRE(mapReader.IsNull()); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestSchemaOffset2ByteFields) |
| { |
| const int fieldsNum = 64; |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(4096); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| for (int i = 0; i < fieldsNum; ++i) |
| { |
| std::stringstream tmp; |
| tmp << "field" << i; |
| |
| writer.WriteInt32(tmp.str().c_str(), i * 10); |
| } |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 6 * fieldsNum; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::TWO_BYTES); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| for (int i = 0; i < fieldsNum; ++i) |
| { |
| std::stringstream tmp; |
| tmp << "field" << i; |
| |
| BOOST_REQUIRE(reader.ReadInt32(tmp.str().c_str()) == i * 10); |
| } |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestSchemaOffset4ByteFields) |
| { |
| const int fieldsNum = 0x10000 / 4; |
| |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024 * 1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| for (int i = 0; i < fieldsNum; ++i) |
| { |
| std::stringstream tmp; |
| tmp << "field" << i; |
| |
| writer.WriteInt32(tmp.str().c_str(), i * 10); |
| } |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 8 * fieldsNum; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::FOUR_BYTES); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| for (int i = 0; i < fieldsNum; ++i) |
| { |
| std::stringstream tmp; |
| tmp << "field" << i; |
| |
| BOOST_REQUIRE(reader.ReadInt32(tmp.str().c_str()) == i * 10); |
| } |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestSchemaOffset2ByteArray) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(4096); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| int8_t dummyArray[256] = {}; |
| |
| writer.WriteInt8Array("field1", dummyArray, sizeof(dummyArray)); |
| writer.WriteInt32("field2", 42); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 6 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::TWO_BYTES); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_REQUIRE(reader.ReadInt32("field2") == 42); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestSchemaOffset4ByteArray) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024 * 1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, NULL, NULL, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| int8_t dummyArray[0x10000] = {}; |
| |
| writer.WriteInt8Array("field1", dummyArray, sizeof(dummyArray)); |
| writer.WriteInt32("field2", 42); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 8 * 2; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::FOUR_BYTES); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| BOOST_REQUIRE(reader.ReadInt32("field2") == 42); |
| } |
| |
| BOOST_AUTO_TEST_CASE(TestPrimitivePointers) |
| { |
| TemplatedBinaryIdResolver<BinaryDummy> idRslvr; |
| |
| InteropUnpooledMemory mem(1024); |
| |
| InteropOutputStream out(&mem); |
| BinaryWriterImpl writerImpl(&out, &idRslvr, 0, 0, 0); |
| BinaryWriter writer(&writerImpl); |
| |
| out.Position(IGNITE_DFLT_HDR_LEN); |
| |
| std::string field1 = "Lorem ipsum"; |
| int32_t field2 = 42; |
| |
| writer.WriteObject("field1", &field1); |
| writer.WriteObject<int8_t*>("null", 0); |
| writer.WriteObject("field2", &field2); |
| |
| writerImpl.PostWrite(); |
| |
| out.Synchronize(); |
| |
| InteropInputStream in(&mem); |
| |
| int32_t footerBegin = in.ReadInt32(IGNITE_OFFSET_SCHEMA_OR_RAW_OFF); |
| int32_t footerEnd = footerBegin + 5 * 3; |
| |
| BinaryReaderImpl readerImpl(&in, &idRslvr, 0, true, idRslvr.GetTypeId(), 0, 100, 100, |
| footerBegin, footerEnd, BinaryOffsetType::ONE_BYTE); |
| BinaryReader reader(&readerImpl); |
| |
| in.Position(IGNITE_DFLT_HDR_LEN); |
| |
| std::auto_ptr<int32_t> field2Res(reader.ReadObject<int32_t*>("field2")); |
| std::auto_ptr<int8_t> fieldNullRes(reader.ReadObject<int8_t*>("null")); |
| std::auto_ptr<std::string> field1Res(reader.ReadObject<std::string*>("field1")); |
| |
| BOOST_CHECK_EQUAL(*field1Res, field1); |
| BOOST_CHECK(fieldNullRes.get() == 0); |
| BOOST_CHECK_EQUAL(*field2Res, field2); |
| } |
| |
| BOOST_AUTO_TEST_SUITE_END() |