diff options
Diffstat (limited to 'src/components/formatters/test/CFormatterJsonBase_test.cc')
| -rw-r--r-- | src/components/formatters/test/CFormatterJsonBase_test.cc | 337 |
1 files changed, 337 insertions, 0 deletions
diff --git a/src/components/formatters/test/CFormatterJsonBase_test.cc b/src/components/formatters/test/CFormatterJsonBase_test.cc new file mode 100644 index 0000000000..9efbfdcf77 --- /dev/null +++ b/src/components/formatters/test/CFormatterJsonBase_test.cc @@ -0,0 +1,337 @@ +/* + * Copyright (c) 2015, 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 <string> +#include <algorithm> +#include "json/value.h" +#include "gtest/gtest.h" +#include "json/reader.h" +#include "formatters/CFormatterJsonBase.hpp" +#include "formatters/generic_json_formatter.h" + +namespace test { +namespace components { +namespace formatters { + +using namespace NsSmartDeviceLink::NsSmartObjects; +using namespace NsSmartDeviceLink::NsJSONHandler::Formatters; + +TEST(CFormatterJsonBaseTest, JSonStringValueToSmartObj_ExpectSuccessful) { + // Arrange value + std::string string_val("test_string"); + Json::Value json_value(string_val); // Json value from string + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_EQ(string_val, object.asString()); +} + +TEST(CFormatterJsonBaseTest, JSonDoubleValueToSmartObj_ExpectSuccessful) { + // Arrange value + double dval = 3.512; + Json::Value json_value(dval); // Json value from double + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_DOUBLE_EQ(dval, object.asDouble()); +} + +TEST(CFormatterJsonBaseTest, JSonMinIntValueToSmartObj_ExpectSuccessful) { + // Arrange value + Json::Int ival = Json::Value::minInt; + Json::Value json_value(ival); // Json value from possible minimum signed int + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_EQ(ival, object.asInt()); +} + +TEST(CFormatterJsonBaseTest, JSonNullIntValueToSmartObj_ExpectSuccessful) { + // Arrange value + Json::Int ival = Json::nullValue; + Json::Value json_value(ival); // Json value from null int value + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_EQ(ival, object.asInt()); +} + +TEST(CFormatterJsonBaseTest, JSonSignedMaxIntValueToSmartObj_ExpectSuccessful) { + // Arrange value + Json::Int ival = Json::Value::maxInt; + Json::Value json_value(ival); // Json value from maximum possible signed int + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_EQ(ival, object.asInt()); +} + +TEST(CFormatterJsonBaseTest, DISABLED_JSonUnsignedMaxIntValueToSmartObj_ExpectSuccessful) { + // Arrange value + Json::UInt ui_val = Json::Value::maxUInt; + Json::Value json_value(ui_val); // Json value from maximum possible unsigned int + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_EQ(ui_val, object.asUInt()); +} + +TEST(CFormatterJsonBaseTest, JSonSignedMaxInt64ValueToSmartObj_ExpectFailed) { + // Arrange value + Json::Int64 ival = Json::Value::maxInt64; + Json::Value json_value(ival); // Json value from maximum possible signed int + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was not successful as there is no such conversion + EXPECT_EQ(invalid_int64_value, object.asInt64()); +} + +TEST(CFormatterJsonBaseTest, JSonBoolValueToSmartObj_ExpectSuccessful) { + // Arrange value + bool bval1 = true; + bool bval2 = false; + Json::Value json_value1(bval1); // Json value from bool + Json::Value json_value2(bval2); // Json value from bool + SmartObject object1; + SmartObject object2; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value1, object1); + CFormatterJsonBase::jsonValueToObj(json_value2, object2); + // Check conversion was successful + EXPECT_TRUE(object1.asBool()); + EXPECT_FALSE(object2.asBool()); +} + +TEST(CFormatterJsonBaseTest, JSonCStringValueToSmartObj_ExpectSuccessful) { + // Arrange value + const char* cstr_val = "cstring_test"; + Json::Value json_value(cstr_val); // Json value from const char* + SmartObject object; + // Convert json to smart object + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_STREQ(cstr_val, object.asCharArray()); +} + +TEST(CFormatterJsonBaseTest, JSonArrayValueToSmartObj_ExpectSuccessful) { + // Arrange value + const char* json_array = "[\"test1\", \"test2\", \"test3\"]"; // Array in json format + Json::Value json_value; // Json value from array. Will be initialized later + SmartObject object; + Json::Reader reader; // Json reader - Needed for correct parsing + // Parse array to json value + ASSERT_TRUE(reader.parse(json_array, json_value)); + // Convert json array to SmartObject + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_TRUE(json_value.isArray()); + EXPECT_EQ(3u, object.asArray()->size()); + SmartArray *ptr = NULL; // Smart Array pointer; + EXPECT_NE(ptr, object.asArray()); +} + +TEST(CFormatterJsonBaseTest, JSonObjectValueToSmartObj_ExpectSuccessful) { + // Arrange value + const char* json_object = + "{ \"json_test_object\": [\"test1\", \"test2\", \"test3\"], \"json_test_object2\": [\"test11\", \"test12\", \"test13\" ]}"; // Json object + Json::Value json_value; // Json value from object. Will be initialized later + SmartObject object; + Json::Reader reader; // Json reader - Needed for correct parsing + ASSERT_TRUE(reader.parse(json_object, json_value)); // If parsing not successful - no sense to continue + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Check conversion was successful + EXPECT_TRUE(json_value.isObject()); + EXPECT_TRUE(json_value.type() == Json::objectValue); + // Get keys collection from Smart Object + std::set<std::string> keys = object.enumerate(); + std::set<std::string>::iterator it1 = keys.begin(); + // Get members names(keys) from Json object + Json::Value::Members mems = json_value.getMemberNames(); + std::vector<std::string>::iterator it; + // Compare sizes + EXPECT_EQ(mems.size(), keys.size()); + // Sort mems + std::sort(mems.begin(), mems.end()); + // Full data compare + for (it = mems.begin(); it != mems.end(); ++it) { + EXPECT_EQ(*it, *it1); + ++it1; + } + ASSERT(it == mems.end() && it1 == keys.end()); +} + +TEST(CFormatterJsonBaseTest, StringSmartObjectToJSon_ExpectSuccessful) { + // Arrange value + std::string string_val("test_string"); + SmartObject object(string_val); + Json::Value json_value; // Json value from string + // Convert smart object to json + CFormatterJsonBase::objToJsonValue(object, json_value); + // Check conversion was successful + EXPECT_EQ(string_val, json_value.asString()); +} + +TEST(CFormatterJsonBaseTest, DoubleSmartObjectToJSon_ExpectSuccessful) { + // Arrange value + double dval = 3.512; + Json::Value json_value; // Json value from double + SmartObject object(dval); + // Convert json to smart object + CFormatterJsonBase::objToJsonValue(object, json_value); + // Check conversion was successful + EXPECT_DOUBLE_EQ(dval, json_value.asDouble()); +} + +TEST(CFormatterJsonBaseTest, ZeroIntSmartObjectToJSon_ExpectSuccessful) { + // Arrange value + Json::Int ival = Json::nullValue; + Json::Value json_value; // Json value from zero int + SmartObject object(ival); + // Convert json to smart object + CFormatterJsonBase::objToJsonValue(object, json_value); + // Check conversion was successful + EXPECT_EQ(ival, json_value.asInt()); +} + +TEST(CFormatterJsonBaseTest, MinIntSmartObjectToJSon_ExpectSuccessful) { + // Arrange value + Json::Int ival = Json::Value::minInt; + Json::Value json_value; // Json value from mimimum possible signed int + SmartObject object(ival); + // Convert json to smart object + CFormatterJsonBase::objToJsonValue(object, json_value); + // Check conversion was successful + EXPECT_EQ(ival, json_value.asInt()); +} + +TEST(CFormatterJsonBaseTest, DISABLED_UnsignedMaxIntSmartObjectToJSon_ExpectSuccessful) { + // Arrange value + Json::UInt ui_val = Json::Value::maxUInt; + Json::Value json_value; // Json value from maximum unsigned int + SmartObject object(ui_val); + // Convert json to smart object + CFormatterJsonBase::objToJsonValue(object, json_value); + // Check conversion was successful + EXPECT_EQ(ui_val, json_value.asUInt()); +} + +TEST(CFormatterJsonBaseTest, BoolSmartObjectToJSon_ExpectSuccessful) { + // Arrange value + bool bval1 = true; + bool bval2 = false; + Json::Value json_value1; // Json value from bool + Json::Value json_value2; // Json value from bool + SmartObject object1(bval1); + SmartObject object2(bval2); + // Convert json to smart object + CFormatterJsonBase::objToJsonValue(object1, json_value1); + CFormatterJsonBase::objToJsonValue(object2, json_value2); + // Check conversion was successful + EXPECT_TRUE(json_value1.asBool()); + EXPECT_FALSE(json_value2.asBool()); +} + +TEST(CFormatterJsonBaseTest, CStringSmartObjectToJSon_ExpectSuccessful) { + // Arrange value + const char* cstr_val = "cstring_test"; + Json::Value json_value; // Json value from const char* + SmartObject object(cstr_val); + // Convert json to smart object + CFormatterJsonBase::objToJsonValue(object, json_value); + // Check conversion was successful + EXPECT_STREQ(cstr_val, json_value.asCString()); +} + +TEST(CFormatterJsonBaseTest, ArraySmartObjectToJSon_ExpectSuccessful) { + // Arrange value + const char* json_array = "[\"test1\", \"test2\", \"test3\"]"; // Array in json format + Json::Value json_value; // Json value from array. Will be initialized later + Json::Value result; // Json value from array. Will be initialized later + SmartObject object; + Json::Reader reader; // Json reader - Needed for correct parsing + // Parse array to json value + ASSERT_TRUE(reader.parse(json_array, json_value)); // Convert json array to SmartObject + // Convert json array to SmartObject + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Convert SmartObject to JSon + CFormatterJsonBase::objToJsonValue(object, result); + // Check conversion was successful + EXPECT_TRUE(result.isArray()); + EXPECT_EQ(3u, result.size()); +} + +TEST(CFormatterJsonBaseTest, JSonObjectValueToObj_ExpectSuccessful) { + // Arrange value + const char* json_object = + "{ \"json_test_object\": [\"test1\", \"test2\", \"test3\"], \"json_test_object2\": [\"test11\", \"test12\", \"test13\" ]}"; // Json object + Json::Value json_value; // Json value from json object. Will be initialized later + Json::Value result; // Json value from Smart object. Will keep conversion result + SmartObject object; + Json::Reader reader; // Json reader - Needed for correct parsing + // Parse json object to correct json value + ASSERT_TRUE(reader.parse(json_object, json_value)); // If parsing not successful - no sense to continue + // Convert json array to SmartObject + CFormatterJsonBase::jsonValueToObj(json_value, object); + // Convert SmartObject to JSon + CFormatterJsonBase::objToJsonValue(object, result); + // Check conversion was successful + EXPECT_TRUE(result.isObject()); + EXPECT_TRUE(result.type() == Json::objectValue); + EXPECT_TRUE(result == json_value); + // Get keys collection from Smart Object + std::set<std::string> keys = object.enumerate(); + std::set<std::string>::iterator it1 = keys.begin(); + // Get members names(keys) from Json object + Json::Value::Members mems = result.getMemberNames(); + std::vector<std::string>::iterator it; + // Compare sizes + EXPECT_EQ(mems.size(), keys.size()); + // Sort mems + std::sort(mems.begin(), mems.end()); + // Full data compare + for (it = mems.begin(); it != mems.end(); ++it) { + EXPECT_EQ(*it, *it1); + ++it1; + } + ASSERT(it == mems.end() && it1 == keys.end()); +} + +} // namespace formatters +} // namespace components +} // namespace test |