diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h
index e21eeb04e29f52..2b72528e4bbca5 100644
--- a/zzz_generated/chip-tool/zap-generated/test/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h
@@ -2994,7 +2994,7 @@ class Test_TC_CC_1_1Suite : public TestCommand
 class Test_TC_CC_2_1Suite : public TestCommand
 {
 public:
-    Test_TC_CC_2_1Suite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("Test_TC_CC_2_1", 60, credsIssuerConfig)
+    Test_TC_CC_2_1Suite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("Test_TC_CC_2_1", 61, credsIssuerConfig)
     {
         AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
         AddArgument("cluster", &mCluster);
@@ -3015,6 +3015,8 @@ class Test_TC_CC_2_1Suite : public TestCommand
     chip::Optional<chip::EndpointId> mEndpoint;
     chip::Optional<uint16_t> mTimeout;
 
+    uint32_t FeatureMapValue;
+
     chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
 
     //
@@ -3196,12 +3198,21 @@ class Test_TC_CC_2_1Suite : public TestCommand
         case 19:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
-                uint16_t value;
+                uint32_t value;
                 VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value)));
-                VerifyOrReturn(CheckValue("colorCapabilities", value, 0U));
+
+                FeatureMapValue = value;
             }
             break;
         case 20:
+            VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
+            {
+                uint16_t value;
+                VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value)));
+                VerifyOrReturn(CheckValue("colorCapabilities", value, FeatureMapValue));
+            }
+            break;
+        case 21:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3211,7 +3222,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 31U));
             }
             break;
-        case 21:
+        case 22:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3219,7 +3230,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckValue("colorTempPhysicalMinMireds", value, 0U));
             }
             break;
-        case 22:
+        case 23:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3229,7 +3240,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 23:
+        case 24:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3237,7 +3248,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckValue("colorTempPhysicalMaxMireds", value, 65279U));
             }
             break;
-        case 24:
+        case 25:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3247,7 +3258,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 25:
+        case 26:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3261,7 +3272,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 26:
+        case 27:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3275,7 +3286,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 27:
+        case 28:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3288,7 +3299,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint16"));
             }
             break;
-        case 28:
+        case 29:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3302,7 +3313,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 4U));
             }
             break;
-        case 29:
+        case 30:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3315,7 +3326,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxLength("value", value.size(), 254));
             }
             break;
-        case 30:
+        case 31:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 chip::app::DataModel::Nullable<uint8_t> value;
@@ -3325,7 +3336,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 6U));
             }
             break;
-        case 31:
+        case 32:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3335,7 +3346,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 32:
+        case 33:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3345,7 +3356,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 33:
+        case 34:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 chip::app::DataModel::Nullable<uint8_t> value;
@@ -3353,7 +3364,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 34:
+        case 35:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3363,7 +3374,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 35:
+        case 36:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3373,7 +3384,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 36:
+        case 37:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 chip::app::DataModel::Nullable<uint8_t> value;
@@ -3381,7 +3392,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 37:
+        case 38:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3391,7 +3402,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 38:
+        case 39:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3401,7 +3412,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 39:
+        case 40:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 chip::app::DataModel::Nullable<uint8_t> value;
@@ -3409,7 +3420,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 40:
+        case 41:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3419,7 +3430,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 41:
+        case 42:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3429,7 +3440,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 42:
+        case 43:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 chip::app::DataModel::Nullable<uint8_t> value;
@@ -3437,7 +3448,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 43:
+        case 44:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3447,7 +3458,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 44:
+        case 45:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3457,7 +3468,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 45:
+        case 46:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 chip::app::DataModel::Nullable<uint8_t> value;
@@ -3465,7 +3476,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 46:
+        case 47:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3475,7 +3486,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 47:
+        case 48:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 uint16_t value;
@@ -3485,7 +3496,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 48:
+        case 49:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             {
                 chip::app::DataModel::Nullable<uint8_t> value;
@@ -3493,7 +3504,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 49:
+        case 50:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3507,7 +3518,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 50:
+        case 51:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3521,7 +3532,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 51:
+        case 52:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3535,7 +3546,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 52:
+        case 53:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3549,7 +3560,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 53:
+        case 54:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3561,7 +3572,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 54:
+        case 55:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3575,7 +3586,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 55:
+        case 56:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3589,7 +3600,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 56:
+        case 57:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3601,7 +3612,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintType("value", "", "uint8"));
             }
             break;
-        case 57:
+        case 58:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3615,7 +3626,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 58:
+        case 59:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3629,7 +3640,7 @@ class Test_TC_CC_2_1Suite : public TestCommand
                 VerifyOrReturn(CheckConstraintMaxValue("value", value, 65279U));
             }
             break;
-        case 59:
+        case 60:
             if (IsUnsupported(status.mStatus))
             {
                 return;
@@ -3772,247 +3783,252 @@ class Test_TC_CC_2_1Suite : public TestCommand
                                  ColorControl::Attributes::ColorLoopStoredEnhancedHue::Id, true, chip::NullOptional);
         }
         case 19: {
-            LogStep(19, "Reads ColorCapabilities attribute from DUT");
+            LogStep(19, "read the optional global attribute: FeatureMap");
+            return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::FeatureMap::Id, true,
+                                 chip::NullOptional);
+        }
+        case 20: {
+            LogStep(20, "Reads ColorCapabilities attribute from DUT");
             VerifyOrDo(!ShouldSkip("CC.S.A400a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorCapabilities::Id,
                                  true, chip::NullOptional);
         }
-        case 20: {
-            LogStep(20, "Validate constraints of attribute: ColorCapabilities");
+        case 21: {
+            LogStep(21, "Validate constraints of attribute: ColorCapabilities");
             VerifyOrDo(!ShouldSkip("CC.S.A400a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorCapabilities::Id,
                                  true, chip::NullOptional);
         }
-        case 21: {
-            LogStep(21, "Reads ColorTempPhysicalMinMireds attribute from DUT");
+        case 22: {
+            LogStep(22, "Reads ColorTempPhysicalMinMireds attribute from DUT");
             VerifyOrDo(!ShouldSkip("CC.S.A400b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::ColorTempPhysicalMinMireds::Id, true, chip::NullOptional);
         }
-        case 22: {
-            LogStep(22, "Validate constraints of attribute: ColorTempPhysicalMinMireds");
+        case 23: {
+            LogStep(23, "Validate constraints of attribute: ColorTempPhysicalMinMireds");
             VerifyOrDo(!ShouldSkip("CC.S.A400b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::ColorTempPhysicalMinMireds::Id, true, chip::NullOptional);
         }
-        case 23: {
-            LogStep(23, "Read ColorTempPhysicalMaxMireds attribute from DUT");
+        case 24: {
+            LogStep(24, "Read ColorTempPhysicalMaxMireds attribute from DUT");
             VerifyOrDo(!ShouldSkip("CC.S.A400c"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::ColorTempPhysicalMaxMireds::Id, true, chip::NullOptional);
         }
-        case 24: {
-            LogStep(24, "Validate constraints of attribute: ColorTempPhysicalMaxMireds");
+        case 25: {
+            LogStep(25, "Validate constraints of attribute: ColorTempPhysicalMaxMireds");
             VerifyOrDo(!ShouldSkip("CC.S.A400c"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::ColorTempPhysicalMaxMireds::Id, true, chip::NullOptional);
         }
-        case 25: {
-            LogStep(25, "Read the optional attribute: CoupleColorTempToLevelMinMireds");
+        case 26: {
+            LogStep(26, "Read the optional attribute: CoupleColorTempToLevelMinMireds");
             VerifyOrDo(!ShouldSkip("CC.S.A400d"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::CoupleColorTempToLevelMinMireds::Id, true, chip::NullOptional);
         }
-        case 26: {
-            LogStep(26, "Read the optional attribute: StartUpColorTemperatureMireds");
+        case 27: {
+            LogStep(27, "Read the optional attribute: StartUpColorTemperatureMireds");
             VerifyOrDo(!ShouldSkip("CC.S.A4010"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::StartUpColorTemperatureMireds::Id, true, chip::NullOptional);
         }
-        case 27: {
-            LogStep(27, "Validate constraints of attribute: RemainingTime");
+        case 28: {
+            LogStep(28, "Validate constraints of attribute: RemainingTime");
             VerifyOrDo(!ShouldSkip("CC.S.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::RemainingTime::Id,
                                  true, chip::NullOptional);
         }
-        case 28: {
-            LogStep(28, "Read the optional attribute: DriftCompensation");
+        case 29: {
+            LogStep(29, "Read the optional attribute: DriftCompensation");
             VerifyOrDo(!ShouldSkip("CC.S.A0005"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::DriftCompensation::Id,
                                  true, chip::NullOptional);
         }
-        case 29: {
-            LogStep(29, "Read the optional attribute: CompensationText");
+        case 30: {
+            LogStep(30, "Read the optional attribute: CompensationText");
             VerifyOrDo(!ShouldSkip("CC.S.A0005"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CompensationText::Id,
                                  true, chip::NullOptional);
         }
-        case 30: {
-            LogStep(30, "Read the mandatory attribute: NumberOfPrimaries");
+        case 31: {
+            LogStep(31, "Read the mandatory attribute: NumberOfPrimaries");
             VerifyOrDo(!ShouldSkip("CC.S.A0010"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::NumberOfPrimaries::Id,
                                  true, chip::NullOptional);
         }
-        case 31: {
-            LogStep(31, "Read the mandatory attribute: Primary1X");
+        case 32: {
+            LogStep(32, "Read the mandatory attribute: Primary1X");
             VerifyOrDo(!ShouldSkip("CC.S.A0011"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary1X::Id, true,
                                  chip::NullOptional);
         }
-        case 32: {
-            LogStep(32, "Read the mandatory attribute: Primary1Y");
+        case 33: {
+            LogStep(33, "Read the mandatory attribute: Primary1Y");
             VerifyOrDo(!ShouldSkip("CC.S.A0012"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary1Y::Id, true,
                                  chip::NullOptional);
         }
-        case 33: {
-            LogStep(33, "Read the mandatory attribute: Primary1Intensity");
+        case 34: {
+            LogStep(34, "Read the mandatory attribute: Primary1Intensity");
             VerifyOrDo(!ShouldSkip("CC.S.A0013"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary1Intensity::Id,
                                  true, chip::NullOptional);
         }
-        case 34: {
-            LogStep(34, "Read the mandatory attribute: Primary2X");
+        case 35: {
+            LogStep(35, "Read the mandatory attribute: Primary2X");
             VerifyOrDo(!ShouldSkip("CC.S.A0015"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary2X::Id, true,
                                  chip::NullOptional);
         }
-        case 35: {
-            LogStep(35, "Read the mandatory attribute: Primary2Y");
+        case 36: {
+            LogStep(36, "Read the mandatory attribute: Primary2Y");
             VerifyOrDo(!ShouldSkip("CC.S.A0016"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary2Y::Id, true,
                                  chip::NullOptional);
         }
-        case 36: {
-            LogStep(36, "Validate constraints of attribute: Primary2Intensity");
+        case 37: {
+            LogStep(37, "Validate constraints of attribute: Primary2Intensity");
             VerifyOrDo(!ShouldSkip("CC.S.A0017"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary2Intensity::Id,
                                  true, chip::NullOptional);
         }
-        case 37: {
-            LogStep(37, "Read the mandatory attribute: Primary3X");
+        case 38: {
+            LogStep(38, "Read the mandatory attribute: Primary3X");
             VerifyOrDo(!ShouldSkip("CC.S.A0019"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary3X::Id, true,
                                  chip::NullOptional);
         }
-        case 38: {
-            LogStep(38, "Read the mandatory attribute: Primary3Y");
+        case 39: {
+            LogStep(39, "Read the mandatory attribute: Primary3Y");
             VerifyOrDo(!ShouldSkip("CC.S.A001a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary3Y::Id, true,
                                  chip::NullOptional);
         }
-        case 39: {
-            LogStep(39, "Read the mandatory attribute: Primary3Intensity");
+        case 40: {
+            LogStep(40, "Read the mandatory attribute: Primary3Intensity");
             VerifyOrDo(!ShouldSkip("CC.S.A001b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary3Intensity::Id,
                                  true, chip::NullOptional);
         }
-        case 40: {
-            LogStep(40, "Read the mandatory attribute: Primary4X");
+        case 41: {
+            LogStep(41, "Read the mandatory attribute: Primary4X");
             VerifyOrDo(!ShouldSkip("CC.S.A0020"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary4X::Id, true,
                                  chip::NullOptional);
         }
-        case 41: {
-            LogStep(41, "Read the mandatory attribute: Primary4Y");
+        case 42: {
+            LogStep(42, "Read the mandatory attribute: Primary4Y");
             VerifyOrDo(!ShouldSkip("CC.S.A0021"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary4Y::Id, true,
                                  chip::NullOptional);
         }
-        case 42: {
-            LogStep(42, "Read the mandatory attribute: Primary4Intensity");
+        case 43: {
+            LogStep(43, "Read the mandatory attribute: Primary4Intensity");
             VerifyOrDo(!ShouldSkip("CC.S.A0022"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary4Intensity::Id,
                                  true, chip::NullOptional);
         }
-        case 43: {
-            LogStep(43, "Read the mandatory attribute: Primary5X");
+        case 44: {
+            LogStep(44, "Read the mandatory attribute: Primary5X");
             VerifyOrDo(!ShouldSkip("CC.S.A0024"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary5X::Id, true,
                                  chip::NullOptional);
         }
-        case 44: {
-            LogStep(44, "Read the mandatory attribute: Primary5Y");
+        case 45: {
+            LogStep(45, "Read the mandatory attribute: Primary5Y");
             VerifyOrDo(!ShouldSkip("CC.S.A0025"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary5Y::Id, true,
                                  chip::NullOptional);
         }
-        case 45: {
-            LogStep(45, "Read the mandatory attribute: Primary5Intensity");
+        case 46: {
+            LogStep(46, "Read the mandatory attribute: Primary5Intensity");
             VerifyOrDo(!ShouldSkip("CC.S.A0026"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary5Intensity::Id,
                                  true, chip::NullOptional);
         }
-        case 46: {
-            LogStep(46, "Read the mandatory attribute: Primary6X");
+        case 47: {
+            LogStep(47, "Read the mandatory attribute: Primary6X");
             VerifyOrDo(!ShouldSkip("CC.S.A0028"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary6X::Id, true,
                                  chip::NullOptional);
         }
-        case 47: {
-            LogStep(47, "Read the mandatory attribute: Primary6Y");
+        case 48: {
+            LogStep(48, "Read the mandatory attribute: Primary6Y");
             VerifyOrDo(!ShouldSkip("CC.S.A0029"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary6Y::Id, true,
                                  chip::NullOptional);
         }
-        case 48: {
-            LogStep(48, "Read the mandatory attribute: Primary6Intensity");
+        case 49: {
+            LogStep(49, "Read the mandatory attribute: Primary6Intensity");
             VerifyOrDo(!ShouldSkip("CC.S.A002a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::Primary6Intensity::Id,
                                  true, chip::NullOptional);
         }
-        case 49: {
-            LogStep(49, "Read the optional attribute: WhitePointX");
+        case 50: {
+            LogStep(50, "Read the optional attribute: WhitePointX");
             VerifyOrDo(!ShouldSkip("CC.S.A0030"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::WhitePointX::Id, true,
                                  chip::NullOptional);
         }
-        case 50: {
-            LogStep(50, "Read the optional attribute: WhitePointY");
+        case 51: {
+            LogStep(51, "Read the optional attribute: WhitePointY");
             VerifyOrDo(!ShouldSkip("CC.S.A0031"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::WhitePointY::Id, true,
                                  chip::NullOptional);
         }
-        case 51: {
-            LogStep(51, "Read the optional attribute: ColorPointRX");
+        case 52: {
+            LogStep(52, "Read the optional attribute: ColorPointRX");
             VerifyOrDo(!ShouldSkip("CC.S.A0032"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorPointRX::Id, true,
                                  chip::NullOptional);
         }
-        case 52: {
-            LogStep(52, "Read the optional attribute: ColorPointRY");
+        case 53: {
+            LogStep(53, "Read the optional attribute: ColorPointRY");
             VerifyOrDo(!ShouldSkip("CC.S.A0033"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorPointRY::Id, true,
                                  chip::NullOptional);
         }
-        case 53: {
-            LogStep(53, "Read the optional attribute: ColorPointRIntensity");
+        case 54: {
+            LogStep(54, "Read the optional attribute: ColorPointRIntensity");
             VerifyOrDo(!ShouldSkip("CC.S.A0034"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::ColorPointRIntensity::Id, true, chip::NullOptional);
         }
-        case 54: {
-            LogStep(54, "Read the optional attribute: ColorPointGX");
+        case 55: {
+            LogStep(55, "Read the optional attribute: ColorPointGX");
             VerifyOrDo(!ShouldSkip("CC.S.A0036"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorPointGX::Id, true,
                                  chip::NullOptional);
         }
-        case 55: {
-            LogStep(55, "Read the optional attribute: ColorPointGY");
+        case 56: {
+            LogStep(56, "Read the optional attribute: ColorPointGY");
             VerifyOrDo(!ShouldSkip("CC.S.A0037"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorPointGY::Id, true,
                                  chip::NullOptional);
         }
-        case 56: {
-            LogStep(56, "Read the optional attribute: ColorPointGIntensity");
+        case 57: {
+            LogStep(57, "Read the optional attribute: ColorPointGIntensity");
             VerifyOrDo(!ShouldSkip("CC.S.A0038"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::ColorPointGIntensity::Id, true, chip::NullOptional);
         }
-        case 57: {
-            LogStep(57, "Read the optional attribute: ColorPointBX");
+        case 58: {
+            LogStep(58, "Read the optional attribute: ColorPointBX");
             VerifyOrDo(!ShouldSkip("CC.S.A003a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorPointBX::Id, true,
                                  chip::NullOptional);
         }
-        case 58: {
-            LogStep(58, "Read the optional attribute: ColorPointBY");
+        case 59: {
+            LogStep(59, "Read the optional attribute: ColorPointBY");
             VerifyOrDo(!ShouldSkip("CC.S.A003b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorPointBY::Id, true,
                                  chip::NullOptional);
         }
-        case 59: {
-            LogStep(59, "Read the optional attribute: ColorPointBIntensity");
+        case 60: {
+            LogStep(60, "Read the optional attribute: ColorPointBIntensity");
             VerifyOrDo(!ShouldSkip("CC.S.A003c"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
             return ReadAttribute(kIdentityAlpha, GetEndpoint(1), ColorControl::Id,
                                  ColorControl::Attributes::ColorPointBIntensity::Id, true, chip::NullOptional);
diff --git a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h
index 3d9be8f97201a2..f80fd978c07b37 100644
--- a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h
+++ b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h
@@ -4162,332 +4162,336 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
             err = TestValidateConstraintsOfAttributeColorLoopStoredEnhancedHue_18();
             break;
         case 19:
-            ChipLogProgress(chipTool, " ***** Test Step 19 : Reads ColorCapabilities attribute from DUT\n");
-            if (ShouldSkip("CC.S.A400a")) {
-                NextTest();
-                return;
-            }
-            err = TestReadsColorCapabilitiesAttributeFromDut_19();
+            ChipLogProgress(chipTool, " ***** Test Step 19 : read the optional global attribute: FeatureMap\n");
+            err = TestReadTheOptionalGlobalAttributeFeatureMap_19();
             break;
         case 20:
-            ChipLogProgress(chipTool, " ***** Test Step 20 : Validate constraints of attribute: ColorCapabilities\n");
+            ChipLogProgress(chipTool, " ***** Test Step 20 : Reads ColorCapabilities attribute from DUT\n");
             if (ShouldSkip("CC.S.A400a")) {
                 NextTest();
                 return;
             }
-            err = TestValidateConstraintsOfAttributeColorCapabilities_20();
+            err = TestReadsColorCapabilitiesAttributeFromDut_20();
             break;
         case 21:
-            ChipLogProgress(chipTool, " ***** Test Step 21 : Reads ColorTempPhysicalMinMireds attribute from DUT\n");
-            if (ShouldSkip("CC.S.A400b")) {
+            ChipLogProgress(chipTool, " ***** Test Step 21 : Validate constraints of attribute: ColorCapabilities\n");
+            if (ShouldSkip("CC.S.A400a")) {
                 NextTest();
                 return;
             }
-            err = TestReadsColorTempPhysicalMinMiredsAttributeFromDut_21();
+            err = TestValidateConstraintsOfAttributeColorCapabilities_21();
             break;
         case 22:
-            ChipLogProgress(chipTool, " ***** Test Step 22 : Validate constraints of attribute: ColorTempPhysicalMinMireds\n");
+            ChipLogProgress(chipTool, " ***** Test Step 22 : Reads ColorTempPhysicalMinMireds attribute from DUT\n");
             if (ShouldSkip("CC.S.A400b")) {
                 NextTest();
                 return;
             }
-            err = TestValidateConstraintsOfAttributeColorTempPhysicalMinMireds_22();
+            err = TestReadsColorTempPhysicalMinMiredsAttributeFromDut_22();
             break;
         case 23:
-            ChipLogProgress(chipTool, " ***** Test Step 23 : Read ColorTempPhysicalMaxMireds attribute from DUT\n");
-            if (ShouldSkip("CC.S.A400c")) {
+            ChipLogProgress(chipTool, " ***** Test Step 23 : Validate constraints of attribute: ColorTempPhysicalMinMireds\n");
+            if (ShouldSkip("CC.S.A400b")) {
                 NextTest();
                 return;
             }
-            err = TestReadColorTempPhysicalMaxMiredsAttributeFromDut_23();
+            err = TestValidateConstraintsOfAttributeColorTempPhysicalMinMireds_23();
             break;
         case 24:
-            ChipLogProgress(chipTool, " ***** Test Step 24 : Validate constraints of attribute: ColorTempPhysicalMaxMireds\n");
+            ChipLogProgress(chipTool, " ***** Test Step 24 : Read ColorTempPhysicalMaxMireds attribute from DUT\n");
             if (ShouldSkip("CC.S.A400c")) {
                 NextTest();
                 return;
             }
-            err = TestValidateConstraintsOfAttributeColorTempPhysicalMaxMireds_24();
+            err = TestReadColorTempPhysicalMaxMiredsAttributeFromDut_24();
             break;
         case 25:
-            ChipLogProgress(chipTool, " ***** Test Step 25 : Read the optional attribute: CoupleColorTempToLevelMinMireds\n");
-            if (ShouldSkip("CC.S.A400d")) {
+            ChipLogProgress(chipTool, " ***** Test Step 25 : Validate constraints of attribute: ColorTempPhysicalMaxMireds\n");
+            if (ShouldSkip("CC.S.A400c")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeCoupleColorTempToLevelMinMireds_25();
+            err = TestValidateConstraintsOfAttributeColorTempPhysicalMaxMireds_25();
             break;
         case 26:
-            ChipLogProgress(chipTool, " ***** Test Step 26 : Read the optional attribute: StartUpColorTemperatureMireds\n");
-            if (ShouldSkip("CC.S.A4010")) {
+            ChipLogProgress(chipTool, " ***** Test Step 26 : Read the optional attribute: CoupleColorTempToLevelMinMireds\n");
+            if (ShouldSkip("CC.S.A400d")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeStartUpColorTemperatureMireds_26();
+            err = TestReadTheOptionalAttributeCoupleColorTempToLevelMinMireds_26();
             break;
         case 27:
-            ChipLogProgress(chipTool, " ***** Test Step 27 : Validate constraints of attribute: RemainingTime\n");
-            if (ShouldSkip("CC.S.A0002")) {
+            ChipLogProgress(chipTool, " ***** Test Step 27 : Read the optional attribute: StartUpColorTemperatureMireds\n");
+            if (ShouldSkip("CC.S.A4010")) {
                 NextTest();
                 return;
             }
-            err = TestValidateConstraintsOfAttributeRemainingTime_27();
+            err = TestReadTheOptionalAttributeStartUpColorTemperatureMireds_27();
             break;
         case 28:
-            ChipLogProgress(chipTool, " ***** Test Step 28 : Read the optional attribute: DriftCompensation\n");
-            if (ShouldSkip("CC.S.A0005")) {
+            ChipLogProgress(chipTool, " ***** Test Step 28 : Validate constraints of attribute: RemainingTime\n");
+            if (ShouldSkip("CC.S.A0002")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeDriftCompensation_28();
+            err = TestValidateConstraintsOfAttributeRemainingTime_28();
             break;
         case 29:
-            ChipLogProgress(chipTool, " ***** Test Step 29 : Read the optional attribute: CompensationText\n");
+            ChipLogProgress(chipTool, " ***** Test Step 29 : Read the optional attribute: DriftCompensation\n");
             if (ShouldSkip("CC.S.A0005")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeCompensationText_29();
+            err = TestReadTheOptionalAttributeDriftCompensation_29();
             break;
         case 30:
-            ChipLogProgress(chipTool, " ***** Test Step 30 : Read the mandatory attribute: NumberOfPrimaries\n");
-            if (ShouldSkip("CC.S.A0010")) {
+            ChipLogProgress(chipTool, " ***** Test Step 30 : Read the optional attribute: CompensationText\n");
+            if (ShouldSkip("CC.S.A0005")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributeNumberOfPrimaries_30();
+            err = TestReadTheOptionalAttributeCompensationText_30();
             break;
         case 31:
-            ChipLogProgress(chipTool, " ***** Test Step 31 : Read the mandatory attribute: Primary1X\n");
-            if (ShouldSkip("CC.S.A0011")) {
+            ChipLogProgress(chipTool, " ***** Test Step 31 : Read the mandatory attribute: NumberOfPrimaries\n");
+            if (ShouldSkip("CC.S.A0010")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary1X_31();
+            err = TestReadTheMandatoryAttributeNumberOfPrimaries_31();
             break;
         case 32:
-            ChipLogProgress(chipTool, " ***** Test Step 32 : Read the mandatory attribute: Primary1Y\n");
-            if (ShouldSkip("CC.S.A0012")) {
+            ChipLogProgress(chipTool, " ***** Test Step 32 : Read the mandatory attribute: Primary1X\n");
+            if (ShouldSkip("CC.S.A0011")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary1Y_32();
+            err = TestReadTheMandatoryAttributePrimary1X_32();
             break;
         case 33:
-            ChipLogProgress(chipTool, " ***** Test Step 33 : Read the mandatory attribute: Primary1Intensity\n");
-            if (ShouldSkip("CC.S.A0013")) {
+            ChipLogProgress(chipTool, " ***** Test Step 33 : Read the mandatory attribute: Primary1Y\n");
+            if (ShouldSkip("CC.S.A0012")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary1Intensity_33();
+            err = TestReadTheMandatoryAttributePrimary1Y_33();
             break;
         case 34:
-            ChipLogProgress(chipTool, " ***** Test Step 34 : Read the mandatory attribute: Primary2X\n");
-            if (ShouldSkip("CC.S.A0015")) {
+            ChipLogProgress(chipTool, " ***** Test Step 34 : Read the mandatory attribute: Primary1Intensity\n");
+            if (ShouldSkip("CC.S.A0013")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary2X_34();
+            err = TestReadTheMandatoryAttributePrimary1Intensity_34();
             break;
         case 35:
-            ChipLogProgress(chipTool, " ***** Test Step 35 : Read the mandatory attribute: Primary2Y\n");
-            if (ShouldSkip("CC.S.A0016")) {
+            ChipLogProgress(chipTool, " ***** Test Step 35 : Read the mandatory attribute: Primary2X\n");
+            if (ShouldSkip("CC.S.A0015")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary2Y_35();
+            err = TestReadTheMandatoryAttributePrimary2X_35();
             break;
         case 36:
-            ChipLogProgress(chipTool, " ***** Test Step 36 : Validate constraints of attribute: Primary2Intensity\n");
-            if (ShouldSkip("CC.S.A0017")) {
+            ChipLogProgress(chipTool, " ***** Test Step 36 : Read the mandatory attribute: Primary2Y\n");
+            if (ShouldSkip("CC.S.A0016")) {
                 NextTest();
                 return;
             }
-            err = TestValidateConstraintsOfAttributePrimary2Intensity_36();
+            err = TestReadTheMandatoryAttributePrimary2Y_36();
             break;
         case 37:
-            ChipLogProgress(chipTool, " ***** Test Step 37 : Read the mandatory attribute: Primary3X\n");
-            if (ShouldSkip("CC.S.A0019")) {
+            ChipLogProgress(chipTool, " ***** Test Step 37 : Validate constraints of attribute: Primary2Intensity\n");
+            if (ShouldSkip("CC.S.A0017")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary3X_37();
+            err = TestValidateConstraintsOfAttributePrimary2Intensity_37();
             break;
         case 38:
-            ChipLogProgress(chipTool, " ***** Test Step 38 : Read the mandatory attribute: Primary3Y\n");
-            if (ShouldSkip("CC.S.A001a")) {
+            ChipLogProgress(chipTool, " ***** Test Step 38 : Read the mandatory attribute: Primary3X\n");
+            if (ShouldSkip("CC.S.A0019")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary3Y_38();
+            err = TestReadTheMandatoryAttributePrimary3X_38();
             break;
         case 39:
-            ChipLogProgress(chipTool, " ***** Test Step 39 : Read the mandatory attribute: Primary3Intensity\n");
-            if (ShouldSkip("CC.S.A001b")) {
+            ChipLogProgress(chipTool, " ***** Test Step 39 : Read the mandatory attribute: Primary3Y\n");
+            if (ShouldSkip("CC.S.A001a")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary3Intensity_39();
+            err = TestReadTheMandatoryAttributePrimary3Y_39();
             break;
         case 40:
-            ChipLogProgress(chipTool, " ***** Test Step 40 : Read the mandatory attribute: Primary4X\n");
-            if (ShouldSkip("CC.S.A0020")) {
+            ChipLogProgress(chipTool, " ***** Test Step 40 : Read the mandatory attribute: Primary3Intensity\n");
+            if (ShouldSkip("CC.S.A001b")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary4X_40();
+            err = TestReadTheMandatoryAttributePrimary3Intensity_40();
             break;
         case 41:
-            ChipLogProgress(chipTool, " ***** Test Step 41 : Read the mandatory attribute: Primary4Y\n");
-            if (ShouldSkip("CC.S.A0021")) {
+            ChipLogProgress(chipTool, " ***** Test Step 41 : Read the mandatory attribute: Primary4X\n");
+            if (ShouldSkip("CC.S.A0020")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary4Y_41();
+            err = TestReadTheMandatoryAttributePrimary4X_41();
             break;
         case 42:
-            ChipLogProgress(chipTool, " ***** Test Step 42 : Read the mandatory attribute: Primary4Intensity\n");
-            if (ShouldSkip("CC.S.A0022")) {
+            ChipLogProgress(chipTool, " ***** Test Step 42 : Read the mandatory attribute: Primary4Y\n");
+            if (ShouldSkip("CC.S.A0021")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary4Intensity_42();
+            err = TestReadTheMandatoryAttributePrimary4Y_42();
             break;
         case 43:
-            ChipLogProgress(chipTool, " ***** Test Step 43 : Read the mandatory attribute: Primary5X\n");
-            if (ShouldSkip("CC.S.A0024")) {
+            ChipLogProgress(chipTool, " ***** Test Step 43 : Read the mandatory attribute: Primary4Intensity\n");
+            if (ShouldSkip("CC.S.A0022")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary5X_43();
+            err = TestReadTheMandatoryAttributePrimary4Intensity_43();
             break;
         case 44:
-            ChipLogProgress(chipTool, " ***** Test Step 44 : Read the mandatory attribute: Primary5Y\n");
-            if (ShouldSkip("CC.S.A0025")) {
+            ChipLogProgress(chipTool, " ***** Test Step 44 : Read the mandatory attribute: Primary5X\n");
+            if (ShouldSkip("CC.S.A0024")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary5Y_44();
+            err = TestReadTheMandatoryAttributePrimary5X_44();
             break;
         case 45:
-            ChipLogProgress(chipTool, " ***** Test Step 45 : Read the mandatory attribute: Primary5Intensity\n");
-            if (ShouldSkip("CC.S.A0026")) {
+            ChipLogProgress(chipTool, " ***** Test Step 45 : Read the mandatory attribute: Primary5Y\n");
+            if (ShouldSkip("CC.S.A0025")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary5Intensity_45();
+            err = TestReadTheMandatoryAttributePrimary5Y_45();
             break;
         case 46:
-            ChipLogProgress(chipTool, " ***** Test Step 46 : Read the mandatory attribute: Primary6X\n");
-            if (ShouldSkip("CC.S.A0028")) {
+            ChipLogProgress(chipTool, " ***** Test Step 46 : Read the mandatory attribute: Primary5Intensity\n");
+            if (ShouldSkip("CC.S.A0026")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary6X_46();
+            err = TestReadTheMandatoryAttributePrimary5Intensity_46();
             break;
         case 47:
-            ChipLogProgress(chipTool, " ***** Test Step 47 : Read the mandatory attribute: Primary6Y\n");
-            if (ShouldSkip("CC.S.A0029")) {
+            ChipLogProgress(chipTool, " ***** Test Step 47 : Read the mandatory attribute: Primary6X\n");
+            if (ShouldSkip("CC.S.A0028")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary6Y_47();
+            err = TestReadTheMandatoryAttributePrimary6X_47();
             break;
         case 48:
-            ChipLogProgress(chipTool, " ***** Test Step 48 : Read the mandatory attribute: Primary6Intensity\n");
-            if (ShouldSkip("CC.S.A002a")) {
+            ChipLogProgress(chipTool, " ***** Test Step 48 : Read the mandatory attribute: Primary6Y\n");
+            if (ShouldSkip("CC.S.A0029")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheMandatoryAttributePrimary6Intensity_48();
+            err = TestReadTheMandatoryAttributePrimary6Y_48();
             break;
         case 49:
-            ChipLogProgress(chipTool, " ***** Test Step 49 : Read the optional attribute: WhitePointX\n");
-            if (ShouldSkip("CC.S.A0030")) {
+            ChipLogProgress(chipTool, " ***** Test Step 49 : Read the mandatory attribute: Primary6Intensity\n");
+            if (ShouldSkip("CC.S.A002a")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeWhitePointX_49();
+            err = TestReadTheMandatoryAttributePrimary6Intensity_49();
             break;
         case 50:
-            ChipLogProgress(chipTool, " ***** Test Step 50 : Read the optional attribute: WhitePointY\n");
-            if (ShouldSkip("CC.S.A0031")) {
+            ChipLogProgress(chipTool, " ***** Test Step 50 : Read the optional attribute: WhitePointX\n");
+            if (ShouldSkip("CC.S.A0030")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeWhitePointY_50();
+            err = TestReadTheOptionalAttributeWhitePointX_50();
             break;
         case 51:
-            ChipLogProgress(chipTool, " ***** Test Step 51 : Read the optional attribute: ColorPointRX\n");
-            if (ShouldSkip("CC.S.A0032")) {
+            ChipLogProgress(chipTool, " ***** Test Step 51 : Read the optional attribute: WhitePointY\n");
+            if (ShouldSkip("CC.S.A0031")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointRX_51();
+            err = TestReadTheOptionalAttributeWhitePointY_51();
             break;
         case 52:
-            ChipLogProgress(chipTool, " ***** Test Step 52 : Read the optional attribute: ColorPointRY\n");
-            if (ShouldSkip("CC.S.A0033")) {
+            ChipLogProgress(chipTool, " ***** Test Step 52 : Read the optional attribute: ColorPointRX\n");
+            if (ShouldSkip("CC.S.A0032")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointRY_52();
+            err = TestReadTheOptionalAttributeColorPointRX_52();
             break;
         case 53:
-            ChipLogProgress(chipTool, " ***** Test Step 53 : Read the optional attribute: ColorPointRIntensity\n");
-            if (ShouldSkip("CC.S.A0034")) {
+            ChipLogProgress(chipTool, " ***** Test Step 53 : Read the optional attribute: ColorPointRY\n");
+            if (ShouldSkip("CC.S.A0033")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointRIntensity_53();
+            err = TestReadTheOptionalAttributeColorPointRY_53();
             break;
         case 54:
-            ChipLogProgress(chipTool, " ***** Test Step 54 : Read the optional attribute: ColorPointGX\n");
-            if (ShouldSkip("CC.S.A0036")) {
+            ChipLogProgress(chipTool, " ***** Test Step 54 : Read the optional attribute: ColorPointRIntensity\n");
+            if (ShouldSkip("CC.S.A0034")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointGX_54();
+            err = TestReadTheOptionalAttributeColorPointRIntensity_54();
             break;
         case 55:
-            ChipLogProgress(chipTool, " ***** Test Step 55 : Read the optional attribute: ColorPointGY\n");
-            if (ShouldSkip("CC.S.A0037")) {
+            ChipLogProgress(chipTool, " ***** Test Step 55 : Read the optional attribute: ColorPointGX\n");
+            if (ShouldSkip("CC.S.A0036")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointGY_55();
+            err = TestReadTheOptionalAttributeColorPointGX_55();
             break;
         case 56:
-            ChipLogProgress(chipTool, " ***** Test Step 56 : Read the optional attribute: ColorPointGIntensity\n");
-            if (ShouldSkip("CC.S.A0038")) {
+            ChipLogProgress(chipTool, " ***** Test Step 56 : Read the optional attribute: ColorPointGY\n");
+            if (ShouldSkip("CC.S.A0037")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointGIntensity_56();
+            err = TestReadTheOptionalAttributeColorPointGY_56();
             break;
         case 57:
-            ChipLogProgress(chipTool, " ***** Test Step 57 : Read the optional attribute: ColorPointBX\n");
-            if (ShouldSkip("CC.S.A003a")) {
+            ChipLogProgress(chipTool, " ***** Test Step 57 : Read the optional attribute: ColorPointGIntensity\n");
+            if (ShouldSkip("CC.S.A0038")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointBX_57();
+            err = TestReadTheOptionalAttributeColorPointGIntensity_57();
             break;
         case 58:
-            ChipLogProgress(chipTool, " ***** Test Step 58 : Read the optional attribute: ColorPointBY\n");
-            if (ShouldSkip("CC.S.A003b")) {
+            ChipLogProgress(chipTool, " ***** Test Step 58 : Read the optional attribute: ColorPointBX\n");
+            if (ShouldSkip("CC.S.A003a")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointBY_58();
+            err = TestReadTheOptionalAttributeColorPointBX_58();
             break;
         case 59:
-            ChipLogProgress(chipTool, " ***** Test Step 59 : Read the optional attribute: ColorPointBIntensity\n");
+            ChipLogProgress(chipTool, " ***** Test Step 59 : Read the optional attribute: ColorPointBY\n");
+            if (ShouldSkip("CC.S.A003b")) {
+                NextTest();
+                return;
+            }
+            err = TestReadTheOptionalAttributeColorPointBY_59();
+            break;
+        case 60:
+            ChipLogProgress(chipTool, " ***** Test Step 60 : Read the optional attribute: ColorPointBIntensity\n");
             if (ShouldSkip("CC.S.A003c")) {
                 NextTest();
                 return;
             }
-            err = TestReadTheOptionalAttributeColorPointBIntensity_59();
+            err = TestReadTheOptionalAttributeColorPointBIntensity_60();
             break;
         }
 
@@ -4680,6 +4684,9 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         case 59:
             VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
             break;
+        case 60:
+            VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
+            break;
         }
 
         // Go on to the next test.
@@ -4693,7 +4700,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
 
 private:
     std::atomic_uint16_t mTestIndex;
-    const uint16_t mTestCount = 60;
+    const uint16_t mTestCount = 61;
 
     chip::Optional<chip::NodeId> mNodeId;
     chip::Optional<chip::CharSpan> mCluster;
@@ -5110,8 +5117,30 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
 
         return CHIP_NO_ERROR;
     }
+    NSNumber * _Nonnull FeatureMapValue;
+
+    CHIP_ERROR TestReadTheOptionalGlobalAttributeFeatureMap_19()
+    {
+        CHIPDevice * device = GetDevice("alpha");
+        CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
+        VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE);
+
+        [cluster readAttributeFeatureMapWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) {
+            NSLog(@"read the optional global attribute: FeatureMap Error: %@", err);
+
+            VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0));
+
+            {
+                FeatureMapValue = value;
+            }
+
+            NextTest();
+        }];
+
+        return CHIP_NO_ERROR;
+    }
 
-    CHIP_ERROR TestReadsColorCapabilitiesAttributeFromDut_19()
+    CHIP_ERROR TestReadsColorCapabilitiesAttributeFromDut_20()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5124,7 +5153,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
 
             {
                 id actualValue = value;
-                VerifyOrReturn(CheckValue("ColorCapabilities", actualValue, 0U));
+                VerifyOrReturn(CheckValue("ColorCapabilities", actualValue, FeatureMapValue));
             }
 
             NextTest();
@@ -5133,7 +5162,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestValidateConstraintsOfAttributeColorCapabilities_20()
+    CHIP_ERROR TestValidateConstraintsOfAttributeColorCapabilities_21()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5154,7 +5183,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadsColorTempPhysicalMinMiredsAttributeFromDut_21()
+    CHIP_ERROR TestReadsColorTempPhysicalMinMiredsAttributeFromDut_22()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5177,7 +5206,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestValidateConstraintsOfAttributeColorTempPhysicalMinMireds_22()
+    CHIP_ERROR TestValidateConstraintsOfAttributeColorTempPhysicalMinMireds_23()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5199,7 +5228,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadColorTempPhysicalMaxMiredsAttributeFromDut_23()
+    CHIP_ERROR TestReadColorTempPhysicalMaxMiredsAttributeFromDut_24()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5222,7 +5251,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestValidateConstraintsOfAttributeColorTempPhysicalMaxMireds_24()
+    CHIP_ERROR TestValidateConstraintsOfAttributeColorTempPhysicalMaxMireds_25()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5244,7 +5273,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeCoupleColorTempToLevelMinMireds_25()
+    CHIP_ERROR TestReadTheOptionalAttributeCoupleColorTempToLevelMinMireds_26()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5272,7 +5301,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeStartUpColorTemperatureMireds_26()
+    CHIP_ERROR TestReadTheOptionalAttributeStartUpColorTemperatureMireds_27()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5299,7 +5328,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestValidateConstraintsOfAttributeRemainingTime_27()
+    CHIP_ERROR TestValidateConstraintsOfAttributeRemainingTime_28()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5327,7 +5356,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeDriftCompensation_28()
+    CHIP_ERROR TestReadTheOptionalAttributeDriftCompensation_29()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5353,7 +5382,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeCompensationText_29()
+    CHIP_ERROR TestReadTheOptionalAttributeCompensationText_30()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5377,7 +5406,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributeNumberOfPrimaries_30()
+    CHIP_ERROR TestReadTheMandatoryAttributeNumberOfPrimaries_31()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5401,7 +5430,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary1X_31()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary1X_32()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5422,7 +5451,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary1Y_32()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary1Y_33()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5443,7 +5472,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary1Intensity_33()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary1Intensity_34()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5465,7 +5494,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary2X_34()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary2X_35()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5486,7 +5515,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary2Y_35()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary2Y_36()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5507,7 +5536,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestValidateConstraintsOfAttributePrimary2Intensity_36()
+    CHIP_ERROR TestValidateConstraintsOfAttributePrimary2Intensity_37()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5529,7 +5558,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary3X_37()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary3X_38()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5550,7 +5579,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary3Y_38()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary3Y_39()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5571,7 +5600,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary3Intensity_39()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary3Intensity_40()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5593,7 +5622,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary4X_40()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary4X_41()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5614,7 +5643,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary4Y_41()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary4Y_42()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5635,7 +5664,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary4Intensity_42()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary4Intensity_43()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5657,7 +5686,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary5X_43()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary5X_44()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5678,7 +5707,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary5Y_44()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary5Y_45()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5699,7 +5728,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary5Intensity_45()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary5Intensity_46()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5721,7 +5750,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary6X_46()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary6X_47()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5742,7 +5771,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary6Y_47()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary6Y_48()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5763,7 +5792,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheMandatoryAttributePrimary6Intensity_48()
+    CHIP_ERROR TestReadTheMandatoryAttributePrimary6Intensity_49()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5785,7 +5814,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeWhitePointX_49()
+    CHIP_ERROR TestReadTheOptionalAttributeWhitePointX_50()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5811,7 +5840,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeWhitePointY_50()
+    CHIP_ERROR TestReadTheOptionalAttributeWhitePointY_51()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5837,7 +5866,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointRX_51()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointRX_52()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5863,7 +5892,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointRY_52()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointRY_53()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5889,7 +5918,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointRIntensity_53()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointRIntensity_54()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5916,7 +5945,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointGX_54()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointGX_55()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5942,7 +5971,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointGY_55()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointGY_56()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5968,7 +5997,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointGIntensity_56()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointGIntensity_57()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -5995,7 +6024,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointBX_57()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointBX_58()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -6021,7 +6050,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointBY_58()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointBY_59()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];
@@ -6047,7 +6076,7 @@ class Test_TC_CC_2_1 : public TestCommandBridge {
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR TestReadTheOptionalAttributeColorPointBIntensity_59()
+    CHIP_ERROR TestReadTheOptionalAttributeColorPointBIntensity_60()
     {
         CHIPDevice * device = GetDevice("alpha");
         CHIPTestColorControl * cluster = [[CHIPTestColorControl alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];