Update fapi2 tests cases with Axone targets

This commit will add new fapi2 tests case to make sure that the
new MCC, OMI, and OMIC target types work correctly. Also in
this commit I realized how much of a pain adding new targets can
be for these tests so I added some macros to reduce the amount of
changes required for some of the tests when new targets get added

Change-Id: I5879c23dcd756686e369b1f81e58d56b73b1607f
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/65204
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Ilya Smirnov <ismirno@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

12 files changed, 997 insertions, 1599 deletions

diff --git a/src/include/usr/fapi2/hwpf_fapi2_reasoncodes.H b/src/include/usr/fapi2/hwpf_fapi2_reasoncodes.H
index 24aa4767d..c8c61211d 100644
--- a/src/include/usr/fapi2/hwpf_fapi2_reasoncodes.H
+++ b/src/include/usr/fapi2/hwpf_fapi2_reasoncodes.H
@@ -94,26 +94,6 @@ namespace fapi2
         //Platform generated errors
         RC_NO_PROCS_FOUND              = FAPI2_COMP_ID | 0x0B,
         RC_NO_PATH_TO_TARGET_FOUND     = FAPI2_COMP_ID | 0x0C,
-        RC_CORE_NO_EX_FOUND            = FAPI2_COMP_ID | 0x0D,
-        RC_CORE_NO_EQ_FOUND            = FAPI2_COMP_ID | 0x0E,
-        RC_CORE_NO_PROC_FOUND          = FAPI2_COMP_ID | 0x10,
-        RC_EX_NO_EQ_FOUND              = FAPI2_COMP_ID | 0x11,
-        RC_EX_NO_PROC_FOUND            = FAPI2_COMP_ID | 0x12,
-        RC_EQ_NO_PROC_FOUND            = FAPI2_COMP_ID | 0x13,
-        RC_MCA_NO_MCS_FOUND            = FAPI2_COMP_ID | 0x14,
-        RC_MCA_NO_PROC_FOUND           = FAPI2_COMP_ID | 0x15,
-        RC_MCS_NO_PROC_FOUND           = FAPI2_COMP_ID | 0x16,
-        RC_MCBIST_NO_PROC_FOUND        = FAPI2_COMP_ID | 0x17,
-        RC_PHB_NO_PEC_FOUND            = FAPI2_COMP_ID | 0x18,
-        RC_PHB_NO_PROC_FOUND           = FAPI2_COMP_ID | 0x19,
-        RC_PEC_NO_PROC_FOUND           = FAPI2_COMP_ID | 0x1a,
-        RC_XBUS_NO_PROC_FOUND          = FAPI2_COMP_ID | 0x1b,
-        RC_OBUS_NO_PROC_FOUND          = FAPI2_COMP_ID | 0x1c,
-        RC_OBRICK_NO_PROC_FOUND        = FAPI2_COMP_ID | 0x1d,
-        RC_PPE_NO_PROC_FOUND           = FAPI2_COMP_ID | 0x1e,
-        RC_PERV_NO_PROC_FOUND          = FAPI2_COMP_ID | 0x1f,
-        RC_CAPP_NO_PROC_FOUND          = FAPI2_COMP_ID | 0x20,
-        RC_SBE_NO_PROC_FOUND           = FAPI2_COMP_ID | 0x21,
         RC_INVALID_CHILD_COUNT         = FAPI2_COMP_ID | 0x22,
         RC_UNIT_NO_PERV_FOUND          = FAPI2_COMP_ID | 0x23,
         RC_INCORRECT_OTHER_END         = FAPI2_COMP_ID | 0x24,
diff --git a/src/usr/fapi2/runtime/test/makefile b/src/usr/fapi2/runtime/test/makefile
index d2a972d38..0a15491d1 100644
--- a/src/usr/fapi2/runtime/test/makefile
+++ b/src/usr/fapi2/runtime/test/makefile
@@ -5,7 +5,7 @@
 #
 # OpenPOWER HostBoot Project
 #
-# Contributors Listed Below - COPYRIGHT 2015,2017
+# Contributors Listed Below - COPYRIGHT 2015,2018
 # [+] International Business Machines Corp.
 #
 #
@@ -39,5 +39,4 @@ TESTS = $(filter-out ${ROOTPATH}/src/usr/fapi2/test/getVpdTest.H ${ROOTPATH}/src
 TMPVAR2 := ${OBJS}
 OBJS = $(filter-out getVpdTest.o, ${TMPVAR2})
 include ${ROOTPATH}/config.mk
-VPATH += ../../test/
-
+VPATH += ../../test/
\ No newline at end of file
diff --git a/src/usr/fapi2/test/fapi2GetChildrenTest.H b/src/usr/fapi2/test/fapi2GetChildrenTest.H
index 12af3432f..38ca8444e 100644
--- a/src/usr/fapi2/test/fapi2GetChildrenTest.H
+++ b/src/usr/fapi2/test/fapi2GetChildrenTest.H
@@ -61,156 +61,29 @@ public:
         };
 
 //******************************************************************************
-// getProc
-// Determine if cumulus or nimbus system and return pointer to first processor
-// target of that type
-//******************************************************************************
-errlHndl_t getProc(TARGETING::Target*& o_nimbusProc,
-        TARGETING::Target*& o_cumulusProc)
-{
-    errlHndl_t l_err = nullptr;
-    FAPI_DBG("start of getProc()");
-
-    // Create a vector of TARGETING::Target pointers
-    TARGETING::TargetHandleList l_chipList;
-
-    // Get a list of all of the proc chips
-    TARGETING::getAllChips(l_chipList, TARGETING::TYPE_PROC, false);
-
-    //Take the first NIMBUS proc and use it
-    for(uint32_t i = 0; i < l_chipList.size(); i++)
-    {
-        if(TARGETING::MODEL_NIMBUS ==
-                l_chipList[i]->getAttr<TARGETING::ATTR_MODEL>())
-        {
-            o_nimbusProc = l_chipList[i];
-            break;
-        }
-        if(TARGETING::MODEL_CUMULUS ==
-                l_chipList[i]->getAttr<TARGETING::ATTR_MODEL>())
-        {
-            o_cumulusProc = l_chipList[i];
-            break;
-        }
-    }
-    if((o_nimbusProc == nullptr) && (o_cumulusProc == nullptr))
-    {
-        // Send an errorlog because we cannot find any procs.
-        FAPI_ERR("getProc: could not find any procs, skipping tests");
-        /*@
-         * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
-         * @moduleid     fapi2::MOD_FAPI2_PLAT_GET_PROC_TEST
-         * @reasoncode   fapi2::RC_NO_PROCS_FOUND
-         * @userdata1    Model Type we looked for
-         * @userdata2    Other Model Type we looked for
-         * @devdesc      Could not find any procs in system model
-         */
-        l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                fapi2::MOD_FAPI2_PLAT_GET_PROC_TEST,
-                fapi2::RC_NO_PROCS_FOUND,
-                TARGETING::MODEL_NIMBUS,
-                TARGETING::MODEL_CUMULUS,
-                true/*SW Error*/);
-    }
-    return l_err;
-}
-
-//******************************************************************************
 // test_fapi2GetChildren
 //******************************************************************************
 void test_fapi2GetChildren()
 {
-    int numTests = 0;
-    int numFails = 0;
     uint32_t l_targetHuid = 0xFFFFFFFF;
     uint32_t l_actualSize = 0;
     uint32_t l_expectedSize = 0;
     errlHndl_t l_err = nullptr;
-    TARGETING::Target * l_nimbusProc = nullptr;
-    TARGETING::Target * l_cumulusProc = nullptr;
-    TARGETING::Target * l_proc = nullptr;
+    int numTests = 0;
+    int numFails = 0;
+
     do
     {
-        numTests++;
-        l_err = getProc(l_nimbusProc, l_cumulusProc);
-        if(l_err)
-        {
-            errlCommit(l_err,HWPF_COMP_ID);
-            numFails++;
-            TS_FAIL("test_fapi2GetChildren Fail: could not find any proc, skipping tests");
-            break;
-        }
-
-        if (l_nimbusProc != nullptr)
-        {
-            l_proc = l_nimbusProc;
-        }
-        else if (l_cumulusProc != nullptr)
-        {
-            l_proc = l_cumulusProc;
-        }
-        else //both are nullptr
-        {
-            // Should never get here since error should have been returned
-            // above
-            FAPI_ERR("test_fapi2GetChildren: Never Should Happen");
-            numFails++;
-            break;
-        }
-
-        TARGETING::Target* targeting_targets[fapi2::NUM_TARGETS];
-        generateTargets(l_proc, targeting_targets);
-
-        for( uint64_t x = 0; x < fapi2::NUM_TARGETS; x++ )
-        {
-            //Skip tests where the HW unit to test isn't valid for the proc type
-            if (!isHwValid(l_proc, x))
-            {
-                continue;
-            }
-            else if(targeting_targets[x] == nullptr)
-            {
-              FAPI_ERR("Unable to find target for item %d in targeting_targets", x);
-              /*@
-              * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
-              * @moduleid     fapi2::MOD_FAPI2_PLAT_GET_CHILDREN_TEST
-              * @reasoncode   fapi2::RC_NO_PATH_TO_TARGET_FOUND
-              * @userdata1    Index of target in array of objects
-              * @userdata2    Unused
-              * @devdesc      Could not find a path to the target of that type
-              */
-              l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                              fapi2::MOD_FAPI2_PLAT_GET_CHILDREN_TEST,
-                                              fapi2::RC_NO_PATH_TO_TARGET_FOUND,
-                                              x,
-                                              NULL,
-                                              true/*SW Error*/);
-              errlCommit(l_err,HWPF_COMP_ID);
-            }
-        }
-
-
-        Target<fapi2::TARGET_TYPE_PROC_CHIP> fapi2_procTarget(
-                l_proc);
-        Target<fapi2::TARGET_TYPE_EQ> fapi2_eqTarget(
-                targeting_targets[MY_EQ]);
-        Target<fapi2::TARGET_TYPE_EX> fapi2_exTarget(
-                targeting_targets[MY_EX]);
-        Target<fapi2::TARGET_TYPE_MCS> fapi2_mcsTarget(
-                targeting_targets[MY_MCS]);;
-        Target<fapi2::TARGET_TYPE_MCBIST> fapi2_mcbistTarget(
-                targeting_targets[MY_MCBIST]);
-        Target<fapi2::TARGET_TYPE_MC> fapi2_mcTarget(
-                targeting_targets[MY_MC]);
-        Target<fapi2::TARGET_TYPE_MI> fapi2_miTarget(
-                targeting_targets[MY_MI]);
+        GENERATE_TEST_TARGETS(test_fapi2GetChildren)
 
+        // Creates some vectors for later use
         std::vector<Target<fapi2::TARGET_TYPE_CORE> > l_childCores;
         std::vector<Target<fapi2::TARGET_TYPE_MCA> > l_childMCAs;
         std::vector<Target<fapi2::TARGET_TYPE_EQ> > l_childEQs;
         std::vector<Target<fapi2::TARGET_TYPE_EX> > l_childEXs;
         std::vector<Target<fapi2::TARGET_TYPE_XBUS> > l_childXBUSs;
         std::vector<Target<fapi2::TARGET_TYPE_DMI> > l_childDMIs;
+        std::vector<Target<fapi2::TARGET_TYPE_OMI> > l_childOMIs;
 
 
         if (isHwValid(l_proc, MY_MCA)
@@ -251,6 +124,26 @@ void test_fapi2GetChildren()
             }
         }
 
+        if (isHwValid(l_proc, MY_MC)
+            && isHwValid(l_proc, MY_MI)
+            && isHwValid(l_proc, MY_MCC)
+            && isHwValid(l_proc, MY_OMI))
+        {
+            l_childOMIs = fapi2_mcTarget.getChildren<fapi2::TARGET_TYPE_OMI>(TARGET_STATE_PRESENT);
+            l_targetHuid = TARGETING::get_huid(targeting_targets[MY_MC]);
+            l_actualSize = l_childOMIs.size();
+
+            //Set expected size to be the number of OMIs per MC
+            l_expectedSize = OMI_PER_MCC * MCC_PER_MI * MI_PER_MC;
+            numTests++;
+            if(l_actualSize != l_expectedSize)
+            {
+                FAPI_INF("fapi2TargetTest:: OMIs per MC mismatch");
+                numFails++;
+                break;
+            }
+        }
+
         l_childCores = fapi2_procTarget.getChildren<fapi2::TARGET_TYPE_CORE>(TARGET_STATE_PRESENT);
         l_targetHuid = TARGETING::get_huid(l_proc) ;
         l_actualSize = l_childCores.size();
@@ -318,6 +211,26 @@ void test_fapi2GetChildren()
             }
         }
 
+        if (isHwValid(l_proc, MY_MC)
+            && isHwValid(l_proc, MY_MI)
+            && isHwValid(l_proc, MY_MCC)
+            && isHwValid(l_proc, MY_OMI))
+        {
+            l_childOMIs = fapi2_procTarget.getChildren<fapi2::TARGET_TYPE_OMI>(TARGET_STATE_PRESENT);
+            l_targetHuid = TARGETING::get_huid(l_proc);
+            l_actualSize = l_childOMIs.size();
+
+            //Set expected size to be the number of OMIs per proc
+            l_expectedSize = OMI_PER_MCC * MCC_PER_MI * MI_PER_MC * MC_PER_PROC;
+            numTests++;
+            if(l_actualSize != l_expectedSize)
+            {
+                FAPI_INF("fapi2TargetTest:: OMIs per proc mismatch");
+                numFails++;
+                break;
+            }
+        }
+
 
         l_childCores = fapi2_exTarget.getChildren<fapi2::TARGET_TYPE_CORE>(TARGET_STATE_PRESENT);
         l_targetHuid = TARGETING::get_huid(targeting_targets[MY_EX]) ;
@@ -383,7 +296,7 @@ void test_fapi2GetChildren()
                  { return i_perv.getChildren<fapi2::TARGET_TYPE_EQ>(
                    TARGET_STATE_PRESENT).size(); } },
 
-            // CORE pervasive has 1 CORE child
+            // CORE pervasive has 32 CORE child
             {PERV_CORE_CHILDREN,
              [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
                  { return ((i_unit >= CORE_LOW) && (i_unit <= CORE_HIGH)); },
@@ -391,7 +304,7 @@ void test_fapi2GetChildren()
                  { return i_perv.getChildren<fapi2::TARGET_TYPE_CORE>(
                    TARGET_STATE_PRESENT).size(); } },
 
-            // XBUS pervasive has 2 XBUS children
+            // XBUS pervasive has 1 XBUS children
             {PERV_XBUS_NIMBUS_CHILDREN,
              [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
                   { return (i_unit == XBUS_RANGE); },
@@ -399,7 +312,7 @@ void test_fapi2GetChildren()
                  { return i_perv.getChildren<fapi2::TARGET_TYPE_XBUS>(
                    TARGET_STATE_PRESENT).size(); } },
 
-            // OBUS pervasive has 1 OBUS child
+            // OBUS pervasive has 3 OBUS child
             {PERV_OBUS_CHILDREN,
              [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
                   { return ((i_unit >= OBUS_LOW) && (i_unit <= OBUS_HIGH)); },
@@ -493,7 +406,7 @@ void test_fapi2GetChildren()
                  { return i_perv.getChildren<fapi2::TARGET_TYPE_EQ>(
                    TARGET_STATE_PRESENT).size(); } },
 
-            // CORE pervasive has 1 CORE child
+            // CORE pervasive has 32 CORE child
             {PERV_CORE_CHILDREN,
              [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
                  { return ((i_unit >= CORE_LOW) && (i_unit <= CORE_HIGH)); },
@@ -501,7 +414,7 @@ void test_fapi2GetChildren()
                  { return i_perv.getChildren<fapi2::TARGET_TYPE_CORE>(
                    TARGET_STATE_PRESENT).size(); } },
 
-            // XBUS pervasive has # XBUS children
+            // XBUS pervasive has 1 XBUS children
             {PERV_XBUS_CUMULUS_CHILDREN,
              [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
                   { return (i_unit == XBUS_RANGE); },
@@ -509,7 +422,7 @@ void test_fapi2GetChildren()
                  { return i_perv.getChildren<fapi2::TARGET_TYPE_XBUS>(
                    TARGET_STATE_PRESENT).size(); } },
 
-            // OBUS pervasive has 1 OBUS child
+            // OBUS pervasive has 3 OBUS child
             {PERV_OBUS_CHILDREN,
              [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
                   { return ((i_unit >= OBUS_LOW) && (i_unit <= OBUS_HIGH)); },
@@ -565,7 +478,7 @@ void test_fapi2GetChildren()
                  { return i_perv.getChildren<fapi2::TARGET_TYPE_PHB>(
                    TARGET_STATE_PRESENT).size(); } },
 
-            // MC / MI / DMI pervasive has 2 MC Children
+            // MC / MI / DMI pervasive has 1 MC Children
             {PERV_MC_CHILDREN,
              [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
                   { return (   (i_unit >= MC_LOW)
@@ -591,18 +504,147 @@ void test_fapi2GetChildren()
                     TARGET_STATE_PRESENT).size(); } },
         };
 
+        static pervasiveChildTestRec axonePervasiveChildTests [] = {
+
+            // EQ pervasive has 1 EQ child
+            {PERV_EQ_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return ((i_unit >= EQ_LOW) && (i_unit <= EQ_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_EQ>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // CORE pervasive has 32 children
+            {PERV_CORE_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                 { return ((i_unit >= CORE_LOW) && (i_unit <= CORE_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_CORE>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // XBUS pervasive has 1 XBUS children
+            {PERV_XBUS_CUMULUS_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return (i_unit == XBUS_RANGE); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_XBUS>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // OBUS pervasive has 3 OBUS child
+            {PERV_OBUS_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return ((i_unit >= OBUS_LOW) && (i_unit <= OBUS_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_OBUS>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // CAPP pervasive has 1 CAPP child
+            {PERV_CAPP_CUMULUS_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                { return ((i_unit == CAPP0_RANGE) || (i_unit == CAPP1_RANGE));},
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_CAPP>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // OBUS pervasive has 3 OBUS BRICK children
+            {PERV_OBUS_BRICK_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return ((i_unit >= OBUS_LOW) && (i_unit <= OBUS_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                  { return i_perv.getChildren<fapi2::TARGET_TYPE_OBUS_BRICK>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // PEC/PHB pervasive has 3 PEC child
+            {PERV_PEC_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+              { return ((i_unit >= PEC_LOW) && (i_unit <= PEC_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_PEC>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // PEC/PHB pervasive with 1 PHB child
+            {PERV_PEC0_PHB_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return (i_unit == PEC_LOW); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_PHB>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // PEC/PHB pervasive with 2 PHB children
+            {PERV_PEC1_PHB_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return (i_unit == PEC_MID); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_PHB>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // PEC/PHB pervasive with 3 PHB children
+            {PERV_PEC2_PHB_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return (i_unit == PEC_HIGH); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                 { return i_perv.getChildren<fapi2::TARGET_TYPE_PHB>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // MC / MI / DMI pervasive has 1 MC Children
+            {PERV_MC_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return (   (i_unit >= MC_LOW)
+                            && (i_unit <= MC_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                  { return i_perv.getChildren<fapi2::TARGET_TYPE_MC>(
+                   TARGET_STATE_PRESENT).size(); } },
+
+            // MC / MI / DMI pervasive has 2 MI Children
+            {PERV_MI_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return ((i_unit >= MC_LOW) && (i_unit <= MC_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                  { return i_perv.getChildren<fapi2::TARGET_TYPE_MI>(
+                    TARGET_STATE_PRESENT).size(); } },
+
+            // MC / MI / MCC / OMI pervasive has 4 MCC children
+            {PERV_OCC_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return ((i_unit >= MC_LOW) && (i_unit <= MC_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                   { return i_perv.getChildren<fapi2::TARGET_TYPE_MCC>(
+                    TARGET_STATE_PRESENT).size(); } },
+
+            // MC / MI / MCC / OMI pervasive has 8 OMI children
+            {PERV_OMI_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return ((i_unit >= MC_LOW) && (i_unit <= MC_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                   { return i_perv.getChildren<fapi2::TARGET_TYPE_OMI>(
+                    TARGET_STATE_PRESENT).size(); } },
+
+            {PERV_OMIC_CHILDREN,
+             [](TARGETING::ATTR_CHIP_UNIT_type i_unit)
+                  { return ((i_unit >= MC_LOW) && (i_unit <= MC_HIGH)); },
+             [](Target<fapi2::TARGET_TYPE_PERV>& i_perv)
+                   { return i_perv.getChildren<fapi2::TARGET_TYPE_OMIC>(
+                    TARGET_STATE_PRESENT).size(); } },
+        };
+
         pervasiveChildTestRec* ptr;
         int numPervTests = 0;
-        if (l_nimbusProc != nullptr)
+        TARGETING::ATTR_MODEL_type l_model = l_proc->getAttr<TARGETING::ATTR_MODEL>();
+        if (l_model == TARGETING::MODEL_NIMBUS)
         {
             numPervTests = sizeof(nimbusPervasiveChildTests) / sizeof(pervasiveChildTestRec);
             ptr = nimbusPervasiveChildTests;
         }
-        else
+        else if(l_model == TARGETING::MODEL_CUMULUS)
         {
             numPervTests = sizeof(cumulusPervasiveChildTests) / sizeof(pervasiveChildTestRec);
             ptr = cumulusPervasiveChildTests;
         }
+        else if(l_model == TARGETING::MODEL_AXONE)
+        {
+            numPervTests = sizeof(axonePervasiveChildTests) / sizeof(pervasiveChildTestRec);
+            ptr = axonePervasiveChildTests;
+        }
 
         // Build list of all pervasive targets in the blueprint
         TARGETING::TargetHandleList pervasiveTargets;
@@ -705,40 +747,26 @@ void test_fapi2GetChildrenFilter()
     uint32_t l_actualSize = 0;
     uint32_t l_expectedSize = 0;
     errlHndl_t l_err = nullptr;
-    TARGETING::Target * l_nimbusProc = nullptr;
-    TARGETING::Target * l_cumulusProc = nullptr;
     TARGETING::Target * l_proc = nullptr;
+    TARGETING::TargetHandleList l_chipList;
     do
     {
         FAPI_DBG("start of test_fapi2GetChildrenFilter()");
 
         numTests++;
-        l_err = getProc(l_nimbusProc, l_cumulusProc);
-        if(l_err)
-        {
-            errlCommit(l_err,HWPF_COMP_ID);
-            numFails++;
-            TS_FAIL("test_fapi2GetChildrenFilter Fail: could not find any proc, skipping tests");
-            break;
-        }
+        // Get a list of all of the proc chips
+        TARGETING::getAllChips(l_chipList, TARGETING::TYPE_PROC, false);
 
-        if (l_nimbusProc != nullptr)
+        if(l_chipList.size())
         {
-            l_proc = l_nimbusProc;
+            l_proc = l_chipList[0];
         }
-        else if (l_cumulusProc != nullptr)
-        {
-            l_proc = l_cumulusProc;
-        }
-        else //both are nullptr
+        else
         {
-            // Should never get here since error should have been returned
-            // above
-            FAPI_ERR("test_fapi2GetChildrenFilter: Never Should Happen");
+            TS_FAIL("test_fapi2GetChildren Fail: could not find any proc, skipping tests");
             numFails++;
             break;
         }
-
         TARGETING::Target* targeting_targets[NUM_TARGETS];
         generateTargets(l_proc, targeting_targets);
 
@@ -794,7 +822,7 @@ void test_fapi2GetChildrenFilter()
             break;
         }
 
-        if (isHwValid(l_proc, MY_MCS))
+        if (isHwValid(l_proc, MY_MC))
         {
             // PERV - TARGET_FILTER_ALL_MC
             l_expectedSize = 2;
@@ -865,41 +893,42 @@ void test_fapi2getChildTargetsForCDG()
 {
     int numTests = 0;
     int numFails = 0;
-    errlHndl_t l_err = nullptr;
-    TARGETING::Target * l_nimbusProc = nullptr;
-    TARGETING::Target * l_cumulusProc = nullptr;
     TARGETING::Target * l_proc = nullptr;
     size_t l_expectedDimms = 0;
     size_t l_expectedDimmsUnderPort0 = 0;
     size_t l_expectedDimmsUnderPort1 = 0;
+    TARGETING::TargetHandleList l_chipList;
     do
     {
         FAPI_DBG("start of test_fapi2getChildTargetsForCDG()");
 
         numTests++;
-        l_err = getProc(l_nimbusProc, l_cumulusProc);
-        if(l_err)
+        // Get a list of all of the proc chips
+        TARGETING::getAllChips(l_chipList, TARGETING::TYPE_PROC, false);
+
+        if(l_chipList.size())
+        {
+            l_proc = l_chipList[0];
+        }
+        else
         {
-            errlCommit(l_err,HWPF_COMP_ID);
-            numFails++;
             TS_FAIL("test_fapi2getChildTargetsForCDG Fail: could not find any proc, skipping tests");
+            numFails++;
             break;
         }
 
-        if (l_nimbusProc != nullptr)
+        if (l_proc->getAttr<TARGETING::ATTR_MODEL>() == TARGETING::MODEL_NIMBUS)
         {
-            l_proc = l_nimbusProc;
             l_expectedDimms = 16;
             l_expectedDimmsUnderPort0 = l_expectedDimms;
             l_expectedDimmsUnderPort1 = 0;
         }
-        else if (l_cumulusProc != nullptr)
+        else if (l_proc->getAttr<TARGETING::ATTR_MODEL>() == TARGETING::MODEL_CUMULUS ||
+                 l_proc->getAttr<TARGETING::ATTR_MODEL>() == TARGETING::MODEL_AXONE)
         {
-            l_proc = l_cumulusProc;
             l_expectedDimms = 8;
             l_expectedDimmsUnderPort0 = l_expectedDimms/2;
             l_expectedDimmsUnderPort1 = l_expectedDimms/2;
-
         }
         else //both are nullptr
         {
diff --git a/src/usr/fapi2/test/fapi2GetChipletNumTest.H b/src/usr/fapi2/test/fapi2GetChipletNumTest.H
index 9c813f377..8dc06f4a4 100644
--- a/src/usr/fapi2/test/fapi2GetChipletNumTest.H
+++ b/src/usr/fapi2/test/fapi2GetChipletNumTest.H
@@ -481,10 +481,12 @@ class Fapi2GetChipletNum : public CxxTest::TestSuite
                     TARGETING::TargetService::ALL,
                     &predMc);
 
+            auto l_model =l_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>();
+
             if (l_TargetList.empty())
             {
-                if(TARGETING::MODEL_CUMULUS ==
-                    l_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>())
+                if(TARGETING::MODEL_CUMULUS == l_model ||
+                   TARGETING::MODEL_AXONE   == l_model )
                 {
                     TS_FAIL("testVerifyMcChipletNum: empty l_TargetList");
                 }
@@ -543,10 +545,12 @@ class Fapi2GetChipletNum : public CxxTest::TestSuite
                     TARGETING::TargetService::ALL,
                     &predMi);
 
+            auto l_model =l_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>();
+
             if (l_TargetList.empty())
             {
-                if(TARGETING::MODEL_CUMULUS ==
-                    l_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>())
+                if(TARGETING::MODEL_CUMULUS == l_model ||
+                   TARGETING::MODEL_AXONE   == l_model )
                 {
                     TS_FAIL("testVerifyMiChipletNum: empty l_TargetList");
                 }
@@ -582,6 +586,192 @@ class Fapi2GetChipletNum : public CxxTest::TestSuite
         FAPI_INF("Complete testVerifyMiChipletNum");
     }
 
+    void testVerifyMccChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  l_chip_unit = 0;
+
+        FAPI_INF("Start testVerifyMccChipletNum");
+
+        do
+        {
+            // find all MCC units
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predMcc(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_MCC);
+
+            TARGETING::Target* l_pMasterProcChip = nullptr;
+            TARGETING::targetService().masterProcChipTargetHandle(l_pMasterProcChip);
+
+            TARGETING::TargetHandleList l_TargetList;
+            TARGETING::targetService().getAssociated( l_TargetList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predMcc);
+
+            if (l_TargetList.empty())
+            {
+                if(TARGETING::MODEL_AXONE ==
+                    l_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>())
+                {
+                    TS_FAIL("testVerifyMccChipletNum: empty l_TargetList");
+                }
+                break;
+            }
+
+            // Iterate through all MCC chiplets
+            for (auto & l_Target : l_TargetList)
+            {
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_MCC> fapi2_Target( l_Target);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyMccChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(l_Target), l_chiplet_id);
+
+                // MCC 0..3, 4..7 maps to pervasive ids 0x07, 0x08
+                l_chip_unit = l_Target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = l_chip_unit / PERV_MCC_CHILDREN + START_MCC_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyMccChipletNum: Mismatch HUID %.8X - Expected: %.8X:, Found: %.8X",
+                            TARGETING::get_huid(l_Target),
+                            l_exp_chiplet_id, l_chiplet_id);
+                }
+            }
+        } while(0);
+
+        FAPI_INF("Complete testVerifyMccChipletNum");
+
+    }
+
+    void testVerifyOmiChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  l_chip_unit = 0;
+
+        FAPI_INF("Start testVerifyOmiChipletNum");
+
+        do
+        {
+            // find all OMI units
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predOmi(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_OMI);
+
+            TARGETING::Target* l_pMasterProcChip = nullptr;
+            TARGETING::targetService().masterProcChipTargetHandle(l_pMasterProcChip);
+
+            TARGETING::TargetHandleList l_TargetList;
+            TARGETING::targetService().getAssociated( l_TargetList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predOmi);
+
+            if (l_TargetList.empty())
+            {
+                if(TARGETING::MODEL_AXONE ==
+                    l_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>())
+                {
+                    TS_FAIL("testVerifyOmiChipletNum: empty l_TargetList");
+                }
+                break;
+            }
+
+            // Iterate through all OMI chiplets
+            for (auto & l_Target : l_TargetList)
+            {
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_OMI> fapi2_Target( l_Target);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyOmiChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(l_Target), l_chiplet_id);
+
+                // OMI 0..7, 8..15 maps to pervasive ids 0x07, 0x08
+                l_chip_unit = l_Target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = l_chip_unit / PERV_OMI_CHILDREN + START_OMI_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyOmiChipletNum: Mismatch HUID %.8X - Expected: %.8X:, Found: %.8X",
+                            TARGETING::get_huid(l_Target),
+                            l_exp_chiplet_id, l_chiplet_id);
+                }
+            }
+        } while(0);
+
+        FAPI_INF("Complete testVerifyOmiChipletNum");
+
+    }
+
+    void testVerifyOmicChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  l_chip_unit = 0;
+
+        FAPI_INF("Start testVerifyOmicChipletNum");
+
+        do
+        {
+            // find all OMIC units
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predOmic(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_OMIC);
+
+            TARGETING::Target* l_pMasterProcChip = nullptr;
+            TARGETING::targetService().masterProcChipTargetHandle(l_pMasterProcChip);
+
+            TARGETING::TargetHandleList l_TargetList;
+            TARGETING::targetService().getAssociated( l_TargetList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predOmic);
+
+            if (l_TargetList.empty())
+            {
+                if(TARGETING::MODEL_AXONE ==
+                    l_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>())
+                {
+                    TS_FAIL("testVerifyOmicChipletNum: empty l_TargetList");
+                }
+                break;
+            }
+
+            // Iterate through all OMI chiplets
+            for (auto & l_Target : l_TargetList)
+            {
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_OMIC> fapi2_Target( l_Target);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyOmicChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(l_Target), l_chiplet_id);
+
+                // OMI 0..5, 6..11 maps to pervasive ids 0x07, 0x08
+                l_chip_unit = l_Target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = l_chip_unit / PERV_OMIC_CHILDREN + START_OMIC_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyOmicChipletNum: Mismatch HUID %.8X - Expected: %.8X:, Found: %.8X",
+                            TARGETING::get_huid(l_Target),
+                            l_exp_chiplet_id, l_chiplet_id);
+                }
+            }
+        } while(0);
+
+        FAPI_INF("Complete testVerifyOmicChipletNum");
+
+    }
+
     void testVerifyDmiChipletNum()
     {
         uint8_t  l_chiplet_id = 0;
@@ -1017,6 +1207,12 @@ class Fapi2GetChipletNum : public CxxTest::TestSuite
 
             testVerifyiPhbChipletNum();
 
+            testVerifyMccChipletNum();
+
+            testVerifyOmiChipletNum();
+
+            testVerifyOmicChipletNum();
+
         } while(0);
         FAPI_DBG("test_fapi2ChipletNum Test Complete.");
     } // end test_fapi2ChipletNum()
diff --git a/src/usr/fapi2/test/fapi2GetParentTest.H b/src/usr/fapi2/test/fapi2GetParentTest.H
index 47492fd78..1dd8ea865 100644
--- a/src/usr/fapi2/test/fapi2GetParentTest.H
+++ b/src/usr/fapi2/test/fapi2GetParentTest.H
@@ -49,948 +49,186 @@ void test_fapi2GetParentPervasive(int& numTests, int& numFails,
                                   const pervasiveParentTestRec[],
                                   TARGETING::Target *);
 
-
 //******************************************************************************
 // fapi2GetParentTest
 //******************************************************************************
 void test_fapi2GetParent()
 {
+    errlHndl_t l_err = nullptr;
     int numTests = 0;
     int numFails = 0;
-    errlHndl_t l_err = nullptr;
     do
     {
-        // Create a vector of TARGETING::Target pointers
-        TARGETING::TargetHandleList l_chipList;
-
-        // Get a list of all of the proc chips
-        TARGETING::getAllChips(l_chipList, TARGETING::TYPE_PROC, false);
-
-        TARGETING::Target * l_nimbusProc = nullptr;
-        TARGETING::Target * l_cumulusProc = nullptr;
-        TARGETING::Target * l_proc = nullptr;
-
-        //Take the first NIMBUS proc and use it
-        for(uint32_t i = 0; i < l_chipList.size(); i++)
-        {
-            if(TARGETING::MODEL_NIMBUS ==
-            l_chipList[i]->getAttr<TARGETING::ATTR_MODEL>())
-            {
-              l_nimbusProc = l_chipList[i];
-              break;
-            }
-            if(TARGETING::MODEL_CUMULUS ==
-            l_chipList[i]->getAttr<TARGETING::ATTR_MODEL>())
-            {
-              l_cumulusProc = l_chipList[i];
-              break;
-            }
-        }
-
-        if (l_nimbusProc != nullptr)
-        {
-            l_proc = l_nimbusProc;
-        }
-        else if (l_cumulusProc != nullptr)
-        {
-            l_proc = l_cumulusProc;
-        }
-        else //both are nullptr
-        {
-            // Send errorlog because we cannot find any NIMBUS or CUMULUS procs.
-            FAPI_ERR("FAPI2_GETPARENT:: could not find Nimbus or Cumulus procs, skipping tests");
-            numFails++;
-            /*@
-            * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid     fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode   fapi2::RC_NO_PROCS_FOUND
-            * @userdata1    Model Type we looked for (Nimbus)
-            * @userdata2    Other Model Type we looked for (Cumulus)
-            * @devdesc      Couldn't find nimbus or cumulus procs in sys model
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_NO_PROCS_FOUND,
-                                          TARGETING::MODEL_NIMBUS,
-                                          TARGETING::MODEL_CUMULUS,
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            break;
-        }
-
-        TARGETING::Target* targeting_targets[NUM_TARGETS];
-        generateTargets(l_proc, targeting_targets);
-
-        for( uint64_t x = 0; x < NUM_TARGETS; x++ )
-        {
-            //Skip tests where the HW unit to test isn't valid for the proc type
-            if (!isHwValid(l_proc, x))
-            {
-                continue;
-            }
-            else if(targeting_targets[x] == nullptr)
-            {
-                FAPI_ERR("Unable to find target for item %d in targeting_targets", x);
-
-                /*@
-                * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
-                * @moduleid     fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-                * @reasoncode   fapi2::RC_NO_PATH_TO_TARGET_FOUND
-                * @userdata1    Index of target in array of objects
-                * @userdata2    Unused
-                * @devdesc      Could not find a path to the target of that type
-                */
-                l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_NO_PATH_TO_TARGET_FOUND,
-                                          x,
-                                          NULL,
-                                          true/*SW Error*/);
-                errlCommit(l_err,HWPF_COMP_ID);
-            }
-        }
-
-        Target<fapi2::TARGET_TYPE_PROC_CHIP> fapi2_procTarget(
-                l_proc);
-        Target<fapi2::TARGET_TYPE_EQ> fapi2_eqTarget(
-                targeting_targets[MY_EQ]);
-        Target<fapi2::TARGET_TYPE_EX> fapi2_exTarget(
-                targeting_targets[MY_EX]);
-        Target<fapi2::TARGET_TYPE_CORE> fapi2_coreTarget(
-                targeting_targets[MY_CORE]);
-        Target<fapi2::TARGET_TYPE_MCS> fapi2_mcsTarget(
-                targeting_targets[MY_MCS]);
-        Target<fapi2::TARGET_TYPE_MCA> fapi2_mcaTarget(
-                targeting_targets[MY_MCA]);
-        Target<fapi2::TARGET_TYPE_MCBIST> fapi2_mcbistTarget(
-                targeting_targets[MY_MCBIST]);
-        Target<fapi2::TARGET_TYPE_PEC> fapi2_pecTarget(
-                targeting_targets[MY_PEC]);
-        Target<fapi2::TARGET_TYPE_PHB> fapi2_phbTarget(
-                targeting_targets[MY_PHB]);
-        Target<fapi2::TARGET_TYPE_XBUS> fapi2_xbusTarget(
-                targeting_targets[MY_XBUS]);
-        Target<fapi2::TARGET_TYPE_OBUS> fapi2_obusTarget(
-                targeting_targets[MY_OBUS]);
-        Target<fapi2::TARGET_TYPE_OBUS_BRICK> fapi2_oBrickTarget(
-                targeting_targets[MY_OBUS_BRICK]);
-        Target<fapi2::TARGET_TYPE_PPE> fapi2_ppeTarget(
-                targeting_targets[MY_PPE]);
-        Target<fapi2::TARGET_TYPE_PERV> fapi2_pervTarget(
-                targeting_targets[MY_PERV]);
-        Target<fapi2::TARGET_TYPE_SBE> fapi2_sbeTarget(
-                targeting_targets[MY_SBE]);
-        Target<fapi2::TARGET_TYPE_CAPP> fapi2_cappTarget(
-                targeting_targets[MY_CAPP]);
-        Target<fapi2::TARGET_TYPE_MC> fapi2_mcTarget( // MC (Cumulus)
-                targeting_targets[MY_MC]);
-        Target<fapi2::TARGET_TYPE_MI> fapi2_miTarget( // MI (Cumulus)
-                targeting_targets[MY_MI]);
-        Target<fapi2::TARGET_TYPE_DMI> fapi2_dmiTarget( // DMI (Cumulus)
-                targeting_targets[MY_DMI]);
-
-        TARGETING::Target * l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_coreTarget.getParent<TARGET_TYPE_EX>());
-
-        //Check CORE's parents
-        numTests++;
-        if(TARGETING::get_huid(targeting_targets[MY_EX]) !=
-           TARGETING::get_huid(l_tempTargetingParent))
-        {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_CORE]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_CORE_NO_EX_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of core
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent EX of this
-            *                     CORE target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_CORE_NO_EX_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          targeting_targets[MY_EX])),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_EX)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL("fapi2TargetTest::Unable to find CORE's EX parent!");
-            numFails++;
-        }
-
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_coreTarget.getParent<TARGET_TYPE_EQ>());
-
-        numTests++;
-        if(TARGETING::get_huid(targeting_targets[MY_EQ]) !=
-           TARGETING::get_huid(l_tempTargetingParent))
-        {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_CORE]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_CORE_NO_EQ_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of core
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent EQ of this
-            *                     CORE target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_CORE_NO_EQ_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          targeting_targets[MY_EQ])),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_EQ)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find CORE's EQ parent!");
-            numFails++;
-        }
-
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_coreTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
-        {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_CORE]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_CORE_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of core
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     CORE target
-            */
-            l_err = new ERRORLOG::ErrlEntry(
-                                ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                fapi2::RC_CORE_NO_PROC_FOUND,
-                                TWO_UINT32_TO_UINT64(
-                                TO_UINT32(
-                                TARGETING::get_huid(
-                                l_proc)),
-                                TO_UINT32(
-                                TARGETING::get_huid(
-                                l_tempTargetingParent))),
-                                TWO_UINT32_TO_UINT64(
-                                TO_UINT32(l_instance),
-                                TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find CORE's PROC parent!");
-            numFails++;
-        }
-
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_exTarget.getParent<TARGET_TYPE_EQ>());
-
-        //Check EX's parents
-        numTests++;
-        if(TARGETING::get_huid(targeting_targets[MY_EQ]) !=
-           TARGETING::get_huid(l_tempTargetingParent))
-        {
-
-          uint8_t l_instance = 0;
-          targeting_targets[MY_EX]->
-          tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-          /*@
-          * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-          * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-          * @reasoncode         fapi2::RC_EX_NO_EQ_FOUND
-          * @userdata1[0:31]    Expected Parent HUID
-          * @userdata1[32:63]   Actual Parent HUID
-          * @userdata2[0:31]    Instance of EX
-          * @userdata2[32:63]   fapi2 Type of expected parent
-          * @devdesc            Could not find the parent EQ of this EX target
-          */
-          l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                        fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                        fapi2::RC_EX_NO_EQ_FOUND,
-                                        TWO_UINT32_TO_UINT64(
-                                        TO_UINT32(
-                                        TARGETING::get_huid(
-                                        targeting_targets[MY_EQ])),
-                                        TO_UINT32(
-                                        TARGETING::get_huid(
-                                        l_tempTargetingParent))),
-                                        TWO_UINT32_TO_UINT64(
-                                        TO_UINT32(l_instance),
-                                        TO_UINT32(TARGET_TYPE_EQ)),
-                                        true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find EX's EQ parent!");
-            numFails++;
-        }
-
-
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_exTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-
-        //Check EX's parents
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
-        {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_EX]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_EX_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of EX
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc           Could not find the parent PROC of this
-            *                    EX target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_EX_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find EXs's PROC parent!");
-            numFails++;
-        }
-
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_eqTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-
-        //Check EQ's parents
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
-        {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_EQ]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_EQ_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of EQ
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     EQ target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_EQ_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find EQs's PROC parent!");
-            numFails++;
-        }
-
-        if (isHwValid(l_proc, MY_MCA)
-              && isHwValid(l_proc, MY_MCBIST)
-              && isHwValid(l_proc, MY_MCS))
-        {
-            l_tempTargetingParent =
-                static_cast<TARGETING::Target*>(
-                    fapi2_mcaTarget.getParent<TARGET_TYPE_MCS>());
-
-            //Check MCA's parents
-            numTests++;
-            if(TARGETING::get_huid(targeting_targets[MY_MCS]) !=
-               TARGETING::get_huid(l_tempTargetingParent))
-            {
-                uint8_t l_instance = 0;
-                targeting_targets[MY_MCA]->
-                tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-                /*@
-                * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-                * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-                * @reasoncode         fapi2::RC_MCA_NO_MCS_FOUND
-                * @userdata1[0:31]    Expected Parent HUID
-                * @userdata1[32:63]   Actual Parent HUID
-                * @userdata2[0:31]    Instance of MCA
-                * @userdata2[32:63]   fapi2 Type of expected parent
-                * @devdesc            Could not find the parent MSC of this
-                *                     MCA target
-                */
-                l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_MCA_NO_MCS_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          targeting_targets[MY_MCS])),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_MCS)),
-                                          true/*SW Error*/);
-                errlCommit(l_err,HWPF_COMP_ID);
-                TS_FAIL( "fapi2TargetTest::Unable to find MCA's MCS parent!");
-                numFails++;
-            }
-
-            l_tempTargetingParent =
-                static_cast<TARGETING::Target*>(
-                    fapi2_mcaTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-
-            numTests++;
-
-            if(TARGETING::get_huid(l_proc) !=
-               TARGETING::get_huid(l_tempTargetingParent))
-            {
-                uint8_t l_instance = 0;
-                targeting_targets[MY_MCA]->
-                tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-                /*@
-                * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-                * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-                * @reasoncode         fapi2::RC_MCA_NO_PROC_FOUND
-                * @userdata1[0:31]    Expected Parent HUID
-                * @userdata1[32:63]   Actual Parent HUID
-                * @userdata2[0:31]    Instance of MCA
-                * @userdata2[32:63]   fapi2 Type of expected parent
-                * @devdesc            Could not find the parent PROC of this
-                *                     MCA target
-                */
-                l_err = new ERRORLOG::ErrlEntry(
-                                  ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                  fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                  fapi2::RC_MCA_NO_PROC_FOUND,
-                                  TWO_UINT32_TO_UINT64(
-                                  TO_UINT32(
-                                  TARGETING::get_huid(
-                                  l_proc)),
-                                  TO_UINT32(
-                                  TARGETING::get_huid(
-                                  l_tempTargetingParent))),
-                                  TWO_UINT32_TO_UINT64(
-                                  TO_UINT32(l_instance),
-                                  TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                  true/*SW Error*/);
-                errlCommit(l_err,HWPF_COMP_ID);
-                TS_FAIL( "fapi2TargetTest::Unable to find MCA's PROC parent!");
-                numFails++;
-            }
-        }
-
-        //Check MCS's parents -- Only for Nimbus
-        if (isHwValid(l_proc, MY_MCA)
-              && isHwValid(l_proc, MY_MCBIST)
-              && isHwValid(l_proc, MY_MCS))
+        GENERATE_TEST_TARGETS(test_fapi2GetChildren)
+
+#define GET_PARENT_TEST_MACRO(TEST_TARGET_ID, SRC_TYPE, PARENT_TEST_TARGET_ID, PARENT_TYPE)                    \
+    {                                                                                                          \
+        fapi2::Target<SRC_TYPE> l_src(targeting_targets[TEST_TARGET_ID]);                                      \
+        TARGETING::Target * l_parent = static_cast<TARGETING::Target*>(l_src.getParent<PARENT_TYPE>());        \
+        numTests++;                                                                                            \
+        if(TARGETING::get_huid(targeting_targets[PARENT_TEST_TARGET_ID]) !=                                    \
+            TARGETING::get_huid(l_parent))                                                                     \
+        {                                                                                                      \
+            uint8_t l_instance = 0;                                                                            \
+            targeting_targets[TEST_TARGET_ID]->                                                                \
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);                                                 \
+            TS_FAIL("fapi2TargetTest::Unable to find SRC_TYPE's" #PARENT_TYPE "parent!");                      \
+            numFails++;                                                                                        \
+        }                                                                                                      \
+    }
+
+    //// Start Common Targets
+    // EQ Parent Tests
+    GET_PARENT_TEST_MACRO(MY_EQ, TARGET_TYPE_EQ, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // EX Parent Tests
+    GET_PARENT_TEST_MACRO(MY_EX, TARGET_TYPE_EX, MY_EQ,   TARGET_TYPE_EQ)
+    GET_PARENT_TEST_MACRO(MY_EX, TARGET_TYPE_EX, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // Core Parent Tests
+    GET_PARENT_TEST_MACRO(MY_CORE, TARGET_TYPE_CORE, MY_EX,   TARGET_TYPE_EX)
+    GET_PARENT_TEST_MACRO(MY_CORE, TARGET_TYPE_CORE, MY_EQ,   TARGET_TYPE_EQ)
+    GET_PARENT_TEST_MACRO(MY_CORE, TARGET_TYPE_CORE, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // PHB Parent Test
+    GET_PARENT_TEST_MACRO(MY_PHB, TARGET_TYPE_PHB, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // PEC Parent Test
+    GET_PARENT_TEST_MACRO(MY_PEC, TARGET_TYPE_PEC, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // XBUS Parent Test
+    GET_PARENT_TEST_MACRO(MY_XBUS, TARGET_TYPE_XBUS, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // OBUS Parent Test
+    GET_PARENT_TEST_MACRO(MY_OBUS, TARGET_TYPE_OBUS, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // OBUS Brick Parent Test
+    GET_PARENT_TEST_MACRO(MY_OBUS_BRICK, TARGET_TYPE_OBUS_BRICK, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    GET_PARENT_TEST_MACRO(MY_OBUS_BRICK, TARGET_TYPE_OBUS_BRICK, MY_OBUS, TARGET_TYPE_OBUS)
+    // PPE Parent Test
+    GET_PARENT_TEST_MACRO(MY_PPE, TARGET_TYPE_PPE, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // PERV Parent Test
+    GET_PARENT_TEST_MACRO(MY_PERV, TARGET_TYPE_PERV, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // CAPP Parent Test
+    GET_PARENT_TEST_MACRO(MY_CAPP, TARGET_TYPE_CAPP, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    // SBE Parent Test
+    GET_PARENT_TEST_MACRO(MY_SBE, TARGET_TYPE_SBE, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    ////End Common Targets
+
+    //// Start Nimbus only Targets
+    // MCA Parent Tests
+    if (isHwValid(l_proc, MY_MCA))
+    {
+        // Check proc parent
+        GET_PARENT_TEST_MACRO(MY_MCA, TARGET_TYPE_MCA, MY_PROC, TARGET_TYPE_PROC_CHIP)
+        if(isHwValid(l_proc, MY_MCS))
         {
-            l_tempTargetingParent =
-                static_cast<TARGETING::Target*>(
-                    fapi2_mcsTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-
-            numTests++;
-            if(TARGETING::get_huid(l_proc) !=
-               TARGETING::get_huid(l_tempTargetingParent))
-            {
-                uint8_t l_instance = 0;
-                targeting_targets[MY_MCS]->
-                tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-                /*@
-                * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-                * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-                * @reasoncode         fapi2::RC_MCS_NO_PROC_FOUND
-                * @userdata1[0:31]    Expected Parent HUID
-                * @userdata1[32:63]   Actual Parent HUID
-                * @userdata2[0:31]    Instance of MCS
-                * @userdata2[32:63]   fapi2 Type of expected parent
-                * @devdesc            Could not find the parent PROC of this
-                *                     MCS target
-                */
-                l_err= new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_MCS_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-                errlCommit(l_err,HWPF_COMP_ID);
-                TS_FAIL( "fapi2TargetTest::Unable to find MCS's PROC parent!");
-                numFails++;
-            }
-
-            //Check MCBIST's parents
-            l_tempTargetingParent =
-                static_cast<TARGETING::Target*>(
-                    fapi2_mcbistTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-
-            numTests++;
-            if(TARGETING::get_huid(l_proc) !=
-               TARGETING::get_huid(l_tempTargetingParent))
-            {
-                uint8_t l_instance = 0;
-                targeting_targets[MY_MCBIST]->
-                tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-                /*@
-                * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-                * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-                * @reasoncode         fapi2::RC_MCBIST_NO_PROC_FOUND
-                * @userdata1[0:31]    Expected Parent HUID
-                * @userdata1[32:63]   Actual Parent HUID
-                * @userdata2[0:31]    Instance of MCS
-                * @userdata2[32:63]   fapi2 Type of expected parent
-                * @devdesc            Could not find the parent PROC of this
-                *                     MCBIST target
-                */
-                l_err =new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_MCBIST_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-                errlCommit(l_err,HWPF_COMP_ID);
-                TS_FAIL( "fapi2TargetTest::Unable to find MCBIST's PROC parent!");
-               numFails++;
-            }
+            // Check MCS parent
+            GET_PARENT_TEST_MACRO(MY_MCA, TARGET_TYPE_MCA, MY_MCS, TARGET_TYPE_MCS)
         }
-
-        //Check PHB's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_phbTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+        if(isHwValid(l_proc, MY_MCBIST))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_PHB]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_PHB_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of PHB
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     PHB target
-            */
-            l_err = new ERRORLOG::ErrlEntry(
-                                ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                fapi2::RC_PHB_NO_PROC_FOUND,
-                                TWO_UINT32_TO_UINT64(
-                                TO_UINT32(
-                                TARGETING::get_huid(
-                                l_proc)),
-                                TO_UINT32(
-                                TARGETING::get_huid(
-                                l_tempTargetingParent))),
-                                TWO_UINT32_TO_UINT64(
-                                TO_UINT32(l_instance),
-                                TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find PHB's PROC parent!");
-            numFails++;
+            // Check MCBIST parent
+            GET_PARENT_TEST_MACRO(MY_MCA, TARGET_TYPE_MCA, MY_MCBIST, TARGET_TYPE_MCBIST)
         }
+    }
+    // MCS Parent Tests
+    if (isHwValid(l_proc, MY_MCBIST) &&
+        isHwValid(l_proc, MY_MCS))
+    {
+        GET_PARENT_TEST_MACRO(MY_MCS, TARGET_TYPE_MCS, MY_MCBIST, TARGET_TYPE_MCBIST)
+        GET_PARENT_TEST_MACRO(MY_MCS, TARGET_TYPE_MCS, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    }
+    // MCBIST Parent Test
+    if (isHwValid(l_proc, MY_MCBIST))
+    {
+        GET_PARENT_TEST_MACRO(MY_MCBIST, TARGET_TYPE_MCBIST, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    }
+    //// End NIMBUS targets
 
-        //Check PEC's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_pecTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+    //// Start Cumulus/Axone common targets
+    // MC Parent Test
+    if (isHwValid(l_proc, MY_MC))
+    {
+        // Check parent proc
+        GET_PARENT_TEST_MACRO(MY_MC, TARGET_TYPE_MC, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    }
+    // MI Parent Tests
+    if (isHwValid(l_proc, MY_MC) &&
+        isHwValid(l_proc, MY_MI))
+    {
+        // Check parent MC
+        GET_PARENT_TEST_MACRO(MY_MI, TARGET_TYPE_MI, MY_MC, TARGET_TYPE_MC)
+        // Check parent proc
+        GET_PARENT_TEST_MACRO(MY_MI, TARGET_TYPE_MI, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    }
+    //// End Cumulus/Axone common targets
+
+    //// Start Cumulus only targets
+    // DMI Parent Tests
+    if (isHwValid(l_proc, MY_DMI))
+    {
+        // Check parent proc
+        GET_PARENT_TEST_MACRO(MY_DMI, TARGET_TYPE_DMI, MY_PROC, TARGET_TYPE_PROC_CHIP)
+        if(isHwValid(l_proc, MY_MI))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_PEC]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_PEC_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of PEC
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     PEC target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_PEC_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find PEC's PROC parent!");
-            numFails++;
+            // Check parent MI
+            GET_PARENT_TEST_MACRO(MY_DMI, TARGET_TYPE_DMI, MY_MI, TARGET_TYPE_MI)
         }
-
-        //Check XBUS's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_xbusTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+        if(isHwValid(l_proc, MY_MC))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_XBUS]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_XBUS_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of XBUS
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     XBUS target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_XBUS_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find XBUS's PROC parent!");
-            numFails++;
+            // Check parent MC
+            GET_PARENT_TEST_MACRO(MY_DMI, TARGET_TYPE_DMI, MY_MC, TARGET_TYPE_MC)
         }
+    }
+    //// End Cumulus only targets
 
-        //Check OBUS's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_obusTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+    //// Start Axone only targets
+    // MCC Parent Tests
+    if (isHwValid(l_proc, MY_MCC))
+    {
+        // Check parent proc
+        GET_PARENT_TEST_MACRO(MY_MCC, TARGET_TYPE_MCC, MY_PROC, TARGET_TYPE_PROC_CHIP)
+        if(isHwValid(l_proc, MY_MI))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_OBUS]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_OBUS_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of OBUS
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     OBUS target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_OBUS_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-           errlCommit(l_err,HWPF_COMP_ID);
-           TS_FAIL( "fapi2TargetTest::Unable to find OBUS's PROC parent!");
-           numFails++;
+            // Check parent MI
+            GET_PARENT_TEST_MACRO(MY_MCC, TARGET_TYPE_MCC, MY_MI, TARGET_TYPE_MI)
         }
-
-        //Check OBUS BRICK's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_oBrickTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+        if(isHwValid(l_proc, MY_MC))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_OBUS_BRICK]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_OBRICK_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of OBUS BRICK
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     OBUS BRICK target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_OBRICK_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find OBUS BRICK's PROC parent!");
-            numFails++;
+            // Check parent MC
+            GET_PARENT_TEST_MACRO(MY_MCC, TARGET_TYPE_MCC, MY_MC, TARGET_TYPE_MC)
         }
-
-        //Check PPE's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_ppeTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+    }
+    // OMIC Parent Tests
+    if (isHwValid(l_proc, MY_MC)  &&
+        isHwValid(l_proc, MY_OMIC))
+    {
+        // Check parent MC
+        GET_PARENT_TEST_MACRO(MY_OMI, TARGET_TYPE_OMIC, MY_MC, TARGET_TYPE_MC)
+        // Check parent proc
+        GET_PARENT_TEST_MACRO(MY_OMI, TARGET_TYPE_OMIC, MY_PROC, TARGET_TYPE_PROC_CHIP)
+    }
+    // OMI Parent Tests
+    if (isHwValid(l_proc, MY_OMI))
+    {
+        // Check parent proc
+        GET_PARENT_TEST_MACRO(MY_OMI, TARGET_TYPE_OMI, MY_PROC, TARGET_TYPE_PROC_CHIP)
+        if (isHwValid(l_proc, MY_MCC))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_PPE]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_PPE_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of PPE
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     PPE target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_PPE_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::Unable to find PPE's PROC parent!");
-            numFails++;
+            // Check parent MCC
+            GET_PARENT_TEST_MACRO(MY_OMI, TARGET_TYPE_OMI, MY_MCC, TARGET_TYPE_MCC)
         }
-
-        //Check PERV's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_pervTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+        if (isHwValid(l_proc, MY_OMIC))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_PERV]->
-              tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_PERV_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of PERV
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     PERV target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_PERV_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-           errlCommit(l_err,HWPF_COMP_ID);
-           TS_FAIL( "fapi2TargetTest::Unable to find PERV's PROC parent!");
-           numFails++;
+            // Check parent OMIC
+            GET_PARENT_TEST_MACRO(MY_OMI, TARGET_TYPE_OMI, MY_OMIC, TARGET_TYPE_OMIC)
         }
-
-        //Check CAPP's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_cappTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+        if (isHwValid(l_proc, MY_MI))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_CAPP]->
-              tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_CAPP_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of CAPP
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     CAPP target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_CAPP_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-           errlCommit(l_err,HWPF_COMP_ID);
-           TS_FAIL( "fapi2TargetTest::Unable to find CAPP's PROC parent!");
-           numFails++;
+            // Check parent MI
+            GET_PARENT_TEST_MACRO(MY_OMI, TARGET_TYPE_OMI, MY_MI, TARGET_TYPE_MI)
         }
-
-        //Check SBE's parents
-        l_tempTargetingParent =
-            static_cast<TARGETING::Target*>(
-                fapi2_sbeTarget.getParent<TARGET_TYPE_PROC_CHIP>());
-        numTests++;
-        if(TARGETING::get_huid(l_proc) !=
-           TARGETING::get_huid(l_tempTargetingParent))
+        if (isHwValid(l_proc, MY_MC))
         {
-            uint8_t l_instance = 0;
-            targeting_targets[MY_SBE]->
-            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
-            /*@
-            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
-            * @reasoncode         fapi2::RC_SBE_NO_PROC_FOUND
-            * @userdata1[0:31]    Expected Parent HUID
-            * @userdata1[32:63]   Actual Parent HUID
-            * @userdata2[0:31]    Instance of SBE
-            * @userdata2[32:63]   fapi2 Type of expected parent
-            * @devdesc            Could not find the parent PROC of this
-            *                     SBE target
-            */
-            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
-                                          fapi2::RC_SBE_NO_PROC_FOUND,
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_proc)),
-                                          TO_UINT32(
-                                          TARGETING::get_huid(
-                                          l_tempTargetingParent))),
-                                          TWO_UINT32_TO_UINT64(
-                                          TO_UINT32(l_instance),
-                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
-                                          true/*SW Error*/);
-            errlCommit(l_err,HWPF_COMP_ID);
-            TS_FAIL( "fapi2TargetTest::UnAble to find SBE's PROC parent!");
-            numFails++;
+            // Check parent MC
+            GET_PARENT_TEST_MACRO(MY_OMI, TARGET_TYPE_OMI, MY_MC, TARGET_TYPE_MC)
         }
+    }
+    // End Axone only targets
 
         static pervasiveParentTestRec nimbusPervasiveParentTests [] = {
              {targeting_targets[MY_EQ],
@@ -1064,18 +302,66 @@ void test_fapi2GetParent()
                  {return getPervasiveParent<TARGET_TYPE_DMI>(i_pTarget); }},
           };
 
+        static pervasiveParentTestRec axonePervasiveParentTests [] = {
+            {targeting_targets[MY_EQ],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_EQ>(i_pTarget); }},
+            {targeting_targets[MY_CORE],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_CORE>(i_pTarget); }},
+            {targeting_targets[MY_PEC],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_PEC>(i_pTarget); }},
+            {targeting_targets[MY_PHB],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_PHB>(i_pTarget); }},
+            {targeting_targets[MY_XBUS],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_XBUS>(i_pTarget); }},
+            {targeting_targets[MY_OBUS],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_OBUS>(i_pTarget); }},
+            {targeting_targets[MY_OBUS_BRICK],
+             [](TARGETING::Target* i_pTarget)
+               {return getPervasiveParent<TARGET_TYPE_OBUS_BRICK>(i_pTarget);}},
+            {targeting_targets[MY_CAPP],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_CAPP>(i_pTarget); }},
+            {targeting_targets[MY_MC],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_MC>(i_pTarget); }},
+            {targeting_targets[MY_MI],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_MI>(i_pTarget); }},
+            {targeting_targets[MY_MCC],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_MCC>(i_pTarget); }},
+            {targeting_targets[MY_OMI],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_OMI>(i_pTarget); }},
+            {targeting_targets[MY_OMIC],
+             [](TARGETING::Target* i_pTarget)
+                 {return getPervasiveParent<TARGET_TYPE_OMIC>(i_pTarget); }},
+          };
+
         pervasiveParentTestRec* ptr;
         int numPervTests = 0;
-        if (l_nimbusProc != nullptr)
+        auto l_model = l_proc->getAttr<TARGETING::ATTR_MODEL>();
+        if (l_model == TARGETING::MODEL_NIMBUS)
         {
             numPervTests = sizeof(nimbusPervasiveParentTests) / sizeof(pervasiveParentTestRec);
             ptr = nimbusPervasiveParentTests;
         }
-        else
+        else if (l_model == TARGETING::MODEL_CUMULUS)
         {
             numPervTests = sizeof(cumulusPervasiveParentTests) / sizeof(pervasiveParentTestRec);
             ptr = cumulusPervasiveParentTests;
         }
+        else
+        {
+            numPervTests = sizeof(axonePervasiveParentTests) / sizeof(pervasiveParentTestRec);
+            ptr = axonePervasiveParentTests;
+        }
 
         // Test each type of target that can have exactly one pervasive parent
         for (int i = 0; i < numPervTests; ++i)
@@ -1087,7 +373,7 @@ void test_fapi2GetParent()
                 FAPI_ERR("Found pervasive parent to be null pervasiveParentTestRec for test: %d",
                           i);
             }
-            l_tempTargetingParent = pervasiveParentTest.getParent(
+            TARGETING::Target * l_tempTargetingParent = pervasiveParentTest.getParent(
                 pervasiveParentTest.pTarget);
 
             // Result must be a non-nullptr target of pervasive type, and its
diff --git a/src/usr/fapi2/test/fapi2HwpTest.H b/src/usr/fapi2/test/fapi2HwpTest.H
index 167e4f313..416086c81 100644
--- a/src/usr/fapi2/test/fapi2HwpTest.H
+++ b/src/usr/fapi2/test/fapi2HwpTest.H
@@ -31,11 +31,8 @@
 #include <p9_sample_procedure.H>
 #include <plat_hwp_invoker.H>
 
-
-
 using namespace fapi2;
 
-
 class Fapi2HwpTest : public CxxTest::TestSuite
 {
 public:
@@ -50,317 +47,61 @@ void test_fapi2Hwp()
 
     do
     {
-        // Create a vector of TARGETING::Target pointers
-        TARGETING::TargetHandleList l_chipList;
-
-        // Get a list of all of the proc chips
-        TARGETING::getAllChips(l_chipList, TARGETING::TYPE_PROC, false);
-
-        TARGETING::Target * l_nimbusProc = nullptr;
-        TARGETING::Target * l_cumulusProc = nullptr;
-        TARGETING::Target * l_proc = nullptr;
-
-        //Take the first NIMBUS proc and use it
-        for(uint32_t i = 0; i < l_chipList.size(); i++)
-        {
-            if(TARGETING::MODEL_NIMBUS ==
-            l_chipList[i]->getAttr<TARGETING::ATTR_MODEL>())
-            {
-              l_nimbusProc = l_chipList[i];
-              break;
-            }
-            if(TARGETING::MODEL_CUMULUS ==
-            l_chipList[i]->getAttr<TARGETING::ATTR_MODEL>())
-            {
-              l_cumulusProc = l_chipList[i];
-              break;
-            }
-        }
-        numTests++;
-
-        if (l_nimbusProc != nullptr)
-        {
-            l_proc = l_nimbusProc;
-        }
-        else if (l_cumulusProc != nullptr)
-        {
-            l_proc = l_cumulusProc;
-        }
-        else //both are nullptr
-        {
-            // Send an errorlog because we cannot find any NIMBUS procs.
-            FAPI_ERR("FAPI2_GETPARENT:: could not find a proc, skipping tests");
-            numFails++;
-            /*@
-            * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
-            * @moduleid     fapi2::MOD_FAPI2_PLAT_HWP_TEST
-            * @reasoncode   fapi2::RC_NO_PROCS_FOUND
-            * @userdata1    Model Type we looked for
-            * @userdata2    Other Model Type we looked for
-            * @devdesc      Could not find procs in system model
-            */
-            l_errl = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                            fapi2::MOD_FAPI2_PLAT_HWP_TEST,
-                                            fapi2::RC_NO_PROCS_FOUND,
-                                            TARGETING::MODEL_NIMBUS,
-                                            TARGETING::MODEL_CUMULUS,
-                                            true/*SW Error*/);
-            errlCommit(l_errl,HWPF_COMP_ID);
-            break;
-        }
-
-        TARGETING::Target* targeting_targets[NUM_TARGETS];
-        generateTargets(l_proc, targeting_targets);
-
-        for( uint64_t x = 0; x < NUM_TARGETS; x++ )
-        {
-            //Skip tests where the HW unit to test isn't valid for the proc type
-            if (!isHwValid(l_proc, x))
-            {
-                continue;
-            }
-            else if(targeting_targets[x] == nullptr)
-            {
-              FAPI_ERR("Unable to find target for item %d in targeting_targets", x);
-
-              /*@
-              * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
-              * @moduleid     fapi2::MOD_FAPI2_PLAT_HWP_TEST
-              * @reasoncode   fapi2::RC_NO_PATH_TO_TARGET_FOUND
-              * @userdata1    Index of target in array of objects
-              * @userdata2    Unused
-              * @devdesc      Could not find a path to the target of that type
-              */
-              l_errl = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                              fapi2::MOD_FAPI2_PLAT_HWP_TEST,
-                                              fapi2::RC_NO_PATH_TO_TARGET_FOUND,
-                                              x,
-                                              NULL,
-                                              true/*SW Error*/);
-              errlCommit(l_errl,HWPF_COMP_ID);
-            }
-        }
-
-        fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP> fapi2_procTarget(l_proc);
-        fapi2::Target<fapi2::TARGET_TYPE_EQ> fapi2_eqTarget(targeting_targets[MY_EQ]);
-        fapi2::Target<fapi2::TARGET_TYPE_EX> fapi2_exTarget(targeting_targets[MY_EX]);
-        fapi2::Target<fapi2::TARGET_TYPE_CORE> fapi2_coreTarget(
-                targeting_targets[MY_CORE]);
-        fapi2::Target<fapi2::TARGET_TYPE_MCS> fapi2_mcsTarget(targeting_targets[MY_MCS]);
-        fapi2::Target<fapi2::TARGET_TYPE_MCA> fapi2_mcaTarget(targeting_targets[MY_MCA]);
-        fapi2::Target<fapi2::TARGET_TYPE_MCBIST> fapi2_mcbistTarget(
-                                                    targeting_targets[MY_MCBIST]);
-        fapi2::Target<fapi2::TARGET_TYPE_PEC> fapi2_pecTarget(targeting_targets[MY_PEC]);
-        fapi2::Target<fapi2::TARGET_TYPE_PHB> fapi2_phbTarget(targeting_targets[MY_PHB]);
-        fapi2::Target<fapi2::TARGET_TYPE_XBUS> fapi2_xbusTarget(
-                targeting_targets[MY_XBUS]);
-        fapi2::Target<fapi2::TARGET_TYPE_OBUS> fapi2_obusTarget(
-                targeting_targets[MY_OBUS]);
-        fapi2::Target<fapi2::TARGET_TYPE_OBUS_BRICK> fapi2_oBrickTarget(
-                targeting_targets[MY_OBUS_BRICK]);
-        fapi2::Target<fapi2::TARGET_TYPE_PPE> fapi2_ppeTarget(targeting_targets[MY_PPE]);
-        fapi2::Target<fapi2::TARGET_TYPE_PERV> fapi2_pervTarget(
-                targeting_targets[MY_PERV]);
-        fapi2::Target<fapi2::TARGET_TYPE_SBE> fapi2_sbeTarget(targeting_targets[MY_SBE]);
-        fapi2::Target<fapi2::TARGET_TYPE_CAPP> fapi2_cappTarget(
-                                      targeting_targets[MY_CAPP]);
-        fapi2::Target<fapi2::TARGET_TYPE_MC> fapi2_mcTarget(targeting_targets[MY_MC]);
-        fapi2::Target<fapi2::TARGET_TYPE_MI> fapi2_miTarget(targeting_targets[MY_MI]);
-        fapi2::Target<fapi2::TARGET_TYPE_DMI> fapi2_dmiTarget(targeting_targets[MY_DMI]);
+        GENERATE_TEST_TARGETS(test_fapi2GetChildren)
 
+        // scratch value to use in following tests
         int scratchWriteValue = 5;
 
-        //Get/Set Attr for all of the targets
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_proc, fapi2_procTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_proc !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_eq, fapi2_eqTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_eq !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_ex, fapi2_exTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_ex !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_core, fapi2_coreTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_core !!");
-        }
-        if (isHwValid(l_proc, MY_MCS))
-        {
-            numTests++;
-            FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_mcs, fapi2_mcsTarget, scratchWriteValue);
-            if(l_errl != nullptr)
-            {
-              delete l_errl;
-              l_errl = nullptr;
-              numFails++;
-              TS_FAIL("Error occured in p9_sample_procedure_mcs !!");
-            }
-        }
-        if (isHwValid(l_proc, MY_MCA))
-        {
-            numTests++;
-            FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_mca, fapi2_mcaTarget, scratchWriteValue);
-            if(l_errl != nullptr)
-            {
-              delete l_errl;
-              l_errl = nullptr;
-              numFails++;
-              TS_FAIL("Error occured in p9_sample_procedure_mca !!");
-            }
-        }
-        if (isHwValid(l_proc, MY_MCBIST))
-        {
-            numTests++;
-            FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_mcbist, fapi2_mcbistTarget, scratchWriteValue);
-            if(l_errl != nullptr)
-            {
-              delete l_errl;
-              l_errl = nullptr;
-              numFails++;
-              TS_FAIL("Error occured in p9_sample_procedure_mcbist !!");
-            }
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_pec, fapi2_pecTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_pec !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_phb, fapi2_phbTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_phb !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_xbus, fapi2_xbusTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_xbus !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_obus, fapi2_obusTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_obus !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_obrick, fapi2_oBrickTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_obrick !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_ppe, fapi2_ppeTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_ppe !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_perv, fapi2_pervTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_perv !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_sbe, fapi2_sbeTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_sbe !!");
-        }
-        numTests++;
-        FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_capp, fapi2_cappTarget, scratchWriteValue);
-        if(l_errl != nullptr)
-        {
-          delete l_errl;
-          l_errl = nullptr;
-          numFails++;
-          TS_FAIL("Error occured in p9_sample_procedure_capp !!");
-        }
-
-        if (isHwValid(l_proc, MY_MC))
-        {
-            numTests++;
-            FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_mc, fapi2_mcTarget, scratchWriteValue);
-            if(l_errl != nullptr)
-            {
-              delete l_errl;
-              l_errl = nullptr;
-              numFails++;
-              TS_FAIL("Error occured in p9_sample_procedure_mc !!");
-            }
-        }
-        if (isHwValid(l_proc, MY_MI))
-        {
-            numTests++;
-            FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_mi, fapi2_miTarget, scratchWriteValue);
-            if(l_errl != nullptr)
-            {
-              delete l_errl;
-              l_errl = nullptr;
-              numFails++;
-              TS_FAIL("Error occured in p9_sample_procedure_mi !!");
-            }
-        }
-        if (isHwValid(l_proc, MY_DMI))
-        {
-            numTests++;
-            FAPI_INVOKE_HWP(l_errl, p9_sample_procedure_dmi, fapi2_dmiTarget, scratchWriteValue);
-            if(l_errl != nullptr)
-            {
-              delete l_errl;
-              l_errl = nullptr;
-              numFails++;
-              TS_FAIL("Error occured in p9_sample_procedure_dmi !!");
-            }
-        }
+        #define HWP_TEST_COMMON_MACRO(PROCEDURE_NAME, FAPI2_TARGET)                             \
+        /*Get/Set Attr for all of the targets*/                                                 \
+        numTests++;                                                                             \
+        FAPI_INVOKE_HWP(l_errl, PROCEDURE_NAME, FAPI2_TARGET, scratchWriteValue);               \
+        if(l_errl != nullptr)                                                                   \
+        {                                                                                       \
+            delete l_errl;                                                                      \
+            l_errl = nullptr;                                                                   \
+            numFails++;                                                                         \
+            TS_FAIL("Error occured in" #PROCEDURE_NAME "!!");                                   \
+        }                                                                                       \
+
+        #define HWP_TEST_MODEL_SPECIFIC_MACRO(PROCEDURE_NAME, FAPI2_TARGET, TEST_TARGET)        \
+        if (isHwValid(l_proc, TEST_TARGET))                                                     \
+        {                                                                                       \
+            numTests++;                                                                         \
+            FAPI_INVOKE_HWP(l_errl, PROCEDURE_NAME, FAPI2_TARGET, scratchWriteValue);           \
+            if(l_errl != nullptr)                                                               \
+            {                                                                                   \
+                delete l_errl;                                                                  \
+                l_errl = nullptr;                                                               \
+                numFails++;                                                                     \
+                TS_FAIL("Error occured in" #PROCEDURE_NAME "!!");                               \
+            }                                                                                   \
+        }                                                                                       \
+
+        // Common for all P9 Models
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_proc, fapi2_procTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_eq, fapi2_eqTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_ex, fapi2_exTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_core, fapi2_coreTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_pec, fapi2_pecTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_phb, fapi2_phbTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_xbus, fapi2_xbusTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_obus, fapi2_obusTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_obrick, fapi2_oBrickTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_ppe, fapi2_ppeTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_perv, fapi2_pervTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_sbe, fapi2_sbeTarget)
+        HWP_TEST_COMMON_MACRO(p9_sample_procedure_capp, fapi2_cappTarget)
+        // Targets that are only found in specific models
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_mcs, fapi2_mcsTarget, MY_MCS)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_mca, fapi2_mcaTarget, MY_MCA)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_mcbist, fapi2_mcbistTarget, MY_MCBIST)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_mc, fapi2_mcTarget, MY_MC)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_mi, fapi2_miTarget, MY_MI)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_dmi, fapi2_dmiTarget, MY_DMI)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_omi, fapi2_omiTarget, MY_OMI)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_omic, fapi2_omicTarget, MY_OMIC)
+        HWP_TEST_MODEL_SPECIFIC_MACRO(p9_sample_procedure_mcc, fapi2_mccTarget, MY_MCC)
 
     }while(0);
     FAPI_INF("test_fapiHWP:: Test Complete. %d/%d fails",  numFails,numTests);
diff --git a/src/usr/fapi2/test/fapi2IsFunctionalTest.H b/src/usr/fapi2/test/fapi2IsFunctionalTest.H
index 35e938eb0..861c917c8 100644
--- a/src/usr/fapi2/test/fapi2IsFunctionalTest.H
+++ b/src/usr/fapi2/test/fapi2IsFunctionalTest.H
@@ -41,173 +41,58 @@ class Fapi2IsFunctional : public CxxTest::TestSuite
     //**************************************************************************
     void test_fapi2IsFunctional()
     {
-        int numTests = 0;
-        int numFails = 0;
 
         TARGETING::HwasState currentState;
         bool functional;
-        TARGETING::Target * currTarg;
-
+        int numTests = 0;
+        int numFails = 0;
         FAPI_DBG("Enter test_fapi2IsFunctional");
         do
         {
-            // get the master proc
-            TARGETING::Target * proc;
-            TARGETING::targetService().masterProcChipTargetHandle(proc);
-
-            // create targeting/fapi2 target arrays to hold targets
-            // *Note: NUM_TARGETS does not include the processor target
-            //  so we make the array big enough to add it.
-            TARGETING::Target*  targetList[NUM_TARGETS+1];
-            fapi2::Target<fapi2::TARGET_TYPE_ALL> fapiTargetList[NUM_TARGETS+1];
-
-            // generate the TARGETING::Targets to test on and add them
-            // to targeting array
-            generateTargets(proc, targetList);
-
-            // add the processor target to the end of the list
-            targetList[NUM_TARGETS] = proc;
-
-            // Verify we generated valid targets
-            for( uint64_t x = 0; x <= NUM_TARGETS; x++ )
-            {
-                //Skip tests where the HW unit to test isn't valid for the proc type
-                if (!isHwValid(proc, x))
-                {
-                    continue;
-                }
-                else if(targetList[x] == nullptr)
-                {
-                   FAPI_INF("fapi2IsFunctionalTest: Unable to find target at index [%d]",
-                            x);
-                }
-            }
-
-            //populate fapiTargetList
-            // EQ
-            Target<fapi2::TARGET_TYPE_EQ> fapi2_eqTarget(
-                    targetList[MY_EQ]);
-            fapiTargetList[MY_EQ] = fapi2_eqTarget;
-
-            // EX
-            Target<fapi2::TARGET_TYPE_EX> fapi2_exTarget(
-                    targetList[MY_EX]);
-            fapiTargetList[MY_EX] = fapi2_exTarget;
-
-            // CORE
-            Target<fapi2::TARGET_TYPE_CORE> fapi2_coreTarget(
-                    targetList[MY_CORE]);
-            fapiTargetList[MY_CORE] = fapi2_coreTarget;
-
-            // MCS
-            Target<fapi2::TARGET_TYPE_MCS> fapi2_mcsTarget(
-                    targetList[MY_MCS]);
-            fapiTargetList[MY_MCS] = fapi2_mcsTarget;
-
-            // MCA
-            Target<fapi2::TARGET_TYPE_MCA> fapi2_mcaTarget(
-                    targetList[MY_MCA]);
-            fapiTargetList[MY_MCA] = fapi2_mcaTarget;
-
-            // MCBIST
-            Target<fapi2::TARGET_TYPE_MCBIST> fapi2_mcbistTarget(
-                    targetList[MY_MCBIST]);
-            fapiTargetList[MY_MCBIST] = fapi2_mcbistTarget;
-
-            // PEC
-            Target<fapi2::TARGET_TYPE_PEC> fapi2_pecTarget(
-                    targetList[MY_PEC]);
-            fapiTargetList[MY_PEC] = fapi2_pecTarget;
-
-            // PHB
-            Target<fapi2::TARGET_TYPE_PHB> fapi2_phbTarget(
-                    targetList[MY_PHB]);
-            fapiTargetList[MY_PHB] = fapi2_phbTarget;
-
-            // XBUS
-            Target<fapi2::TARGET_TYPE_XBUS> fapi2_xbusTarget(
-                    targetList[MY_XBUS]);
-            fapiTargetList[MY_XBUS] = fapi2_xbusTarget;
-
-            // OBUS
-            Target<fapi2::TARGET_TYPE_OBUS> fapi2_obusTarget(
-                    targetList[MY_OBUS]);
-            fapiTargetList[MY_OBUS] = fapi2_obusTarget;
-
-            // OBUS_BRICK
-            Target<fapi2::TARGET_TYPE_OBUS_BRICK> fapi2_oBrickTarget(
-                    targetList[MY_OBUS_BRICK]);
-            fapiTargetList[MY_OBUS_BRICK] = fapi2_oBrickTarget;
-
-            // PPE
-            Target<fapi2::TARGET_TYPE_PPE> fapi2_ppeTarget(
-                    targetList[MY_PPE]);
-            fapiTargetList[MY_PPE] = fapi2_ppeTarget;
-
-            // PERV
-            Target<fapi2::TARGET_TYPE_PERV> fapi2_pervTarget(
-                    targetList[MY_PERV]);
-            fapiTargetList[MY_PERV] = fapi2_pervTarget;
-
-            // SBE
-            Target<fapi2::TARGET_TYPE_SBE> fapi2_sbeTarget(
-                    targetList[MY_SBE]);
-            fapiTargetList[MY_SBE] = fapi2_sbeTarget;
-
-            // CAPP
-            Target<fapi2::TARGET_TYPE_CAPP> fapi2_cappTarget(
-                    targetList[MY_CAPP]);
-            fapiTargetList[MY_CAPP] = fapi2_cappTarget;
-
-            // MC (Cumulus)
-            Target<fapi2::TARGET_TYPE_MC> fapi2_mcTarget(
-                    targetList[MY_MC]);
-            fapiTargetList[MY_MC] = fapi2_mcTarget;
-
-            // MI (Cumulus)
-            Target<fapi2::TARGET_TYPE_MI> fapi2_miTarget(
-                    targetList[MY_MI]);
-            fapiTargetList[MY_MI] = fapi2_miTarget;
-
-            // DMI (Cumulus)
-            Target<fapi2::TARGET_TYPE_DMI> fapi2_dmiTarget(
-                     targetList[MY_DMI]);
-            fapiTargetList[MY_DMI] = fapi2_dmiTarget;
-
-            // PROC_CHIP
-            Target<fapi2::TARGET_TYPE_PROC_CHIP> fapi2_procTarget(
-                    targetList[NUM_TARGETS]);
-            fapiTargetList[NUM_TARGETS] = fapi2_procTarget;
-
-            // Iterate through both arrays comparing ATTR_HWAS_STATE
-            // against the return of fapi2::Target<K> isFunctional()
-            for( int i = 0; i <= NUM_TARGETS; i++ )
-            {
-                numTests++;
-
-                if(targetList[i] == nullptr)
-                {
-                    continue;
-                }
-
-                currTarg = targetList[i];
-
-                // get the HWAS_STATE of the current target
-                currentState = currTarg->getAttr<TARGETING::ATTR_HWAS_STATE>();
-
-                functional = fapiTargetList[i].isFunctional();
+            GENERATE_TEST_TARGETS(test_fapi2GetChildren)
+
+            #define IS_FUNCTIONAL_TEST_MACRO(TARGETING_TARGET, FAPI2_TARGET)                \
+                if(TARGETING_TARGET != nullptr)                                             \
+                {                                                                           \
+                    numTests++;                                                             \
+                    /* get the HWAS_STATE of the current target */                          \
+                    currentState = TARGETING_TARGET->getAttr<TARGETING::ATTR_HWAS_STATE>(); \
+                    functional = FAPI2_TARGET.isFunctional();                               \
+                    if(currentState.functional != functional)                               \
+                    {                                                                       \
+                        TS_FAIL("The functional state is incorrect. huid: 0x%x - "          \
+                        "Functional State (Expected/Actual): (%d/%d)",                      \
+                                TARGETING::get_huid(TARGETING_TARGET),                      \
+                                currentState.functional,                                    \
+                                functional);                                                \
+                                numFails++;                                                 \
+                    }                                                                       \
+                }                                                                           \
+
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_EQ], fapi2_eqTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_EX], fapi2_exTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_CORE], fapi2_coreTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_MCS], fapi2_mcsTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_MCBIST], fapi2_mcbistTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_MCA], fapi2_mcaTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_PEC], fapi2_pecTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_PHB], fapi2_phbTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_XBUS], fapi2_xbusTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_OBUS], fapi2_obusTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_OBUS_BRICK], fapi2_oBrickTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_PPE], fapi2_ppeTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_PERV], fapi2_pervTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_SBE], fapi2_sbeTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_CAPP], fapi2_cappTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_MC], fapi2_mcTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_MI], fapi2_miTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_DMI], fapi2_dmiTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_OMI], fapi2_omiTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_OMIC], fapi2_omicTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_MCC], fapi2_mccTarget)
+            IS_FUNCTIONAL_TEST_MACRO(targeting_targets[MY_PROC], fapi2_procTarget)
 
-                if(currentState.functional != functional)
-                {
-                    TS_FAIL("The functional state is incorrect. huid: 0x%x - "
-                            "Functional State (Expected/Actual): (%d/%d)",
-                            TARGETING::get_huid(currTarg),
-                            currentState.functional,
-                            functional);
-                    numFails++;
-                }
 
-            }
         } while(0);
         FAPI_INF("test_fapi2IsFunctional Test Complete. %d/%d fails",
                   numFails,
diff --git a/src/usr/fapi2/test/fapi2Test.mk b/src/usr/fapi2/test/fapi2Test.mk
index ebead350d..3f9770f90 100644
--- a/src/usr/fapi2/test/fapi2Test.mk
+++ b/src/usr/fapi2/test/fapi2Test.mk
@@ -5,7 +5,7 @@
 #
 # OpenPOWER HostBoot Project
 #
-# Contributors Listed Below - COPYRIGHT 2016,2017
+# Contributors Listed Below - COPYRIGHT 2016,2018
 # [+] International Business Machines Corp.
 #
 #
@@ -52,6 +52,7 @@ OBJS += fapi2TestUtils.o
 OBJS += getVpdTest.o
 OBJS += p9_pm_get_poundv_bucket.o
 
-TESTS += ${shell find ${ROOTPATH}/src/usr/fapi2/test/ | sort | grep -e "Test.H" -e "TestCxx.H" | xargs}
+TESTS += ${shell ls ${ROOTPATH}/src/usr/fapi2/test/*Test.H | sort | xargs}
+
 
 VPATH += ${ROOTPATH}/src/import/chips/p9/procedures/hwp/pm/
diff --git a/src/usr/fapi2/test/fapi2TestUtils.C b/src/usr/fapi2/test/fapi2TestUtils.C
index 2e1f98623..bb548e057 100644
--- a/src/usr/fapi2/test/fapi2TestUtils.C
+++ b/src/usr/fapi2/test/fapi2TestUtils.C
@@ -53,6 +53,9 @@
 #define NUM_MC           2
 #define NUM_MI           2
 #define NUM_DMI          2
+#define NUM_OMI          2
+#define NUM_OMIC         3
+#define NUM_MCC          2
 
 namespace fapi2
 {
@@ -65,10 +68,12 @@ void generateTargets(TARGETING::Target* i_pMasterProcChip,
         o_targetList[x] = nullptr;
     }
 
-    // Set up entity path for NIMBUS proc
+    // Set up entity path for proc
     TARGETING::EntityPath l_epath;
     i_pMasterProcChip->tryGetAttr<TARGETING::ATTR_PHYS_PATH>(l_epath);
 
+    o_targetList[MY_PROC] = i_pMasterProcChip;
+
     //Setup EQs, COREs, and EXs
     for(int i = 0; i < NUM_EQS; i++)
     {
@@ -209,6 +214,80 @@ void generateTargets(TARGETING::Target* i_pMasterProcChip,
             }
         }
     }
+    else if (TARGETING::MODEL_AXONE ==
+                i_pMasterProcChip->getAttr<TARGETING::ATTR_MODEL>())
+    {
+        //Setup MC, MI, MCC, OMI, and OMIC
+        i_pMasterProcChip->tryGetAttr<TARGETING::ATTR_PHYS_PATH>(l_epath);
+        for(int i = 0; i < NUM_MC; i++)
+        {
+            l_epath.addLast(TARGETING::TYPE_MC, i);
+            if(TARGETING::targetService().toTarget(l_epath) != nullptr)
+            {
+                o_targetList[MY_MC] =
+                TARGETING::targetService().toTarget(l_epath);
+                for(int j = 0; j < NUM_MI; j++)
+                {
+                    l_epath.addLast(TARGETING::TYPE_MI, j);
+                    if(TARGETING::targetService().toTarget(l_epath) != nullptr)
+                    {
+                        o_targetList[MY_MI] =
+                        TARGETING::targetService().toTarget(l_epath);
+                        for(int k = 0; k < NUM_MCC; k++)
+                        {
+                            l_epath.addLast(TARGETING::TYPE_MCC,k);
+                            if(TARGETING::targetService().toTarget(l_epath)!=nullptr)
+                            {
+                                o_targetList[MY_MCC] =
+                                TARGETING::targetService().toTarget(l_epath);
+                                for(int l = 0; l < NUM_OMI; l++)
+                                {
+                                    l_epath.addLast(TARGETING::TYPE_OMI,l);
+                                    if(TARGETING::targetService().toTarget(l_epath)!=nullptr)
+                                    {
+                                        o_targetList[MY_OMI] =
+                                        TARGETING::targetService().toTarget(l_epath);
+                                    }
+                                    else
+                                    {
+                                        l_epath.removeLast();
+                                    }
+                                }
+                                break;
+                            }
+                            else
+                            {
+                                l_epath.removeLast();
+                            }
+                        }
+                        break;
+                    }
+                    else
+                    {
+                        l_epath.removeLast();
+                    }
+                }
+                for(int j = 0; j < NUM_OMIC; j++)
+                {
+                    l_epath.addLast(TARGETING::TYPE_OMIC, j);
+                    if(TARGETING::targetService().toTarget(l_epath) != nullptr)
+                    {
+                        o_targetList[MY_OMIC] =
+                        TARGETING::targetService().toTarget(l_epath);
+                    }
+                    else
+                    {
+                        l_epath.removeLast();
+                    }
+                }
+                break;
+            }
+            else
+            {
+                l_epath.removeLast();
+            }
+        }
+    }
 
     //Setup PECs and PHBs
     i_pMasterProcChip->tryGetAttr<TARGETING::ATTR_PHYS_PATH>(l_epath);
@@ -364,18 +443,37 @@ void generateTargets(TARGETING::Target* i_pMasterProcChip,
 bool isHwValid(TARGETING::Target* i_procChip, uint8_t i_hwType)
 {
     bool isValid = true;
-    if (i_procChip->getAttr<TARGETING::ATTR_MODEL>() == TARGETING::MODEL_CUMULUS)
+
+    // Only need to check model if this is NOT a common target for p9
+    if (!(i_hwType == MY_PROC || i_hwType == MY_EQ || i_hwType == MY_EX || i_hwType == MY_CORE ||
+        i_hwType == MY_PEC || i_hwType == MY_PHB || i_hwType == MY_XBUS || i_hwType == MY_OBUS ||
+        i_hwType == MY_OBUS_BRICK || i_hwType == MY_PPE || i_hwType == MY_PERV || i_hwType == MY_CAPP ||
+        i_hwType == MY_SBE))
     {
-        if (i_hwType == MY_MCS || i_hwType == MY_MCA || i_hwType == MY_MCBIST)
+        auto l_model = i_procChip->getAttr<TARGETING::ATTR_MODEL>();
+        if (l_model == TARGETING::MODEL_CUMULUS)
         {
-            isValid = false;
+            if (i_hwType == MY_MCS || i_hwType == MY_MCA || i_hwType == MY_MCBIST ||
+                i_hwType == MY_OMI || i_hwType == MY_OMIC || i_hwType == MY_MCC )
+            {
+                isValid = false;
+            }
         }
-    }
-    else if (i_procChip->getAttr<TARGETING::ATTR_MODEL>() == TARGETING::MODEL_NIMBUS)
-    {
-        if (i_hwType == MY_MC || i_hwType == MY_MI || i_hwType == MY_DMI)
+        else if (l_model == TARGETING::MODEL_NIMBUS)
         {
-            isValid = false;
+            if (i_hwType == MY_MC || i_hwType == MY_MI || i_hwType == MY_DMI ||
+                i_hwType == MY_OMI || i_hwType == MY_OMIC || i_hwType == MY_MCC)
+            {
+                isValid = false;
+            }
+        }
+        else if (l_model == TARGETING::MODEL_AXONE)
+        {
+            if (i_hwType == MY_MCS || i_hwType == MY_MCA || i_hwType == MY_MCBIST ||
+                i_hwType == MY_DMI)
+            {
+                isValid = false;
+            }
         }
     }
     return isValid;
diff --git a/src/usr/fapi2/test/fapi2TestUtils.H b/src/usr/fapi2/test/fapi2TestUtils.H
index 9036a4ead..f513a5fc9 100644
--- a/src/usr/fapi2/test/fapi2TestUtils.H
+++ b/src/usr/fapi2/test/fapi2TestUtils.H
@@ -47,6 +47,9 @@
 #define PERV_PER_PROC        43
 #define XBUS_PER_PROC        1
 #define OBUS_PER_PROC        2
+#define MCC_PER_MI           2
+#define OMI_PER_MCC          2
+#define OMIC_PER_MC          3
 
 #define SIMULATED_GOOD_CORES 4
 
@@ -66,6 +69,12 @@
 #define START_MI_CHIPLET_NUM          0x07
 // DMI (0, 3 => 0x07, 0x08)
 #define START_DMI_CHIPLET_NUM         0x07
+// OMI (0, 16 => 0x07, 0x08)
+#define START_OMI_CHIPLET_NUM         0x07
+// OMIC (0, 5 => 0x07, 0x08)
+#define START_OMIC_CHIPLET_NUM        0x07
+// MCC (0, 8 => 0x07, 0x08)
+#define START_MCC_CHIPLET_NUM         0x07
 // OBUS (0, 3 => 0x09, 0x0C)
 #define START_OBUS_CHIPLET_NUM        0x09
 // PEC (0, 1, 2 => 0x0D, 0x0E, 0x0F)
@@ -86,7 +95,9 @@ namespace fapi2
 
 //Used by generateTargets to get a list of all platform target
 // types that directly relate to fapi2 target types
-enum{
+// NOTE: KEEP THIS IN SAME ORDER AS testTargetInfoList ARRAY BELOW
+enum FAPI2_TEST_TARGET_ID {
+    MY_PROC,
     MY_EQ,
     MY_EX,
     MY_CORE,
@@ -105,9 +116,91 @@ enum{
     MY_MC,
     MY_MI,
     MY_DMI,
+    MY_OMI,
+    MY_OMIC,
+    MY_MCC,
     NUM_TARGETS
 };
 
+// Use the following macro to generate a list of TARGETING targets for each FAPI2_TEST_TARGET_ID
+// you can then use the generated TARGETING targets by using targeting_targets[FAPI2_TEST_TARGET_ID] .
+// In addition you will be able to use the fapi2 version of the targets by using the fapi2_<target>Target.
+// You can see how the fapi2 targets are instantiated below.
+//
+// NOTE: This is expected to be called inside a do-while(0) wrapper
+// variables created : numTests, numFails, generationSuccess, l_proc, l_chipList, targeting_targets,
+//                     fapi2_procTarget, fapi2_eqTarget, fapi2_exTarget, fapi2_coreTarget, fapi2_pecTarget,
+//                     fapi2_phbTarget, fapi2_xbusTarget, fapi2_obusTarget, fapi2_oBrickTarget, fapi2_ppeTarget,
+//                     fapi2_pervTarget, fapi2_sbeTarget, fapi2_cappTarget, fapi2_mcsTarget, fapi2_mcaTarget,
+//                     fapi2_mcbistTarget, fapi2_mcTarget, fapi2_miTarget, fapi2_dmiTarget, fapi2_omiTarget,
+//                     fapi2_omicTarget, fapi2_mccTarget
+// Keep in the same order as FAPI2_TEST_TARGET_ID for ease of read
+#define GENERATE_TEST_TARGETS(TEST_FUNCTION_NAME)                                                            \
+int generationSuccess = true;                                                                                \
+TARGETING::Target * l_proc = nullptr;                                                                        \
+TARGETING::TargetHandleList l_chipList;                                                                      \
+numTests++;                                                                                                  \
+/* Get a list of all of the proc chips */                                                                    \
+TARGETING::getAllChips(l_chipList, TARGETING::TYPE_PROC, false);                                             \
+if(l_chipList.size())                                                                                        \
+{                                                                                                            \
+    l_proc = l_chipList[0];                                                                                  \
+}                                                                                                            \
+else                                                                                                         \
+{                                                                                                            \
+    TS_FAIL("TEST_FUNCTION_NAME Fail: could not find any proc, skipping tests");                             \
+    numFails++;                                                                                              \
+    break;                                                                                                   \
+}                                                                                                            \
+TARGETING::Target* targeting_targets[fapi2::NUM_TARGETS];                                                    \
+/* Call helper function to generate a bunch of TARGETING targets to use to test  */                          \
+generateTargets(l_proc, targeting_targets);                                                                  \
+for( uint64_t x = 0; x < NUM_TARGETS; x++ )                                                                  \
+{                                                                                                            \
+    /*Skip tests where the HW unit to test isn't valid for the proc type */                                  \
+    if (!isHwValid(l_proc, x))                                                                               \
+    {                                                                                                        \
+        continue;                                                                                            \
+    }                                                                                                        \
+    else if(targeting_targets[x] == nullptr)                                                                 \
+    {                                                                                                        \
+        FAPI_ERR("TEST_FUNCTION_NAME:: targeting_targets[%d] is null", x);                                   \
+        generationSuccess = false;                                                                           \
+    }                                                                                                        \
+}                                                                                                            \
+numTests++;                                                                                                  \
+if(!generationSuccess)                                                                                       \
+{                                                                                                            \
+    numFails++;                                                                                              \
+    TS_FAIL("TEST_FUNCTION_NAME Fail : failed to correctly generate targets");                               \
+}                                                                                                            \
+/* Common Targets  */                                                                                        \
+fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>  fapi2_procTarget(targeting_targets[MY_PROC]);                   \
+fapi2::Target<fapi2::TARGET_TYPE_EQ>         fapi2_eqTarget(targeting_targets[MY_EQ]);                       \
+fapi2::Target<fapi2::TARGET_TYPE_EX>         fapi2_exTarget(targeting_targets[MY_EX]);                       \
+fapi2::Target<fapi2::TARGET_TYPE_CORE>       fapi2_coreTarget(targeting_targets[MY_CORE]);                   \
+fapi2::Target<fapi2::TARGET_TYPE_PEC>        fapi2_pecTarget(targeting_targets[MY_PEC]);                     \
+fapi2::Target<fapi2::TARGET_TYPE_PHB>        fapi2_phbTarget(targeting_targets[MY_PHB]);                     \
+fapi2::Target<fapi2::TARGET_TYPE_XBUS>       fapi2_xbusTarget(targeting_targets[MY_XBUS]);                   \
+fapi2::Target<fapi2::TARGET_TYPE_OBUS>       fapi2_obusTarget(targeting_targets[MY_OBUS]);                   \
+fapi2::Target<fapi2::TARGET_TYPE_OBUS_BRICK> fapi2_oBrickTarget(targeting_targets[MY_OBUS_BRICK]);           \
+fapi2::Target<fapi2::TARGET_TYPE_PPE>        fapi2_ppeTarget(targeting_targets[MY_PPE]);                     \
+fapi2::Target<fapi2::TARGET_TYPE_PERV>       fapi2_pervTarget(targeting_targets[MY_PERV]);                   \
+fapi2::Target<fapi2::TARGET_TYPE_SBE>        fapi2_sbeTarget(targeting_targets[MY_SBE]);                     \
+fapi2::Target<fapi2::TARGET_TYPE_CAPP>       fapi2_cappTarget(targeting_targets[MY_CAPP]);                   \
+/* Model Specific Targets */                                                                                 \
+fapi2::Target<fapi2::TARGET_TYPE_MCS>        fapi2_mcsTarget(targeting_targets[MY_MCS]);       /* Nimbus */  \
+fapi2::Target<fapi2::TARGET_TYPE_MCA>        fapi2_mcaTarget(targeting_targets[MY_MCA]);       /* Nimbus */  \
+fapi2::Target<fapi2::TARGET_TYPE_MCBIST>     fapi2_mcbistTarget(targeting_targets[MY_MCBIST]); /* Nimbus */  \
+fapi2::Target<fapi2::TARGET_TYPE_MC>         fapi2_mcTarget(targeting_targets[MY_MC]);   /* Cumulus / Axone*/\
+fapi2::Target<fapi2::TARGET_TYPE_MI>         fapi2_miTarget(targeting_targets[MY_MI]);   /* Cumulus / Axone*/\
+fapi2::Target<fapi2::TARGET_TYPE_DMI>        fapi2_dmiTarget(targeting_targets[MY_DMI]); /* Cumulus */       \
+fapi2::Target<fapi2::TARGET_TYPE_OMI>        fapi2_omiTarget(targeting_targets[MY_OMI]);   /* Axone */       \
+fapi2::Target<fapi2::TARGET_TYPE_OMIC>       fapi2_omicTarget(targeting_targets[MY_OMIC]); /* Axone */       \
+fapi2::Target<fapi2::TARGET_TYPE_MCC>        fapi2_mccTarget(targeting_targets[MY_MCC]);   /* Axone */
+
+
+
 /**
  *  @brief Number of children of given type that applicable pervasive has
  */
@@ -130,6 +223,10 @@ enum PERVASIVE_CHILDREN {
     PERV_MC_CHILDREN           = 1,
     PERV_MI_CHILDREN           = 2,
     PERV_DMI_CHILDREN          = 4,
+    PERV_OCC_CHILDREN          = 4,
+    PERV_MCC_CHILDREN          = 4,
+    PERV_OMI_CHILDREN          = 8,
+    PERV_OMIC_CHILDREN         = 3,
 };
 
 /**
diff --git a/src/usr/fapi2/test/p9_sample_procedure.C b/src/usr/fapi2/test/p9_sample_procedure.C
index 469fa534a..425768ac7 100644
--- a/src/usr/fapi2/test/p9_sample_procedure.C
+++ b/src/usr/fapi2/test/p9_sample_procedure.C
@@ -455,3 +455,77 @@ fapi_try_exit:
     return fapi2::current_err;
 
 }
+
+fapi2::ReturnCode p9_sample_procedure_omi(
+               fapi2::Target<fapi2::TARGET_TYPE_OMI>& i_target,
+                                            uint8_t expectedValue)
+{
+    uint8_t l_attr_scratch = 0;
+    FAPI_INF("Entering ...");
+    FAPI_INF("Set Scratch Attr on OMI Target");
+    FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_SCRATCH_UINT8_1, i_target,
+                        expectedValue));
+
+    FAPI_INF("Get Scratch Attr on OMI Target");
+    FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_SCRATCH_UINT8_1, i_target,
+                        l_attr_scratch));
+    FAPI_ASSERT( (l_attr_scratch == expectedValue),
+                  fapi2::FAPI2_SAMPLE(),
+                  "p9_sample_procedure_omi read scratch value: %d , expected it to be: %d", l_attr_scratch, expectedValue);
+    FAPI_INF("Read scratch value : %d , expected it to be %d", l_attr_scratch, expectedValue);
+
+fapi_try_exit:
+    FAPI_INF("Exiting ...");
+    return fapi2::current_err;
+
+}
+
+fapi2::ReturnCode p9_sample_procedure_omic(
+               fapi2::Target<fapi2::TARGET_TYPE_OMIC>& i_target,
+                uint8_t expectedValue)
+{
+    uint8_t l_attr_scratch = 0;
+    FAPI_INF("Entering ...");
+    FAPI_INF("Set Scratch Attr on OMIC Target");
+    FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_SCRATCH_UINT8_1, i_target,
+                        expectedValue));
+
+    FAPI_INF("Get Scratch Attr on OMIC Target");
+    FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_SCRATCH_UINT8_1, i_target,
+                        l_attr_scratch));
+    FAPI_ASSERT( (l_attr_scratch == expectedValue),
+                  fapi2::FAPI2_SAMPLE(),
+                  "p9_sample_procedure_omic read scratch value: %d , expected it to be: %d", l_attr_scratch, expectedValue);
+    FAPI_INF("Read scratch value : %d , expected it to be %d", l_attr_scratch, expectedValue);
+
+fapi_try_exit:
+    FAPI_INF("Exiting ...");
+    return fapi2::current_err;
+
+}
+
+fapi2::ReturnCode p9_sample_procedure_mcc(
+               fapi2::Target<fapi2::TARGET_TYPE_MCC>& i_target,
+                uint8_t expectedValue)
+{
+    uint8_t l_attr_scratch = 0;
+    FAPI_INF("Entering ...");
+    FAPI_INF("Set Scratch Attr on MCC Target");
+    FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_SCRATCH_UINT8_1, i_target,
+                        expectedValue));
+
+    FAPI_INF("Get Scratch Attr on MCC Target");
+    FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_SCRATCH_UINT8_1, i_target,
+                        l_attr_scratch));
+    FAPI_ASSERT( (l_attr_scratch == expectedValue),
+                  fapi2::FAPI2_SAMPLE(),
+                  "p9_sample_procedure_mcc read scratch value: %d , expected it to be: %d", l_attr_scratch, expectedValue);
+    FAPI_INF("Read scratch value : %d , expected it to be %d", l_attr_scratch, expectedValue);
+
+fapi_try_exit:
+    FAPI_INF("Exiting ...");
+    return fapi2::current_err;
+
+}
+
+
diff --git a/src/usr/fapi2/test/p9_sample_procedure.H b/src/usr/fapi2/test/p9_sample_procedure.H
index 04e3d692f..cb3cd6ccd 100644
--- a/src/usr/fapi2/test/p9_sample_procedure.H
+++ b/src/usr/fapi2/test/p9_sample_procedure.H
@@ -122,6 +122,18 @@ fapi2::ReturnCode p9_sample_procedure_dmi(
                fapi2::Target<fapi2::TARGET_TYPE_DMI>& i_target,
                 uint8_t expectedValue);
 
+fapi2::ReturnCode p9_sample_procedure_omi(
+               fapi2::Target<fapi2::TARGET_TYPE_OMI>& i_target,
+                uint8_t expectedValue);
+
+fapi2::ReturnCode p9_sample_procedure_omic(
+               fapi2::Target<fapi2::TARGET_TYPE_OMIC>& i_target,
+                uint8_t expectedValue);
+
+fapi2::ReturnCode p9_sample_procedure_mcc(
+               fapi2::Target<fapi2::TARGET_TYPE_MCC>& i_target,
+                uint8_t expectedValue);
+
 }
 
 #endif // _P9_SAMPLE_PROCEDURE_H_