| /* $Id$ |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to you under the Apache License, Version |
| * 2.0 (the "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <gtest/gtest.h> |
| #include <gmock/gmock.h> |
| #include "serialization/EtchField.h" |
| #include "serialization/EtchStructValue.h" |
| #include "serialization/EtchValueFactory.h" |
| #include "serialization/EtchValidatorBoolean.h" |
| #include "serialization/EtchValidatorByte.h" |
| |
| class MockValueFactory_FULL : public virtual EtchValueFactory { |
| public: |
| |
| ~MockValueFactory_FULL() { |
| |
| } |
| MOCK_METHOD2(getType, status_t(capu::uint32_t id, EtchType*& result)); |
| |
| MOCK_METHOD2(getType, status_t(EtchString &name, EtchType *&result)); |
| |
| MOCK_METHOD1(addType, status_t(EtchType *type)); |
| |
| MOCK_METHOD0(lockDynamicTypes, status_t()); |
| |
| MOCK_METHOD0(unlockDynamicTypes, status_t()); |
| |
| MOCK_METHOD2(getMessageId, status_t(EtchMessage* msg, capu::int64_t &result)); |
| |
| MOCK_METHOD2(setMessageId, status_t(EtchMessage* msg, capu::int64_t msgid)); |
| |
| MOCK_METHOD0(get_mf__messageId, EtchField()); |
| |
| MOCK_METHOD2(getInReplyToMessageId, status_t(EtchMessage* msg, capu::int64_t &result)); |
| |
| MOCK_METHOD2(setInReplyToMessageId, status_t(EtchMessage* msg, capu::int64_t msgid)); |
| |
| MOCK_METHOD0(get_mf__inReplyTo, EtchField()); |
| |
| MOCK_METHOD2(importCustomValue, status_t(EtchStructValue* _struct, capu::SmartPointer<EtchObject> &result)); |
| |
| MOCK_METHOD2(exportCustomValue, status_t(capu::SmartPointer<EtchObject> value, EtchStructValue *&result)); |
| |
| MOCK_METHOD0(get_mt__exception, EtchType*()); |
| |
| MOCK_METHOD2(getCustomStructType, status_t(const EtchObjectType *c, EtchType *& type)); |
| |
| MOCK_METHOD4(getNativeArrayForComponentType, status_t(const EtchObjectType *objectType, capu::SmartPointer<EtchNativeArrayBase> &nativeArray, capu::int32_t length, capu::int32_t dim)); |
| |
| EtchLevel getLevel() { |
| return LEVEL_FULL; |
| } |
| |
| MOCK_METHOD1(setLevel, EtchLevel(EtchLevel level)); |
| |
| }; |
| |
| class MockValueFactory_MISSING_OK : public virtual EtchValueFactory { |
| public: |
| |
| ~MockValueFactory_MISSING_OK() { |
| |
| } |
| MOCK_METHOD2(getType, status_t(capu::uint32_t id, EtchType*& result)); |
| |
| MOCK_METHOD2(getType, status_t(EtchString &name, EtchType *&result)); |
| |
| MOCK_METHOD1(addType, status_t(EtchType* type)); |
| |
| MOCK_METHOD0(lockDynamicTypes, status_t()); |
| |
| MOCK_METHOD0(unlockDynamicTypes, status_t()); |
| |
| MOCK_METHOD2(getMessageId, status_t(EtchMessage* msg, capu::int64_t &result)); |
| |
| MOCK_METHOD2(setMessageId, status_t(EtchMessage* msg, capu::int64_t msgid)); |
| |
| MOCK_METHOD0(get_mf__messageId, EtchField()); |
| |
| MOCK_METHOD2(getInReplyToMessageId, status_t(EtchMessage* msg, capu::int64_t &result)); |
| |
| MOCK_METHOD2(setInReplyToMessageId, status_t(EtchMessage* msg, capu::int64_t msgid)); |
| |
| MOCK_METHOD0(get_mf__inReplyTo, EtchField()); |
| |
| MOCK_METHOD2(importCustomValue, status_t(EtchStructValue* _struct, capu::SmartPointer<EtchObject> &result)); |
| |
| MOCK_METHOD2(exportCustomValue, status_t(capu::SmartPointer<EtchObject> value, EtchStructValue *&result)); |
| |
| MOCK_METHOD0(get_mt__exception, EtchType*()); |
| |
| MOCK_METHOD2(getCustomStructType, status_t(const EtchObjectType *c, EtchType *& type)); |
| |
| MOCK_METHOD4(getNativeArrayForComponentType, status_t(const EtchObjectType *objectType, capu::SmartPointer<EtchNativeArrayBase> &nativeArray, capu::int32_t length, capu::int32_t dim)); |
| |
| EtchLevel getLevel() { |
| return LEVEL_MISSING_OK; |
| } |
| |
| MOCK_METHOD1(setLevel, EtchLevel(EtchLevel level)); |
| |
| }; |
| |
| class MockValueFactory_NONE : public virtual EtchValueFactory { |
| public: |
| |
| ~MockValueFactory_NONE() { |
| |
| } |
| MOCK_METHOD2(getType, status_t(capu::uint32_t id, EtchType*& result)); |
| |
| MOCK_METHOD2(getType, status_t(EtchString &name, EtchType *&result)); |
| |
| MOCK_METHOD1(addType, status_t(EtchType* type)); |
| |
| MOCK_METHOD0(lockDynamicTypes, status_t()); |
| |
| MOCK_METHOD0(unlockDynamicTypes, status_t()); |
| |
| MOCK_METHOD2(getMessageId, status_t(EtchMessage* msg, capu::int64_t &result)); |
| |
| MOCK_METHOD2(setMessageId, status_t(EtchMessage* msg, capu::int64_t msgid)); |
| |
| MOCK_METHOD0(get_mf__messageId, EtchField()); |
| |
| MOCK_METHOD2(getInReplyToMessageId, status_t(EtchMessage* msg, capu::int64_t &result)); |
| |
| MOCK_METHOD2(setInReplyToMessageId, status_t(EtchMessage* msg, capu::int64_t msgid)); |
| |
| MOCK_METHOD0(get_mf__inReplyTo, EtchField()); |
| |
| MOCK_METHOD2(importCustomValue, status_t(EtchStructValue* _struct, capu::SmartPointer<EtchObject> &result)); |
| |
| MOCK_METHOD2(exportCustomValue, status_t(capu::SmartPointer<EtchObject> value, EtchStructValue *&result)); |
| |
| MOCK_METHOD0(get_mt__exception, EtchType*()); |
| |
| MOCK_METHOD2(getCustomStructType, status_t(const EtchObjectType *c, EtchType *& type)); |
| |
| MOCK_METHOD4(getNativeArrayForComponentType, status_t(const EtchObjectType *objectType, capu::SmartPointer<EtchNativeArrayBase> &nativeArray, capu::int32_t length, capu::int32_t dim)); |
| |
| EtchLevel getLevel() { |
| return LEVEL_NONE; |
| } |
| |
| MOCK_METHOD1(setLevel, EtchLevel(EtchLevel level)); |
| |
| }; |
| |
| class EtchStructValueTest
|
| : public ::testing::Test {
|
| protected:
|
| virtual void SetUp() {
|
| mRuntime = new EtchRuntime();
|
| mRuntime->start();
|
| }
|
|
|
| virtual void TearDown() {
|
| mRuntime->shutdown();
|
| delete mRuntime;
|
| mRuntime = NULL;
|
| }
|
| |
| EtchRuntime* mRuntime; |
| }; |
| |
| TEST_F(EtchStructValueTest, createTest) { |
| EtchString fieldtype1("type1"); |
| EtchString fieldtype2("type2"); |
| EtchField field1(fieldtype1); |
| EtchField field2(fieldtype2); |
| EtchString typeName("comp"); |
| //CreateType |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| capu::SmartPointer<EtchValidator> v2; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| EtchValidatorBoolean::Get(mRuntime, 0, v2); |
| |
| comp->putValidator(field1, v1); |
| comp->putValidator(field2, v2); |
| |
| EtchStructValue *ptr = NULL; |
| //Create Value Factory |
| EtchValueFactory* factory = new MockValueFactory_FULL(); |
| ptr = new EtchStructValue(comp, factory); |
| |
| delete ptr; |
| delete factory; |
| delete comp; |
| } |
| |
| TEST_F(EtchStructValueTest, getTypeTest) { |
| EtchString fieldtype1("type1"); |
| EtchString fieldtype2("type2"); |
| EtchField field1(fieldtype1); |
| EtchField field2(fieldtype2); |
| EtchString typeName("comp"); |
| //CreateType |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| capu::SmartPointer<EtchValidator> v2; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| EtchValidatorBoolean::Get(mRuntime, 0, v2); |
| |
| comp->putValidator(field1, v1); |
| comp->putValidator(field2, v2); |
| //Create Value Factory |
| EtchValueFactory* factory = new MockValueFactory_FULL(); |
| EtchStructValue *sv = new EtchStructValue(comp, factory); |
| EXPECT_TRUE(sv->getType()->equals(comp)); |
| delete sv; |
| delete factory; |
| delete comp; |
| } |
| |
| TEST_F(EtchStructValueTest, isType) { |
| //Type 1 |
| EtchString fieldtype1("type1"); |
| EtchString fieldtype2("type2"); |
| EtchField field1(fieldtype1); |
| EtchField field2(fieldtype2); |
| EtchString typeName("comp"); |
| //CreateType |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| capu::SmartPointer<EtchValidator> v2; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| EtchValidatorBoolean::Get(mRuntime, 0, v2); |
| |
| comp->putValidator(field1, v1); |
| comp->putValidator(field2, v2); |
| //Create Value Factory |
| EtchValueFactory* factory = new MockValueFactory_FULL(); |
| //type 2 |
| EtchString typeName2("comp2"); |
| EtchType* comp2 = new EtchType(91, typeName2); |
| |
| EtchStructValue *sv = new EtchStructValue(comp, factory); |
| EXPECT_TRUE(sv->isType(comp)); |
| EXPECT_FALSE(sv->isType(comp2)); |
| delete sv; |
| delete factory; |
| delete comp; |
| delete comp2; |
| } |
| |
| TEST_F(EtchStructValueTest, putTest_FULL) { |
| EtchString fieldtype1("type1"); |
| EtchString fieldtype2("type2"); |
| EtchString fieldtype3("type3"); |
| EtchString typeName("comp"); |
| |
| EtchField field1(fieldtype1); |
| EtchField field2(fieldtype2); |
| EtchField field3(fieldtype3); |
| //Create Value Factory |
| EtchValueFactory* factory = new MockValueFactory_FULL(); |
| //CreateType |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| capu::SmartPointer<EtchValidator> v2; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| EtchValidatorBoolean::Get(mRuntime, 0, v2); |
| |
| comp->putValidator(field1, v1); |
| comp->putValidator(field2, v2); |
| |
| EtchStructValue *sv = new EtchStructValue(comp, factory); |
| |
| capu::SmartPointer<EtchObject> object = new EtchBool(true); |
| capu::SmartPointer<EtchObject> object2 = new EtchBool(false); |
| capu::SmartPointer<EtchObject> object3 = NULL; |
| capu::SmartPointer<EtchObject> object5 = new EtchInt32(32); |
| |
| //check the empty struct value |
| EXPECT_TRUE(sv->count() == 0); |
| //add new element |
| EXPECT_TRUE(sv->put(field1, object) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 1); |
| //add another element |
| EXPECT_TRUE(sv->put(field2, object2) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 2); |
| //add another element with missing validator |
| EXPECT_TRUE(sv->put(field3, object5) == ETCH_ENOT_EXIST); |
| EXPECT_TRUE(sv->count() == 2); |
| //add a null element and expect a remove operation |
| EXPECT_TRUE(sv->put(field1, object3) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 1); |
| |
| delete sv; |
| delete factory; |
| delete comp; |
| } |
| |
| TEST_F(EtchStructValueTest, putTest_MISSING_OK) { |
| EtchString fieldtype1("type1"); |
| EtchString fieldtype2("type2"); |
| EtchString fieldtype3("type3"); |
| EtchString typeName("comp"); |
| |
| EtchField field1(fieldtype1); |
| EtchField field2(fieldtype2); |
| EtchField field3(fieldtype3); |
| //Create Value Factory |
| EtchValueFactory* factory = new MockValueFactory_MISSING_OK(); |
| //CreateType |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| capu::SmartPointer<EtchValidator> v2; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| EtchValidatorBoolean::Get(mRuntime, 0, v2); |
| |
| comp->putValidator(field1, v1); |
| comp->putValidator(field2, v2); |
| |
| EtchStructValue *sv = new EtchStructValue(comp, factory); |
| |
| capu::SmartPointer<EtchObject> object = new EtchBool(true); |
| capu::SmartPointer<EtchObject> object2 = new EtchBool(false); |
| capu::SmartPointer<EtchObject> object3 = NULL; |
| capu::SmartPointer<EtchObject> object5 = new EtchInt32(32); |
| |
| //check the empty struct value |
| EXPECT_TRUE(sv->count() == 0); |
| //add new element |
| EXPECT_TRUE(sv->put(field1, object) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 1); |
| //add another element |
| EXPECT_TRUE(sv->put(field2, object2) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 2); |
| //add another element with missing validator |
| EXPECT_TRUE(sv->put(field3, object5) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 3); |
| //add a null element and expect a remove operation |
| EXPECT_TRUE(sv->put(field1, object3) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 2); |
| |
| delete sv; |
| delete factory; |
| delete comp; |
| } |
| |
| TEST_F(EtchStructValueTest, putTest_NONE) { |
| EtchString fieldtype1("type1"); |
| EtchString fieldtype2("type2"); |
| EtchString fieldtype3("type3"); |
| EtchString typeName("comp"); |
| |
| EtchField field1(fieldtype1); |
| EtchField field2(fieldtype2); |
| EtchField field3(fieldtype3); |
| //Create Value Factory |
| EtchValueFactory* factory = new MockValueFactory_NONE(); |
| //CreateType |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| capu::SmartPointer<EtchValidator> v2; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| EtchValidatorBoolean::Get(mRuntime, 0, v2); |
| |
| comp->putValidator(field1, v1); |
| comp->putValidator(field2, v2); |
| |
| EtchStructValue *sv = new EtchStructValue(comp, factory); |
| |
| capu::SmartPointer<EtchObject> object = new EtchBool(true); |
| capu::SmartPointer<EtchObject> object2 = new EtchBool(false); |
| capu::SmartPointer<EtchObject> object3 = NULL; |
| capu::SmartPointer<EtchObject> object5 = new EtchInt32(32); |
| |
| //check the empty struct value |
| EXPECT_TRUE(sv->count() == 0); |
| //add new element |
| EXPECT_TRUE(sv->put(field1, object) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 1); |
| //add another element |
| EXPECT_TRUE(sv->put(field2, object2) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 2); |
| //add another element with missing validator |
| EXPECT_TRUE(sv->put(field3, object5) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 3); |
| //add a null element and expect a remove operation |
| EXPECT_TRUE(sv->put(field1, object3) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 2); |
| |
| delete sv; |
| delete factory; |
| delete comp; |
| } |
| |
| TEST_F(EtchStructValueTest, getTest) { |
| EtchString fieldtype1("type1"); |
| EtchString fieldtype2("type2"); |
| EtchField field1(fieldtype1); |
| EtchField field2(fieldtype2); |
| EtchString typeName("comp"); |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| capu::SmartPointer<EtchValidator> v2; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| EtchValidatorBoolean::Get(mRuntime, 0, v2); |
| |
| comp->putValidator(field1, v1); |
| comp->putValidator(field2, v2); |
| |
| //Create Value Factory |
| EtchValueFactory* factory = new MockValueFactory_FULL(); |
| //create struct value |
| EtchStructValue *sv = new EtchStructValue(comp, factory); |
| EXPECT_TRUE(0 == sv->count()); |
| |
| //add element |
| capu::SmartPointer<EtchObject> object = new EtchBool(true); |
| EXPECT_TRUE(sv->put(field1, object) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 1); |
| |
| //add another element |
| capu::SmartPointer<EtchObject> object2 = new EtchBool(false); |
| EXPECT_TRUE(sv->put(field1, object2) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 1); |
| |
| //get element |
| EXPECT_TRUE(sv->get(field1, &object) == ETCH_OK); |
| EXPECT_TRUE(((EtchBool*) object.get())->get() == false); |
| |
| delete sv; |
| delete factory; |
| delete comp; |
| } |
| |
| TEST_F(EtchStructValueTest, removeTest) { |
| EtchString fieldtype1("type1"); |
| EtchString typeName("comp"); |
| EtchField field1(fieldtype1); |
| EtchValueFactory* factory = new MockValueFactory_FULL(); |
| |
| EtchType* comp = new EtchType(90, typeName); |
| |
| capu::SmartPointer<EtchValidator> v1; |
| EtchValidatorBoolean::Get(mRuntime, 0, v1); |
| comp->putValidator(field1, v1); |
| |
| EtchStructValue *sv = new EtchStructValue(comp, factory); |
| capu::SmartPointer<EtchObject> object; |
| capu::SmartPointer<EtchObject> object2; |
| //check the empty struct value |
| EXPECT_TRUE(sv->count() == 0); |
| EXPECT_TRUE(sv->get(field1, &object) == ETCH_ENOT_EXIST); |
| |
| //try to delete non existing element |
| EXPECT_TRUE(sv->remove(field1, &object) == ETCH_ERANGE); |
| EXPECT_TRUE(sv->count() == 0); |
| EXPECT_TRUE(sv->get(field1, &object) == ETCH_ENOT_EXIST); |
| |
| //add element |
| capu::SmartPointer<EtchObject> boolean = new EtchBool(true); |
| sv->put(field1, boolean); |
| EXPECT_TRUE(sv->count() == 1); |
| EXPECT_TRUE(sv->get(field1, &object) == ETCH_OK); |
| capu::SmartPointer<EtchBool> smBoolean = capu::smartpointer_cast<EtchBool>(object); |
| EXPECT_TRUE(smBoolean->get() == true); |
| |
| //delete element |
| EXPECT_TRUE(sv->remove(field1, &object2) == ETCH_OK); |
| EXPECT_TRUE(sv->count() == 0); |
| EXPECT_TRUE(sv->get(field1, &object2) == ETCH_ENOT_EXIST); |
| //try to delete non existing element |
| EXPECT_TRUE(sv->remove(field1, &object2) == ETCH_ERANGE); |
| EXPECT_TRUE(sv->count() == 0); |
| EXPECT_TRUE(sv->get(field1, &object2) == ETCH_ENOT_EXIST); |
| delete sv; |
| delete comp; |
| delete factory; |
| } |
| |
| TEST_F(EtchStructValueTest, isInstanceOf) { |
| EtchString typeName("comp"); |
| EtchType* comp = new EtchType(90, typeName); |
| EtchValueFactory* factory = new MockValueFactory_FULL(); |
| EtchObject* o1 = new EtchStructValue(comp, factory); |
| EXPECT_TRUE(o1->isInstanceOf(EtchObject::TYPE())); |
| EXPECT_TRUE(o1->isInstanceOf(EtchStructValue::TYPE())); |
| EXPECT_FALSE(o1->isInstanceOf(EtchInt32::TYPE())); |
| delete o1; |
| delete comp; |
| delete factory; |
| } |