1 files changed, 377 insertions, 0 deletions
diff --git a/src/components/rpc_base/test/rpc_base_json_test.cc b/src/components/rpc_base/test/rpc_base_json_test.cc
new file mode 100644
index 000000000..8c0bef930
--- /dev/null
+++ b/src/components/rpc_base/test/rpc_base_json_test.cc
@@ -0,0 +1,377 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "gtest/gtest.h"
+#include "json/value.h"
+#include "rpc_base/rpc_base.h"
+
+namespace test {
+using namespace rpc;
+using Json::Value;
+
+namespace {
+enum TestEnum {
+  kValue0,
+  kValue1,
+  kInvalidValue
+};
+
+bool IsValidEnum(TestEnum val) {
+  return val == kValue0 || val == kValue1;
+}
+
+bool EnumFromJsonString(const std::string& value, TestEnum* enm) {
+  if (value == "kValue0") {
+    *enm = kValue0;
+    return true;
+  } else if (value == "kValue1") {
+    *enm = kValue1;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+const char* EnumToJsonString(TestEnum enm) {
+  switch(enm) {
+    case kValue0: return "kValue0";
+    case kValue1: return "kValue1";
+    default: return "UNKNOWN";
+  }
+}
+
+}  // namespace
+
+TEST(ValidatedTypesJson, BooleanFromJsonTest) {
+  Value val(true);
+  Boolean boolean(&val);
+  ASSERT_TRUE(boolean.is_initialized());
+  ASSERT_TRUE(boolean.is_valid());
+  ASSERT_EQ(boolean, true);
+  Value readback = boolean.ToJsonValue();
+  ASSERT_TRUE(readback.isBool());
+  ASSERT_EQ(readback.asBool(), true);
+}
+
+TEST(ValidatedTypesJson, BooleanNullTest) {
+  Boolean boolean(&Value::null);
+  ASSERT_TRUE(boolean.is_initialized());
+  ASSERT_FALSE(boolean.is_valid());
+}
+
+TEST(ValidatedTypesJson, BooleanAbsentValueTest) {
+  Value* novalue = NULL;
+  Boolean boolean(novalue);
+  ASSERT_FALSE(boolean.is_initialized());
+  ASSERT_FALSE(boolean.is_valid());
+}
+
+TEST(ValidatedTypesJson, BooleanFromInvalidJsonTest) {
+  Value inv(7);
+  Boolean boolean(&inv);
+  ASSERT_TRUE(boolean.is_initialized());
+  ASSERT_FALSE(boolean.is_valid());
+}
+
+TEST(ValidatedTypesJson, IntegerFromJsonTest) {
+  Value int_val(42);
+  Integer<int32_t, -5, 192> integer(&int_val);
+  ASSERT_TRUE(integer.is_initialized());
+  ASSERT_TRUE(integer.is_valid());
+  Value readback = integer.ToJsonValue();
+  ASSERT_TRUE(readback.isInt());
+  ASSERT_EQ(readback.asInt(), 42);
+}
+
+TEST(ValidatedTypesJson, IntegerNullTest) {
+  Integer<int32_t, -5, 192> integer(&Value::null);
+  ASSERT_TRUE(integer.is_initialized());
+  ASSERT_FALSE(integer.is_valid());
+}
+
+TEST(ValidatedTypesJson, IntegerAbsentValueTest) {
+  Value* novalue = NULL;
+  Integer<int32_t, -5, 192> integer(novalue);
+  ASSERT_FALSE(integer.is_initialized());
+  ASSERT_FALSE(integer.is_valid());
+}
+
+TEST(ValidatedTypesJson, IntegerFromOverflowingJsonTest) {
+  Value int_val(0xFFFFFFFFFFll);
+  Integer<int32_t, -5, 192> integer(&int_val);
+  ASSERT_TRUE(integer.is_initialized());
+  ASSERT_FALSE(integer.is_valid());
+}
+
+TEST(ValidatedTypesJson, IntegerFromInvalidJsonTest) {
+  Value str_val("Hello");
+  Integer<int8_t, -3, 15> integer(&str_val);
+  ASSERT_TRUE(integer.is_initialized());
+  ASSERT_FALSE(integer.is_valid());
+}
+
+TEST(ValidatedTypesJson, IntegerFromOutOfRangeValueTest) {
+  Value big_int_val(500);
+  Integer<int8_t, 0, 100> integer(&big_int_val);
+  ASSERT_TRUE(integer.is_initialized());
+  ASSERT_FALSE(integer.is_valid());
+}
+
+TEST(ValidatedTypesJson, FloatFromJsonTest) {
+  Value float_value(4.2);
+  Float<1, 7> flt(&float_value);
+  ASSERT_TRUE(flt.is_initialized());
+  ASSERT_TRUE(flt.is_valid());
+  Value readback = flt.ToJsonValue();
+  ASSERT_TRUE(readback.isDouble());
+  ASSERT_EQ(readback.asDouble(), 4.2);
+}
+
+TEST(ValidatedTypesJson, FloatNullTest) {
+  Float<1, 7> flt(&Value::null);
+  ASSERT_TRUE(flt.is_initialized());
+  ASSERT_FALSE(flt.is_valid());
+}
+
+TEST(ValidatedTypesJson, FloatAbsentValueTest) {
+  Value* novalue = NULL;
+  Float<1, 7> flt(novalue);
+  ASSERT_FALSE(flt.is_initialized());
+  ASSERT_FALSE(flt.is_valid());
+}
+
+TEST(ValidatedTypesJson, FloatFromInvalidJsonTest) {
+  Value str_val("Hello");
+  Float<-5, 3> flt(&str_val);
+  ASSERT_TRUE(flt.is_initialized());
+  ASSERT_FALSE(flt.is_valid());
+}
+
+TEST(ValidatedTypesJson, StringFromJsonTest) {
+  Value str_val("Hello");
+  String<1, 42> str(&str_val);
+  ASSERT_TRUE(str.is_initialized());
+  ASSERT_TRUE(str.is_valid());
+  Value readback = str.ToJsonValue();
+  ASSERT_TRUE(readback.isString());
+  ASSERT_STREQ(readback.asCString(), "Hello");
+}
+
+TEST(ValidatedTypesJson, StringNullTest) {
+  String<1, 42> str(&Value::null);
+  ASSERT_TRUE(str.is_initialized());
+  ASSERT_FALSE(str.is_valid());
+}
+
+TEST(ValidatedTypesJson, StringFromInvalidJsonTest) {
+  Value int_val(42);
+  String<1, 500> str(&int_val);
+  ASSERT_TRUE(str.is_initialized());
+  ASSERT_FALSE(str.is_valid());
+}
+
+TEST(ValidatedTypesJson, StringAbsentValueTest) {
+  Value* novalue = NULL;
+  String<1, 500> str(novalue);
+  ASSERT_FALSE(str.is_initialized());
+  ASSERT_FALSE(str.is_valid());
+}
+
+TEST(ValidatedTypesJson, StringFromToLongJsonString) {
+  Value str_val("Too long string");
+  String<1, 5> str(&str_val);
+  ASSERT_TRUE(str.is_initialized());
+  ASSERT_FALSE(str.is_valid());
+}
+
+TEST(ValidatedTypesJson, EnumFromJsonTest) {
+  Value str_enum("kValue1");
+  Enum<TestEnum> enm(&str_enum);
+  ASSERT_TRUE(enm.is_initialized());
+  ASSERT_TRUE(enm.is_valid());
+  Value readback = enm.ToJsonValue();
+  ASSERT_TRUE(readback.isString());
+  ASSERT_STREQ(readback.asCString(), "kValue1");
+}
+
+TEST(ValidatedTypesJson, EnumNullTest) {
+  Enum<TestEnum> enm(&Value::null);
+  ASSERT_TRUE(enm.is_initialized());
+  ASSERT_FALSE(enm.is_valid());
+}
+
+TEST(ValidatedTypesJson, EnumAbsentValueTest) {
+  Value* novalue = NULL;
+  Enum<TestEnum> enm(novalue);
+  ASSERT_FALSE(enm.is_initialized());
+  ASSERT_FALSE(enm.is_valid());
+}
+
+TEST(ValidatedTypesJson, EnumFromInvalidJsonTest) {
+  Value str_value("Random string");
+  Enum<TestEnum> enm(&str_value);
+  ASSERT_TRUE(enm.is_initialized());
+  ASSERT_FALSE(enm.is_valid());
+}
+
+TEST(ValidatedTypesJson, ArrayFromJsonTest) {
+  Value array_value;
+  array_value.append(Value("haha"));
+  array_value.append(Value("hoho"));
+  Array<String<1, 32>, 2, 5> arr(&array_value);
+  ASSERT_TRUE(arr.is_initialized());
+  ASSERT_TRUE(arr.is_valid());
+  Value readback = arr.ToJsonValue();
+  ASSERT_TRUE(readback.isArray());
+  ASSERT_EQ(readback.size(), array_value.size());
+}
+
+TEST(ValidatedTypesJson, MandatoryArrayNullTest) {
+  Array<String<1, 32>, 2, 5> arr(&Value::null);
+  ASSERT_TRUE(arr.is_initialized());
+  ASSERT_FALSE(arr.is_valid());
+}
+
+TEST(ValidatedTypesJson, ArrayAbsentValueTest) {
+  Value* novalue = NULL;
+  Array<String<1, 32>, 2, 5> arr(novalue);
+  ASSERT_FALSE(arr.is_initialized());
+  ASSERT_FALSE(arr.is_valid());
+}
+
+TEST(ValidatedTypesJson, MandatoryMapNullTest) {
+  Map<String<1, 32>, 2, 5> map(&Value::null);
+  ASSERT_TRUE(map.is_initialized());
+  ASSERT_FALSE(map.is_valid());
+}
+
+TEST(ValidatedTypesJson, OptionalMapAbsentValueTest) {
+  Value* novalue = NULL;
+  Optional< Map<String<1, 32>, 0, 5> > map(novalue);
+  ASSERT_FALSE(map.is_initialized());
+  ASSERT_TRUE(map.is_valid());
+}
+
+TEST(ValidatedTypesJson, ArrayJsonTest) {
+  Value array_value;
+  array_value.append(Value("Hello"));
+  array_value.append(Value("World"));
+  Array<Integer<int8_t, 0, 32>, 2, 4> int_array(&array_value);
+  ASSERT_TRUE(int_array.is_initialized());
+  ASSERT_TRUE(int_array.is_valid());
+  ASSERT_EQ(int_array.size(), array_value.size());
+}
+
+TEST(ValidatedTypesJson, ArrayFromNonArrayJsonTest) {
+  Value array_value = "Hello";
+  Array<Integer<int8_t, 0, 32>, 0, 4> int_array(&array_value);
+  ASSERT_TRUE(int_array.is_initialized());
+  ASSERT_FALSE(int_array.is_valid());
+  ASSERT_TRUE(int_array.empty());
+}
+
+TEST(ValidatedTypesJson, MapFromNonArrayJsonTest) {
+  Value array_value = "Hello";
+  Map<Integer<int8_t, 0, 32>, 0, 4> int_map(&array_value);
+  ASSERT_TRUE(int_map.is_initialized());
+  ASSERT_FALSE(int_map.is_valid());
+  ASSERT_TRUE(int_map.empty());
+}
+
+TEST(ValidatedTypesJson, OptionalBoolFromJsonTest) {
+  Value bool_value(true);
+  Optional< Boolean > optional_bool;
+  *optional_bool = Boolean(&bool_value);
+  ASSERT_TRUE(optional_bool.is_initialized());
+  ASSERT_TRUE(optional_bool.is_valid());
+  Value readback = optional_bool->ToJsonValue();
+  ASSERT_TRUE(readback.isBool());
+  ASSERT_EQ(readback.asBool(), true);
+}
+
+TEST(ValidatedTypesJson, OptionalBoolFromAbsentValueTest) {
+  Value* none = NULL;
+  Optional< Boolean > optional_bool;
+  *optional_bool = Boolean(none);
+  ASSERT_FALSE(optional_bool.is_initialized());
+  // It is ok for Optional value to be absent
+  ASSERT_TRUE(optional_bool.is_valid());
+}
+
+TEST(ValidatedTypesJson, OptionalBoolFromNullValueTest) {
+  Optional< Boolean > optional_bool;
+  *optional_bool = Boolean(&Value::null);
+  ASSERT_TRUE(optional_bool.is_initialized());
+  // Optional values should not be absent
+  ASSERT_FALSE(optional_bool.is_valid());
+}
+
+TEST(ValidatedTypesJson, NullableIntFromNullValueTest) {
+  Nullable< Integer<int8_t, 1, 15> > nullable_int(&Value::null);
+  ASSERT_TRUE(nullable_int.is_initialized());
+  ASSERT_TRUE(nullable_int.is_valid());
+  ASSERT_TRUE(nullable_int.is_null());
+}
+
+TEST(ValidatedTypesJson, NullableIntFromNonNullValueTest) {
+  Value json(3);
+  Nullable< Integer<int8_t, 1, 15> > nullable_int(&json);
+  ASSERT_TRUE(nullable_int.is_initialized());
+  ASSERT_TRUE(nullable_int.is_valid());
+  ASSERT_FALSE(nullable_int.is_null());
+  ASSERT_EQ(3, nullable_int);
+}
+
+TEST(ValidatedTypesJson, NullableIntFromAbsentValueTest) {
+  Value* noval = NULL;
+  Nullable< Integer<int8_t, 1, 15> > nullable_int(noval);
+  ASSERT_FALSE(nullable_int.is_initialized());
+  ASSERT_FALSE(nullable_int.is_valid());
+  ASSERT_FALSE(nullable_int.is_null());
+}
+
+TEST(ValidatedTypesJson, OptionalIntFromJsonTest) {
+  Value int_value(42);
+  Optional< Integer<int64_t, 42, 43> > optional_int;
+  *optional_int = Integer<int64_t, 42, 43> (&int_value);
+  ASSERT_TRUE(optional_int.is_initialized());
+  ASSERT_TRUE(optional_int.is_valid());
+  Value readback = optional_int->ToJsonValue();
+  ASSERT_TRUE(readback.isInt());
+  ASSERT_EQ(readback.asInt(), 42);
+}
+
+
+}  // namespace test
+
+
+