diff options
Diffstat (limited to 'src/usr/targeting/test/testAttribute.H')
| -rw-r--r-- | src/usr/targeting/test/testAttribute.H | 1271 |
1 files changed, 1271 insertions, 0 deletions
diff --git a/src/usr/targeting/test/testAttribute.H b/src/usr/targeting/test/testAttribute.H new file mode 100644 index 000000000..8014f1397 --- /dev/null +++ b/src/usr/targeting/test/testAttribute.H @@ -0,0 +1,1271 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: src/usr/targeting/test/testAttribute.H $ */ +/* */ +/* OpenPOWER HostBoot Project */ +/* */ +/* Contributors Listed Below - COPYRIGHT 2011,2019 */ +/* [+] International Business Machines Corp. */ +/* */ +/* */ +/* Licensed 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. */ +/* */ +/* IBM_PROLOG_END_TAG */ + +#ifndef __TEST_ATTRIBUTE_H +#define __TEST_ATTRIBUTE_H + +/** + * @file targeting/test/testAttribute.H + * + * @brief Unit test for TARGETING::AttributeTank::Attribute + */ + +//****************************************************************************** +// Includes +//****************************************************************************** + +// CXX TEST +#include <cxxtest/TestSuite.H> + +#include <targeting/common/attributeTank.H> + +using namespace TARGETING; + +class AttributeTest: public CxxTest::TestSuite +{ +public: + /** + * @test Tests the setters and getter methods + */ + void testSimpleSettersAndGetters(void); + + /** + * @test Test setting the Attribute Value + */ + void testSettingAndGettingValue(void); + + /** + * @test Test Serialize and Deserialize methods + */ + void testSerializeAndDeserializeMethod(void); + + /** + * @test Test the Operator Equal method + */ + void testOperatorEqual(void); + + /** + * @test Test the Copy Constructor Method + */ + void testCopyConstructor(void); + + private: + + /** + * @test Compare the Attribute Header for the two given attributes + * + * @param[in] l_attribute1 Attribute to compare with + * @param[in] l_attribute2 Attribute to compare with + * + * @return true if Attribute Header's match, false otherwise + */ + bool compareAttributeHeader( + const AttributeTank::Attribute* const l_attribute1, + const AttributeTank::Attribute* const l_attribute2); + + /** + * @test Compare the Attribute Values for the two given attributes + * + * @param[in] l_attribute1 Attribute to compare with + * @param[in] l_attribute2 Attribute to compare with + * + * @return true if Attribute Values` match, false otherwise + */ + bool compareAttributeValues( + const AttributeTank::Attribute* const l_attribute1, + const AttributeTank::Attribute* const l_attribute2); +}; // end class AttributeTest + + +// testSimpleSettersAndGetters +void AttributeTest::testSimpleSettersAndGetters(void) +{ + TRACFCOMP( g_trac_test, ENTER_MRK "testSimpleSettersAndGetters" ); + + // Test stats + uint8_t l_numTests(0); + uint8_t l_numFails(0); + + // Create an Attribute to test against + TARGETING::AttributeTank::Attribute l_attribute; + + // Get a reference to the Attribute Header to test that + // what is returned is truly a reference and not a copy + const TARGETING::AttributeTank::AttributeHeader &l_attributeHeader = + l_attribute.getHeader(); + + // Test setting/getting the Attribute ID + ++l_numTests; + l_attribute.setId(0x1001); + if (0x1001 != l_attribute.getHeader().iv_attrId) + { + TS_FAIL("testSimpleSettersAndGetters: Test 1 - " + "set/get Attribute ID failed; " + "expected 0x1001 but got back 0x%X", + l_attribute.getHeader().iv_attrId); + ++l_numFails; + } + + ++l_numTests; + if (0x1001 != l_attributeHeader.iv_attrId) + { + TS_FAIL("testSimpleSettersAndGetters: Test 2 - get Attribute ID " + "via Attribute Header reference failed; " + "expected 0x1001 but got back 0x%X", + l_attributeHeader.iv_attrId); + ++l_numFails; + } + + // Test setting/getting the Attribute Target Type + ++l_numTests; + l_attribute.setTargetType(0x2002); + if (0x2002 != l_attribute.getHeader().iv_targetType) + { + TS_FAIL("testSimpleSettersAndGetters: Test 3 - " + "set/get Attribute Target Type failed; " + "expected 0x2002 but got back 0x%X", + l_attribute.getHeader().iv_targetType); + ++l_numFails; + } + + ++l_numTests; + if (0x2002 != l_attributeHeader.iv_targetType) + { + TS_FAIL("testSimpleSettersAndGetters: Test 4 - get Attribute " + "Target Type via Attribute Header reference failed; " + "expected 0x2002 but got back 0x%X", + l_attributeHeader.iv_targetType); + ++l_numFails; + } + + // Test setting/getting the Attribute Position + ++l_numTests; + l_attribute.setPosition(0x3003); + if (0x3003 != l_attribute.getHeader().iv_pos) + { + TS_FAIL("testSimpleSettersAndGetters: Test 5 - " + "set/get Attribute Position failed; " + "expected 0x3003 but got back 0x%X", + l_attribute.getHeader().iv_pos); + ++l_numFails; + } + + ++l_numTests; + if (0x3003 != l_attributeHeader.iv_pos) + { + TS_FAIL("testSimpleSettersAndGetters: Test 6 - get Attribute Position " + "via Attribute Header reference failed; " + "expected 0x3003 but got back 0x%X", + l_attributeHeader.iv_pos); + ++l_numFails; + } + + // Test setting/getting the Attribute Unit Position + ++l_numTests; + l_attribute.setUnitPosition(0x4); + if (0x4 != l_attribute.getHeader().iv_unitPos) + { + TS_FAIL("testSimpleSettersAndGetters: Test 7 - " + "set/get Attribute Unit Position failed; " + "expected 0x4 but got back 0x%X", + l_attribute.getHeader().iv_unitPos); + ++l_numFails; + } + + ++l_numTests; + if (0x4 != l_attributeHeader.iv_unitPos) + { + TS_FAIL("testSimpleSettersAndGetters: Test 8 - " + "get Attribute Unit Position via Attribute Header reference " + "failed; expected 0x4 but got back 0x%X", + l_attributeHeader.iv_unitPos); + ++l_numFails; + } + + // Test setting/getting the Attribute Node + ++l_numTests; + l_attribute.setNode(0x5); + if (0x5 != l_attribute.getHeader().iv_node) + { + TS_FAIL("testSimpleSettersAndGetters: Test 9 - " + "set/get Attribute Node failed; " + "expected 0x5 but got back 0x%X", + l_attribute.getHeader().iv_node); + ++l_numFails; + } + + ++l_numTests; + if (0x5 != l_attributeHeader.iv_node) + { + TS_FAIL("testSimpleSettersAndGetters: Test 10 - get Attribute Node " + "via Attribute Header reference failed; " + "expected 0x5 but got back 0x%X", + l_attributeHeader.iv_node); + ++l_numFails; + } + + // Test setting/getting the Attribute Flags + ++l_numTests; + l_attribute.setFlags(0x6); + if (0x6 != l_attribute.getHeader().iv_flags) + { + TS_FAIL("testSimpleSettersAndGetters: Test 11 - " + "set/get Attribute Flags failed; " + "expected 0x6 but got back 0x%X", + l_attribute.getHeader().iv_flags); + ++l_numFails; + } + + ++l_numTests; + if (0x6 != l_attributeHeader.iv_flags) + { + TS_FAIL("testSimpleSettersAndGetters: Test 12 - get Attribute Flags " + "via Attribute Header reference failed; " + "expected 0x6 but got back 0x%X", + l_attributeHeader.iv_flags); + ++l_numFails; + } + + TRACFCOMP( g_trac_test, EXIT_MRK "testSimpleSettersAndGetters " + "num tests = %d / num fails = %d", l_numTests, l_numFails); +} // end testSimpleSettersAndGetters + + +// testSettingAndGettingValue +void AttributeTest::testSettingAndGettingValue(void) +{ + TRACFCOMP( g_trac_test, ENTER_MRK "testSettingAndGettingValue" ); + + // Test stats + uint8_t l_numTests(0); + uint8_t l_numFails(0); + + // Create an Attribute to test with + TARGETING::AttributeTank::Attribute l_attribute; + + /// Test getting Size of the Attribute when no Value exists/has been set + ++l_numTests; + if (l_attribute.getSize() != + sizeof(TARGETING::AttributeTank::AttributeHeader)) + { + TS_FAIL("testSettingAndGettingValue: Test 1 - " + "get Attribute Size failed, when no value set; " + "expected size %d but got back size %d", + sizeof(TARGETING::AttributeTank::AttributeHeader), + l_attribute.getSize()); + ++l_numFails; + } + + /// Test cloning the value when no Value exists/has been set + // First create a buffer + uint32_t l_bufferSize = 3; + uint8_t l_buffer[l_bufferSize] = { 0 }; + uint8_t l_compareBuffer[l_bufferSize] = { 0 }; + + uint32_t l_returnedSize = l_attribute.cloneValue(l_buffer, l_bufferSize); + // Make sure 0 is returned + ++l_numTests; + if (0 != l_returnedSize) + { + TS_FAIL("testSettingAndGettingValue: Test 2 - " + "Attribute clone value failed, with buffer size 0; " + "expected size 0 but got back size %d", + l_returnedSize); + ++l_numFails; + } + + // Make sure cloned data is correct + ++l_numTests; + if (0 != memcmp(l_buffer, l_compareBuffer, l_bufferSize)) + { + TS_FAIL("testSettingAndGettingValue: Test 3 - " + "Attribute clone value failed, with buffer size 0; " + "incorrect data returned"); + ++l_numFails; + } + + /// Test clearing the Value + l_returnedSize = l_attribute.setValue(nullptr, 0); + // Make sure 0 is returned + ++l_numTests; + if (0 != l_returnedSize) + { + TS_FAIL("testSettingAndGettingValue: Test 4 - " + "returned Attribute Size failed, sent a value of size 0; " + "expected size 0 but got back size %d", + l_returnedSize); + ++l_numFails; + } + + // Make sure size is only the Attribute Header size + ++l_numTests; + if (l_attribute.getSize() != + sizeof(TARGETING::AttributeTank::AttributeHeader)) + { + TS_FAIL("testSettingAndGettingValue: Test 5 - " + "get Attribute Size failed, sent a value of size 0; " + "expected size %d but got back size %d", + sizeof(TARGETING::AttributeTank::AttributeHeader), + l_attribute.getSize()); + ++l_numFails; + } + + // Make sure value is NULL + ++l_numTests; + if (nullptr != l_attribute.getValue()) + { + TS_FAIL("testSettingAndGettingValue: Test 6 - " + "get Attribute Value failed, sent a value of size 0; " + "expected nullptr but got back %p", + l_attribute.getValue()); + ++l_numFails; + } + + /// Send in buffer with smaller size than actual size of buffer + // Add data o the buffer + l_buffer[0] = 0xAA; + l_buffer[1] = 0xBB; + l_buffer[2] = 0xCC; + + // Set the Attribute Value to the buffer's first element + l_returnedSize = l_attribute.setValue(l_buffer, 1); + // Make sure only 1 is returned + ++l_numTests; + if (1 != l_returnedSize) + { + TS_FAIL("testSettingAndGettingValue: Test 7 - " + "returned Attribute Size failed, sent a value of size 1; " + "expected size 1 but got back size %d", + l_returnedSize); + ++l_numFails; + } + + // Make sure Attribute Value size is size of Attribute Header plus one + ++l_numTests; + if (l_attribute.getSize() != + (sizeof(TARGETING::AttributeTank::AttributeHeader) + 1)) + { + TS_FAIL("testSettingAndGettingValue: Test 8 - " + "get Attribute Size failed, sent a Value of size 1 " + "expected size %d but got back size %d", + sizeof(TARGETING::AttributeTank::AttributeHeader) + 1, + l_attribute.getSize()); + ++l_numFails; + } + + // Get a handle to the Value to do some testing on it + const uint8_t* const l_value = + reinterpret_cast<const uint8_t* const>(l_attribute.getValue()); + + // Make sure Value is not NULL + ++l_numTests; + if (nullptr == l_value) + { + TS_FAIL("testSettingAndGettingValue: Test 9 - " + "get Attribute Value failed; " + "expected a non-null pointer but got back a null pointer"); + ++l_numFails; + } + + // Make sure the first value is what we expect + ++l_numTests; + if (l_value[0] != 0xAA) + { + TS_FAIL("testSettingAndGettingValue: Test 10 - " + "Accessing first value in Attribute Value failed; " + "expected 0xAA but got back 0x%X", + l_value[0]); + ++l_numFails; + } + + // Test cloning with Attribute + uint8_t l_clonedBuffer[l_bufferSize] = { 0 }; + memset(l_compareBuffer, 0, l_bufferSize); + l_compareBuffer[0] = 0xAA; + l_returnedSize = l_attribute.cloneValue(l_clonedBuffer, l_bufferSize); + // Make sure 1 is returned + ++l_numTests; + if (1 != l_returnedSize) + { + TS_FAIL("testSettingAndGettingValue: Test 11 - " + "Attribute clone value failed, with buffer size 1; " + "expected size 1 but got back size %d", + l_returnedSize); + ++l_numFails; + } + + // Make sure the cloned data is correct + ++l_numTests; + if (0 != memcmp(l_clonedBuffer, l_compareBuffer, l_bufferSize)) + { + TS_FAIL("testSettingAndGettingValue: Test 12 - " + "Attribute clone value failed, with buffer size 1; " + "incorrect data returned"); + ++l_numFails; + } + + /// Send in buffer with actual size of said buffer + // First set the buffer's values + l_buffer[0] = 0xDD; + l_buffer[1] = 0xEE; + l_buffer[2] = 0xFF; + l_returnedSize = l_attribute.setValue(l_buffer, l_bufferSize); + + // Make sure buffer size is returned correctly + ++l_numTests; + if (l_bufferSize != l_returnedSize) + { + TS_FAIL("testSettingAndGettingValue: Test 13 - " + "returned Attribute Size failed, sent a buffer of size %d; " + "expected size %d but got back size %d", + l_bufferSize, + l_bufferSize, + l_returnedSize); + ++l_numFails; + } + + // Make sure Attribute Value size is size of Attribute Header + // plus buffer size + ++l_numTests; + if (l_attribute.getSize() != + (sizeof(TARGETING::AttributeTank::AttributeHeader) + l_bufferSize)) + { + TS_FAIL("testSettingAndGettingValue: Test 14 - " + "get Attribute Size failed, sent a buffer of size %d; " + "expected size %d but got back size %d", + l_bufferSize, + sizeof(TARGETING::AttributeTank::AttributeHeader) + l_bufferSize, + l_attribute.getSize()); + ++l_numFails; + } + + // Get a handle to the Value to do some testing on it + const uint8_t* const l_value2 = + reinterpret_cast<const uint8_t* const>(l_attribute.getValue()); + + // Make sure Value is not NULL + ++l_numTests; + if (nullptr == l_value2) + { + TS_FAIL("testSettingAndGettingValue: Test 15 - " + "get Attribute Value failed, sent a buffer of size %d " + "expected a non-null pointer but got back a null pointer", + l_bufferSize); + ++l_numFails; + } + + // Make sure the first value is what we expect + ++l_numTests; + if (l_value2[0] != 0xDD) + { + TS_FAIL("testSettingAndGettingValue: Test 16 - " + "Accessing first value in Attribute Value failed, " + "for a Value of size %d; " + "expected 0xDD but got back 0x%X", + l_bufferSize, + l_value2[0]); + ++l_numFails; + } + + // Make sure the second value is what we expect + ++l_numTests; + if (l_value2[1] != 0xEE) + { + TS_FAIL("testSettingAndGettingValue: Test 17 - " + "Accessing second value in Attribute Value failed, " + "for a Value of size %d; " + "expected 0xEE but got back 0x%X", + l_bufferSize, + l_value2[1]); + ++l_numFails; + } + + // Make sure the third value is what we expect + ++l_numTests; + if (l_value2[2] != 0xFF) + { + TS_FAIL("testSettingAndGettingValue: Test 18 - " + "Accessing third value in Attribute Value failed, " + "for a Value of size %d; " + "expected 0xFF but got back 0x%X", + l_bufferSize, + l_value2[2]); + ++l_numFails; + } + + /// Make sure previously cloned data is an actually cloned and not + /// a copy + ++l_numTests; + if (0 != memcmp(l_clonedBuffer, l_compareBuffer, l_bufferSize)) + { + TS_FAIL("testSettingAndGettingValue: Test 19 - " + "Attribute clone value failed, with buffer size 1; " + "data not cloned but is a reference a pointer"); + ++l_numFails; + } + + l_returnedSize = l_attribute.cloneValue(l_clonedBuffer, l_bufferSize); + // Make sure 3 is returned + ++l_numTests; + if (3 != l_returnedSize) + { + TS_FAIL("testSettingAndGettingValue: Test 20 - " + "returned Attribute clone value failed, with buffer size 3; " + "expected size 3 but got back size %d", + l_returnedSize); + ++l_numFails; + } + + /// Make sure previously cloned data is correct + ++l_numTests; + if (0 != memcmp(l_clonedBuffer, l_buffer, l_bufferSize)) + { + TS_FAIL("testSettingAndGettingValue: Test 21 - " + "Attribute clone value failed, with buffer size 3 ; " + "incorrect data returned"); + ++l_numFails; + } + + TRACFCOMP( g_trac_test, EXIT_MRK "testSettingAndGettingValue " + "num tests = %d / num fails = %d", l_numTests, l_numFails); +} // end AttributeTest::testSettingAndGettingValue + + +// testSerializeAndDeserializeMethod +void AttributeTest::testSerializeAndDeserializeMethod(void) +{ + TRACFCOMP( g_trac_test, ENTER_MRK "testSerializeAndDeserializeMethod" ); + + // Test stats + uint8_t l_numTests(0); + uint8_t l_numFails(0); + + // Create an Attribute to test with + AttributeTank::Attribute l_attribute; + // Get a copy of the Attribute Size for later purposes + uint32_t l_attributeSize(l_attribute.getSize()); + + /// Test serializing when attribute has no data at all + { + // Create a buffer to hold serialized data + uint8_t* l_serializedData = new uint8_t[l_attributeSize]; + // Get the serialized data + uint32_t l_returnedSize = l_attribute.serialize(l_serializedData, + l_attributeSize); + + // Make sure serialized data is the size expected + ++l_numTests; + if (l_returnedSize != l_attributeSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 1 - " + "Attribute Serialize failed, with a 0 size Data Value; " + "expected size %d but got back size %d", + l_attributeSize, + l_returnedSize); + ++l_numFails; + } + + // Make sure the serialized Attribute Header + // matches original Attribute Header + // Get a handle to Attribute Header + AttributeTank::Attribute* l_attribute2 = + reinterpret_cast<AttributeTank::Attribute*>(l_serializedData); + const AttributeTank::AttributeHeader & l_attributeHeader2 = + l_attribute2->getHeader(); + + // Compare the two different Attribute Header for a match + ++l_numTests; + if (!compareAttributeHeader(l_attribute2, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 2 - " + "Attribute Serialize failed, with a 0 size Data Value; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure that the size of the Attribute Values is zero + ++l_numTests; + if (0 != l_attributeHeader2.iv_valSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 3 - " + "Attribute Serialize failed, with a 0 size Data Value; " + "Expected 0 size Data Value but %d was returned", + l_attributeHeader2.iv_valSize); + ++l_numFails; + } + + // Test deserialize + { + AttributeTank::Attribute l_attribute3; + uint32_t l_returnedSize2 = + l_attribute3.deserialize(l_serializedData, l_returnedSize); + + // Make sure data size copied is correct + ++l_numTests; + if (l_returnedSize2 != l_returnedSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 4 - " + "Attribute Deserialize failed, with a 0 size Data Value; " + "expected size %d but got back size %d", + l_returnedSize, + l_returnedSize2); + ++l_numFails; + } + + // Make sure the Attribute Header matches original data + ++l_numTests; + if (!compareAttributeHeader(&l_attribute3, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 5 - " + "Attribute deserialize failed, with a 0 size Data Value; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Test when buffer is too small + ++l_numTests; + AttributeTank::Attribute l_attribute4; + l_returnedSize2 = l_attribute4.deserialize(l_serializedData, + l_returnedSize - 1); + if (0 != l_returnedSize2) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 6 - " + "Attribute Deserialize failed, with too small of buffer;" + "expected size 0 but got back size %d", + l_returnedSize2); + ++l_numFails; + } + } + // Cleanup memory used for this test + delete []l_serializedData; + l_serializedData = nullptr; + } + + /// Test serializing when Attribute has Attribute Header data + /// and no Attribute Values + // Set some values for the Attribute Header + l_attribute.setId(0x1001); + l_attribute.setTargetType(0x2002); + l_attribute.setPosition(0x3003); + l_attribute.setUnitPosition(0x4); + l_attribute.setNode(0x5); + l_attribute.setFlags(0x6); + { + // Create a buffer to hold serialized data + uint8_t* l_serializedData = new uint8_t[l_attributeSize]; + // Get the serialized data + uint32_t l_returnedSize = l_attribute.serialize(l_serializedData, + l_attributeSize); + + // Make sure serialized data is the size expected + ++l_numTests; + if (l_returnedSize != l_attributeSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 7 - " + "Attribute Serialize failed, with valid Attribute " + "Header data and no Data Value;" + "expected size %d but got back size %d", + l_attributeSize, + l_returnedSize); + ++l_numFails; + } + + // Make sure the serialized Attribute Header + // matches original Attribute Header + // Get a handle to Attribute Header + AttributeTank::Attribute* l_attribute2 = + reinterpret_cast<AttributeTank::Attribute*>(l_serializedData); + const AttributeTank::AttributeHeader & l_attributeHeader2 = + l_attribute2->getHeader(); + // Compare the two different Attribute Header for a match + ++l_numTests; + if (!compareAttributeHeader(l_attribute2, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 8 - " + "Attribute Serialize failed, with valid Attribute " + "Header data and no Data Value;" + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure that the size of the Attribute Values is zero + ++l_numTests; + if (0 != l_attributeHeader2.iv_valSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 9 - " + "Attribute Serialize failed, with valid Attribute " + "Header data and no Data Value;" + "Expected 0 size Data Value but %d was returned", + l_attributeHeader2.iv_valSize); + ++l_numFails; + } + + // Test deserialize + { + AttributeTank::Attribute l_attribute3; + uint32_t l_returnedSize2 = + l_attribute3.deserialize(l_serializedData, l_returnedSize); + + // Make sure data size copied is correct + ++l_numTests; + if (l_returnedSize2 != l_returnedSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 10 - " + "Attribute Deserialize failed, with valid Attribute " + "Header data and no Data Value;" + "expected size %d but got back size %d", + l_returnedSize, + l_returnedSize2); + ++l_numFails; + } + + // Make sure the Attribute Header matches original data + ++l_numTests; + if (!compareAttributeHeader(&l_attribute3, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 11 - " + "Attribute Deserialize failed, with valid Attribute " + "Header data and no Data Value;" + "incorrect Attribute Header data returned"); + ++l_numFails; + } + } + + // Cleanup memory used for this test + delete []l_serializedData; + l_serializedData = nullptr; + } + + /// Test serializing when Attribute has Attribute Header data + /// and a single Attribute Value + // Give the Attribute a single Attribute Value + uint8_t l_dataBuffer[1] = { 0 }; + l_dataBuffer[0] = 0x44; + l_attribute.setValue(l_dataBuffer, 1); + l_attributeSize = l_attribute.getSize(); + { + // Create a buffer to hold serialized data + uint8_t* l_serializedData = new uint8_t[l_attributeSize]; + // Get the serialized data + uint32_t l_returnedSize = l_attribute.serialize(l_serializedData, + l_attributeSize); + + // Make sure serialized data is the size expected + ++l_numTests; + if (l_returnedSize != l_attributeSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 12 - " + "Attribute Serialize failed, with a size 1 Data Value; " + "expected size %d but got back size %d", + l_attributeSize, + l_returnedSize); + ++l_numFails; + } + + // Make sure the serialized Attribute Header + // matches original Attribute Header + // Get a handle to Attribute Header + AttributeTank::Attribute* l_attribute2 = + reinterpret_cast<AttributeTank::Attribute*>(l_serializedData); + const AttributeTank::AttributeHeader & l_attributeHeader2 = + l_attribute2->getHeader(); + // Compare the two different Attribute Header for a match + ++l_numTests; + if (!compareAttributeHeader(l_attribute2, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 13 - " + "Attribute Serialize failed, with a size 1 Data Value; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure that the size of the Attribute Values is 1 + ++l_numTests; + if (1 != l_attributeHeader2.iv_valSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 14 - " + "Attribute Serialize failed, with a size 1 Data Value; " + "Expected 1 size Data Value but %d was returned", + l_attributeHeader2.iv_valSize); + ++l_numFails; + } + + // Point to the Attribute Values + l_serializedData += sizeof(AttributeTank::AttributeHeader); + + // Compare the two different Attribute Value + ++l_numTests; + if (0 != memcmp(l_serializedData, &l_dataBuffer, 1)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 15 - " + "Attribute Serialize failed, with a size 1 Data Value; " + "incorrect Attribute Data Value returned"); + ++l_numFails; + } + + // Reset the Serialized Data for next test + l_serializedData -= sizeof(AttributeTank::AttributeHeader); + + // Test deserialize + { + AttributeTank::Attribute l_attribute3; + uint32_t l_returnedSize2 = + l_attribute3.deserialize(l_serializedData, l_returnedSize); + // Make sure data size copied is correct + ++l_numTests; + if (l_returnedSize2 != l_returnedSize) + { + + TS_FAIL("testSerializeAndDeserializeMethod: Test 16 - " + "Attribute Deserialize failed, with a size 1 Data Value; " + "expected size %d but got back size %d", + l_returnedSize, + l_returnedSize2); + ++l_numFails; + } + + // Make sure the Attribute Header matches original data + ++l_numTests; + if (!compareAttributeHeader(&l_attribute3, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 17 - " + "Attribute deserialize failed, with a size 1 Data Value; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Test when buffer is too small + AttributeTank::Attribute l_attribute4; + l_returnedSize2 = l_attribute4.deserialize(l_serializedData, + l_returnedSize - 1); + + // Make sure returned size is 0 + ++l_numTests; + if (0 != l_returnedSize2) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 18 - " + "Attribute Deserialize failed, with too small of buffer " + "for 1 data value; expected size 0 but got back size %d", + l_returnedSize2); + ++l_numFails; + } + } + + // Cleanup memory used for this test + delete []l_serializedData; + l_serializedData = nullptr; + } + + /// Test serializing when Attribute has Attribute Header data + /// and a several Attribute Values + // Give the Attribute several Attribute Values + uint32_t l_bufferSize(3); + uint8_t l_dataBuffer2[l_bufferSize] = { 0 }; + l_dataBuffer2[0] = 0x55; + l_dataBuffer2[1] = 0x66; + l_dataBuffer2[2] = 0x77; + l_attribute.setValue(l_dataBuffer2, l_bufferSize); + l_attributeSize = l_attribute.getSize(); + { + // Create a buffer to hold serialized data + uint8_t* l_serializedData = new uint8_t[l_attributeSize]; + // Get the serialized data + uint32_t l_returnedSize = l_attribute.serialize(l_serializedData, + l_attributeSize); + + // Make sure serialized data is the size expected + ++l_numTests; + if (l_returnedSize != l_attributeSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 19 - " + "Attribute Serialize failed, with a size 3 Data Value; " + "expected size %d but got back size %d", + l_attributeSize, + l_returnedSize); + ++l_numFails; + } + + // Make sure the serialized Attribute Header + // matches original Attribute Header + // Get a handle to Attribute Header + AttributeTank::Attribute* l_attribute2 = + reinterpret_cast<AttributeTank::Attribute*>(l_serializedData); + + // Compare the two different Attribute Header for a match + ++l_numTests; + if (!compareAttributeHeader(l_attribute2, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 20 - " + "Attribute Serialize failed, with a size 3 Data Value; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure that the size of the Attribute Values is 3 + ++l_numTests; + if (l_bufferSize != l_attribute2->getHeader().iv_valSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 21 - " + "Attribute Serialize failed, with a size 3 Data Value; " + "Expected %d size Data Value but %d was returned", + l_bufferSize, + l_attribute2->getHeader().iv_valSize); + + ++l_numFails; + } + + // Point to the Attribute Values + l_serializedData += sizeof(AttributeTank::AttributeHeader); + + + // Compare the two different Attribute Value + ++l_numTests; + if (0 != memcmp(l_serializedData, &l_dataBuffer2, l_bufferSize)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 22 - " + "Attribute Serialize failed, with a size 3 Data Value; " + "incorrect Attribute Data Values returned"); + ++l_numFails; + } + + // Reset the Serialized Data for next test + l_serializedData -= sizeof(AttributeTank::AttributeHeader); + + // Test deserialize + { + AttributeTank::Attribute l_attribute3; + uint32_t l_returnedSize2 = + l_attribute3.deserialize(l_serializedData, l_returnedSize); + + // Make sure data size copied is correct + ++l_numTests; + if (l_returnedSize2 != l_returnedSize) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 23 - " + "Attribute Deserialize failed, with a size 3 Data Value; " + "expected size %d but got back size %d", + l_returnedSize, + l_returnedSize2); + ++l_numFails; + } + + // Make sure the Attribute Header matches original data + ++l_numTests; + if (!compareAttributeHeader(&l_attribute3, &l_attribute)) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 24 - " + "Attribute Deserialize failed, with a size 3 Data Value; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Test when buffer is too small + AttributeTank::Attribute l_attribute4; + l_returnedSize2 = l_attribute4.deserialize(l_serializedData, + l_returnedSize - 1); + + // Make sure returned size is 0 + ++l_numTests; + if (0 != l_returnedSize2) + { + TS_FAIL("testSerializeAndDeserializeMethod: Test 25 - " + "Attribute Deserialize failed, with too small of buffer " + "for 3 data values; expected size 0 but got back size %d", + l_returnedSize2); + ++l_numFails; + } + } + + // Cleanup memory used for this test + delete []l_serializedData; + l_serializedData = nullptr; + } + + TRACFCOMP( g_trac_test, EXIT_MRK "testSerializeAndDeserializeMethod " + "num tests = %d / num fails = %d", l_numTests, l_numFails); +} // end AttributeTest::testSerializeAndDeserializeMethod + +// testOperatorEqual +void AttributeTest::testOperatorEqual(void) +{ + TRACFCOMP( g_trac_test, ENTER_MRK "testOperatorEqual" ); + + // Test stats + uint8_t l_numTests(0); + uint8_t l_numFails(0); + + // Create an Attribute to test against + AttributeTank::Attribute l_attribute1; + + // Test with an empty attribute + AttributeTank::Attribute l_attribute2; + // Invoke Operator Equal + l_attribute2 = l_attribute1; + + // Make sure the Attribute Header match + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute2)) + { + TS_FAIL("testOperatorEqual: Test 1 - " + "Attribute Operator = failed, with default values; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Modify the data + l_attribute1.setId(0x1001); + l_attribute1.setTargetType(0x2002); + l_attribute1.setPosition(0x3003); + l_attribute1.setUnitPosition(0x4); + l_attribute1.setNode(0x5); + l_attribute1.setFlags(0x6); + + // Test with modified data + AttributeTank::Attribute l_attribute3; + // Invoke Operator Equal + l_attribute3 = l_attribute1; + + // Make sure the Attribute Header match + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute3)) + { + TS_FAIL("testOperatorEqual: Test 2 - " + "Attribute Operator = failed, with modifed values; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Add attribute values + uint32_t l_bufferSize(3); + uint8_t l_buffer[l_bufferSize]; + l_buffer[0] = 0x66; + l_buffer[0] = 0x77; + l_buffer[0] = 0x88; + l_attribute1.setValue(l_buffer, l_bufferSize); + + // Test with modified data + AttributeTank::Attribute l_attribute4; + // Invoke Operator Equal + l_attribute4 = l_attribute1; + + // Make sure the Attribute Header match + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testOperatorEqual: Test 3 - " + "Attribute Operator = failed, with data values; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure the Attribute Values match + ++l_numTests; + if (!compareAttributeValues(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testOperatorEqual: Test 4 - " + "Attribute Operator = failed, with data values; " + "incorrect Attribute Values data returned"); + ++l_numFails; + } + + // Update the Attribute Values and test again + l_buffer[0] = 0x22; + l_buffer[0] = 0x33; + l_buffer[0] = 0x55; + l_attribute1.setValue(l_buffer, l_bufferSize); + + // Make sure the Attribute Header match original data + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testOperatorEqual: Test 5 - " + "Attribute Operator = failed, with data values updated; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure the Attribute Values DO NOT match + ++l_numTests; + if (compareAttributeValues(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testOperatorEqual: Test 6 - " + "Attribute Operator = failed, with data values updated; " + "incorrect Attribute Values data returned"); + ++l_numFails; + } + + TRACFCOMP( g_trac_test, EXIT_MRK "testOperatorEqual " + "num tests = %d / num fails = %d", l_numTests, l_numFails); +} // end testOperatorEqual + +// testCopyConstructor +void AttributeTest::testCopyConstructor(void) +{ + TRACFCOMP( g_trac_test, ENTER_MRK "testCopyConstructor" ); + + // Test stats + uint8_t l_numTests(0); + uint8_t l_numFails(0); + + // Create an Attribute to test against + AttributeTank::Attribute l_attribute1; + + l_attribute1.setId(0x1001); + l_attribute1.setFlags(0x5); + + // Test with an empty attribute, invoke copy constructor + AttributeTank::Attribute l_attribute2 = l_attribute1; + + // Make sure the Attribute Header match + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute2)) + { + TS_FAIL("testCopyConstructor: Test 1 - " + "Attribute Copy Ctor failed, with default values; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Modify the data + l_attribute1.setId(0x1001); + l_attribute1.setTargetType(0x2002); + l_attribute1.setPosition(0x3003); + l_attribute1.setUnitPosition(0x4); + l_attribute1.setNode(0x5); + l_attribute1.setFlags(0x6); + + // Test with modified data, invoke copy constructor + AttributeTank::Attribute l_attribute3 = l_attribute1; + + // Make sure the Attribute Header match + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute3)) + { + TS_FAIL("testCopyConstructor: Test 2 - " + "Attribute Copy Ctor failed, with modifed values; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Add attribute values + uint32_t l_bufferSize(3); + uint8_t l_buffer[l_bufferSize]; + l_buffer[0] = 0x66; + l_buffer[0] = 0x77; + l_buffer[0] = 0x88; + l_attribute1.setValue(l_buffer, l_bufferSize); + + // Test with modified data, invoke copy constructor + AttributeTank::Attribute l_attribute4 = l_attribute1; + + // Make sure the Attribute Header match + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testCopyConstructor: Test 3 - " + "Attribute Copy Ctor failed, with data values; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure the Attribute Values match + ++l_numTests; + if (!compareAttributeValues(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testCopyConstructor: Test 4 - " + "Attribute Copy Ctor failed, with data values; " + "incorrect Attribute Values data returned"); + ++l_numFails; + } + + // Update the Attribute Values and test again + l_buffer[0] = 0x22; + l_buffer[0] = 0x33; + l_buffer[0] = 0x55; + l_attribute1.setValue(l_buffer, l_bufferSize); + + // Make sure the Attribute Header match original data + ++l_numTests; + if (!compareAttributeHeader(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testCopyConstructor: Test 5 - " + "Attribute Copy Ctor failed, with data values updated; " + "incorrect Attribute Header data returned"); + ++l_numFails; + } + + // Make sure the Attribute Values DO NOT match + ++l_numTests; + if (compareAttributeValues(&l_attribute1, &l_attribute4)) + { + TS_FAIL("testCopyConstructor: Test 6 - " + "Attribute Copy Ctor failed, with data values updated; " + "incorrect Attribute Values data returned"); + ++l_numFails; + } + + TRACFCOMP( g_trac_test, EXIT_MRK "testCopyConstructor " + "num tests = %d / num fails = %d", l_numTests, l_numFails); +} // end testCopyConstructor + +// compareAttributeHeader +bool AttributeTest::compareAttributeHeader( + const AttributeTank::Attribute* const l_attribute1, + const AttributeTank::Attribute* const l_attribute2) +{ + bool retVal(true); + + // Make sure the Attribute Header matches original data + if (0 != memcmp(&(l_attribute1->getHeader()), + &(l_attribute2->getHeader()), + sizeof(AttributeTank::AttributeHeader))) + { + retVal = false; + } + + return retVal; + +} // end compareAttributeHeader + +// compareAttributeValues +bool AttributeTest::compareAttributeValues( + const AttributeTank::Attribute* const l_attribute1, + const AttributeTank::Attribute* const l_attribute2) +{ + bool retVal(true); + + // Compare the Attribute Values for a match + if (0 != memcmp(l_attribute1->getValue(), + l_attribute2->getValue(), + l_attribute2->getHeader().iv_valSize)) + { + retVal = false; + } + + return retVal; + +} // end compareAttributeValues + +#endif // end __TEST_ATTRIBUTE_H |
