You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by vo...@apache.org on 2015/09/03 11:28:38 UTC
[10/14] ignite git commit: IGNITE-1364: WIP.
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core-test/src/cache_test.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core-test/src/cache_test.cpp b/modules/platform/src/main/cpp/core-test/src/cache_test.cpp
new file mode 100644
index 0000000..a531252
--- /dev/null
+++ b/modules/platform/src/main/cpp/core-test/src/cache_test.cpp
@@ -0,0 +1,473 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _MSC_VER
+ #define BOOST_TEST_DYN_LINK
+#endif
+
+#include <boost/test/unit_test.hpp>
+
+#include "gridgain/cache/cache_peek_mode.h"
+#include "gridgain/grid.h"
+#include "gridgain/grid_factory.h"
+
+using namespace gridgain;
+using namespace boost::unit_test;
+
+/* Nodes started during the test. */
+Grid grid0 = Grid();
+Grid grid1 = Grid();
+
+/** Cache accessor. */
+cache::Cache<int, int> Cache()
+{
+ return grid0.GetCache<int, int>("partitioned");
+}
+
+struct Person
+{
+ std::string name;
+ int age;
+
+ Person() : name(""), age(0)
+ {
+ // No-op.
+ }
+
+ Person(std::string name, int age) : name(name), age(age)
+ {
+ // No-op.
+ }
+};
+
+namespace gridgain
+{
+ namespace portable
+ {
+ GG_PORTABLE_TYPE_START(Person)
+ GG_PORTABLE_GET_TYPE_ID_AS_HASH(Person)
+ GG_PORTABLE_GET_TYPE_NAME_AS_IS(Person)
+ GG_PORTABLE_GET_FIELD_ID_AS_HASH
+ GG_PORTABLE_GET_HASH_CODE_ZERO(Person)
+ GG_PORTABLE_IS_NULL_FALSE(Person)
+ GG_PORTABLE_GET_NULL_DEFAULT_CTOR(Person)
+
+ void Write(PortableWriter& writer, Person obj)
+ {
+ writer.WriteString("name", obj.name);
+ writer.WriteInt32("age", obj.age);
+ }
+
+ Person Read(PortableReader& reader)
+ {
+ std::string name = reader.ReadString("name");
+ int age = reader.ReadInt32("age");
+
+ return Person(name, age);
+ }
+
+ GG_PORTABLE_TYPE_END
+ }
+}
+
+/*
+ * Test setup fixture.
+ */
+struct CacheTestSuiteFixture {
+ /*
+ * Constructor.
+ */
+ CacheTestSuiteFixture()
+ {
+ GridConfiguration cfg;
+
+ GridJvmOption opts[5];
+
+ opts[0] = GridJvmOption("-Xdebug");
+ opts[1] = GridJvmOption("-Xnoagent");
+ opts[2] = GridJvmOption("-Djava.compiler=NONE");
+ opts[3] = GridJvmOption("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005");
+ opts[4] = GridJvmOption("-XX:+HeapDumpOnOutOfMemoryError");
+
+ cfg.jvmOptsLen = 5;
+ cfg.jvmOpts = opts;
+
+ cfg.jvmInitMem = 1024;
+ cfg.jvmMaxMem = 4096;
+
+ char* cfgPath = getenv("GRIDGAIN_NATIVE_TEST_CPP_CONFIG_PATH");
+
+ std::string cfgPathStr = std::string(cfgPath).append("/").append("cache-test.xml");
+
+ cfg.springCfgPath = const_cast<char*>(cfgPathStr.c_str());
+
+ for (int i = 0; i < 2; i++)
+ {
+ std::stringstream stream;
+
+ stream << "grid-" << i;
+
+ GridError err;
+
+ Grid grid = GridFactory::Start(cfg, stream.str().c_str(), &err);
+
+ if (err.GetCode() != GridError::GG_SUCCESS)
+ BOOST_FAIL(err.GetText());
+
+ if (i == 0)
+ grid0 = grid;
+ else
+ grid1 = grid;
+ }
+ }
+
+ /*
+ * Destructor.
+ */
+ ~CacheTestSuiteFixture()
+ {
+ GridFactory::Stop(grid0.GetName(), true);
+ GridFactory::Stop(grid1.GetName(), true);
+
+ grid0 = Grid();
+ grid1 = Grid();
+ }
+};
+
+BOOST_FIXTURE_TEST_SUITE(CacheTestSuite, CacheTestSuiteFixture)
+
+BOOST_AUTO_TEST_CASE(TestRemoveAllKeys)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(1, 1);
+ cache.Put(2, 2);
+ cache.Put(3, 3);
+
+ int size = cache.Size(cache::GG_PEEK_MODE_PRIMARY);
+
+ BOOST_REQUIRE(3 == size);
+
+ cache.RemoveAll();
+
+ size = cache.Size(cache::GG_PEEK_MODE_ALL);
+
+ BOOST_REQUIRE(0 == size);
+
+ cache.Put(1, 1);
+ cache.Put(2, 2);
+ cache.Put(3, 3);
+
+ int keys[] = { 1, 2, 4, 5 };
+
+ std::set<int> keySet(keys, keys + 4);
+
+ cache.RemoveAll(keySet);
+
+ size = cache.Size(cache::GG_PEEK_MODE_PRIMARY);
+
+ BOOST_REQUIRE(1 == size);
+}
+
+BOOST_AUTO_TEST_CASE(TestPut)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(1, 1);
+
+ BOOST_REQUIRE(1 == cache.Get(1));
+}
+
+BOOST_AUTO_TEST_CASE(TestPutAll)
+{
+ std::map<int, int> map;
+
+ for (int i = 0; i < 100; i++)
+ map[i] = i + 1;
+
+ cache::Cache<int, int> cache = Cache();
+
+ cache.PutAll(map);
+
+ for (int i = 0; i < 100; i++)
+ BOOST_REQUIRE(i + 1 == cache.Get(i));
+}
+
+BOOST_AUTO_TEST_CASE(TestPutIfAbsent)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(true == cache.PutIfAbsent(1, 3));
+ BOOST_REQUIRE(false == cache.PutIfAbsent(1, 3));
+}
+
+BOOST_AUTO_TEST_CASE(TestGet)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(1, 1);
+ cache.Put(2, 2);
+
+ BOOST_REQUIRE(1 == cache.Get(1));
+ BOOST_REQUIRE(2 == cache.Get(2));
+
+ BOOST_REQUIRE(0 == cache.Get(3));
+}
+
+BOOST_AUTO_TEST_CASE(TestGetAll)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ int keys[] = { 1, 2, 3, 4, 5 };
+
+ std::set<int> keySet (keys, keys + 5);
+
+ for (int i = 0; i < keySet.size(); i++)
+ cache.Put(i + 1, i + 1);
+
+ std::map<int, int> map = cache.GetAll(keySet);
+
+ for (int i = 0; i < keySet.size(); i++)
+ BOOST_REQUIRE(i + 1 == map[i + 1]);
+}
+
+BOOST_AUTO_TEST_CASE(TestGetAndPut)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(0 == cache.GetAndPut(1, 3));
+ BOOST_REQUIRE(3 == cache.GetAndPut(1, 1));
+ BOOST_REQUIRE(1 == cache.GetAndPut(1, 0));
+}
+
+BOOST_AUTO_TEST_CASE(TestGetAndPutIfAbsent)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(0 == cache.GetAndPutIfAbsent(1, 3));
+ BOOST_REQUIRE(3 == cache.GetAndPutIfAbsent(1, 1));
+ BOOST_REQUIRE(3 == cache.GetAndPutIfAbsent(1, 1));
+}
+
+BOOST_AUTO_TEST_CASE(TestGetAndRemove)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(1, 3);
+
+ BOOST_REQUIRE(3 == cache.GetAndRemove(1));
+ BOOST_REQUIRE(0 == cache.GetAndRemove(1));
+}
+
+BOOST_AUTO_TEST_CASE(TestGetAndReplace)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(0 == cache.GetAndReplace(1, 3));
+ BOOST_REQUIRE(0 == cache.GetAndReplace(1, 3));
+
+ cache.Put(1, 5);
+
+ BOOST_REQUIRE(5 == cache.GetAndReplace(1, 3));
+ BOOST_REQUIRE(3 == cache.GetAndReplace(1, 3));
+}
+
+BOOST_AUTO_TEST_CASE(TestContainsKey)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(false == cache.ContainsKey(1));
+
+ cache.Put(1, 1);
+
+ BOOST_REQUIRE(true == cache.ContainsKey(1));
+
+ BOOST_REQUIRE(true == cache.Remove(1));
+
+ BOOST_REQUIRE(false == cache.ContainsKey(1));
+}
+
+BOOST_AUTO_TEST_CASE(TestContainsKeys)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ int keys[] = { 1, 2 };
+
+ std::set<int> keySet(keys, keys + 2);
+
+ BOOST_REQUIRE(false == cache.ContainsKeys(keySet));
+
+ cache.Put(1, 1);
+ cache.Put(2, 2);
+
+ BOOST_REQUIRE(true == cache.ContainsKeys(keySet));
+
+ cache.Remove(1);
+
+ BOOST_REQUIRE(false == cache.ContainsKeys(keySet));
+}
+
+BOOST_AUTO_TEST_CASE(TestIsEmpty)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(true == cache.IsEmpty());
+
+ cache.Put(1, 1);
+
+ BOOST_REQUIRE(false == cache.IsEmpty());
+
+ cache.Remove(1);
+
+ BOOST_REQUIRE(true == cache.IsEmpty());
+}
+
+BOOST_AUTO_TEST_CASE(TestRemove)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(false == cache.Remove(1));
+
+ cache.Put(1, 1);
+
+ BOOST_REQUIRE(true == cache.Remove(1));
+ BOOST_REQUIRE(false == cache.Remove(1));
+ BOOST_REQUIRE(false == cache.ContainsKey(1));
+}
+
+BOOST_AUTO_TEST_CASE(TestClear)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(1, 1);
+
+ BOOST_REQUIRE(true == cache.ContainsKey(1));
+
+ cache.Clear(1);
+
+ BOOST_REQUIRE(false == cache.ContainsKey(1));
+}
+
+BOOST_AUTO_TEST_CASE(TestLocalClear)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(0, 2);
+
+ BOOST_REQUIRE(2 == cache.LocalPeek(0, cache::GG_PEEK_MODE_PRIMARY));
+
+ cache.LocalClear(0);
+
+ BOOST_REQUIRE(0 == cache.LocalPeek(0, cache::GG_PEEK_MODE_PRIMARY));
+}
+
+BOOST_AUTO_TEST_CASE(TestLocalClearAll)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(0, 3);
+ cache.Put(1, 3);
+
+ int keys[] = { 0, 1 };
+
+ std::set<int> keySet(keys, keys + 2);
+
+ BOOST_REQUIRE(3 == cache.LocalPeek(0, cache::GG_PEEK_MODE_PRIMARY));
+ BOOST_REQUIRE(3 == cache.LocalPeek(1, cache::GG_PEEK_MODE_PRIMARY));
+
+ cache.LocalClearAll(keySet);
+
+ BOOST_REQUIRE(0 == cache.LocalPeek(0, cache::GG_PEEK_MODE_PRIMARY));
+ BOOST_REQUIRE(0 == cache.LocalPeek(1, cache::GG_PEEK_MODE_PRIMARY));
+}
+
+BOOST_AUTO_TEST_CASE(TestSizes)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ BOOST_REQUIRE(0 == cache.Size());
+
+ cache.Put(1, 1);
+ cache.Put(2, 2);
+
+ BOOST_REQUIRE(2 <= cache.Size());
+
+ BOOST_REQUIRE(1 <= cache.LocalSize(cache::GG_PEEK_MODE_PRIMARY));
+}
+
+BOOST_AUTO_TEST_CASE(TestLocalEvict)
+{
+ cache::Cache<int, int> cache = Cache();
+
+ cache.Put(1, 5);
+
+ BOOST_REQUIRE(5 == cache.LocalPeek(1, cache::GG_PEEK_MODE_ONHEAP));
+
+ int keys[] = { 0, 1 };
+
+ std::set<int> keySet(keys, keys + 2);
+
+ cache.LocalEvict(keySet);
+
+ BOOST_REQUIRE(0 == cache.LocalPeek(1, cache::GG_PEEK_MODE_ONHEAP));
+
+ BOOST_REQUIRE(5 == cache.Get(1));
+
+ BOOST_REQUIRE(5 == cache.LocalPeek(1, cache::GG_PEEK_MODE_ONHEAP));
+}
+
+BOOST_AUTO_TEST_CASE(TestPortable)
+{
+ cache::Cache<int, Person> cache = grid0.GetCache<int, Person>("partitioned");
+
+ Person person("John Johnson", 3);
+
+ cache.Put(1, person);
+
+ Person person0 = cache.Get(1);
+
+ BOOST_REQUIRE(person.age == person0.age);
+ BOOST_REQUIRE(person.name.compare(person0.name) == 0);
+}
+
+BOOST_AUTO_TEST_CASE(TestCreateCache)
+{
+ // Create new cache
+ cache::Cache<int, int> cache = grid0.CreateCache<int, int>("dynamic_cache");
+
+ cache.Put(5, 7);
+
+ BOOST_REQUIRE(7 == cache.Get(5));
+
+ // Attempt to create cache with existing name
+ GridError err;
+
+ grid0.CreateCache<int, int>("dynamic_cache", &err);
+
+ BOOST_REQUIRE(err.GetCode() != GridError::GG_SUCCESS);
+}
+
+BOOST_AUTO_TEST_CASE(TestGetOrCreateCache)
+{
+ // Get existing cache
+ cache::Cache<int, int> cache = grid0.GetOrCreateCache<int, int>("partitioned");
+
+ cache.Put(5, 7);
+
+ BOOST_REQUIRE(7 == cache.Get(5));
+
+ // Create new cache
+ cache::Cache<int, int> cache2 = grid0.GetOrCreateCache<int, int>("partitioned_new");
+
+ cache2.Put(5, 7);
+
+ BOOST_REQUIRE(7 == cache2.Get(5));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core-test/src/concurrent_test.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core-test/src/concurrent_test.cpp b/modules/platform/src/main/cpp/core-test/src/concurrent_test.cpp
new file mode 100644
index 0000000..5bd09a2
--- /dev/null
+++ b/modules/platform/src/main/cpp/core-test/src/concurrent_test.cpp
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _MSC_VER
+ #define BOOST_TEST_DYN_LINK
+#endif
+
+#include <boost/test/unit_test.hpp>
+
+#include <ignite/common/concurrent.h>
+
+using namespace ignite::common::concurrent;
+
+BOOST_AUTO_TEST_SUITE(ConcurrentTestSuite)
+
+BOOST_AUTO_TEST_CASE(TestAtomic32)
+{
+ int32_t val = 1;
+
+ BOOST_REQUIRE(Atomics::CompareAndSet32(&val, 1, 2));
+ BOOST_REQUIRE(val == 2);
+
+ BOOST_REQUIRE(!Atomics::CompareAndSet32(&val, 3, 1));
+ BOOST_REQUIRE(val == 2);
+
+ BOOST_REQUIRE(Atomics::CompareAndSet32Val(&val, 2, 3) == 2);
+ BOOST_REQUIRE(val == 3);
+
+ BOOST_REQUIRE(Atomics::CompareAndSet32Val(&val, 4, 2) == 3);
+ BOOST_REQUIRE(val == 3);
+
+ BOOST_REQUIRE(Atomics::IncrementAndGet32(&val) == 4);
+ BOOST_REQUIRE(val == 4);
+
+ BOOST_REQUIRE(Atomics::DecrementAndGet32(&val) == 3);
+ BOOST_REQUIRE(val == 3);
+}
+
+BOOST_AUTO_TEST_CASE(TestAtomic64)
+{
+ int64_t val = 1;
+
+ BOOST_REQUIRE(Atomics::CompareAndSet64(&val, 1, 2));
+ BOOST_REQUIRE(val == 2);
+
+ BOOST_REQUIRE(!Atomics::CompareAndSet64(&val, 3, 1));
+ BOOST_REQUIRE(val == 2);
+
+ BOOST_REQUIRE(Atomics::CompareAndSet64Val(&val, 2, 3) == 2);
+ BOOST_REQUIRE(val == 3);
+
+ BOOST_REQUIRE(Atomics::CompareAndSet64Val(&val, 4, 2) == 3);
+ BOOST_REQUIRE(val == 3);
+
+ BOOST_REQUIRE(Atomics::IncrementAndGet64(&val) == 4);
+ BOOST_REQUIRE(val == 4);
+
+ BOOST_REQUIRE(Atomics::DecrementAndGet64(&val) == 3);
+ BOOST_REQUIRE(val == 3);
+}
+
+BOOST_AUTO_TEST_CASE(TestThreadLocal)
+{
+ int32_t idx1 = ThreadLocal::NextIndex();
+ int32_t idx2 = ThreadLocal::NextIndex();
+ BOOST_REQUIRE(idx2 > idx1);
+
+ BOOST_REQUIRE(ThreadLocal::Get<int32_t>(idx1) == 0);
+
+ ThreadLocal::Set(idx1, 1);
+ BOOST_REQUIRE(ThreadLocal::Get<int32_t>(idx1) == 1);
+
+ ThreadLocal::Set(idx1, 2);
+ BOOST_REQUIRE(ThreadLocal::Get<int32_t>(idx1) == 2);
+
+ ThreadLocal::Remove(idx1);
+ BOOST_REQUIRE(ThreadLocal::Get<int32_t>(idx1) == 0);
+
+ ThreadLocal::Set(idx1, 1);
+ BOOST_REQUIRE(ThreadLocal::Get<int32_t>(idx1) == 1);
+
+ ThreadLocal::Remove(idx1);
+}
+
+BOOST_AUTO_TEST_CASE(TestThreadLocalInstance)
+{
+ ThreadLocalInstance<int32_t> val;
+
+ BOOST_REQUIRE(val.Get() == 0);
+
+ val.Set(1);
+ BOOST_REQUIRE(val.Get() == 1);
+
+ val.Set(2);
+ BOOST_REQUIRE(val.Get() == 2);
+
+ val.Remove();
+ BOOST_REQUIRE(val.Get() == 0);
+
+ val.Set(1);
+ BOOST_REQUIRE(val.Get() == 1);
+
+ val.Remove();
+}
+
+struct SharedPointerTarget
+{
+ bool deleted;
+
+ SharedPointerTarget() : deleted(false)
+ {
+ // No-op.
+ }
+};
+
+void DeleteSharedPointerTarget(SharedPointerTarget* ptr)
+{
+ ptr->deleted = true;
+}
+
+BOOST_AUTO_TEST_CASE(TestSharedPointer)
+{
+ // 1. Test the simples scenario.
+ SharedPointerTarget* target = new SharedPointerTarget();
+
+ SharedPointer<SharedPointerTarget>* ptr1 =
+ new SharedPointer<SharedPointerTarget>(target, DeleteSharedPointerTarget);
+
+ delete ptr1;
+ BOOST_REQUIRE(target->deleted);
+
+ target->deleted = false;
+
+ // 2. Test copy ctor.
+ ptr1 = new SharedPointer<SharedPointerTarget>(target, DeleteSharedPointerTarget);
+ SharedPointer<SharedPointerTarget>* ptr2 = new SharedPointer<SharedPointerTarget>(*ptr1);
+
+ delete ptr1;
+ BOOST_REQUIRE(!target->deleted);
+
+ delete ptr2;
+ BOOST_REQUIRE(target->deleted);
+
+ target->deleted = false;
+
+ // 3. Test assignment logic.
+ ptr1 = new SharedPointer<SharedPointerTarget>(target, DeleteSharedPointerTarget);
+
+ SharedPointer<SharedPointerTarget> ptr3 = *ptr1;
+
+ delete ptr1;
+ BOOST_REQUIRE(!target->deleted);
+
+ ptr3 = SharedPointer<SharedPointerTarget>();
+ BOOST_REQUIRE(target->deleted);
+
+ target->deleted = false;
+
+ // 4. Test self-assignment.
+ ptr1 = new SharedPointer<SharedPointerTarget>(target, DeleteSharedPointerTarget);
+
+ *ptr1 = *ptr1;
+
+ delete ptr1;
+
+ BOOST_REQUIRE(target->deleted);
+
+ // 5. Tear-down.
+ delete target;
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core-test/src/grid_factory_test.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core-test/src/grid_factory_test.cpp b/modules/platform/src/main/cpp/core-test/src/grid_factory_test.cpp
new file mode 100644
index 0000000..e1a098c
--- /dev/null
+++ b/modules/platform/src/main/cpp/core-test/src/grid_factory_test.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _MSC_VER
+ #define BOOST_TEST_DYN_LINK
+#endif
+
+#include <boost/test/unit_test.hpp>
+
+#include "gridgain/grid.h"
+#include "gridgain/grid_factory.h"
+
+using namespace gridgain;
+using namespace boost::unit_test;
+
+BOOST_AUTO_TEST_SUITE(GridFactoryTestSuite)
+
+BOOST_AUTO_TEST_CASE(TestGridFactory)
+{
+ GridConfiguration cfg;
+
+ GridJvmOption opts[5];
+
+ opts[0] = GridJvmOption("-Xdebug");
+ opts[1] = GridJvmOption("-Xnoagent");
+ opts[2] = GridJvmOption("-Djava.compiler=NONE");
+ opts[3] = GridJvmOption("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005");
+ opts[4] = GridJvmOption("-XX:+HeapDumpOnOutOfMemoryError");
+
+ cfg.jvmOptsLen = 5;
+ cfg.jvmOpts = opts;
+
+ cfg.jvmInitMem = 1024;
+ cfg.jvmMaxMem = 4096;
+
+ char* cfgPath = getenv("GRIDGAIN_NATIVE_TEST_CPP_CONFIG_PATH");
+
+ std::string cfgPathStr = std::string(cfgPath).append("/").append("cache-test.xml");
+
+ cfg.springCfgPath = const_cast<char*>(cfgPathStr.c_str());
+
+ GridError err;
+
+ // Start two grids
+ Grid grid1 = GridFactory::Start(cfg, "gridFactoryTest-1", &err);
+
+ if (err.GetCode() != GridError::GG_SUCCESS)
+ BOOST_ERROR(err.GetText());
+
+ BOOST_REQUIRE(strcmp(grid1.GetName(), "gridFactoryTest-1") == 0);
+
+ Grid grid2 = GridFactory::Start(cfg, "gridFactoryTest-2", &err);
+
+ if (err.GetCode() != GridError::GG_SUCCESS)
+ BOOST_ERROR(err.GetText());
+
+ BOOST_REQUIRE(strcmp(grid2.GetName(), "gridFactoryTest-2") == 0);
+
+ // Test get
+ Grid grid0 = GridFactory::Get("gridFactoryTest-1", &err);
+
+ if (err.GetCode() != GridError::GG_SUCCESS)
+ BOOST_ERROR(err.GetText());
+
+ BOOST_REQUIRE(strcmp(grid0.GetName(), grid1.GetName()) == 0);
+
+ // Stop one grid
+ GridFactory::Stop(grid1.GetName(), true);
+
+ GridFactory::Get("gridFactoryTest-1", &err);
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_GENERIC);
+
+ GridFactory::Get("gridFactoryTest-2", &err);
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_SUCCESS);
+
+ // Stop all
+ GridFactory::StopAll(true);
+
+ GridFactory::Get("gridFactoryTest-2", &err);
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_GENERIC);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core-test/src/handle_registry_test.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core-test/src/handle_registry_test.cpp b/modules/platform/src/main/cpp/core-test/src/handle_registry_test.cpp
new file mode 100644
index 0000000..6ec2a02
--- /dev/null
+++ b/modules/platform/src/main/cpp/core-test/src/handle_registry_test.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _MSC_VER
+ #define BOOST_TEST_DYN_LINK
+#endif
+
+#include <boost/test/unit_test.hpp>
+
+#include "gridgain/impl/handle_registry.h"
+
+using namespace ignite::common::concurrent;
+using namespace gridgain::impl;
+
+struct HandleRegistryTestProbe
+{
+ bool deleted;
+
+ HandleRegistryTestProbe()
+ {
+ deleted = false;
+ }
+};
+
+class HandleRegistryTestEntry : public HandleRegistryEntry
+{
+public:
+ HandleRegistryTestEntry(HandleRegistryTestProbe* probe) : probe(probe)
+ {
+ // No-op.
+ }
+
+ virtual ~HandleRegistryTestEntry()
+ {
+ probe->deleted = true;
+ }
+
+private:
+ HandleRegistryTestProbe* probe;
+};
+
+BOOST_AUTO_TEST_SUITE(HandleRegistryTestSuite)
+
+BOOST_AUTO_TEST_CASE(TestCritical)
+{
+ HandleRegistry reg(2, 1);
+
+ HandleRegistryTestProbe probe0;
+ HandleRegistryTestProbe probe1;
+ HandleRegistryTestProbe probe2;
+
+ HandleRegistryTestEntry* entry0 = new HandleRegistryTestEntry(&probe0);
+ HandleRegistryTestEntry* entry1 = new HandleRegistryTestEntry(&probe1);
+ HandleRegistryTestEntry* entry2 = new HandleRegistryTestEntry(&probe2);
+
+ int64_t hnd0 = reg.AllocateCritical(SharedPointer<HandleRegistryEntry>(entry0));
+ int64_t hnd1 = reg.AllocateCritical(SharedPointer<HandleRegistryEntry>(entry1));
+ int64_t hnd2 = reg.AllocateCritical(SharedPointer<HandleRegistryEntry>(entry2));
+
+ BOOST_REQUIRE(reg.Get(hnd0).Get() == entry0);
+ BOOST_REQUIRE(!probe0.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd1).Get() == entry1);
+ BOOST_REQUIRE(!probe1.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd2).Get() == entry2);
+ BOOST_REQUIRE(!probe2.deleted);
+
+ reg.Release(hnd0);
+
+ BOOST_REQUIRE(reg.Get(hnd0).Get() == NULL);
+ BOOST_REQUIRE(probe0.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd1).Get() == entry1);
+ BOOST_REQUIRE(!probe1.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd2).Get() == entry2);
+ BOOST_REQUIRE(!probe2.deleted);
+
+ reg.Close();
+
+ BOOST_REQUIRE(reg.Get(hnd0).Get() == NULL);
+ BOOST_REQUIRE(probe0.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd1).Get() == NULL);
+ BOOST_REQUIRE(probe1.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd2).Get() == NULL);
+ BOOST_REQUIRE(probe2.deleted);
+
+ HandleRegistry closedReg(2, 1);
+
+ closedReg.Close();
+
+ HandleRegistryTestProbe closedProbe;
+ HandleRegistryTestEntry* closedEntry = new HandleRegistryTestEntry(&closedProbe);
+
+ int64_t closedHnd = closedReg.AllocateCritical(SharedPointer<HandleRegistryEntry>(closedEntry));
+ BOOST_REQUIRE(closedHnd == -1);
+ BOOST_REQUIRE(closedProbe.deleted);
+}
+
+BOOST_AUTO_TEST_CASE(TestNonCritical)
+{
+ HandleRegistry reg(0, 2);
+
+ HandleRegistryTestProbe probe0;
+ HandleRegistryTestProbe probe1;
+ HandleRegistryTestProbe probe2;
+
+ HandleRegistryTestEntry* entry0 = new HandleRegistryTestEntry(&probe0);
+ HandleRegistryTestEntry* entry1 = new HandleRegistryTestEntry(&probe1);
+ HandleRegistryTestEntry* entry2 = new HandleRegistryTestEntry(&probe2);
+
+ int64_t hnd0 = reg.AllocateCritical(SharedPointer<HandleRegistryEntry>(entry0));
+ int64_t hnd1 = reg.Allocate(SharedPointer<HandleRegistryEntry>(entry1));
+ int64_t hnd2 = reg.Allocate(SharedPointer<HandleRegistryEntry>(entry2));
+
+ BOOST_REQUIRE(reg.Get(hnd0).Get() == entry0);
+ BOOST_REQUIRE(!probe0.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd1).Get() == entry1);
+ BOOST_REQUIRE(!probe1.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd2).Get() == entry2);
+ BOOST_REQUIRE(!probe2.deleted);
+
+ reg.Release(hnd0);
+
+ BOOST_REQUIRE(reg.Get(hnd0).Get() == NULL);
+ BOOST_REQUIRE(probe0.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd1).Get() == entry1);
+ BOOST_REQUIRE(!probe1.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd2).Get() == entry2);
+ BOOST_REQUIRE(!probe2.deleted);
+
+ reg.Close();
+
+ BOOST_REQUIRE(reg.Get(hnd0).Get() == NULL);
+ BOOST_REQUIRE(probe0.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd1).Get() == NULL);
+ BOOST_REQUIRE(probe1.deleted);
+
+ BOOST_REQUIRE(reg.Get(hnd2).Get() == NULL);
+ BOOST_REQUIRE(probe2.deleted);
+
+ HandleRegistry closedReg(0, 2);
+
+ closedReg.Close();
+
+ HandleRegistryTestProbe closedProbe;
+ HandleRegistryTestEntry* closedEntry = new HandleRegistryTestEntry(&closedProbe);
+
+ int64_t closedHnd = closedReg.Allocate(SharedPointer<HandleRegistryEntry>(closedEntry));
+ BOOST_REQUIRE(closedHnd == -1);
+ BOOST_REQUIRE(closedProbe.deleted);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core-test/src/portable_reader_writer_raw_test.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core-test/src/portable_reader_writer_raw_test.cpp b/modules/platform/src/main/cpp/core-test/src/portable_reader_writer_raw_test.cpp
new file mode 100644
index 0000000..1d070b6
--- /dev/null
+++ b/modules/platform/src/main/cpp/core-test/src/portable_reader_writer_raw_test.cpp
@@ -0,0 +1,1524 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _MSC_VER
+ #define BOOST_TEST_DYN_LINK
+#endif
+
+#include <boost/test/unit_test.hpp>
+
+#include "gridgain/impl/interop/interop.h"
+#include "gridgain/portable/portable.h"
+
+#include "gridgain/portable_test_defs.h"
+#include "gridgain/portable_test_utils.h"
+
+using namespace gridgain;
+using namespace gridgain::impl::interop;
+using namespace gridgain::impl::portable;
+using namespace gridgain::portable;
+using namespace gridgain_test::core::portable;
+
+template<typename T>
+void CheckRawPrimitive(T val)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ Write<T>(rawWriter, val);
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ T readVal = Read<T>(rawReader);
+
+ BOOST_REQUIRE(readVal == val);
+}
+
+template<typename T>
+void CheckRawPrimitiveArray(T dflt, T val1, T val2)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ // 1. Write NULL and see what happens.
+ WriteArray<T>(rawWriter, NULL, 0);
+
+ out.Synchronize();
+ in.Synchronize();
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 0) == -1);
+
+ in.Position(0);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 2) == -1);
+
+ T arr1[2];
+ arr1[0] = dflt;
+ arr1[1] = dflt;
+
+ in.Position(0);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, 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(0);
+ in.Position(0);
+
+ WriteArray<T>(rawWriter, arr2, 0);
+
+ out.Synchronize();
+ in.Synchronize();
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 0) == 0);
+
+ in.Position(0);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 2) == 0);
+
+ in.Position(0);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 0) == 0);
+ BOOST_REQUIRE(arr1[0] == dflt);
+ BOOST_REQUIRE(arr1[1] == dflt);
+
+ in.Position(0);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 2) == 0);
+ BOOST_REQUIRE(arr1[0] == dflt);
+ BOOST_REQUIRE(arr1[1] == dflt);
+
+ // 3. Partial array write.
+ out.Position(0);
+ in.Position(0);
+
+ WriteArray<T>(rawWriter, arr2, 1);
+
+ out.Synchronize();
+ in.Synchronize();
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 0) == 1);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 2) == 1);
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 0) == 1);
+ BOOST_REQUIRE(arr1[0] == dflt);
+ BOOST_REQUIRE(arr1[1] == dflt);
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 1) == 1);
+ BOOST_REQUIRE(arr1[0] == val1);
+ BOOST_REQUIRE(arr1[1] == dflt);
+ arr1[0] = dflt;
+
+ in.Position(0);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 2) == 1);
+ BOOST_REQUIRE(arr1[0] == val1);
+ BOOST_REQUIRE(arr1[1] == dflt);
+ arr1[0] = dflt;
+
+ // 4. Full array write.
+ out.Position(0);
+ in.Position(0);
+
+ WriteArray<T>(rawWriter, arr2, 2);
+
+ out.Synchronize();
+ in.Synchronize();
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 0) == 2);
+ BOOST_REQUIRE(ReadArray<T>(rawReader, NULL, 2) == 2);
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 0) == 2);
+ BOOST_REQUIRE(arr1[0] == dflt);
+ BOOST_REQUIRE(arr1[1] == dflt);
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 1) == 2);
+ BOOST_REQUIRE(arr1[0] == dflt);
+ BOOST_REQUIRE(arr1[1] == dflt);
+
+ BOOST_REQUIRE(ReadArray<T>(rawReader, arr1, 2) == 2);
+ BOOST_REQUIRE(arr1[0] == val1);
+ BOOST_REQUIRE(arr1[1] == val2);
+}
+
+void CheckRawWritesRestricted(PortableRawWriter& writer)
+{
+ try
+ {
+ writer.WriteInt8(1);
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ int8_t arr[1];
+
+ writer.WriteInt8Array(arr, 1);
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ Guid val(1, 1);
+
+ writer.WriteGuid(val);
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ writer.WriteString("test");
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ writer.WriteArray<int8_t>();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ writer.WriteCollection<int8_t>();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ writer.WriteMap<int8_t, int8_t>();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+}
+
+void CheckRawReadsRestricted(PortableRawReader& reader)
+{
+ try
+ {
+ reader.ReadInt8();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ int8_t arr[1];
+
+ reader.ReadInt8Array(arr, 1);
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ reader.ReadGuid();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ reader.ReadString();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ reader.ReadArray<int8_t>();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ reader.ReadCollection<int8_t>();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ reader.ReadMap<int8_t, int8_t>();
+
+ BOOST_FAIL("Not restricted.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+}
+
+void CheckRawCollectionEmpty(CollectionType* colType)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableCollectionWriter<PortableInner> colWriter = colType ?
+ rawWriter.WriteCollection<PortableInner>(*colType) : rawWriter.WriteCollection<PortableInner>();
+
+ CheckRawWritesRestricted(rawWriter);
+
+ colWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ colWriter.Write(1);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ colWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableCollectionReader<PortableInner> colReader = rawReader.ReadCollection<PortableInner>();
+
+ if (colType)
+ BOOST_REQUIRE(colReader.GetType() == *colType);
+ else
+ BOOST_REQUIRE(colReader.GetType() == GG_COLLECTION_UNDEFINED);
+
+ BOOST_REQUIRE(colReader.GetSize() == 0);
+ BOOST_REQUIRE(!colReader.HasNext());
+ BOOST_REQUIRE(!colReader.IsNull());
+
+ try
+ {
+ colReader.GetNext();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+void CheckRawCollection(CollectionType* colType)
+{
+ PortableInner writeVal1 = PortableInner(1);
+ PortableInner writeVal2 = PortableInner(0);
+ PortableInner writeVal3 = PortableInner(2);
+
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableCollectionWriter<PortableInner> colWriter = colType ?
+ rawWriter.WriteCollection<PortableInner>(*colType) : rawWriter.WriteCollection<PortableInner>();
+
+ colWriter.Write(writeVal1);
+ colWriter.Write(writeVal2);
+ colWriter.Write(writeVal3);
+
+ CheckRawWritesRestricted(rawWriter);
+
+ colWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ colWriter.Write(1);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ colWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableCollectionReader<PortableInner> colReader = rawReader.ReadCollection<PortableInner>();
+
+ CheckRawReadsRestricted(rawReader);
+
+ if (colType)
+ BOOST_REQUIRE(colReader.GetType() == *colType);
+ else
+ BOOST_REQUIRE(colReader.GetType() == GG_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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+void CheckRawMapEmpty(MapType* mapType)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableMapWriter<int8_t, PortableInner> mapWriter = mapType ?
+ rawWriter.WriteMap<int8_t, PortableInner>(*mapType) : rawWriter.WriteMap<int8_t, PortableInner>();
+
+ CheckRawWritesRestricted(rawWriter);
+
+ mapWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ mapWriter.Write(1, PortableInner(1));
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ mapWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableMapReader<int8_t, PortableInner> mapReader = rawReader.ReadMap<int8_t, PortableInner>();
+
+ if (mapType)
+ BOOST_REQUIRE(mapReader.GetType() == *mapType);
+ else
+ BOOST_REQUIRE(mapReader.GetType() == GG_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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+void CheckRawMap(MapType* mapType)
+{
+ PortableInner writeVal1 = PortableInner(1);
+ PortableInner writeVal2 = PortableInner(0);
+ PortableInner writeVal3 = PortableInner(2);
+
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableMapWriter<int8_t, PortableInner> mapWriter = mapType ?
+ rawWriter.WriteMap<int8_t, PortableInner>(*mapType) : rawWriter.WriteMap<int8_t, PortableInner>();
+
+ mapWriter.Write(1, writeVal1);
+ mapWriter.Write(2, writeVal2);
+ mapWriter.Write(3, writeVal3);
+
+ CheckRawWritesRestricted(rawWriter);
+
+ mapWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ mapWriter.Write(4, PortableInner(4));
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ mapWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableMapReader<int8_t, PortableInner> mapReader = rawReader.ReadMap<int8_t, PortableInner>();
+
+ CheckRawReadsRestricted(rawReader);
+
+ if (mapType)
+ BOOST_REQUIRE(mapReader.GetType() == *mapType);
+ else
+ BOOST_REQUIRE(mapReader.GetType() == GG_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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_SUITE(PortableReaderWriterRawTestSuite)
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveInt8)
+{
+ CheckRawPrimitive<int8_t>(1);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveBool)
+{
+ CheckRawPrimitive<bool>(true);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveInt16)
+{
+ CheckRawPrimitive<int16_t>(1);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveUInt16)
+{
+ CheckRawPrimitive<uint16_t>(1);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveInt32)
+{
+ CheckRawPrimitive<int32_t>(1);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveInt64)
+{
+ CheckRawPrimitive<int64_t>(1);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveFloat)
+{
+ CheckRawPrimitive<float>(1.1f);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveDouble)
+{
+ CheckRawPrimitive<double>(1.1);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveGuid)
+{
+ Guid val(1, 2);
+
+ CheckRawPrimitive<Guid>(val);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt8)
+{
+ CheckRawPrimitiveArray<int8_t>(1, 2, 3);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayBool)
+{
+ CheckRawPrimitiveArray<bool>(false, true, false);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt16)
+{
+ CheckRawPrimitiveArray<int16_t>(1, 2, 3);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayUInt16)
+{
+ CheckRawPrimitiveArray<uint16_t>(1, 2, 3);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt32)
+{
+ CheckRawPrimitiveArray<int32_t>(1, 2, 3);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayInt64)
+{
+ CheckRawPrimitiveArray<int64_t>(1, 2, 3);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayFloat)
+{
+ CheckRawPrimitiveArray<float>(1.1f, 2.2f, 3.3f);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayDouble)
+{
+ CheckRawPrimitiveArray<double>(1.1, 2.2, 3.3);
+}
+
+BOOST_AUTO_TEST_CASE(TestPrimitiveArrayGuid)
+{
+ Guid dflt(1, 2);
+ Guid val1(3, 4);
+ Guid val2(5, 6);
+
+ CheckRawPrimitiveArray<Guid>(dflt, val1, val2);
+}
+
+BOOST_AUTO_TEST_CASE(TestGuidNull)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ rawWriter.WriteNull();
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ Guid expVal;
+ Guid actualVal = rawReader.ReadGuid();
+
+ BOOST_REQUIRE(actualVal == expVal);
+}
+
+BOOST_AUTO_TEST_CASE(TestString) {
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ const char* writeVal1 = "testtest";
+ const char* writeVal2 = "test";
+ std::string writeVal3 = writeVal1;
+
+ rawWriter.WriteString(writeVal1);
+ rawWriter.WriteString(writeVal1, 4);
+ rawWriter.WriteString(writeVal3);
+ rawWriter.WriteString(NULL);
+ rawWriter.WriteString(NULL, 4);
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ char readVal1[9];
+ char readVal2[5];
+
+ BOOST_REQUIRE(rawReader.ReadString(NULL, 0) == 8);
+ BOOST_REQUIRE(rawReader.ReadString(NULL, 8) == 8);
+ BOOST_REQUIRE(rawReader.ReadString(readVal1, 0) == 8);
+ BOOST_REQUIRE(rawReader.ReadString(readVal1, 4) == 8);
+
+ BOOST_REQUIRE(rawReader.ReadString(readVal1, 9) == 8);
+ std::string writeVal1Str = writeVal1;
+ std::string readVal1Str = readVal1;
+ BOOST_REQUIRE(readVal1Str.compare(writeVal1Str) == 0);
+
+ BOOST_REQUIRE(rawReader.ReadString(readVal2, 5) == 4);
+ std::string writeVal2Str = writeVal2;
+ std::string readVal2Str = readVal2;
+ BOOST_REQUIRE(readVal2Str.compare(writeVal2Str) == 0);
+
+ std::string readVal3 = rawReader.ReadString();
+ BOOST_REQUIRE(readVal3.compare(writeVal3) == 0);
+
+ BOOST_REQUIRE(rawReader.ReadString(readVal1, 9) == -1);
+ BOOST_REQUIRE(rawReader.ReadString(readVal1, 9) == -1);
+}
+
+BOOST_AUTO_TEST_CASE(TestStringArrayNull)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ rawWriter.WriteNull();
+ rawWriter.WriteInt8(1);
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableStringArrayReader arrReader = rawReader.ReadStringArray();
+
+ 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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ arrReader.GetNext();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestStringArrayEmpty)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableStringArrayWriter arrWriter = rawWriter.WriteStringArray();
+
+ CheckRawWritesRestricted(rawWriter);
+
+ arrWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ const char* val = "test";
+
+ arrWriter.Write(val, 4);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ const char* val = "test";
+
+ arrWriter.Write(val);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ std::string val = "test";
+
+ arrWriter.Write(val);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ arrWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableStringArrayReader arrReader = rawReader.ReadStringArray();
+
+ 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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ arrReader.GetNext();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestStringArray)
+{
+ const char* writeVal1 = "testtest";
+ const char* writeVal2 = "test";
+ std::string writeVal3 = "test2";
+
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableStringArrayWriter arrWriter = rawWriter.WriteStringArray();
+
+ arrWriter.Write(writeVal1);
+ arrWriter.Write(writeVal1, 4);
+ arrWriter.Write(NULL); // NULL value.
+ arrWriter.Write(NULL, 100); // NULL value again.
+ arrWriter.Write(writeVal3);
+
+ CheckRawWritesRestricted(rawWriter);
+
+ arrWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ const char* val = "test";
+
+ arrWriter.Write(val, 4);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ const char* val = "test";
+
+ arrWriter.Write(val);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ std::string val = "test";
+
+ arrWriter.Write(val);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ arrWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableStringArrayReader arrReader = rawReader.ReadStringArray();
+
+ CheckRawReadsRestricted(rawReader);
+
+ 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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ arrReader.GetNext();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestObject)
+{
+ PortableInner writeVal1(1);
+ PortableInner writeVal2(0);
+
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ rawWriter.WriteObject(writeVal1);
+ rawWriter.WriteObject(writeVal2);
+ rawWriter.WriteNull();
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableInner readVal1 = rawReader.ReadObject<PortableInner>();
+ BOOST_REQUIRE(writeVal1.GetValue() == readVal1.GetValue());
+
+ PortableInner readVal2 = rawReader.ReadObject<PortableInner>();
+ BOOST_REQUIRE(writeVal2.GetValue() == readVal2.GetValue());
+
+ PortableInner readVal3 = rawReader.ReadObject<PortableInner>();
+ BOOST_REQUIRE(0 == readVal3.GetValue());
+}
+
+BOOST_AUTO_TEST_CASE(TestNestedObject)
+{
+ PortableOuter writeVal1(1, 2);
+ PortableOuter writeVal2(0, 0);
+
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ rawWriter.WriteObject(writeVal1);
+ rawWriter.WriteObject(writeVal2);
+ rawWriter.WriteNull();
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableOuter readVal1 = rawReader.ReadObject<PortableOuter>();
+ BOOST_REQUIRE(writeVal1.GetValue() == readVal1.GetValue());
+ BOOST_REQUIRE(writeVal1.GetInner().GetValue() == readVal1.GetInner().GetValue());
+
+ PortableOuter readVal2 = rawReader.ReadObject<PortableOuter>();
+ BOOST_REQUIRE(writeVal2.GetValue() == readVal2.GetValue());
+ BOOST_REQUIRE(writeVal2.GetInner().GetValue() == readVal2.GetInner().GetValue());
+
+ PortableOuter readVal3 = rawReader.ReadObject<PortableOuter>();
+ BOOST_REQUIRE(0 == readVal3.GetValue());
+ BOOST_REQUIRE(0 == readVal3.GetInner().GetValue());
+}
+
+BOOST_AUTO_TEST_CASE(TestArrayNull)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ rawWriter.WriteNull();
+ rawWriter.WriteInt8(1);
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableArrayReader<PortableInner> arrReader = rawReader.ReadArray<PortableInner>();
+
+ BOOST_REQUIRE(arrReader.GetSize() == -1);
+ BOOST_REQUIRE(!arrReader.HasNext());
+ BOOST_REQUIRE(arrReader.IsNull());
+
+ try
+ {
+ arrReader.GetNext();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestArrayEmpty)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableArrayWriter<PortableInner> arrWriter = rawWriter.WriteArray<PortableInner>();
+
+ CheckRawWritesRestricted(rawWriter);
+
+ arrWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ arrWriter.Write(1);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ arrWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableArrayReader<PortableInner> arrReader = rawReader.ReadArray<PortableInner>();
+
+ BOOST_REQUIRE(arrReader.GetSize() == 0);
+ BOOST_REQUIRE(!arrReader.HasNext());
+ BOOST_REQUIRE(!arrReader.IsNull());
+
+ try
+ {
+ arrReader.GetNext();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestArray)
+{
+ PortableInner writeVal1 = PortableInner(1);
+ PortableInner writeVal2 = PortableInner(0);
+ PortableInner writeVal3 = PortableInner(2);
+
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ PortableArrayWriter<PortableInner> arrWriter = rawWriter.WriteArray<PortableInner>();
+
+ arrWriter.Write(writeVal1);
+ arrWriter.Write(writeVal2);
+ arrWriter.Write(writeVal3);
+
+ CheckRawWritesRestricted(rawWriter);
+
+ arrWriter.Close();
+
+ rawWriter.WriteInt8(1);
+
+ try
+ {
+ arrWriter.Write(1);
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ try
+ {
+ arrWriter.Close();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableArrayReader<PortableInner> arrReader = rawReader.ReadArray<PortableInner>();
+
+ CheckRawReadsRestricted(rawReader);
+
+ 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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestCollectionNull)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ rawWriter.WriteNull();
+ rawWriter.WriteInt8(1);
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableCollectionReader<PortableInner> colReader = rawReader.ReadCollection<PortableInner>();
+
+ BOOST_REQUIRE(colReader.GetType() == GG_COLLECTION_UNDEFINED);
+ BOOST_REQUIRE(colReader.GetSize() == -1);
+ BOOST_REQUIRE(!colReader.HasNext());
+ BOOST_REQUIRE(colReader.IsNull());
+
+ try
+ {
+ colReader.GetNext();
+
+ BOOST_FAIL("Error expected.");
+ }
+ catch (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestCollectionEmpty)
+{
+ CheckRawCollectionEmpty(NULL);
+}
+
+BOOST_AUTO_TEST_CASE(TestCollectionEmptyTyped)
+{
+ CollectionType typ = GG_COLLECTION_CONCURRENT_SKIP_LIST_SET;
+
+ CheckRawCollectionEmpty(&typ);
+}
+
+BOOST_AUTO_TEST_CASE(TestCollection)
+{
+ CheckRawCollection(NULL);
+}
+
+BOOST_AUTO_TEST_CASE(testCollectionTyped)
+{
+ CollectionType typ = GG_COLLECTION_CONCURRENT_SKIP_LIST_SET;
+
+ CheckRawCollection(&typ);
+}
+
+BOOST_AUTO_TEST_CASE(TestMapNull)
+{
+ InteropUnpooledMemory mem(1024);
+
+ InteropOutputStream out(&mem);
+ PortableWriterImpl writer(&out, NULL);
+ PortableRawWriter rawWriter(&writer);
+
+ rawWriter.WriteNull();
+ rawWriter.WriteInt8(1);
+
+ out.Synchronize();
+
+ InteropInputStream in(&mem);
+ PortableReaderImpl reader(&in);
+ PortableRawReader rawReader(&reader);
+
+ PortableMapReader<int8_t, PortableInner> mapReader = rawReader.ReadMap<int8_t, PortableInner>();
+
+ BOOST_REQUIRE(mapReader.GetType() == GG_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 (GridError& err)
+ {
+ BOOST_REQUIRE(err.GetCode() == GridError::GG_ERR_PORTABLE);
+ }
+
+ BOOST_REQUIRE(rawReader.ReadInt8() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(TestMapEmpty)
+{
+ CheckRawMapEmpty(NULL);
+}
+
+BOOST_AUTO_TEST_CASE(TestMapEmptyTyped)
+{
+ MapType typ = GG_MAP_CONCURRENT_HASH_MAP;
+
+ CheckRawMapEmpty(&typ);
+}
+
+BOOST_AUTO_TEST_CASE(TestMap)
+{
+ CheckRawMap(NULL);
+}
+
+BOOST_AUTO_TEST_CASE(TestMapTyped)
+{
+ MapType typ = GG_MAP_CONCURRENT_HASH_MAP;
+
+ CheckRawMap(&typ);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file