Unit test for structure TARGETING::AttributeTank::Attribute

This unit test, exercises the Attribute API, and the
make attribute templates

Change-Id: Iab9072f25c7920eb7f135c52e79198efdb755719
RTC:208343
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/78795
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

3 files changed, 1732 insertions, 1 deletions

diff --git a/src/usr/targeting/test/makefile b/src/usr/targeting/test/makefile
index b8d466539..fa6fd0584 100644
--- a/src/usr/targeting/test/makefile
+++ b/src/usr/targeting/test/makefile
@@ -5,7 +5,7 @@
 #
 # OpenPOWER HostBoot Project
 #
-# Contributors Listed Below - COPYRIGHT 2011,2015
+# Contributors Listed Below - COPYRIGHT 2011,2019
 # [+] International Business Machines Corp.
 #
 #
@@ -67,6 +67,8 @@ COMMON_TESTCASE_REL_PATHS = \
 TESTS += testtargeting.H
 TESTS += testattrsync.H
 TESTS += testattrtank.H
+TESTS += testAttribute.H
+TESTS += testTargetUtil.H
 TESTS += ${COMMON_TESTCASE_REL_PATHS}
 
 OBJS += attributestrings.o
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
diff --git a/src/usr/targeting/test/testTargetUtil.H b/src/usr/targeting/test/testTargetUtil.H
new file mode 100644
index 000000000..1cfc8412f
--- /dev/null
+++ b/src/usr/targeting/test/testTargetUtil.H
@@ -0,0 +1,458 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/targeting/test/testTargetUtil.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_TARGETING_UTIL_H
+#define __TEST_TARGETING_UTIL_H
+
+/**
+ *  @file targeting/test/testTargetUtil.H
+ *
+ *  @brief Unit test for the templates makeAttribute
+ *         and makeAttributeStdArr
+ */
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+
+// CXX TEST
+#include <cxxtest/TestSuite.H>
+
+#include <targeting/common/targetUtil.H>
+
+using namespace TARGETING;
+
+//******************************************************************************
+// class MakeAttributeTest
+//******************************************************************************
+class MakeAttributeTest: public CxxTest::TestSuite
+{
+public:
+
+    /**
+     *  @test Test the Make Attribute template
+     */
+    void testMakeAttribute(void);
+
+    /**
+     *  @test Test the Make Attribute for Standard Array template
+     */
+    void  testMakeAttributeStdArr(void);
+
+};  //  end class MakeAttributeTest
+
+// testMakeAttribute
+void MakeAttributeTest::testMakeAttribute(void)
+{
+    TRACFCOMP( g_trac_test, ENTER_MRK "testMakeAttribute" );
+
+    // Test stats
+    uint8_t l_numTests(0);
+    uint8_t l_numFails(0);
+
+    if (!TARGETING::targetService().isInitialized())
+    {
+        TS_FAIL("testMakeAttribute: Target Service is not initialized, "
+                "cannot perform test, exiting");
+
+        TRACFCOMP( g_trac_test, EXIT_MRK "testMakeAttribute "
+               "num tests = 1  / num fails = 1");
+        return;
+    }
+
+    // Get the top level target
+    TARGETING::Target * l_sys(nullptr);
+    TARGETING::targetService().getTopLevelTarget( l_sys );
+
+    if(!l_sys)
+    {
+        TS_FAIL("testMakeAttribute: Get Top Level Target failed, "
+                "unable to get top level target, cannot perform "
+                "test, exiting");
+
+        TRACFCOMP( g_trac_test, EXIT_MRK "testMakeAttribute "
+               "num tests = 1  / num fails = 1");
+        return;
+    }
+
+    // Save initial value to restore later
+    uint8_t l_simpleTypeRestoreValue =
+                       l_sys->getAttr<TARGETING::ATTR_IS_SIMULATION>();
+
+    // Test 1, test a simple attribute with known data
+    ++l_numTests;
+    do
+    {
+        // Set the attribute 'Is Simulation' to a known value to
+        // facilitate testing
+        uint8_t l_isSimulationSet = 1;
+        l_sys->setAttr<TARGETING::ATTR_IS_SIMULATION>(l_isSimulationSet);
+        uint8_t l_isSimulationReturn =
+                       l_sys->getAttr<TARGETING::ATTR_IS_SIMULATION>();
+
+        // Verify setting the attribute worked
+        if (l_isSimulationSet != l_isSimulationReturn)
+        {
+            TS_FAIL("testMakeAttribute: Test 1 - Setting attribute failed "
+                    "to initialize attribute to %d but retained "
+                    "value at %d, cannot perform test, exiting",
+                    l_isSimulationSet,
+                    l_isSimulationReturn);
+            ++l_numFails;
+            break;
+        }
+
+        // Retrieve that set attribute back via the 'make attribute' call
+        TARGETING::AttributeTank::Attribute l_attribute;
+        bool l_return =
+                TARGETING::makeAttribute<TARGETING::ATTR_IS_SIMULATION>
+                                                  (l_sys, l_attribute);
+
+        // Verify the called worked
+        if (true != l_return)
+        {
+            TS_INFO("testMakeAttribute: Test 1 - Make attribute call failed");
+            ++l_numFails;
+            break;
+        }
+
+        // Get a pointer to the attribute created in make attribute call,
+        // to get to the data.
+        const uint8_t* l_attributeValue =
+                        static_cast<const uint8_t*>(l_attribute.getValue());
+
+        // If the pointer to the data is NULL, then the make attribute did fail
+        if (l_attributeValue == nullptr)
+        {
+            TS_INFO("testMakeAttribute: Test 1 - Getting attribute value "
+                    "failed, NULL pointer returned when getting value.");
+            ++l_numFails;
+            break;
+        }
+
+        // Verify the returned attribute matches it's set value
+        if (*l_attributeValue != l_isSimulationSet)
+        {
+           TS_INFO("testMakeAttribute: Test 1 - Retrieved attribute value "
+                    "failed, retrieved attribute value(%d) does not "
+                    "match set attribute value(%d)",
+                    l_isSimulationSet,
+                    *l_attributeValue);
+            ++l_numFails;
+            break;
+        }
+    }
+    while (0);
+
+    // Test 2, test the same simple attribute but with different data
+    ++l_numTests;
+    do
+    {
+        // Set the attribute 'Is Simulation' to a known value to
+        // facilitate testing
+        uint8_t l_isSimulationSet = 5;
+        l_sys->setAttr<TARGETING::ATTR_IS_SIMULATION>(l_isSimulationSet);
+        uint8_t l_isSimulationReturn =
+                       l_sys->getAttr<TARGETING::ATTR_IS_SIMULATION>();
+
+        // Verify setting the attribute worked
+        if (l_isSimulationSet != l_isSimulationReturn)
+        {
+            TS_FAIL("testMakeAttribute: Test 2 - Setting attribute failed "
+                    "to initialize attribute to %d but retained "
+                    "value at %d, cannot perform test, exiting",
+                    l_isSimulationSet,
+                    l_isSimulationReturn);
+            ++l_numFails;
+            break;
+        }
+
+        // Retrieve that set attribute back via the 'make attribute' call
+        TARGETING::AttributeTank::Attribute l_attribute;
+        bool l_return =
+                TARGETING::makeAttribute<TARGETING::ATTR_IS_SIMULATION>
+                                                  (l_sys, l_attribute);
+
+        // Verify the called worked
+        if (true != l_return)
+        {
+            TS_INFO("testMakeAttribute: Test 2 - Make attribute call failed");
+            ++l_numFails;
+            break;
+        }
+
+        // Get a pointer to the attribute created in make attribute call,
+        // to get to the data.
+        const uint8_t* l_attributeValue =
+                        static_cast<const uint8_t*>(l_attribute.getValue());
+
+        // If the pointer to the data is NULL, then the make attribute did fail
+        if (l_attributeValue == nullptr)
+        {
+            TS_INFO("testMakeAttribute: Test 1 - Getting attribute value "
+                    "failed, NULL pointer returned when getting value.");
+            ++l_numFails;
+            break;
+        }
+
+        // Verify the returned attribute matches it's set value
+        if (*l_attributeValue != l_isSimulationSet)
+        {
+           TS_INFO("testMakeAttribute: Test 2 - Retrieved attribute value "
+                    "failed, retrieved attribute value(%d) does not "
+                    "match set attribute value(%d)",
+                    l_isSimulationSet,
+                    *l_attributeValue);
+            ++l_numFails;
+            break;
+        }
+    }
+    while (0);
+
+    // Restore value
+    l_sys->setAttr<TARGETING::ATTR_IS_SIMULATION>(l_simpleTypeRestoreValue);
+
+    TRACFCOMP( g_trac_test, EXIT_MRK "testMakeAttribute "
+               "num tests = %d  / num fails = %d", l_numTests, l_numFails);
+}  // end testMakeAttribute
+
+// testMakeAttributeStdArr
+void MakeAttributeTest::testMakeAttributeStdArr(void)
+{
+    TRACFCOMP( g_trac_test, ENTER_MRK "testMakeAttributeStdArr" );
+
+    // Test stats
+    uint8_t l_numTests(0);
+    uint8_t l_numFails(0);
+
+
+    if (!TARGETING::targetService().isInitialized())
+    {
+        TS_FAIL("testMakeAttributeStdArr: Target Service is not initialized, "
+                "cannot perform test, exiting");
+
+        TRACFCOMP( g_trac_test, EXIT_MRK "testMakeAttributeStdArr: "
+               "num tests = 1  / num fails = 1");
+        return;
+    }
+
+    // Get the top level target
+    TARGETING::Target * l_sys(nullptr);
+    TARGETING::targetService().getTopLevelTarget( l_sys );
+
+    if(!l_sys)
+    {
+        TS_FAIL("testMakeAttributeStdArr: Get Top Level Target failed, "
+                "unable to get top level target, cannot perform "
+                "test, exiting");
+
+        TRACFCOMP( g_trac_test, EXIT_MRK "testMakeAttributeStdArr: "
+               "num tests = 1  / num fails = 1");
+        return;
+    }
+
+    // Save initial value to restore later
+    TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS_typeStdArr
+            l_complexTypeRestoreValue;
+
+    // Test 1, test a complex attribute with known data
+    ++l_numTests;
+    do
+    {
+        // Set the attribute 'IPC Node Buffer Global Address' to a
+        // known value to facilitate testing
+        TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS_typeStdArr
+            l_complexTypeSet = {9, 6, 3, 1, 5, 1, 7, 3};
+
+        if ( !l_sys->trySetAttr<TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS>(
+                         l_complexTypeSet) )
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 1 - can't set "
+                    "TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS ");
+            ++l_numFails;
+            break;
+        }
+
+        // Do a sanity check and make sure we can set/get attribute via
+        // trySetAttr/tryGetAttr
+        TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS_typeStdArr
+            l_complexTypeGet;
+
+        if ( !l_sys->tryGetAttr<TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS>(
+                         l_complexTypeGet) )
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 1 - can't get "
+                    "TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS ");
+            ++l_numFails;
+            break;
+        }
+
+        // Verify setting the attribute worked
+        if (0 != memcmp(&l_complexTypeGet, &l_complexTypeSet,
+                         sizeof(l_complexTypeSet)) )
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 1 - Setting "
+                    "attribute failed, cannot perform test, exiting");
+            ++l_numFails;
+            break;
+        }
+
+        // Retrieved that set attribute back via the 'make attribute' call
+        TARGETING::AttributeTank::Attribute l_attribute;
+        bool l_return =
+                TARGETING::makeAttributeStdArr
+                               <TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS>
+                               (l_sys, l_attribute);
+
+        // Verify the called worked
+        if (l_return == false)
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 1 - Make "
+                    "attribute call failed");
+            ++l_numFails;
+            break;
+        }
+
+        // Get a pointer to the attribute created in make attribute call,
+        // to get to the data.
+        const uint8_t* l_attributeValue =
+                        static_cast<const uint8_t*>(l_attribute.getValue());
+
+        // If the pointer to the data is NULL, then the make attribute did fail
+        if (l_attributeValue == nullptr)
+        {
+            TS_INFO("testMakeAttributeStdArr: Test 1 - Getting attribute value "
+                    "failed, NULL pointer returned when getting value.");
+            ++l_numFails;
+        }
+
+        // Verify the returned attribute matches it's set value
+        if (0 != memcmp(l_attributeValue, &l_complexTypeSet,
+                         sizeof(l_complexTypeSet)) )
+        {
+           TS_INFO("testMakeAttributeStdArr: Test 1 - Retrieved attribute "
+                   "value failed, expected value and retrieved value do "
+                   "not match");
+            ++l_numFails;
+            break;
+        }
+    }
+    while (0);
+
+
+    // Test 2, test the same complex attribute but with different data
+    ++l_numTests;
+    do
+    {
+        // Set the attribute 'IPC Node Buffer Global Address' to a
+        // known value to facilitate testing
+        TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS_typeStdArr
+            l_complexTypeSet = {1, 2, 6, 8, 3, 2, 9, 3};
+
+        if ( !l_sys->trySetAttr<TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS>(
+                         l_complexTypeSet) )
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 2 - can't set "
+                    "TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS ");
+            ++l_numFails;
+            break;
+        }
+
+        // Do a sanity check and make sure we can set/get attribute via
+        // trySetAttr/tryGetAttr
+        TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS_typeStdArr
+            l_complexTypeGet;
+
+        if ( !l_sys->tryGetAttr<TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS>(
+                         l_complexTypeGet) )
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 2 - can't get "
+                    "TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS ");
+            ++l_numFails;
+            break;
+        }
+
+        // Verify setting the attribute worked
+        if (0 != memcmp(&l_complexTypeGet, &l_complexTypeSet,
+                         sizeof(l_complexTypeSet)) )
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 2 - Setting "
+                    "attribute failed, cannot perform test, exiting");
+            ++l_numFails;
+            break;
+        }
+
+        // Retrieved that set attribute back via the 'make attribute' call
+        TARGETING::AttributeTank::Attribute l_attribute;
+        bool l_return =
+                TARGETING::makeAttributeStdArr
+                               <TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS>
+                               (l_sys, l_attribute);
+
+        // Verify the called worked
+        if (l_return == false)
+        {
+            TS_FAIL("testMakeAttributeStdArr: Test 2 - Make "
+                    "attribute call failed");
+            ++l_numFails;
+            break;
+        }
+
+        // Get a pointer to the attribute created in make attribute call,
+        // to get to the data.
+        const uint8_t* l_attributeValue =
+                        static_cast<const uint8_t*>(l_attribute.getValue());
+
+        // If the pointer to the data is NULL, then the make attribute did fail
+        if (l_attributeValue == nullptr)
+        {
+            TS_INFO("testMakeAttributeStdArr: Test 2 - Getting attribute value "
+                    "failed, NULL pointer returned when getting value.");
+            ++l_numFails;
+        }
+
+        // Verify the returned attribute matches it's set value
+        if (0 != memcmp(l_attributeValue, &l_complexTypeSet,
+                         sizeof(l_complexTypeSet)) )
+        {
+           TS_INFO("testMakeAttributeStdArr: Test 2 - Retrieved attribute "
+                   "value failed, expected value and retrieved value do "
+                   "not match");
+            ++l_numFails;
+            break;
+        }
+    }
+    while (0);
+
+    // Restore value
+    l_sys->trySetAttr<TARGETING::ATTR_IPC_NODE_BUFFER_GLOBAL_ADDRESS>(
+                         l_complexTypeRestoreValue);
+
+    TRACFCOMP( g_trac_test, EXIT_MRK "testMakeAttributeStdArr "
+               "num tests = %d  / num fails = %d", l_numTests, l_numFails);
+
+}  // end testMakeAttributeStdArr
+
+#endif  // end __TEST_ATTRIBUTE_H