diff options
Diffstat (limited to 'src/components/formatters/test/src')
3 files changed, 1102 insertions, 0 deletions
diff --git a/src/components/formatters/test/src/SmartFactoryTestHelper.cc b/src/components/formatters/test/src/SmartFactoryTestHelper.cc new file mode 100644 index 0000000000..8f601afc29 --- /dev/null +++ b/src/components/formatters/test/src/SmartFactoryTestHelper.cc @@ -0,0 +1,501 @@ +/* + * 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 "SmartFactoryTestHelper.h" + +using namespace test::components::formatters; + +template<> +const EnumConversionHelper<TestType::eType>::EnumToCStringMap EnumConversionHelper< + test::components::formatters::TestType::eType>::enum_to_cstring_map_ = + EnumConversionHelper<test::components::formatters::TestType::eType>::InitEnumToCStringMap(); + +template<> +const EnumConversionHelper<TestType::eType>::CStringToEnumMap EnumConversionHelper< + test::components::formatters::TestType::eType>::cstring_to_enum_map_ = + EnumConversionHelper<test::components::formatters::TestType::eType>::InitCStringToEnumMap(); + +template<> +const char* const EnumConversionHelper<TestType::eType>::cstring_values_[] = { + "APPLICATION_NOT_REGISTERED", "SUCCESS", "TOO_MANY_PENDING_REQUESTS", + "REJECTED", "INVALID_DATA", "OUT_OF_MEMORY", "ABORTED", "USER_DISALLOWED", + "GENERIC_ERROR", "DISALLOWED" }; + +template<> +const TestType::eType EnumConversionHelper<TestType::eType>::enum_values_[] = { + test::components::formatters::TestType::APPLICATION_NOT_REGISTERED, + test::components::formatters::TestType::SUCCESS, + test::components::formatters::TestType::TOO_MANY_PENDING_REQUESTS, + test::components::formatters::TestType::REJECTED, + test::components::formatters::TestType::INVALID_DATA, + test::components::formatters::TestType::OUT_OF_MEMORY, + test::components::formatters::TestType::ABORTED, + test::components::formatters::TestType::USER_DISALLOWED, + test::components::formatters::TestType::GENERIC_ERROR, + test::components::formatters::TestType::DISALLOWED }; + +template<> +const EnumConversionHelper<FunctionIdTest::eType>::EnumToCStringMap EnumConversionHelper< + test::components::formatters::FunctionIdTest::eType>::enum_to_cstring_map_ = + EnumConversionHelper<test::components::formatters::FunctionIdTest::eType>::InitEnumToCStringMap(); + +template<> +const EnumConversionHelper<FunctionIdTest::eType>::CStringToEnumMap EnumConversionHelper< + test::components::formatters::FunctionIdTest::eType>::cstring_to_enum_map_ = + EnumConversionHelper<test::components::formatters::FunctionIdTest::eType>::InitCStringToEnumMap(); + +template<> +const char* const EnumConversionHelper<FunctionIdTest::eType>::cstring_values_[] = + { "Function1", "Function2", "Function3" }; + +template<> +const FunctionIdTest::eType EnumConversionHelper<FunctionIdTest::eType>::enum_values_[] = + { test::components::formatters::FunctionIdTest::Function1, + test::components::formatters::FunctionIdTest::Function2, + test::components::formatters::FunctionIdTest::Function3 }; + +template<> +const EnumConversionHelper<MessageTypeTest::eType>::EnumToCStringMap EnumConversionHelper< + test::components::formatters::MessageTypeTest::eType>::enum_to_cstring_map_ = + EnumConversionHelper<test::components::formatters::MessageTypeTest::eType>::InitEnumToCStringMap(); + +template<> +const EnumConversionHelper<MessageTypeTest::eType>::CStringToEnumMap EnumConversionHelper< + test::components::formatters::MessageTypeTest::eType>::cstring_to_enum_map_ = + EnumConversionHelper<test::components::formatters::MessageTypeTest::eType>::InitCStringToEnumMap(); + +template<> +const char* const EnumConversionHelper<MessageTypeTest::eType>::cstring_values_[] = + { "request", "response", "notification" }; + +template<> +const MessageTypeTest::eType EnumConversionHelper<MessageTypeTest::eType>::enum_values_[] = + { test::components::formatters::MessageTypeTest::request, + test::components::formatters::MessageTypeTest::response, + test::components::formatters::MessageTypeTest::notification }; + +CSmartFactoryTest::CSmartFactoryTest() + : CSmartFactory<FunctionIdTest::eType, MessageTypeTest::eType, + StructIdentifiersTest::eType>() { + TStructsSchemaItems struct_schema_items; + InitStructSchemes(struct_schema_items); + std::set<FunctionIdTest::eType> function_id_items; + function_id_items.insert(FunctionIdTest::Function1); + function_id_items.insert(FunctionIdTest::Function2); + function_id_items.insert(FunctionIdTest::Function3); + + std::set<MessageTypeTest::eType> message_type_items; + message_type_items.insert(MessageTypeTest::request); + message_type_items.insert(MessageTypeTest::response); + message_type_items.insert(MessageTypeTest::notification); + message_type_items.insert(MessageTypeTest::error_response); + InitFunctionSchemes(struct_schema_items, function_id_items, + message_type_items); +} + +void CSmartFactoryTest::InitStructSchemes( + TStructsSchemaItems &struct_schema_items) { + utils::SharedPtr<ISchemaItem> struct_schema_item_Common_1 = + InitStructSchemaItem_Common_1(struct_schema_items); + struct_schema_items.insert( + std::make_pair(StructIdentifiersTest::Common_1, + struct_schema_item_Common_1)); + structs_schemes_.insert( + std::make_pair(StructIdentifiersTest::Common_1, + CSmartSchema(struct_schema_item_Common_1))); + + utils::SharedPtr<ISchemaItem> struct_schema_item_Common_2 = + InitStructSchemaItem_Common_2(); + struct_schema_items.insert( + std::make_pair(StructIdentifiersTest::Common_2, + struct_schema_item_Common_2)); + structs_schemes_.insert( + std::make_pair(StructIdentifiersTest::Common_2, + CSmartSchema(struct_schema_item_Common_2))); +} + +void CSmartFactoryTest::InitFunctionSchemes( + const TStructsSchemaItems &struct_schema_items, + const std::set<FunctionIdTest::eType> &function_id_items, + const std::set<MessageTypeTest::eType> &message_type_items) { + CObjectSchemaItem::Members params_members; + params_members[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIdTest::eType>::create(function_id_items), true); + params_members[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create(message_type_items), + true); + params_members[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[kCode] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[kMessage] = CObjectSchemaItem::SMember( + CStringSchemaItem::create(), true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = + CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), + true); + + CSmartSchema error_response_schema( + CObjectSchemaItem::create(root_members_map)); + + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function1, MessageTypeTest::error_response), + error_response_schema)); + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function1, MessageTypeTest::request), + InitFunction_Function1_request(function_id_items, + message_type_items))); + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function1, MessageTypeTest::response), + InitFunction_Function1_response(struct_schema_items, + function_id_items, + message_type_items))); + + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function2, MessageTypeTest::error_response), + error_response_schema)); + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function2, MessageTypeTest::request), + InitFunction_Function2_request(function_id_items, + message_type_items))); + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function2, MessageTypeTest::response), + InitFunction_Function2_response(struct_schema_items, + function_id_items, + message_type_items))); + + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function3, MessageTypeTest::error_response), + error_response_schema)); + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function3, MessageTypeTest::request), + InitFunction_Function3_request(function_id_items, + message_type_items))); + functions_schemes_.insert( + std::make_pair( + SmartSchemaKey<FunctionIdTest::eType, MessageTypeTest::eType>( + FunctionIdTest::Function3, MessageTypeTest::response), + InitFunction_Function3_response(struct_schema_items, + function_id_items, + message_type_items))); +} + +CSmartSchema CSmartFactoryTest::InitFunction_Function1_request( + const std::set<FunctionIdTest::eType> &function_id_items, + const std::set<MessageTypeTest::eType> &message_type_items) { + + CObjectSchemaItem::Members schema_members; + CObjectSchemaItem::Members params_members; + + params_members[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIdTest::eType>::create(function_id_items), true); + params_members[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create(message_type_items), + true); + params_members[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schema_members), true); + root_members_map[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(params_members), true); + + return CSmartSchema(CObjectSchemaItem::create(root_members_map)); +} + +CSmartSchema CSmartFactoryTest::InitFunction_Function1_response( + const TStructsSchemaItems &struct_schema_items, + const std::set<FunctionIdTest::eType> &function_id_items, + const std::set<MessageTypeTest::eType> &message_type_items) { + // Function parameter available. + utils::SharedPtr<ISchemaItem> available_SchemaItem = CBoolSchemaItem::create( + TSchemaItemParameter<bool>()); + + CObjectSchemaItem::Members schema_members; + + schema_members["available"] = CObjectSchemaItem::SMember(available_SchemaItem, + true); + + CObjectSchemaItem::Members params_members; + params_members[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIdTest::eType>::create(function_id_items), true); + params_members[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create(message_type_items), + true); + params_members[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[kCode] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schema_members), true); + root_members_map[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(params_members), true); + + return CSmartSchema(CObjectSchemaItem::create(root_members_map)); +} + +CSmartSchema CSmartFactoryTest::InitFunction_Function2_request( + const std::set<FunctionIdTest::eType> &function_id_items, + const std::set<MessageTypeTest::eType> &message_type_items) { + CObjectSchemaItem::Members schema_members; + + CObjectSchemaItem::Members params_members; + params_members[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIdTest::eType>::create(function_id_items), true); + params_members[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create(message_type_items), + true); + params_members[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schema_members), true); + root_members_map[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(params_members), true); + + return CSmartSchema(CObjectSchemaItem::create(root_members_map)); +} + +CSmartSchema CSmartFactoryTest::InitFunction_Function2_response( + const TStructsSchemaItems &struct_schema_items, + const std::set<FunctionIdTest::eType> &function_id_items, + const std::set<MessageTypeTest::eType> &message_type_items) { + // Function parameter available. + utils::SharedPtr<ISchemaItem> available_SchemaItem = CBoolSchemaItem::create( + TSchemaItemParameter<bool>()); + + CObjectSchemaItem::Members schema_members; + + schema_members["available"] = CObjectSchemaItem::SMember(available_SchemaItem, + true); + + CObjectSchemaItem::Members params_members; + params_members[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIdTest::eType>::create(function_id_items), true); + params_members[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create(message_type_items), + true); + params_members[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[kCode] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schema_members), true); + root_members_map[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(params_members), true); + + return CSmartSchema(CObjectSchemaItem::create(root_members_map)); +} + +CSmartSchema CSmartFactoryTest::InitFunction_Function3_request( + const std::set<FunctionIdTest::eType> &function_id_items, + const std::set<MessageTypeTest::eType> &message_type_items) { + CObjectSchemaItem::Members schema_members; + + CObjectSchemaItem::Members params_members; + params_members[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIdTest::eType>::create(function_id_items), true); + params_members[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create(message_type_items), + true); + params_members[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schema_members), true); + root_members_map[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(params_members), true); + + return CSmartSchema(CObjectSchemaItem::create(root_members_map)); +} + +CSmartSchema CSmartFactoryTest::InitFunction_Function3_response( + const TStructsSchemaItems &struct_schema_items, + const std::set<FunctionIdTest::eType> &function_id_items, + const std::set<MessageTypeTest::eType> &message_type_items) { + // Function parameter available. + // + // Must be true if VR is present and ready to communicate with SDL. + utils::SharedPtr<ISchemaItem> available_SchemaItem = CBoolSchemaItem::create( + TSchemaItemParameter<bool>()); + + CObjectSchemaItem::Members schema_members; + + schema_members["available"] = CObjectSchemaItem::SMember(available_SchemaItem, + true); + + CObjectSchemaItem::Members params_members; + params_members[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIdTest::eType>::create(function_id_items), true); + params_members[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create(message_type_items), + true); + params_members[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + params_members[kCode] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schema_members), true); + root_members_map[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(params_members), true); + + return CSmartSchema(CObjectSchemaItem::create(root_members_map)); +} + +utils::SharedPtr<ISchemaItem> CSmartFactoryTest::InitStructSchemaItem_Common_1( + TStructsSchemaItems &struct_schema_items) { + // Struct member text. + // + // Text to display + utils::SharedPtr<ISchemaItem> text_SchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(1), TSchemaItemParameter<size_t>(500), + TSchemaItemParameter<std::string>()); + + // Struct member image. + // + // Image struct + utils::SharedPtr<ISchemaItem> image_SchemaItem = + ProvideObjectSchemaItemForStruct(struct_schema_items, + StructIdentifiersTest::Common_2); + + // Struct member position. + // + // Position to display item + utils::SharedPtr<ISchemaItem> position_SchemaItem = + TNumberSchemaItem<int32_t>::create(TSchemaItemParameter<int32_t>(1), + TSchemaItemParameter<int32_t>(500), + TSchemaItemParameter<int32_t>()); + CObjectSchemaItem::Members struct_members; + struct_members["image"] = CObjectSchemaItem::SMember(image_SchemaItem, false); + + CObjectSchemaItem::Members schema_members; + + schema_members["text"] = CObjectSchemaItem::SMember(text_SchemaItem, true); + schema_members["position"] = CObjectSchemaItem::SMember(position_SchemaItem, + true); + + CObjectSchemaItem::Members root_members_map; + root_members_map[""] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(struct_members), true); + root_members_map[""] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schema_members), true); + return CObjectSchemaItem::create(schema_members); +} + +utils::SharedPtr<ISchemaItem> CSmartFactoryTest::InitStructSchemaItem_Common_2() { + // Struct member text. + // + // Text to display + utils::SharedPtr<ISchemaItem> text_SchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(1), TSchemaItemParameter<size_t>(500), + TSchemaItemParameter<std::string>()); + // Struct member position. + // + // Position to display item + utils::SharedPtr<ISchemaItem> position_SchemaItem = + TNumberSchemaItem<int32_t>::create(TSchemaItemParameter<int32_t>(1), + TSchemaItemParameter<int32_t>(500), + TSchemaItemParameter<int32_t>()); + + CObjectSchemaItem::Members schema_members; + schema_members["text"] = CObjectSchemaItem::SMember(text_SchemaItem, true); + schema_members["position"] = CObjectSchemaItem::SMember(position_SchemaItem, + true); + + return CObjectSchemaItem::create(schema_members); +} + +utils::SharedPtr<ISchemaItem> CSmartFactoryTest::ProvideObjectSchemaItemForStruct( + TStructsSchemaItems &struct_schema_items, + const StructIdentifiersTest::eType struct_id) { + const TStructsSchemaItems::const_iterator it = struct_schema_items.find( + struct_id); + if (it != struct_schema_items.end()) { + return it->second; + } + return NsSmartDeviceLink::NsSmartObjects::CAlwaysFalseSchemaItem::create(); +} + diff --git a/src/components/formatters/test/src/create_smartSchema.cc b/src/components/formatters/test/src/create_smartSchema.cc new file mode 100644 index 0000000000..9d44567dcd --- /dev/null +++ b/src/components/formatters/test/src/create_smartSchema.cc @@ -0,0 +1,379 @@ +/* + * 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 "create_smartSchema.h" +namespace test { +namespace components { +namespace formatters { + +using namespace NsSmartDeviceLink::NsJSONHandler::strings; +using namespace NsSmartDeviceLink::NsJSONHandler::Formatters; +using namespace NsSmartDeviceLink::NsSmartObjects; + +template<> +const EnumConversionHelper<FunctionIDTest::eType>::EnumToCStringMap EnumConversionHelper< + test::components::formatters::FunctionIDTest::eType>::enum_to_cstring_map_ = + EnumConversionHelper<test::components::formatters::FunctionIDTest::eType>::InitEnumToCStringMap(); + +template<> +const EnumConversionHelper<FunctionIDTest::eType>::CStringToEnumMap EnumConversionHelper< + test::components::formatters::FunctionIDTest::eType>::cstring_to_enum_map_ = + EnumConversionHelper<test::components::formatters::FunctionIDTest::eType>::InitCStringToEnumMap(); + +template<> +const char* const EnumConversionHelper<FunctionIDTest::eType>::cstring_values_[] = + { "RegisterAppInterface", "UnregisterAppInterface", "SetGlobalProperties" }; + +template<> +const FunctionIDTest::eType EnumConversionHelper<FunctionIDTest::eType>::enum_values_[] = + { test::components::formatters::FunctionIDTest::RegisterAppInterface, + test::components::formatters::FunctionIDTest::UnregisterAppInterface, + test::components::formatters::FunctionIDTest::SetGlobalProperties }; + +template<> +const EnumConversionHelper<Language::eType>::EnumToCStringMap EnumConversionHelper< + test::components::formatters::Language::eType>::enum_to_cstring_map_ = + EnumConversionHelper<test::components::formatters::Language::eType>::InitEnumToCStringMap(); + +template<> +const EnumConversionHelper<Language::eType>::CStringToEnumMap EnumConversionHelper< + test::components::formatters::Language::eType>::cstring_to_enum_map_ = + EnumConversionHelper<test::components::formatters::Language::eType>::InitCStringToEnumMap(); + +template<> +const char* const EnumConversionHelper<Language::eType>::cstring_values_[] = + { "EN_EU", "RU_RU"}; + +template<> +const Language::eType EnumConversionHelper<Language::eType>::enum_values_[] = + { test::components::formatters::Language::EN_EU, + test::components::formatters::Language::RU_RU}; + +template<> +const EnumConversionHelper<SpeechCapabilities::eType>::EnumToCStringMap EnumConversionHelper< + test::components::formatters::SpeechCapabilities::eType>::enum_to_cstring_map_ = + EnumConversionHelper<test::components::formatters::SpeechCapabilities::eType>::InitEnumToCStringMap(); + +template<> +const EnumConversionHelper<SpeechCapabilities::eType>::CStringToEnumMap EnumConversionHelper< + test::components::formatters::SpeechCapabilities::eType>::cstring_to_enum_map_ = + EnumConversionHelper<test::components::formatters::SpeechCapabilities::eType>::InitCStringToEnumMap(); + +template<> +const char* const EnumConversionHelper<SpeechCapabilities::eType>::cstring_values_[] = + { "SC_TEXT"}; + +template<> +const SpeechCapabilities::eType EnumConversionHelper<SpeechCapabilities::eType>::enum_values_[] = + { test::components::formatters::SpeechCapabilities::SC_TEXT}; + +template<> +const EnumConversionHelper<AppTypeTest::eType>::EnumToCStringMap EnumConversionHelper< + test::components::formatters::AppTypeTest::eType>::enum_to_cstring_map_ = + EnumConversionHelper<test::components::formatters::AppTypeTest::eType>::InitEnumToCStringMap(); + +template<> +const EnumConversionHelper<AppTypeTest::eType>::CStringToEnumMap EnumConversionHelper< + test::components::formatters::AppTypeTest::eType>::cstring_to_enum_map_ = + EnumConversionHelper<test::components::formatters::AppTypeTest::eType>::InitCStringToEnumMap(); + +template<> +const char* const EnumConversionHelper<AppTypeTest::eType>::cstring_values_[] = + { "SYSTEM", "MEDIA"}; + +template<> +const AppTypeTest::eType EnumConversionHelper<AppTypeTest::eType>::enum_values_[] = + { test::components::formatters::AppTypeTest::SYSTEM, + test::components::formatters::AppTypeTest::MEDIA, + }; + +CSmartSchema initObjectSchema() { + std::set<TestType::eType> resultCode_allowedEnumSubsetValues; + resultCode_allowedEnumSubsetValues.insert( + TestType::APPLICATION_NOT_REGISTERED); + resultCode_allowedEnumSubsetValues.insert(TestType::SUCCESS); + resultCode_allowedEnumSubsetValues.insert( + TestType::TOO_MANY_PENDING_REQUESTS); + resultCode_allowedEnumSubsetValues.insert(TestType::REJECTED); + resultCode_allowedEnumSubsetValues.insert(TestType::INVALID_DATA); + resultCode_allowedEnumSubsetValues.insert(TestType::OUT_OF_MEMORY); + resultCode_allowedEnumSubsetValues.insert(TestType::ABORTED); + resultCode_allowedEnumSubsetValues.insert(TestType::USER_DISALLOWED); + resultCode_allowedEnumSubsetValues.insert(TestType::GENERIC_ERROR); + resultCode_allowedEnumSubsetValues.insert(TestType::DISALLOWED); + + // Possible functions in this test scheme + std::set<FunctionIDTest::eType> functionId_allowedEnumSubsetValues; + functionId_allowedEnumSubsetValues.insert( + FunctionIDTest::RegisterAppInterface); + functionId_allowedEnumSubsetValues.insert( + FunctionIDTest::UnregisterAppInterface); + functionId_allowedEnumSubsetValues.insert( + FunctionIDTest::SetGlobalProperties); + + // Possible message types + std::set<MessageTypeTest::eType> messageType_allowedEnumSubsetValues; + messageType_allowedEnumSubsetValues.insert(MessageTypeTest::request); + messageType_allowedEnumSubsetValues.insert(MessageTypeTest::response); + messageType_allowedEnumSubsetValues.insert(MessageTypeTest::notification); + + // Create result item + ISchemaItemPtr success_SchemaItem = CBoolSchemaItem::create( + TSchemaItemParameter<bool>()); + ISchemaItemPtr resultCode_SchemaItem = + TEnumSchemaItem<TestType::eType>::create( + resultCode_allowedEnumSubsetValues, + TSchemaItemParameter<TestType::eType>()); + + // Create info value with min 0 length and max 1000 + ISchemaItemPtr info_SchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000), + TSchemaItemParameter<std::string>()); + + ISchemaItemPtr tryAgainTime_SchemaItem = TNumberSchemaItem<int>::create( + TSchemaItemParameter<int>(0), TSchemaItemParameter<int>(2000000000), + TSchemaItemParameter<int>()); + + // Map of parameters + std::map<std::string, CObjectSchemaItem::SMember> schemaMembersMap; + + schemaMembersMap["success"] = CObjectSchemaItem::SMember(success_SchemaItem, + false); + schemaMembersMap["resultCode"] = CObjectSchemaItem::SMember( + resultCode_SchemaItem, false); + schemaMembersMap["info"] = CObjectSchemaItem::SMember(info_SchemaItem, false); + schemaMembersMap["tryAgainTime"] = CObjectSchemaItem::SMember( + tryAgainTime_SchemaItem, false); + + std::map<std::string, CObjectSchemaItem::SMember> paramsMembersMap; + paramsMembersMap[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIDTest::eType>::create( + functionId_allowedEnumSubsetValues), + true); + paramsMembersMap[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create( + messageType_allowedEnumSubsetValues), + true); + paramsMembersMap[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + paramsMembersMap[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(1), + TSchemaItemParameter<int>(2)), + true); + paramsMembersMap[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + std::map<std::string, CObjectSchemaItem::SMember> rootMembersMap; + rootMembersMap[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schemaMembersMap), true); + rootMembersMap[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(paramsMembersMap), true); + return CSmartSchema(CObjectSchemaItem::create(rootMembersMap)); +}; + + +CSmartSchema initSchemaForMetaFormatter() { + std::set<TestType::eType> resultCode_allowedEnumSubsetValues; + resultCode_allowedEnumSubsetValues.insert( + TestType::APPLICATION_NOT_REGISTERED); + resultCode_allowedEnumSubsetValues.insert(TestType::SUCCESS); + resultCode_allowedEnumSubsetValues.insert( + TestType::TOO_MANY_PENDING_REQUESTS); + resultCode_allowedEnumSubsetValues.insert(TestType::REJECTED); + resultCode_allowedEnumSubsetValues.insert(TestType::INVALID_DATA); + resultCode_allowedEnumSubsetValues.insert(TestType::OUT_OF_MEMORY); + resultCode_allowedEnumSubsetValues.insert(TestType::ABORTED); + resultCode_allowedEnumSubsetValues.insert(TestType::USER_DISALLOWED); + resultCode_allowedEnumSubsetValues.insert(TestType::GENERIC_ERROR); + resultCode_allowedEnumSubsetValues.insert(TestType::DISALLOWED); + + // Possible functions in this test scheme + std::set<FunctionIDTest::eType> functionId_allowedEnumSubsetValues; + functionId_allowedEnumSubsetValues.insert( + FunctionIDTest::RegisterAppInterface); + functionId_allowedEnumSubsetValues.insert( + FunctionIDTest::UnregisterAppInterface); + functionId_allowedEnumSubsetValues.insert( + FunctionIDTest::SetGlobalProperties); + + std::set<Language::eType> languageDesired_allowedEnumSubsetValues; + languageDesired_allowedEnumSubsetValues.insert(Language::RU_RU); + languageDesired_allowedEnumSubsetValues.insert(Language::EN_EU); + + + std::set<AppTypeTest::eType> appType_allowedEnumSubsetValues; + appType_allowedEnumSubsetValues.insert(AppTypeTest::SYSTEM); + appType_allowedEnumSubsetValues.insert(AppTypeTest::MEDIA); + + std::set<SpeechCapabilities::eType> speechCapabilities_allowedEnumSubsetValues; + speechCapabilities_allowedEnumSubsetValues.insert(SpeechCapabilities::SC_TEXT); + + // Possible message types + std::set<MessageTypeTest::eType> messageType_allowedEnumSubsetValues; + messageType_allowedEnumSubsetValues.insert(MessageTypeTest::request); + messageType_allowedEnumSubsetValues.insert(MessageTypeTest::response); + messageType_allowedEnumSubsetValues.insert(MessageTypeTest::notification); + + // Create param items + ISchemaItemPtr appID_SchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000), + TSchemaItemParameter<std::string>()); + ISchemaItemPtr appName_SchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000), + TSchemaItemParameter<std::string>()); + ISchemaItemPtr isMediaApplication_SchemaItem = CBoolSchemaItem::create( + TSchemaItemParameter<bool>()); + ISchemaItemPtr ngnMediaScreenAppName_SchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000), + TSchemaItemParameter<std::string>()); + + ISchemaItemPtr ttsNameItem_SchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000), + TSchemaItemParameter<std::string>()); + + ISchemaItemPtr ttstype_SchemaItem = + TEnumSchemaItem<SpeechCapabilities::eType>::create( + speechCapabilities_allowedEnumSubsetValues, + TSchemaItemParameter<SpeechCapabilities::eType>()); + + std::map<std::string, CObjectSchemaItem::SMember> ttsMap; + ttsMap["text"]=CObjectSchemaItem::SMember(ttsNameItem_SchemaItem, + false); + ttsMap["type"]=CObjectSchemaItem::SMember(ttstype_SchemaItem, + false);; + + ISchemaItemPtr hmiDisplayLanguageDesired_SchemaItem = + TEnumSchemaItem<Language::eType>::create( + languageDesired_allowedEnumSubsetValues, + TSchemaItemParameter<Language::eType>()); + + ISchemaItemPtr languageDesired_SchemaItem = + TEnumSchemaItem<Language::eType>::create( + languageDesired_allowedEnumSubsetValues, + TSchemaItemParameter<Language::eType>()); + + ISchemaItemPtr vrElementSchemaItem = CStringSchemaItem::create( + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000), + TSchemaItemParameter<std::string>()); + + ISchemaItemPtr appTypeElementSchemaItem = + TEnumSchemaItem<AppTypeTest::eType>::create( + appType_allowedEnumSubsetValues, + TSchemaItemParameter<AppTypeTest::eType>()); + + ISchemaItemPtr ttsElementSchemaItem = CObjectSchemaItem::create(ttsMap); + + ISchemaItemPtr ttsName_SchemaItem = + CArraySchemaItem::create(ttsElementSchemaItem, + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000)); + + ISchemaItemPtr vrSynonyms_SchemaItem = + CArraySchemaItem::create(vrElementSchemaItem, + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000)); + + ISchemaItemPtr appType_SchemaItem = + CArraySchemaItem::create(appTypeElementSchemaItem, + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000)); + + + ISchemaItemPtr majorVersion_SchemaItem = TNumberSchemaItem<int>::create(); + ISchemaItemPtr minorVersion_SchemaItem = TNumberSchemaItem<int>::create(); + + ISchemaItemPtr syncMsg_SchemaItem =CStringSchemaItem::create( + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000), + TSchemaItemParameter<std::string>()); + + ISchemaItemPtr syncMsgVersion_SchemaItem = + CArraySchemaItem::create(syncMsg_SchemaItem, + TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(1000)); + + // Creation map for syncMsgVersion + std::map<std::string, CObjectSchemaItem::SMember> schemaSyncMsgVersionMap; + schemaSyncMsgVersionMap["majorVersion"]=CObjectSchemaItem::SMember(majorVersion_SchemaItem, + false); + schemaSyncMsgVersionMap["minorVersion"]=CObjectSchemaItem::SMember(minorVersion_SchemaItem, + false);; + + // Map of parameters + std::map<std::string, CObjectSchemaItem::SMember> schemaMembersMap; + + schemaMembersMap["appID"] = CObjectSchemaItem::SMember(appID_SchemaItem, + false); + schemaMembersMap["appName"] = CObjectSchemaItem::SMember(appName_SchemaItem, + false); + schemaMembersMap["appType"] = CObjectSchemaItem::SMember(appType_SchemaItem, + false); + schemaMembersMap["hmiDisplayLanguageDesired"] = CObjectSchemaItem::SMember(hmiDisplayLanguageDesired_SchemaItem, + false); + schemaMembersMap["isMediaApplication"] = CObjectSchemaItem::SMember(isMediaApplication_SchemaItem, + false); + schemaMembersMap["languageDesired"] = CObjectSchemaItem::SMember(languageDesired_SchemaItem, + false); + schemaMembersMap["ngnMediaScreenAppName"] = CObjectSchemaItem::SMember(ngnMediaScreenAppName_SchemaItem, + false); + schemaMembersMap["syncMsgVersion"] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schemaSyncMsgVersionMap), + false); + schemaMembersMap["ttsName"] = CObjectSchemaItem::SMember(ttsName_SchemaItem, + false); + schemaMembersMap["vrSynonyms"] = CObjectSchemaItem::SMember(vrSynonyms_SchemaItem, false); + + std::map<std::string, CObjectSchemaItem::SMember> paramsMembersMap; + paramsMembersMap[S_FUNCTION_ID] = CObjectSchemaItem::SMember( + TEnumSchemaItem<FunctionIDTest::eType>::create( + functionId_allowedEnumSubsetValues), + true); + paramsMembersMap[S_MESSAGE_TYPE] = CObjectSchemaItem::SMember( + TEnumSchemaItem<MessageTypeTest::eType>::create( + messageType_allowedEnumSubsetValues), + true); + paramsMembersMap[S_CORRELATION_ID] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + paramsMembersMap[S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(1), + TSchemaItemParameter<int>(2)), + true); + paramsMembersMap[S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember( + TNumberSchemaItem<int>::create(), true); + + std::map<std::string, CObjectSchemaItem::SMember> rootMembersMap; + rootMembersMap[S_MSG_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(schemaMembersMap), true); + rootMembersMap[S_PARAMS] = CObjectSchemaItem::SMember( + CObjectSchemaItem::create(paramsMembersMap), true); + return CSmartSchema(CObjectSchemaItem::create(rootMembersMap)); +}; + + + +} // namespace formatters +} // namespace components +} // namespace test diff --git a/src/components/formatters/test/src/meta_formatter_test_helper.cc b/src/components/formatters/test/src/meta_formatter_test_helper.cc new file mode 100644 index 0000000000..3445d948bb --- /dev/null +++ b/src/components/formatters/test/src/meta_formatter_test_helper.cc @@ -0,0 +1,222 @@ +/* + * 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 "gtest/gtest.h" +#include "meta_formatter_test_helper.h" + +namespace test { +namespace components { +namespace formatters { + +using namespace NsSmartDeviceLink::NsJSONHandler::strings; +using namespace NsSmartDeviceLink::NsJSONHandler::Formatters; + +void CMetaFormatterTestHelper::SetUp() { + function_id_items_.insert(FunctionIDTest::RegisterAppInterface); + function_id_items_.insert(FunctionIDTest::UnregisterAppInterface); + function_id_items_.insert(FunctionIDTest::SetGlobalProperties); + + message_type_items_.insert(MessageTypeTest::request); + message_type_items_.insert(MessageTypeTest::response); + message_type_items_.insert(MessageTypeTest::notification); +} + +void CMetaFormatterTestHelper::TearDown() { + function_id_items_.clear(); + message_type_items_.clear(); +} + +//----------------------------------------------------------- + +void CMetaFormatterTestHelper::AnyObjectToJsonString( + const SmartObject& obj, std::string& result_string) { + + Json::Value params(Json::objectValue); + + SmartObject formattedObj(obj); + + CFormatterJsonBase::objToJsonValue(formattedObj, params); + + result_string = params.toStyledString(); +} + +//----------------------------------------------------------- + +void CMetaFormatterTestHelper::FillObjectIdenticalToSchema(SmartObject& obj) { + + obj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request; + obj[S_PARAMS][S_FUNCTION_ID] = FunctionIDTest::RegisterAppInterface; + obj[S_PARAMS][S_CORRELATION_ID] = 12; + obj[S_PARAMS][S_PROTOCOL_VERSION] = 1; + obj[S_PARAMS][S_PROTOCOL_TYPE] = 0; + + obj[S_MSG_PARAMS]["syncMsgVersion"]["majorVersion"] = 2; + obj[S_MSG_PARAMS]["syncMsgVersion"]["minorVersion"] = 10; + obj[S_MSG_PARAMS]["appName"] = "APP NAME"; + obj[S_MSG_PARAMS]["ttsName"][0]["text"] = "ABC"; + obj[S_MSG_PARAMS]["ttsName"][0]["type"] = SpeechCapabilities::SC_TEXT; + obj[S_MSG_PARAMS]["ngnMediaScreenAppName"] = "SCREEN NAME"; + obj[S_MSG_PARAMS]["vrSynonyms"][0] = "Synonym1"; + obj[S_MSG_PARAMS]["vrSynonyms"][1] = "Synonym2"; + obj[S_MSG_PARAMS]["isMediaApplication"] = true; + obj[S_MSG_PARAMS]["languageDesired"] = Language::EN_EU; + obj[S_MSG_PARAMS]["hmiDisplayLanguageDesired"] = Language::RU_RU; + obj[S_MSG_PARAMS]["appType"][0] = AppTypeTest::SYSTEM; + obj[S_MSG_PARAMS]["appType"][1] = AppTypeTest::MEDIA; + obj[S_MSG_PARAMS]["appID"] = "APP ID"; +} + +//----------------------------------------------------------- +void CMetaFormatterTestHelper::FillObjectIdenticalToSchemaWithoutNoMandatoriesParams( + SmartObject& obj) { + obj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request; + obj[S_PARAMS][S_FUNCTION_ID] = FunctionIDTest::RegisterAppInterface; + obj[S_PARAMS][S_CORRELATION_ID] = 12; + obj[S_PARAMS][S_PROTOCOL_VERSION] = 1; + obj[S_PARAMS][S_PROTOCOL_TYPE] = 0; + + obj[S_MSG_PARAMS]["syncMsgVersion"]["majorVersion"] = 2; + obj[S_MSG_PARAMS]["syncMsgVersion"]["minorVersion"] = 10; + obj[S_MSG_PARAMS]["appName"] = "APP NAME"; + obj[S_MSG_PARAMS]["ngnMediaScreenAppName"] = "SCREEN NAME"; + obj[S_MSG_PARAMS]["isMediaApplication"] = true; + obj[S_MSG_PARAMS]["languageDesired"] = Language::EN_EU; + obj[S_MSG_PARAMS]["hmiDisplayLanguageDesired"] = Language::RU_RU; + obj[S_MSG_PARAMS]["appID"] = "APP ID"; + + // Commented not mandatory params for check creation object without them +// obj[S_MSG_PARAMS]["ttsName"][0]["text"] = "ABC"; +// obj[S_MSG_PARAMS]["ttsName"][0]["type"] = +// SpeechCapabilities::SC_TEXT; + +// obj[S_MSG_PARAMS]["vrSynonyms"][0] = "Synonym1"; +// obj[S_MSG_PARAMS]["vrSynonyms"][1] = "Synonym2"; + +// obj[S_MSG_PARAMS]["appType"][0] = AppTypeTest::SYSTEM; // not mandatory +// obj[S_MSG_PARAMS]["appType"][1] = AppTypeTest::MEDIA; + +} + +void CMetaFormatterTestHelper::FillObjectWithoutSomeMandatoryFields( + SmartObject& obj) { + obj[S_PARAMS][S_MESSAGE_TYPE] = MessageTypeTest::request; + obj[S_PARAMS][S_FUNCTION_ID] = FunctionIDTest::RegisterAppInterface; + + obj[S_PARAMS][S_PROTOCOL_VERSION] = 1; + obj[S_PARAMS][S_PROTOCOL_TYPE] = 0; + +// Commented mandatory params for check creation object without them +// obj[S_PARAMS][S_CORRELATION_ID] = 12; +// obj[S_MSG_PARAMS]["syncMsgVersion"]["majorVersion"] = 2; +// obj[S_MSG_PARAMS]["syncMsgVersion"]["minorVersion"] = 10; + + obj[S_MSG_PARAMS]["appName"] = "APP NAME"; + obj[S_MSG_PARAMS]["ttsName"][0]["text"] = "ABC"; + obj[S_MSG_PARAMS]["ttsName"][0]["type"] = SpeechCapabilities::SC_TEXT; + obj[S_MSG_PARAMS]["ngnMediaScreenAppName"] = "SCREEN NAME"; + obj[S_MSG_PARAMS]["vrSynonyms"][0] = "Synonym1"; + obj[S_MSG_PARAMS]["vrSynonyms"][1] = "Synonym2"; + obj[S_MSG_PARAMS]["isMediaApplication"] = true; + obj[S_MSG_PARAMS]["languageDesired"] = Language::EN_EU; + obj[S_MSG_PARAMS]["hmiDisplayLanguageDesired"] = Language::RU_RU; + obj[S_MSG_PARAMS]["appType"][0] = AppTypeTest::SYSTEM; + obj[S_MSG_PARAMS]["appType"][1] = AppTypeTest::MEDIA; + obj[S_MSG_PARAMS]["appID"] = "APP ID"; +} + +//----------------------------------------------------------- + +void CMetaFormatterTestHelper::CompareObjects(const SmartObject& first, + const SmartObject& second) { + + if (SmartType_Array == first.getType()) { + ASSERT_EQ(SmartType_Array, second.getType()); + for (size_t i = 0; i < first.length(); i++) { + CompareObjects(first.getElement(i), second.getElement(i)); + } + } else if (SmartType_Map == first.getType()) { + ASSERT_EQ(SmartType_Map, second.getType()); + std::set < std::string > keys = first.enumerate(); + + for (std::set<std::string>::const_iterator key = keys.begin(); + key != keys.end(); key++) { + CompareObjects(first.getElement(*key), second.getElement(*key)); + } + } else if (SmartType_Boolean == first.getType()) { + ASSERT_EQ(first.asBool(), second.asBool()); + } else if (SmartType_Integer == first.getType()) { + ASSERT_EQ(first.asInt(), second.asInt()); + } else if (SmartType_Double == first.getType()) { + ASSERT_EQ(first.asDouble(), second.asDouble()); + } else if (SmartType_String == first.getType()) { + ASSERT_EQ(first.asString(), second.asString()); + } else if (SmartType_Null == first.getType()) { + ASSERT_EQ(SmartType_Null, second.getType()); + } else { + FAIL()<< "Unknown SmartObject type: " << first.getType(); + } +} + +//----------------------------------------------------------- + +void CMetaFormatterTestHelper::FillObjectWithDefaultValues(SmartObject& obj) { + + obj[S_PARAMS][S_MESSAGE_TYPE] = -1; + obj[S_PARAMS][S_FUNCTION_ID] = -1; + obj[S_PARAMS][S_CORRELATION_ID] = 0; + obj[S_PARAMS][S_PROTOCOL_VERSION] = 0; + obj[S_PARAMS][S_PROTOCOL_TYPE] = 0; + + obj[S_MSG_PARAMS]["syncMsgVersion"]["majorVersion"] = 0; + obj[S_MSG_PARAMS]["syncMsgVersion"]["minorVersion"] = 0; + obj[S_MSG_PARAMS]["appName"] = ""; + obj[S_MSG_PARAMS]["ngnMediaScreenAppName"] = ""; + obj[S_MSG_PARAMS]["isMediaApplication"] = false; + obj[S_MSG_PARAMS]["languageDesired"] = -1; + obj[S_MSG_PARAMS]["hmiDisplayLanguageDesired"] = -1; + obj[S_MSG_PARAMS]["appID"] = ""; + +// Commented params for check creation object with only default values +// obj[S_MSG_PARAMS]["ttsName"][0]["text"] = "ABC"; +// obj[S_MSG_PARAMS]["ttsName"][0]["type"] = +// SpeechCapabilities::SC_TEXT; + +// obj[S_MSG_PARAMS]["vrSynonyms"][0] = "Synonym1"; +// obj[S_MSG_PARAMS]["vrSynonyms"][1] = "Synonym2"; + +// obj[S_MSG_PARAMS]["appType"][0] = AppTypeTest::SYSTEM; +// obj[S_MSG_PARAMS]["appType"][1] = AppTypeTest::MEDIA; + +} + +} // namespace formatters +} // namespace components +} // namespace test |