From 2419824c52d14246ee5659ad3b343d2f8f772703 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Thu, 16 Dec 2021 07:37:12 -0500 Subject: [PATCH] Enable more TestCluster tests. (#13057) Minor tweak to Darwin templates make them use the right suffixes on literals to make this compile. --- src/app/tests/suites/TestCluster.yaml | 142 +- .../CHIP/templates/partials/test_cluster.zapt | 6 +- .../Framework/CHIPTests/CHIPClustersTests.m | 810 ++-- .../chip-tool/zap-generated/test/Commands.h | 3508 +++++++++-------- 4 files changed, 2530 insertions(+), 1936 deletions(-) diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml index 22486acfd425db..fda216b4704955 100644 --- a/src/app/tests/suites/TestCluster.yaml +++ b/src/app/tests/suites/TestCluster.yaml @@ -2011,42 +2011,41 @@ tests: response: value: null - # TODO: TestCluster INT64 Darwin fix err integer literal is too large to be represented in a signed integer type - #- label: "Read attribute NULLABLE_INT64U null Value & range" - # command: "readAttribute" - # attribute: "nullable_int64u" - # response: - # constraints: - # minValue: 0 - # maxValue: "18446744073709551614" - - #- label: "Read attribute NULLABLE_INT64U null Value & not" - # command: "readAttribute" - # attribute: "nullable_int64u" - # response: - # constraints: - # notValue: "18446744073709551614" - - #- label: "Write attribute NULLABLE_INT64U Value" - # command: "writeAttribute" - # attribute: "nullable_int64u" - # arguments: - # value: "18000000000000000000" - - #- label: "Read attribute NULLABLE_INT64U Value in range" - # command: "readAttribute" - # attribute: "nullable_int64u" - # response: - # constraints: - # minValue: 0 - # maxValue: "18446744073709551614" - - #- label: "Read attribute NULLABLE_INT64U notValue OK" - # command: "readAttribute" - # attribute: "nullable_int64u" - # response: - # constraints: - # notValue: "18000000000000000001" + - label: "Read attribute NULLABLE_INT64U null Value & range" + command: "readAttribute" + attribute: "nullable_int64u" + response: + constraints: + minValue: 0 + maxValue: "18446744073709551614" + + - label: "Read attribute NULLABLE_INT64U null Value & not" + command: "readAttribute" + attribute: "nullable_int64u" + response: + constraints: + notValue: "18446744073709551614" + + - label: "Write attribute NULLABLE_INT64U Value" + command: "writeAttribute" + attribute: "nullable_int64u" + arguments: + value: "18000000000000000000" + + - label: "Read attribute NULLABLE_INT64U Value in range" + command: "readAttribute" + attribute: "nullable_int64u" + response: + constraints: + minValue: 0 + maxValue: "18446744073709551614" + + - label: "Read attribute NULLABLE_INT64U notValue OK" + command: "readAttribute" + attribute: "nullable_int64u" + response: + constraints: + notValue: "18000000000000000001" # Tests for nullable Int8 attribute @@ -2319,42 +2318,41 @@ tests: response: value: null - # TODO: TestCluster INT64 Darwin fix err integer literal is too large to be represented in a signed integer type - #- label: "Read attribute NULLABLE_INT64S null Value & range" - # command: "readAttribute" - # attribute: "nullable_int64s" - # response: - # constraints: - # minValue: "-9223372036854775807" - # maxValue: "9223372036854775807" - - #- label: "Read attribute NULLABLE_INT64S null Value & not" - # command: "readAttribute" - # attribute: "nullable_int64s" - # response: - # constraints: - # notValue: "-9223372036854775807" - - #- label: "Write attribute NULLABLE_INT64S Value" - # command: "writeAttribute" - # attribute: "nullable_int64s" - # arguments: - # value: "-9223372036854775807" - - #- label: "Read attribute NULLABLE_INT64S Value in range" - # command: "readAttribute" - # attribute: "nullable_int64s" - # response: - # constraints: - # minValue: "-9223372036854775807" - # maxValue: "9223372036854775807" - - #- label: "Read attribute NULLABLE_INT64S notValue OK" - # command: "readAttribute" - # attribute: "nullable_int64s" - # response: - # constraints: - # notValue: "-9223372036854775806" + - label: "Read attribute NULLABLE_INT64S null Value & range" + command: "readAttribute" + attribute: "nullable_int64s" + response: + constraints: + minValue: "-9223372036854775807" + maxValue: "9223372036854775807" + + - label: "Read attribute NULLABLE_INT64S null Value & not" + command: "readAttribute" + attribute: "nullable_int64s" + response: + constraints: + notValue: "-9223372036854775807" + + - label: "Write attribute NULLABLE_INT64S Value" + command: "writeAttribute" + attribute: "nullable_int64s" + arguments: + value: "-9223372036854775807" + + - label: "Read attribute NULLABLE_INT64S Value in range" + command: "readAttribute" + attribute: "nullable_int64s" + response: + constraints: + minValue: "-9223372036854775807" + maxValue: "9223372036854775807" + + - label: "Read attribute NULLABLE_INT64S notValue OK" + command: "readAttribute" + attribute: "nullable_int64s" + response: + constraints: + notValue: "-9223372036854775806" # Tests for float attribute diff --git a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt index 9e66246521cd56..4eb9bfb668e530 100644 --- a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt @@ -136,7 +136,7 @@ ResponseHandler {{> subscribeDataCallback}} = nil; { {{> actualValue}} if (actualValue != nil) { - XCTAssertGreaterThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.minValue}}); + XCTAssertGreaterThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.minValue type}}); } } {{/if}} @@ -144,7 +144,7 @@ ResponseHandler {{> subscribeDataCallback}} = nil; { {{> actualValue}} if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.maxValue}}); + XCTAssertLessThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.maxValue type}}); } } {{/if}} @@ -152,7 +152,7 @@ ResponseHandler {{> subscribeDataCallback}} = nil; { {{> actualValue}} if (actualValue != nil) { - XCTAssertNotEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.notValue}}); + XCTAssertNotEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.notValue type}}); } } {{/if}} diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 9c4be6de85347e..02df3fe8e53744 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -1281,7 +1281,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000010_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -1376,7 +1376,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000014_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -1449,7 +1449,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000017_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -2183,7 +2183,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000049_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -2281,7 +2281,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000053_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -2383,7 +2383,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000057_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -2534,7 +2534,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000063_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -2635,7 +2635,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000067_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 254); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 254U); } } @@ -2877,7 +2877,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000077_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -2948,7 +2948,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000080_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3038,7 +3038,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000084_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3109,7 +3109,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000087_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3199,7 +3199,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000091_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3270,7 +3270,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000094_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3360,7 +3360,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000098_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3431,7 +3431,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000101_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3521,7 +3521,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000105_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3592,7 +3592,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000108_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3682,7 +3682,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000112_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3753,7 +3753,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000115_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3843,7 +3843,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000119_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3915,7 +3915,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000122_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -3987,7 +3987,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000125_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -4059,7 +4059,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000128_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -4150,7 +4150,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000132_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -4222,7 +4222,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000135_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -4313,7 +4313,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000139_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -4385,7 +4385,7 @@ - (void)testSendClusterTest_TC_CC_2_1_000142_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279U); } } @@ -14136,7 +14136,7 @@ - (void)testSendClusterTest_TC_RH_2_1_000002_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 9999); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 9999U); } } @@ -18042,13 +18042,13 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000001_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertGreaterThanOrEqual([actualValue unsignedShortValue], 5); + XCTAssertGreaterThanOrEqual([actualValue unsignedShortValue], 5U); } } { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 200); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 200U); } } @@ -18097,7 +18097,7 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000003_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 201); + XCTAssertNotEqual([actualValue unsignedShortValue], 201U); } } @@ -18123,7 +18123,7 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000004_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 32768); + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 32768UL); } } @@ -18171,7 +18171,7 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000006_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedIntValue], 32769); + XCTAssertNotEqual([actualValue unsignedIntValue], 32769UL); } } @@ -18581,7 +18581,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000016_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000U); } } @@ -18634,7 +18634,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000018_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + XCTAssertNotEqual([actualValue unsignedShortValue], 20000U); } } @@ -18662,7 +18662,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000019_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000U); } } @@ -18715,7 +18715,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000021_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + XCTAssertNotEqual([actualValue unsignedShortValue], 20000U); } } @@ -18743,7 +18743,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000022_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000U); } } @@ -18796,7 +18796,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000024_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + XCTAssertNotEqual([actualValue unsignedShortValue], 20000U); } } @@ -18824,7 +18824,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000025_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000U); } } @@ -18877,7 +18877,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000027_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + XCTAssertNotEqual([actualValue unsignedShortValue], 20000U); } } @@ -18904,7 +18904,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000028_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -18956,7 +18956,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000030_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -18983,7 +18983,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000031_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19035,7 +19035,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000033_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19062,7 +19062,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000034_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19114,7 +19114,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000036_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19141,7 +19141,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000037_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19193,7 +19193,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000039_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19219,7 +19219,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000040_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 2047); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 2047U); } } @@ -19267,7 +19267,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000042_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 4096); + XCTAssertNotEqual([actualValue unsignedShortValue], 4096U); } } @@ -19294,7 +19294,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000043_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19345,7 +19345,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000045_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19372,7 +19372,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000046_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -19423,7 +19423,7 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000048_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535U); } } @@ -25656,7 +25656,7 @@ - (void)testSendClusterTestCluster_000217_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65534); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65534U); } } @@ -25682,7 +25682,7 @@ - (void)testSendClusterTestCluster_000218_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 65534); + XCTAssertNotEqual([actualValue unsignedShortValue], 65534U); } } @@ -25730,7 +25730,7 @@ - (void)testSendClusterTestCluster_000220_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65534); + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65534U); } } @@ -25756,7 +25756,7 @@ - (void)testSendClusterTestCluster_000221_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedShortValue], 32001); + XCTAssertNotEqual([actualValue unsignedShortValue], 32001U); } } @@ -25922,7 +25922,7 @@ - (void)testSendClusterTestCluster_000228_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 4294967294); + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 4294967294UL); } } @@ -25948,7 +25948,7 @@ - (void)testSendClusterTestCluster_000229_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedIntValue], 4294967294); + XCTAssertNotEqual([actualValue unsignedIntValue], 4294967294UL); } } @@ -25996,7 +25996,7 @@ - (void)testSendClusterTestCluster_000231_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 4294967294); + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 4294967294UL); } } @@ -26022,7 +26022,7 @@ - (void)testSendClusterTestCluster_000232_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedIntValue], 2147483648); + XCTAssertNotEqual([actualValue unsignedIntValue], 2147483648UL); } } @@ -26171,7 +26171,133 @@ - (void)testSendClusterTestCluster_000238_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000239_WriteAttribute +- (void)testSendClusterTestCluster_000239_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value & range"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000240_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value & not"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000241_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableInt64uArgument; + nullableInt64uArgument = [NSNumber numberWithUnsignedLongLong:18000000000000000000ULL]; + [cluster writeAttributeNullableInt64uWithValue:nullableInt64uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64U Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000242_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Value in range"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000243_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U notValue OK"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedLongLongValue], 18000000000000000001ULL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000244_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Min Value"]; @@ -26193,7 +26319,7 @@ - (void)testSendClusterTestCluster_000239_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000240_ReadAttribute +- (void)testSendClusterTestCluster_000245_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Min Value"]; @@ -26218,7 +26344,7 @@ - (void)testSendClusterTestCluster_000240_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000241_WriteAttribute +- (void)testSendClusterTestCluster_000246_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Invalid Value"]; @@ -26239,7 +26365,7 @@ - (void)testSendClusterTestCluster_000241_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000242_ReadAttribute +- (void)testSendClusterTestCluster_000247_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S unchanged Value"]; @@ -26264,7 +26390,7 @@ - (void)testSendClusterTestCluster_000242_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000243_WriteAttribute +- (void)testSendClusterTestCluster_000248_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S null Value"]; @@ -26286,7 +26412,7 @@ - (void)testSendClusterTestCluster_000243_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000244_ReadAttribute +- (void)testSendClusterTestCluster_000249_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value"]; @@ -26310,7 +26436,7 @@ - (void)testSendClusterTestCluster_000244_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000245_ReadAttribute +- (void)testSendClusterTestCluster_000250_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value & range"]; @@ -26342,7 +26468,7 @@ - (void)testSendClusterTestCluster_000245_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000246_ReadAttribute +- (void)testSendClusterTestCluster_000251_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value & not"]; @@ -26368,7 +26494,7 @@ - (void)testSendClusterTestCluster_000246_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000247_WriteAttribute +- (void)testSendClusterTestCluster_000252_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Value"]; @@ -26390,7 +26516,7 @@ - (void)testSendClusterTestCluster_000247_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000248_ReadAttribute +- (void)testSendClusterTestCluster_000253_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Value in range"]; @@ -26422,7 +26548,7 @@ - (void)testSendClusterTestCluster_000248_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000249_ReadAttribute +- (void)testSendClusterTestCluster_000254_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S notValue OK"]; @@ -26448,7 +26574,7 @@ - (void)testSendClusterTestCluster_000249_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000250_WriteAttribute +- (void)testSendClusterTestCluster_000255_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Min Value"]; @@ -26470,7 +26596,7 @@ - (void)testSendClusterTestCluster_000250_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000251_ReadAttribute +- (void)testSendClusterTestCluster_000256_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Min Value"]; @@ -26495,7 +26621,7 @@ - (void)testSendClusterTestCluster_000251_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000252_WriteAttribute +- (void)testSendClusterTestCluster_000257_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Invalid Value"]; @@ -26517,7 +26643,7 @@ - (void)testSendClusterTestCluster_000252_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000253_ReadAttribute +- (void)testSendClusterTestCluster_000258_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S unchanged Value"]; @@ -26542,7 +26668,7 @@ - (void)testSendClusterTestCluster_000253_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000254_WriteAttribute +- (void)testSendClusterTestCluster_000259_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S null Value"]; @@ -26564,7 +26690,7 @@ - (void)testSendClusterTestCluster_000254_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000255_ReadAttribute +- (void)testSendClusterTestCluster_000260_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value"]; @@ -26588,7 +26714,7 @@ - (void)testSendClusterTestCluster_000255_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000256_ReadAttribute +- (void)testSendClusterTestCluster_000261_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value & range"]; @@ -26620,7 +26746,7 @@ - (void)testSendClusterTestCluster_000256_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000257_ReadAttribute +- (void)testSendClusterTestCluster_000262_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value & not"]; @@ -26646,7 +26772,7 @@ - (void)testSendClusterTestCluster_000257_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000258_WriteAttribute +- (void)testSendClusterTestCluster_000263_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Value"]; @@ -26668,7 +26794,7 @@ - (void)testSendClusterTestCluster_000258_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000259_ReadAttribute +- (void)testSendClusterTestCluster_000264_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Value in range"]; @@ -26700,7 +26826,7 @@ - (void)testSendClusterTestCluster_000259_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000260_ReadAttribute +- (void)testSendClusterTestCluster_000265_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S notValue OK"]; @@ -26726,7 +26852,7 @@ - (void)testSendClusterTestCluster_000260_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000261_WriteAttribute +- (void)testSendClusterTestCluster_000266_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Min Value"]; @@ -26748,7 +26874,7 @@ - (void)testSendClusterTestCluster_000261_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000262_ReadAttribute +- (void)testSendClusterTestCluster_000267_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Min Value"]; @@ -26773,7 +26899,7 @@ - (void)testSendClusterTestCluster_000262_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000263_WriteAttribute +- (void)testSendClusterTestCluster_000268_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Invalid Value"]; @@ -26795,7 +26921,7 @@ - (void)testSendClusterTestCluster_000263_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000264_ReadAttribute +- (void)testSendClusterTestCluster_000269_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S unchanged Value"]; @@ -26820,7 +26946,7 @@ - (void)testSendClusterTestCluster_000264_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000265_WriteAttribute +- (void)testSendClusterTestCluster_000270_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S null Value"]; @@ -26842,7 +26968,7 @@ - (void)testSendClusterTestCluster_000265_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000266_ReadAttribute +- (void)testSendClusterTestCluster_000271_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value"]; @@ -26866,7 +26992,7 @@ - (void)testSendClusterTestCluster_000266_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000267_ReadAttribute +- (void)testSendClusterTestCluster_000272_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value & range"]; @@ -26883,13 +27009,13 @@ - (void)testSendClusterTestCluster_000267_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertGreaterThanOrEqual([actualValue intValue], -2147483647); + XCTAssertGreaterThanOrEqual([actualValue intValue], -2147483647L); } } { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue intValue], 2147483647); + XCTAssertLessThanOrEqual([actualValue intValue], 2147483647L); } } @@ -26898,7 +27024,7 @@ - (void)testSendClusterTestCluster_000267_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000268_ReadAttribute +- (void)testSendClusterTestCluster_000273_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value & not"]; @@ -26915,7 +27041,7 @@ - (void)testSendClusterTestCluster_000268_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue intValue], -2147483647); + XCTAssertNotEqual([actualValue intValue], -2147483647L); } } @@ -26924,7 +27050,7 @@ - (void)testSendClusterTestCluster_000268_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000269_WriteAttribute +- (void)testSendClusterTestCluster_000274_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Value"]; @@ -26946,7 +27072,7 @@ - (void)testSendClusterTestCluster_000269_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000270_ReadAttribute +- (void)testSendClusterTestCluster_000275_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Value in range"]; @@ -26963,13 +27089,13 @@ - (void)testSendClusterTestCluster_000270_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertGreaterThanOrEqual([actualValue intValue], -2147483647); + XCTAssertGreaterThanOrEqual([actualValue intValue], -2147483647L); } } { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue intValue], 2147483647); + XCTAssertLessThanOrEqual([actualValue intValue], 2147483647L); } } @@ -26978,7 +27104,7 @@ - (void)testSendClusterTestCluster_000270_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000271_ReadAttribute +- (void)testSendClusterTestCluster_000276_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S notValue OK"]; @@ -26995,7 +27121,7 @@ - (void)testSendClusterTestCluster_000271_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue intValue], -2147483646); + XCTAssertNotEqual([actualValue intValue], -2147483646L); } } @@ -27004,7 +27130,7 @@ - (void)testSendClusterTestCluster_000271_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000272_WriteAttribute +- (void)testSendClusterTestCluster_000277_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Min Value"]; @@ -27026,7 +27152,7 @@ - (void)testSendClusterTestCluster_000272_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000273_ReadAttribute +- (void)testSendClusterTestCluster_000278_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Min Value"]; @@ -27051,7 +27177,7 @@ - (void)testSendClusterTestCluster_000273_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000274_WriteAttribute +- (void)testSendClusterTestCluster_000279_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Invalid Value"]; @@ -27073,7 +27199,7 @@ - (void)testSendClusterTestCluster_000274_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000275_ReadAttribute +- (void)testSendClusterTestCluster_000280_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S unchanged Value"]; @@ -27098,7 +27224,7 @@ - (void)testSendClusterTestCluster_000275_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000276_WriteAttribute +- (void)testSendClusterTestCluster_000281_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S null Value"]; @@ -27120,7 +27246,7 @@ - (void)testSendClusterTestCluster_000276_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000277_ReadAttribute +- (void)testSendClusterTestCluster_000282_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value"]; @@ -27144,7 +27270,145 @@ - (void)testSendClusterTestCluster_000277_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000278_WriteAttribute +- (void)testSendClusterTestCluster_000283_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value & range"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64S null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue longLongValue], -9223372036854775807LL); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue longLongValue], 9223372036854775807LL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000284_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value & not"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64S null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue longLongValue], -9223372036854775807LL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000285_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableInt64sArgument; + nullableInt64sArgument = [NSNumber numberWithLongLong:-9223372036854775807LL]; + [cluster writeAttributeNullableInt64sWithValue:nullableInt64sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64S Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000286_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Value in range"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64S Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue longLongValue], -9223372036854775807LL); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue longLongValue], 9223372036854775807LL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000287_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S notValue OK"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64S notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue longLongValue], -9223372036854775806LL); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000288_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE medium Value"]; @@ -27166,7 +27430,7 @@ - (void)testSendClusterTestCluster_000278_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000279_ReadAttribute +- (void)testSendClusterTestCluster_000289_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE medium Value"]; @@ -27191,7 +27455,7 @@ - (void)testSendClusterTestCluster_000279_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000280_WriteAttribute +- (void)testSendClusterTestCluster_000290_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE largest Value"]; @@ -27213,7 +27477,7 @@ - (void)testSendClusterTestCluster_000280_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000281_ReadAttribute +- (void)testSendClusterTestCluster_000291_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE largest Value"]; @@ -27238,7 +27502,7 @@ - (void)testSendClusterTestCluster_000281_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000282_WriteAttribute +- (void)testSendClusterTestCluster_000292_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE smallest Value"]; @@ -27260,7 +27524,7 @@ - (void)testSendClusterTestCluster_000282_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000283_ReadAttribute +- (void)testSendClusterTestCluster_000293_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE smallest Value"]; @@ -27285,7 +27549,7 @@ - (void)testSendClusterTestCluster_000283_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000284_WriteAttribute +- (void)testSendClusterTestCluster_000294_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE null Value"]; @@ -27307,7 +27571,7 @@ - (void)testSendClusterTestCluster_000284_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000285_ReadAttribute +- (void)testSendClusterTestCluster_000295_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE null Value"]; @@ -27331,7 +27595,7 @@ - (void)testSendClusterTestCluster_000285_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000286_WriteAttribute +- (void)testSendClusterTestCluster_000296_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE 0 Value"]; @@ -27353,7 +27617,7 @@ - (void)testSendClusterTestCluster_000286_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000287_ReadAttribute +- (void)testSendClusterTestCluster_000297_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE 0 Value"]; @@ -27378,7 +27642,7 @@ - (void)testSendClusterTestCluster_000287_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000288_WriteAttribute +- (void)testSendClusterTestCluster_000298_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE medium Value"]; @@ -27400,7 +27664,7 @@ - (void)testSendClusterTestCluster_000288_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000289_ReadAttribute +- (void)testSendClusterTestCluster_000299_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE medium Value"]; @@ -27425,7 +27689,7 @@ - (void)testSendClusterTestCluster_000289_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000290_WriteAttribute +- (void)testSendClusterTestCluster_000300_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE largest Value"]; @@ -27447,7 +27711,7 @@ - (void)testSendClusterTestCluster_000290_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000291_ReadAttribute +- (void)testSendClusterTestCluster_000301_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE largest Value"]; @@ -27472,7 +27736,7 @@ - (void)testSendClusterTestCluster_000291_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000292_WriteAttribute +- (void)testSendClusterTestCluster_000302_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE smallest Value"]; @@ -27494,7 +27758,7 @@ - (void)testSendClusterTestCluster_000292_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000293_ReadAttribute +- (void)testSendClusterTestCluster_000303_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE smallest Value"]; @@ -27519,7 +27783,7 @@ - (void)testSendClusterTestCluster_000293_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000294_WriteAttribute +- (void)testSendClusterTestCluster_000304_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE null Value"]; @@ -27541,7 +27805,7 @@ - (void)testSendClusterTestCluster_000294_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000295_ReadAttribute +- (void)testSendClusterTestCluster_000305_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE null Value"]; @@ -27565,7 +27829,7 @@ - (void)testSendClusterTestCluster_000295_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000296_WriteAttribute +- (void)testSendClusterTestCluster_000306_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE 0 Value"]; @@ -27587,7 +27851,7 @@ - (void)testSendClusterTestCluster_000296_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000297_ReadAttribute +- (void)testSendClusterTestCluster_000307_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE 0 Value"]; @@ -27612,7 +27876,7 @@ - (void)testSendClusterTestCluster_000297_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000298_WriteAttribute +- (void)testSendClusterTestCluster_000308_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Max Value"]; @@ -27634,7 +27898,7 @@ - (void)testSendClusterTestCluster_000298_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000299_ReadAttribute +- (void)testSendClusterTestCluster_000309_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Max Value"]; @@ -27659,7 +27923,7 @@ - (void)testSendClusterTestCluster_000299_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000300_WriteAttribute +- (void)testSendClusterTestCluster_000310_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Invalid Value"]; @@ -27680,7 +27944,7 @@ - (void)testSendClusterTestCluster_000300_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000301_ReadAttribute +- (void)testSendClusterTestCluster_000311_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 unchanged Value"]; @@ -27705,7 +27969,7 @@ - (void)testSendClusterTestCluster_000301_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000302_WriteAttribute +- (void)testSendClusterTestCluster_000312_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 null Value"]; @@ -27727,7 +27991,7 @@ - (void)testSendClusterTestCluster_000302_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000303_ReadAttribute +- (void)testSendClusterTestCluster_000313_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 null Value"]; @@ -27751,7 +28015,7 @@ - (void)testSendClusterTestCluster_000303_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000304_WriteAttribute +- (void)testSendClusterTestCluster_000314_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Max Value"]; @@ -27773,7 +28037,7 @@ - (void)testSendClusterTestCluster_000304_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000305_ReadAttribute +- (void)testSendClusterTestCluster_000315_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Max Value"]; @@ -27798,7 +28062,7 @@ - (void)testSendClusterTestCluster_000305_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000306_WriteAttribute +- (void)testSendClusterTestCluster_000316_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Invalid Value"]; @@ -27820,7 +28084,7 @@ - (void)testSendClusterTestCluster_000306_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000307_ReadAttribute +- (void)testSendClusterTestCluster_000317_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 unchanged Value"]; @@ -27845,7 +28109,7 @@ - (void)testSendClusterTestCluster_000307_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000308_WriteAttribute +- (void)testSendClusterTestCluster_000318_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 null Value"]; @@ -27867,7 +28131,7 @@ - (void)testSendClusterTestCluster_000308_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000309_ReadAttribute +- (void)testSendClusterTestCluster_000319_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 null Value"]; @@ -27891,7 +28155,7 @@ - (void)testSendClusterTestCluster_000309_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000310_ReadAttribute +- (void)testSendClusterTestCluster_000320_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING Default Value"]; @@ -27916,7 +28180,7 @@ - (void)testSendClusterTestCluster_000310_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000311_WriteAttribute +- (void)testSendClusterTestCluster_000321_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -27938,7 +28202,7 @@ - (void)testSendClusterTestCluster_000311_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000312_ReadAttribute +- (void)testSendClusterTestCluster_000322_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -27963,7 +28227,7 @@ - (void)testSendClusterTestCluster_000312_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000313_WriteAttribute +- (void)testSendClusterTestCluster_000323_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -27985,7 +28249,7 @@ - (void)testSendClusterTestCluster_000313_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000314_ReadAttribute +- (void)testSendClusterTestCluster_000324_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -28009,7 +28273,7 @@ - (void)testSendClusterTestCluster_000314_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000315_WriteAttribute +- (void)testSendClusterTestCluster_000325_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -28031,7 +28295,7 @@ - (void)testSendClusterTestCluster_000315_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000316_ReadAttribute +- (void)testSendClusterTestCluster_000326_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -28056,7 +28320,7 @@ - (void)testSendClusterTestCluster_000316_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000317_ReadAttribute +- (void)testSendClusterTestCluster_000327_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING Default Value"]; @@ -28081,7 +28345,7 @@ - (void)testSendClusterTestCluster_000317_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000318_WriteAttribute +- (void)testSendClusterTestCluster_000328_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING"]; @@ -28103,7 +28367,7 @@ - (void)testSendClusterTestCluster_000318_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000319_ReadAttribute +- (void)testSendClusterTestCluster_000329_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -28128,7 +28392,7 @@ - (void)testSendClusterTestCluster_000319_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000320_WriteAttribute +- (void)testSendClusterTestCluster_000330_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Value too long"]; @@ -28150,7 +28414,7 @@ - (void)testSendClusterTestCluster_000320_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000321_ReadAttribute +- (void)testSendClusterTestCluster_000331_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -28174,7 +28438,7 @@ - (void)testSendClusterTestCluster_000321_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000322_WriteAttribute +- (void)testSendClusterTestCluster_000332_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Empty"]; @@ -28196,7 +28460,7 @@ - (void)testSendClusterTestCluster_000322_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000323_ReadAttribute +- (void)testSendClusterTestCluster_000333_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -28221,7 +28485,7 @@ - (void)testSendClusterTestCluster_000323_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000324_ReadAttribute +- (void)testSendClusterTestCluster_000334_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent endpoint."]; @@ -28239,7 +28503,7 @@ - (void)testSendClusterTestCluster_000324_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000325_ReadAttribute +- (void)testSendClusterTestCluster_000335_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent cluster."]; @@ -28257,7 +28521,7 @@ - (void)testSendClusterTestCluster_000325_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000326_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000336_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -28279,7 +28543,7 @@ - (void)testSendClusterTestCluster_000326_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000327_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000337_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -28303,9 +28567,9 @@ - (void)testSendClusterTestCluster_000327_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -bool testSendClusterTestCluster_000328_WaitForReport_Fulfilled = false; +bool testSendClusterTestCluster_000338_WaitForReport_Fulfilled = false; ResponseHandler test_TestCluster_list_int8u_Reported = nil; -- (void)testSendClusterTestCluster_000328_WaitForReport +- (void)testSendClusterTestCluster_000338_WaitForReport { CHIPDevice * device = GetConnectedDevice(); @@ -28327,10 +28591,10 @@ - (void)testSendClusterTestCluster_000328_WaitForReport XCTAssertEqual([actualValue[3] unsignedCharValue], 4); } - testSendClusterTestCluster_000328_WaitForReport_Fulfilled = true; + testSendClusterTestCluster_000338_WaitForReport_Fulfilled = true; }; } -- (void)testSendClusterTestCluster_000329_SubscribeAttribute +- (void)testSendClusterTestCluster_000339_SubscribeAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Subscribe to list attribute"]; @@ -28344,7 +28608,7 @@ - (void)testSendClusterTestCluster_000329_SubscribeAttribute [cluster subscribeAttributeListInt8uWithMinInterval:minIntervalArgument maxInterval:maxIntervalArgument subscriptionEstablished:^{ - XCTAssertEqual(testSendClusterTestCluster_000328_WaitForReport_Fulfilled, true); + XCTAssertEqual(testSendClusterTestCluster_000338_WaitForReport_Fulfilled, true); [expectation fulfill]; } reportHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { @@ -28360,7 +28624,7 @@ - (void)testSendClusterTestCluster_000329_SubscribeAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000330_WriteAttribute +- (void)testSendClusterTestCluster_000340_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write subscribed-to list attribute"]; @@ -28389,7 +28653,7 @@ - (void)testSendClusterTestCluster_000330_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000331_WaitForReport +- (void)testSendClusterTestCluster_000341_WaitForReport { XCTestExpectation * expectation = [self expectationWithDescription:@"Check for list attribute report"]; @@ -28417,7 +28681,7 @@ - (void)testSendClusterTestCluster_000331_WaitForReport [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000332_ReadAttribute +- (void)testSendClusterTestCluster_000342_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 8-bit integer"]; @@ -28441,7 +28705,7 @@ - (void)testSendClusterTestCluster_000332_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000333_WriteAttribute +- (void)testSendClusterTestCluster_000343_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 8-bit integer"]; @@ -28464,7 +28728,7 @@ - (void)testSendClusterTestCluster_000333_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000334_WriteAttribute +- (void)testSendClusterTestCluster_000344_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 8-bit integer"]; @@ -28489,7 +28753,7 @@ - (void)testSendClusterTestCluster_000334_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000335_WriteAttribute +- (void)testSendClusterTestCluster_000345_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 8-bit integer"]; @@ -28514,7 +28778,7 @@ - (void)testSendClusterTestCluster_000335_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000336_WriteAttribute +- (void)testSendClusterTestCluster_000346_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 8-bit integer"]; @@ -28537,7 +28801,7 @@ - (void)testSendClusterTestCluster_000336_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000337_ReadAttribute +- (void)testSendClusterTestCluster_000347_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value has not changed"]; @@ -28562,7 +28826,7 @@ - (void)testSendClusterTestCluster_000337_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000338_WriteAttribute +- (void)testSendClusterTestCluster_000348_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 8-bit integer"]; @@ -28586,7 +28850,7 @@ - (void)testSendClusterTestCluster_000338_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000339_ReadAttribute +- (void)testSendClusterTestCluster_000349_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at min valid"]; @@ -28611,7 +28875,7 @@ - (void)testSendClusterTestCluster_000339_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000340_WriteAttribute +- (void)testSendClusterTestCluster_000350_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 8-bit integer"]; @@ -28635,7 +28899,7 @@ - (void)testSendClusterTestCluster_000340_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000341_ReadAttribute +- (void)testSendClusterTestCluster_000351_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at max valid"]; @@ -28660,7 +28924,7 @@ - (void)testSendClusterTestCluster_000341_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000342_WriteAttribute +- (void)testSendClusterTestCluster_000352_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 8-bit integer"]; @@ -28684,7 +28948,7 @@ - (void)testSendClusterTestCluster_000342_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000343_ReadAttribute +- (void)testSendClusterTestCluster_000353_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -28709,7 +28973,7 @@ - (void)testSendClusterTestCluster_000343_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000344_ReadAttribute +- (void)testSendClusterTestCluster_000354_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 16-bit integer"]; @@ -28733,7 +28997,7 @@ - (void)testSendClusterTestCluster_000344_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000345_WriteAttribute +- (void)testSendClusterTestCluster_000355_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 16-bit integer"]; @@ -28756,7 +29020,7 @@ - (void)testSendClusterTestCluster_000345_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000346_WriteAttribute +- (void)testSendClusterTestCluster_000356_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 16-bit integer"]; @@ -28782,7 +29046,7 @@ - (void)testSendClusterTestCluster_000346_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000347_WriteAttribute +- (void)testSendClusterTestCluster_000357_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 16-bit integer"]; @@ -28808,7 +29072,7 @@ - (void)testSendClusterTestCluster_000347_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000348_WriteAttribute +- (void)testSendClusterTestCluster_000358_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 16-bit integer"]; @@ -28831,7 +29095,7 @@ - (void)testSendClusterTestCluster_000348_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000349_ReadAttribute +- (void)testSendClusterTestCluster_000359_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value has not changed"]; @@ -28856,7 +29120,7 @@ - (void)testSendClusterTestCluster_000349_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000350_WriteAttribute +- (void)testSendClusterTestCluster_000360_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 16-bit integer"]; @@ -28880,7 +29144,7 @@ - (void)testSendClusterTestCluster_000350_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000351_ReadAttribute +- (void)testSendClusterTestCluster_000361_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at min valid"]; @@ -28905,7 +29169,7 @@ - (void)testSendClusterTestCluster_000351_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000352_WriteAttribute +- (void)testSendClusterTestCluster_000362_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 16-bit integer"]; @@ -28929,7 +29193,7 @@ - (void)testSendClusterTestCluster_000352_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000353_ReadAttribute +- (void)testSendClusterTestCluster_000363_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at max valid"]; @@ -28954,7 +29218,7 @@ - (void)testSendClusterTestCluster_000353_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000354_WriteAttribute +- (void)testSendClusterTestCluster_000364_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 16-bit integer"]; @@ -28979,7 +29243,7 @@ - (void)testSendClusterTestCluster_000354_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000355_ReadAttribute +- (void)testSendClusterTestCluster_000365_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -29004,7 +29268,7 @@ - (void)testSendClusterTestCluster_000355_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000356_ReadAttribute +- (void)testSendClusterTestCluster_000366_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 8-bit integer"]; @@ -29028,7 +29292,7 @@ - (void)testSendClusterTestCluster_000356_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000357_WriteAttribute +- (void)testSendClusterTestCluster_000367_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 8-bit integer"]; @@ -29051,7 +29315,7 @@ - (void)testSendClusterTestCluster_000357_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000358_WriteAttribute +- (void)testSendClusterTestCluster_000368_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 8-bit integer"]; @@ -29076,7 +29340,7 @@ - (void)testSendClusterTestCluster_000358_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000359_WriteAttribute +- (void)testSendClusterTestCluster_000369_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 8-bit integer"]; @@ -29101,7 +29365,7 @@ - (void)testSendClusterTestCluster_000359_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000360_WriteAttribute +- (void)testSendClusterTestCluster_000370_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 8-bit integer"]; @@ -29124,7 +29388,7 @@ - (void)testSendClusterTestCluster_000360_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000361_ReadAttribute +- (void)testSendClusterTestCluster_000371_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value has not changed"]; @@ -29149,7 +29413,7 @@ - (void)testSendClusterTestCluster_000361_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000362_WriteAttribute +- (void)testSendClusterTestCluster_000372_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 8-bit integer"]; @@ -29173,7 +29437,7 @@ - (void)testSendClusterTestCluster_000362_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000363_ReadAttribute +- (void)testSendClusterTestCluster_000373_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at min valid"]; @@ -29198,7 +29462,7 @@ - (void)testSendClusterTestCluster_000363_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000364_WriteAttribute +- (void)testSendClusterTestCluster_000374_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 8-bit integer"]; @@ -29222,7 +29486,7 @@ - (void)testSendClusterTestCluster_000364_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000365_ReadAttribute +- (void)testSendClusterTestCluster_000375_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at max valid"]; @@ -29247,7 +29511,7 @@ - (void)testSendClusterTestCluster_000365_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000366_WriteAttribute +- (void)testSendClusterTestCluster_000376_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 8-bit integer"]; @@ -29271,7 +29535,7 @@ - (void)testSendClusterTestCluster_000366_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000367_ReadAttribute +- (void)testSendClusterTestCluster_000377_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at mid valid"]; @@ -29296,7 +29560,7 @@ - (void)testSendClusterTestCluster_000367_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000368_ReadAttribute +- (void)testSendClusterTestCluster_000378_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 16-bit integer"]; @@ -29320,7 +29584,7 @@ - (void)testSendClusterTestCluster_000368_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000369_WriteAttribute +- (void)testSendClusterTestCluster_000379_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 16-bit integer"]; @@ -29343,7 +29607,7 @@ - (void)testSendClusterTestCluster_000369_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000370_WriteAttribute +- (void)testSendClusterTestCluster_000380_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 16-bit integer"]; @@ -29368,7 +29632,7 @@ - (void)testSendClusterTestCluster_000370_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000371_WriteAttribute +- (void)testSendClusterTestCluster_000381_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 16-bit integer"]; @@ -29393,7 +29657,7 @@ - (void)testSendClusterTestCluster_000371_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000372_WriteAttribute +- (void)testSendClusterTestCluster_000382_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 16-bit integer"]; @@ -29416,7 +29680,7 @@ - (void)testSendClusterTestCluster_000372_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000373_ReadAttribute +- (void)testSendClusterTestCluster_000383_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value has not changed"]; @@ -29441,7 +29705,7 @@ - (void)testSendClusterTestCluster_000373_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000374_WriteAttribute +- (void)testSendClusterTestCluster_000384_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 16-bit integer"]; @@ -29465,7 +29729,7 @@ - (void)testSendClusterTestCluster_000374_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000375_ReadAttribute +- (void)testSendClusterTestCluster_000385_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at min valid"]; @@ -29490,7 +29754,7 @@ - (void)testSendClusterTestCluster_000375_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000376_WriteAttribute +- (void)testSendClusterTestCluster_000386_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 16-bit integer"]; @@ -29514,7 +29778,7 @@ - (void)testSendClusterTestCluster_000376_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000377_ReadAttribute +- (void)testSendClusterTestCluster_000387_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at max valid"]; @@ -29539,7 +29803,7 @@ - (void)testSendClusterTestCluster_000377_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000378_WriteAttribute +- (void)testSendClusterTestCluster_000388_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 16-bit integer"]; @@ -29563,7 +29827,7 @@ - (void)testSendClusterTestCluster_000378_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000379_ReadAttribute +- (void)testSendClusterTestCluster_000389_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at mid valid"]; @@ -29588,7 +29852,7 @@ - (void)testSendClusterTestCluster_000379_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000380_ReadAttribute +- (void)testSendClusterTestCluster_000390_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 8-bit integer"]; @@ -29613,7 +29877,7 @@ - (void)testSendClusterTestCluster_000380_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000381_WriteAttribute +- (void)testSendClusterTestCluster_000391_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29638,7 +29902,7 @@ - (void)testSendClusterTestCluster_000381_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000382_WriteAttribute +- (void)testSendClusterTestCluster_000392_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29663,7 +29927,7 @@ - (void)testSendClusterTestCluster_000382_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000383_WriteAttribute +- (void)testSendClusterTestCluster_000393_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29688,7 +29952,7 @@ - (void)testSendClusterTestCluster_000383_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000384_WriteAttribute +- (void)testSendClusterTestCluster_000394_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29713,7 +29977,7 @@ - (void)testSendClusterTestCluster_000384_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000385_ReadAttribute +- (void)testSendClusterTestCluster_000395_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value has not changed"]; @@ -29739,7 +30003,7 @@ - (void)testSendClusterTestCluster_000385_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000386_WriteAttribute +- (void)testSendClusterTestCluster_000396_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29764,7 +30028,7 @@ - (void)testSendClusterTestCluster_000386_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000387_ReadAttribute +- (void)testSendClusterTestCluster_000397_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at min valid"]; @@ -29790,7 +30054,7 @@ - (void)testSendClusterTestCluster_000387_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000388_WriteAttribute +- (void)testSendClusterTestCluster_000398_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29815,7 +30079,7 @@ - (void)testSendClusterTestCluster_000388_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000389_ReadAttribute +- (void)testSendClusterTestCluster_000399_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at max valid"]; @@ -29841,7 +30105,7 @@ - (void)testSendClusterTestCluster_000389_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000390_WriteAttribute +- (void)testSendClusterTestCluster_000400_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29866,7 +30130,7 @@ - (void)testSendClusterTestCluster_000390_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000391_ReadAttribute +- (void)testSendClusterTestCluster_000401_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -29892,7 +30156,7 @@ - (void)testSendClusterTestCluster_000391_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000392_WriteAttribute +- (void)testSendClusterTestCluster_000402_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29917,7 +30181,7 @@ - (void)testSendClusterTestCluster_000392_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000393_ReadAttribute +- (void)testSendClusterTestCluster_000403_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is null"]; @@ -29942,7 +30206,7 @@ - (void)testSendClusterTestCluster_000393_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000394_ReadAttribute +- (void)testSendClusterTestCluster_000404_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 16-bit integer"]; @@ -29968,7 +30232,7 @@ - (void)testSendClusterTestCluster_000394_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000395_WriteAttribute +- (void)testSendClusterTestCluster_000405_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29993,7 +30257,7 @@ - (void)testSendClusterTestCluster_000395_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000396_WriteAttribute +- (void)testSendClusterTestCluster_000406_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30018,7 +30282,7 @@ - (void)testSendClusterTestCluster_000396_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000397_WriteAttribute +- (void)testSendClusterTestCluster_000407_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30043,7 +30307,7 @@ - (void)testSendClusterTestCluster_000397_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000398_WriteAttribute +- (void)testSendClusterTestCluster_000408_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30068,7 +30332,7 @@ - (void)testSendClusterTestCluster_000398_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000399_ReadAttribute +- (void)testSendClusterTestCluster_000409_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value has not changed"]; @@ -30095,7 +30359,7 @@ - (void)testSendClusterTestCluster_000399_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000400_WriteAttribute +- (void)testSendClusterTestCluster_000410_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30120,7 +30384,7 @@ - (void)testSendClusterTestCluster_000400_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000401_ReadAttribute +- (void)testSendClusterTestCluster_000411_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at min valid"]; @@ -30147,7 +30411,7 @@ - (void)testSendClusterTestCluster_000401_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000402_WriteAttribute +- (void)testSendClusterTestCluster_000412_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30172,7 +30436,7 @@ - (void)testSendClusterTestCluster_000402_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000403_ReadAttribute +- (void)testSendClusterTestCluster_000413_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at max valid"]; @@ -30199,7 +30463,7 @@ - (void)testSendClusterTestCluster_000403_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000404_WriteAttribute +- (void)testSendClusterTestCluster_000414_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30224,7 +30488,7 @@ - (void)testSendClusterTestCluster_000404_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000405_ReadAttribute +- (void)testSendClusterTestCluster_000415_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -30251,7 +30515,7 @@ - (void)testSendClusterTestCluster_000405_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000406_WriteAttribute +- (void)testSendClusterTestCluster_000416_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30276,7 +30540,7 @@ - (void)testSendClusterTestCluster_000406_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000407_ReadAttribute +- (void)testSendClusterTestCluster_000417_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is null"]; @@ -30302,7 +30566,7 @@ - (void)testSendClusterTestCluster_000407_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000408_ReadAttribute +- (void)testSendClusterTestCluster_000418_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 8-bit integer"]; @@ -30327,7 +30591,7 @@ - (void)testSendClusterTestCluster_000408_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000409_WriteAttribute +- (void)testSendClusterTestCluster_000419_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 8-bit integer"]; @@ -30353,7 +30617,7 @@ - (void)testSendClusterTestCluster_000409_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000410_WriteAttribute +- (void)testSendClusterTestCluster_000420_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 8-bit integer"]; @@ -30378,7 +30642,7 @@ - (void)testSendClusterTestCluster_000410_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000411_WriteAttribute +- (void)testSendClusterTestCluster_000421_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 8-bit integer"]; @@ -30403,7 +30667,7 @@ - (void)testSendClusterTestCluster_000411_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000412_WriteAttribute +- (void)testSendClusterTestCluster_000422_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 8-bit integer"]; @@ -30429,7 +30693,7 @@ - (void)testSendClusterTestCluster_000412_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000413_ReadAttribute +- (void)testSendClusterTestCluster_000423_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value has not changed"]; @@ -30455,7 +30719,7 @@ - (void)testSendClusterTestCluster_000413_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000414_WriteAttribute +- (void)testSendClusterTestCluster_000424_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 8-bit integer"]; @@ -30480,7 +30744,7 @@ - (void)testSendClusterTestCluster_000414_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000415_ReadAttribute +- (void)testSendClusterTestCluster_000425_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at min valid"]; @@ -30506,7 +30770,7 @@ - (void)testSendClusterTestCluster_000415_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000416_WriteAttribute +- (void)testSendClusterTestCluster_000426_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 8-bit integer"]; @@ -30531,7 +30795,7 @@ - (void)testSendClusterTestCluster_000416_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000417_ReadAttribute +- (void)testSendClusterTestCluster_000427_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at max valid"]; @@ -30557,7 +30821,7 @@ - (void)testSendClusterTestCluster_000417_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000418_WriteAttribute +- (void)testSendClusterTestCluster_000428_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 8-bit integer"]; @@ -30582,7 +30846,7 @@ - (void)testSendClusterTestCluster_000418_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000419_ReadAttribute +- (void)testSendClusterTestCluster_000429_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at mid valid"]; @@ -30608,7 +30872,7 @@ - (void)testSendClusterTestCluster_000419_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000420_WriteAttribute +- (void)testSendClusterTestCluster_000430_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 8-bit integer"]; @@ -30634,7 +30898,7 @@ - (void)testSendClusterTestCluster_000420_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000421_ReadAttribute +- (void)testSendClusterTestCluster_000431_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at null"]; @@ -30659,7 +30923,7 @@ - (void)testSendClusterTestCluster_000421_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000422_ReadAttribute +- (void)testSendClusterTestCluster_000432_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 16-bit integer"]; @@ -30685,7 +30949,7 @@ - (void)testSendClusterTestCluster_000422_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000423_WriteAttribute +- (void)testSendClusterTestCluster_000433_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 16-bit integer"]; @@ -30710,7 +30974,7 @@ - (void)testSendClusterTestCluster_000423_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000424_WriteAttribute +- (void)testSendClusterTestCluster_000434_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 16-bit integer"]; @@ -30735,7 +30999,7 @@ - (void)testSendClusterTestCluster_000424_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000425_WriteAttribute +- (void)testSendClusterTestCluster_000435_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 16-bit integer"]; @@ -30760,7 +31024,7 @@ - (void)testSendClusterTestCluster_000425_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000426_WriteAttribute +- (void)testSendClusterTestCluster_000436_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 16-bit integer"]; @@ -30785,7 +31049,7 @@ - (void)testSendClusterTestCluster_000426_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000427_ReadAttribute +- (void)testSendClusterTestCluster_000437_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value has not changed"]; @@ -30812,7 +31076,7 @@ - (void)testSendClusterTestCluster_000427_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000428_WriteAttribute +- (void)testSendClusterTestCluster_000438_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 16-bit integer"]; @@ -30837,7 +31101,7 @@ - (void)testSendClusterTestCluster_000428_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000429_ReadAttribute +- (void)testSendClusterTestCluster_000439_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at min valid"]; @@ -30864,7 +31128,7 @@ - (void)testSendClusterTestCluster_000429_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000430_WriteAttribute +- (void)testSendClusterTestCluster_000440_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 16-bit integer"]; @@ -30889,7 +31153,7 @@ - (void)testSendClusterTestCluster_000430_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000431_ReadAttribute +- (void)testSendClusterTestCluster_000441_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at max valid"]; @@ -30916,7 +31180,7 @@ - (void)testSendClusterTestCluster_000431_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000432_WriteAttribute +- (void)testSendClusterTestCluster_000442_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 16-bit integer"]; @@ -30941,7 +31205,7 @@ - (void)testSendClusterTestCluster_000432_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000433_ReadAttribute +- (void)testSendClusterTestCluster_000443_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at mid valid"]; @@ -30968,7 +31232,7 @@ - (void)testSendClusterTestCluster_000433_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000434_WriteAttribute +- (void)testSendClusterTestCluster_000444_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 16-bit integer"]; @@ -30993,7 +31257,7 @@ - (void)testSendClusterTestCluster_000434_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000435_ReadAttribute +- (void)testSendClusterTestCluster_000445_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is null"]; @@ -33327,7 +33591,7 @@ - (void)testSendClusterTestConstraints_000002_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertGreaterThanOrEqual([actualValue unsignedIntValue], 5); + XCTAssertGreaterThanOrEqual([actualValue unsignedIntValue], 5UL); } } @@ -33353,7 +33617,7 @@ - (void)testSendClusterTestConstraints_000003_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 5); + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 5UL); } } @@ -33379,7 +33643,7 @@ - (void)testSendClusterTestConstraints_000004_ReadAttribute { id actualValue = value; if (actualValue != nil) { - XCTAssertNotEqual([actualValue unsignedIntValue], 6); + XCTAssertNotEqual([actualValue unsignedIntValue], 6UL); } } diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 0e489dfde8bbdd..46ace0f3bb842f 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -35432,892 +35432,932 @@ class TestCluster : public TestCommand err = TestReadAttributeNullableInt64uNullValue_238(); break; case 239: - ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_INT8S Min Value\n"); - err = TestWriteAttributeNullableInt8sMinValue_239(); + ChipLogProgress(chipTool, " ***** Test Step 239 : Read attribute NULLABLE_INT64U null Value & range\n"); + err = TestReadAttributeNullableInt64uNullValueRange_239(); break; case 240: - ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT8S Min Value\n"); - err = TestReadAttributeNullableInt8sMinValue_240(); + ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT64U null Value & not\n"); + err = TestReadAttributeNullableInt64uNullValueNot_240(); break; case 241: - ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_INT8S Invalid Value\n"); - err = TestWriteAttributeNullableInt8sInvalidValue_241(); + ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_INT64U Value\n"); + err = TestWriteAttributeNullableInt64uValue_241(); break; case 242: - ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT8S unchanged Value\n"); - err = TestReadAttributeNullableInt8sUnchangedValue_242(); + ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT64U Value in range\n"); + err = TestReadAttributeNullableInt64uValueInRange_242(); break; case 243: - ChipLogProgress(chipTool, " ***** Test Step 243 : Write attribute NULLABLE_INT8S null Value\n"); - err = TestWriteAttributeNullableInt8sNullValue_243(); + ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_INT64U notValue OK\n"); + err = TestReadAttributeNullableInt64uNotValueOk_243(); break; case 244: - ChipLogProgress(chipTool, " ***** Test Step 244 : Read attribute NULLABLE_INT8S null Value\n"); - err = TestReadAttributeNullableInt8sNullValue_244(); + ChipLogProgress(chipTool, " ***** Test Step 244 : Write attribute NULLABLE_INT8S Min Value\n"); + err = TestWriteAttributeNullableInt8sMinValue_244(); break; case 245: - ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_INT8S null Value & range\n"); - err = TestReadAttributeNullableInt8sNullValueRange_245(); + ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_INT8S Min Value\n"); + err = TestReadAttributeNullableInt8sMinValue_245(); break; case 246: - ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT8S null Value & not\n"); - err = TestReadAttributeNullableInt8sNullValueNot_246(); + ChipLogProgress(chipTool, " ***** Test Step 246 : Write attribute NULLABLE_INT8S Invalid Value\n"); + err = TestWriteAttributeNullableInt8sInvalidValue_246(); break; case 247: - ChipLogProgress(chipTool, " ***** Test Step 247 : Write attribute NULLABLE_INT8S Value\n"); - err = TestWriteAttributeNullableInt8sValue_247(); + ChipLogProgress(chipTool, " ***** Test Step 247 : Read attribute NULLABLE_INT8S unchanged Value\n"); + err = TestReadAttributeNullableInt8sUnchangedValue_247(); break; case 248: - ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_INT8S Value in range\n"); - err = TestReadAttributeNullableInt8sValueInRange_248(); + ChipLogProgress(chipTool, " ***** Test Step 248 : Write attribute NULLABLE_INT8S null Value\n"); + err = TestWriteAttributeNullableInt8sNullValue_248(); break; case 249: - ChipLogProgress(chipTool, " ***** Test Step 249 : Read attribute NULLABLE_INT8S notValue OK\n"); - err = TestReadAttributeNullableInt8sNotValueOk_249(); + ChipLogProgress(chipTool, " ***** Test Step 249 : Read attribute NULLABLE_INT8S null Value\n"); + err = TestReadAttributeNullableInt8sNullValue_249(); break; case 250: - ChipLogProgress(chipTool, " ***** Test Step 250 : Write attribute NULLABLE_INT16S Min Value\n"); - err = TestWriteAttributeNullableInt16sMinValue_250(); + ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_INT8S null Value & range\n"); + err = TestReadAttributeNullableInt8sNullValueRange_250(); break; case 251: - ChipLogProgress(chipTool, " ***** Test Step 251 : Read attribute NULLABLE_INT16S Min Value\n"); - err = TestReadAttributeNullableInt16sMinValue_251(); + ChipLogProgress(chipTool, " ***** Test Step 251 : Read attribute NULLABLE_INT8S null Value & not\n"); + err = TestReadAttributeNullableInt8sNullValueNot_251(); break; case 252: - ChipLogProgress(chipTool, " ***** Test Step 252 : Write attribute NULLABLE_INT16S Invalid Value\n"); - err = TestWriteAttributeNullableInt16sInvalidValue_252(); + ChipLogProgress(chipTool, " ***** Test Step 252 : Write attribute NULLABLE_INT8S Value\n"); + err = TestWriteAttributeNullableInt8sValue_252(); break; case 253: - ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_INT16S unchanged Value\n"); - err = TestReadAttributeNullableInt16sUnchangedValue_253(); + ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_INT8S Value in range\n"); + err = TestReadAttributeNullableInt8sValueInRange_253(); break; case 254: - ChipLogProgress(chipTool, " ***** Test Step 254 : Write attribute NULLABLE_INT16S null Value\n"); - err = TestWriteAttributeNullableInt16sNullValue_254(); + ChipLogProgress(chipTool, " ***** Test Step 254 : Read attribute NULLABLE_INT8S notValue OK\n"); + err = TestReadAttributeNullableInt8sNotValueOk_254(); break; case 255: - ChipLogProgress(chipTool, " ***** Test Step 255 : Read attribute NULLABLE_INT16S null Value\n"); - err = TestReadAttributeNullableInt16sNullValue_255(); + ChipLogProgress(chipTool, " ***** Test Step 255 : Write attribute NULLABLE_INT16S Min Value\n"); + err = TestWriteAttributeNullableInt16sMinValue_255(); break; case 256: - ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_INT16S null Value & range\n"); - err = TestReadAttributeNullableInt16sNullValueRange_256(); + ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_INT16S Min Value\n"); + err = TestReadAttributeNullableInt16sMinValue_256(); break; case 257: - ChipLogProgress(chipTool, " ***** Test Step 257 : Read attribute NULLABLE_INT16S null Value & not\n"); - err = TestReadAttributeNullableInt16sNullValueNot_257(); + ChipLogProgress(chipTool, " ***** Test Step 257 : Write attribute NULLABLE_INT16S Invalid Value\n"); + err = TestWriteAttributeNullableInt16sInvalidValue_257(); break; case 258: - ChipLogProgress(chipTool, " ***** Test Step 258 : Write attribute NULLABLE_INT16S Value\n"); - err = TestWriteAttributeNullableInt16sValue_258(); + ChipLogProgress(chipTool, " ***** Test Step 258 : Read attribute NULLABLE_INT16S unchanged Value\n"); + err = TestReadAttributeNullableInt16sUnchangedValue_258(); break; case 259: - ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_INT16S Value in range\n"); - err = TestReadAttributeNullableInt16sValueInRange_259(); + ChipLogProgress(chipTool, " ***** Test Step 259 : Write attribute NULLABLE_INT16S null Value\n"); + err = TestWriteAttributeNullableInt16sNullValue_259(); break; case 260: - ChipLogProgress(chipTool, " ***** Test Step 260 : Read attribute NULLABLE_INT16S notValue OK\n"); - err = TestReadAttributeNullableInt16sNotValueOk_260(); + ChipLogProgress(chipTool, " ***** Test Step 260 : Read attribute NULLABLE_INT16S null Value\n"); + err = TestReadAttributeNullableInt16sNullValue_260(); break; case 261: - ChipLogProgress(chipTool, " ***** Test Step 261 : Write attribute NULLABLE_INT32S Min Value\n"); - err = TestWriteAttributeNullableInt32sMinValue_261(); + ChipLogProgress(chipTool, " ***** Test Step 261 : Read attribute NULLABLE_INT16S null Value & range\n"); + err = TestReadAttributeNullableInt16sNullValueRange_261(); break; case 262: - ChipLogProgress(chipTool, " ***** Test Step 262 : Read attribute NULLABLE_INT32S Min Value\n"); - err = TestReadAttributeNullableInt32sMinValue_262(); + ChipLogProgress(chipTool, " ***** Test Step 262 : Read attribute NULLABLE_INT16S null Value & not\n"); + err = TestReadAttributeNullableInt16sNullValueNot_262(); break; case 263: - ChipLogProgress(chipTool, " ***** Test Step 263 : Write attribute NULLABLE_INT32S Invalid Value\n"); - err = TestWriteAttributeNullableInt32sInvalidValue_263(); + ChipLogProgress(chipTool, " ***** Test Step 263 : Write attribute NULLABLE_INT16S Value\n"); + err = TestWriteAttributeNullableInt16sValue_263(); break; case 264: - ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_INT32S unchanged Value\n"); - err = TestReadAttributeNullableInt32sUnchangedValue_264(); + ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_INT16S Value in range\n"); + err = TestReadAttributeNullableInt16sValueInRange_264(); break; case 265: - ChipLogProgress(chipTool, " ***** Test Step 265 : Write attribute NULLABLE_INT32S null Value\n"); - err = TestWriteAttributeNullableInt32sNullValue_265(); + ChipLogProgress(chipTool, " ***** Test Step 265 : Read attribute NULLABLE_INT16S notValue OK\n"); + err = TestReadAttributeNullableInt16sNotValueOk_265(); break; case 266: - ChipLogProgress(chipTool, " ***** Test Step 266 : Read attribute NULLABLE_INT32S null Value\n"); - err = TestReadAttributeNullableInt32sNullValue_266(); + ChipLogProgress(chipTool, " ***** Test Step 266 : Write attribute NULLABLE_INT32S Min Value\n"); + err = TestWriteAttributeNullableInt32sMinValue_266(); break; case 267: - ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_INT32S null Value & range\n"); - err = TestReadAttributeNullableInt32sNullValueRange_267(); + ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_INT32S Min Value\n"); + err = TestReadAttributeNullableInt32sMinValue_267(); break; case 268: - ChipLogProgress(chipTool, " ***** Test Step 268 : Read attribute NULLABLE_INT32S null Value & not\n"); - err = TestReadAttributeNullableInt32sNullValueNot_268(); + ChipLogProgress(chipTool, " ***** Test Step 268 : Write attribute NULLABLE_INT32S Invalid Value\n"); + err = TestWriteAttributeNullableInt32sInvalidValue_268(); break; case 269: - ChipLogProgress(chipTool, " ***** Test Step 269 : Write attribute NULLABLE_INT32S Value\n"); - err = TestWriteAttributeNullableInt32sValue_269(); + ChipLogProgress(chipTool, " ***** Test Step 269 : Read attribute NULLABLE_INT32S unchanged Value\n"); + err = TestReadAttributeNullableInt32sUnchangedValue_269(); break; case 270: - ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_INT32S Value in range\n"); - err = TestReadAttributeNullableInt32sValueInRange_270(); + ChipLogProgress(chipTool, " ***** Test Step 270 : Write attribute NULLABLE_INT32S null Value\n"); + err = TestWriteAttributeNullableInt32sNullValue_270(); break; case 271: - ChipLogProgress(chipTool, " ***** Test Step 271 : Read attribute NULLABLE_INT32S notValue OK\n"); - err = TestReadAttributeNullableInt32sNotValueOk_271(); + ChipLogProgress(chipTool, " ***** Test Step 271 : Read attribute NULLABLE_INT32S null Value\n"); + err = TestReadAttributeNullableInt32sNullValue_271(); break; case 272: - ChipLogProgress(chipTool, " ***** Test Step 272 : Write attribute NULLABLE_INT64S Min Value\n"); - err = TestWriteAttributeNullableInt64sMinValue_272(); + ChipLogProgress(chipTool, " ***** Test Step 272 : Read attribute NULLABLE_INT32S null Value & range\n"); + err = TestReadAttributeNullableInt32sNullValueRange_272(); break; case 273: - ChipLogProgress(chipTool, " ***** Test Step 273 : Read attribute NULLABLE_INT64S Min Value\n"); - err = TestReadAttributeNullableInt64sMinValue_273(); + ChipLogProgress(chipTool, " ***** Test Step 273 : Read attribute NULLABLE_INT32S null Value & not\n"); + err = TestReadAttributeNullableInt32sNullValueNot_273(); break; case 274: - ChipLogProgress(chipTool, " ***** Test Step 274 : Write attribute NULLABLE_INT64S Invalid Value\n"); - err = TestWriteAttributeNullableInt64sInvalidValue_274(); + ChipLogProgress(chipTool, " ***** Test Step 274 : Write attribute NULLABLE_INT32S Value\n"); + err = TestWriteAttributeNullableInt32sValue_274(); break; case 275: - ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_INT64S unchanged Value\n"); - err = TestReadAttributeNullableInt64sUnchangedValue_275(); + ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_INT32S Value in range\n"); + err = TestReadAttributeNullableInt32sValueInRange_275(); break; case 276: - ChipLogProgress(chipTool, " ***** Test Step 276 : Write attribute NULLABLE_INT64S null Value\n"); - err = TestWriteAttributeNullableInt64sNullValue_276(); + ChipLogProgress(chipTool, " ***** Test Step 276 : Read attribute NULLABLE_INT32S notValue OK\n"); + err = TestReadAttributeNullableInt32sNotValueOk_276(); break; case 277: - ChipLogProgress(chipTool, " ***** Test Step 277 : Read attribute NULLABLE_INT64S null Value\n"); - err = TestReadAttributeNullableInt64sNullValue_277(); + ChipLogProgress(chipTool, " ***** Test Step 277 : Write attribute NULLABLE_INT64S Min Value\n"); + err = TestWriteAttributeNullableInt64sMinValue_277(); break; case 278: - ChipLogProgress(chipTool, " ***** Test Step 278 : Write attribute NULLABLE_SINGLE medium Value\n"); - err = TestWriteAttributeNullableSingleMediumValue_278(); + ChipLogProgress(chipTool, " ***** Test Step 278 : Read attribute NULLABLE_INT64S Min Value\n"); + err = TestReadAttributeNullableInt64sMinValue_278(); break; case 279: - ChipLogProgress(chipTool, " ***** Test Step 279 : Read attribute NULLABLE_SINGLE medium Value\n"); - err = TestReadAttributeNullableSingleMediumValue_279(); + ChipLogProgress(chipTool, " ***** Test Step 279 : Write attribute NULLABLE_INT64S Invalid Value\n"); + err = TestWriteAttributeNullableInt64sInvalidValue_279(); break; case 280: - ChipLogProgress(chipTool, " ***** Test Step 280 : Write attribute NULLABLE_SINGLE largest Value\n"); - err = TestWriteAttributeNullableSingleLargestValue_280(); + ChipLogProgress(chipTool, " ***** Test Step 280 : Read attribute NULLABLE_INT64S unchanged Value\n"); + err = TestReadAttributeNullableInt64sUnchangedValue_280(); break; case 281: - ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_SINGLE largest Value\n"); - err = TestReadAttributeNullableSingleLargestValue_281(); + ChipLogProgress(chipTool, " ***** Test Step 281 : Write attribute NULLABLE_INT64S null Value\n"); + err = TestWriteAttributeNullableInt64sNullValue_281(); break; case 282: - ChipLogProgress(chipTool, " ***** Test Step 282 : Write attribute NULLABLE_SINGLE smallest Value\n"); - err = TestWriteAttributeNullableSingleSmallestValue_282(); + ChipLogProgress(chipTool, " ***** Test Step 282 : Read attribute NULLABLE_INT64S null Value\n"); + err = TestReadAttributeNullableInt64sNullValue_282(); break; case 283: - ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_SINGLE smallest Value\n"); - err = TestReadAttributeNullableSingleSmallestValue_283(); + ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_INT64S null Value & range\n"); + err = TestReadAttributeNullableInt64sNullValueRange_283(); break; case 284: - ChipLogProgress(chipTool, " ***** Test Step 284 : Write attribute NULLABLE_SINGLE null Value\n"); - err = TestWriteAttributeNullableSingleNullValue_284(); + ChipLogProgress(chipTool, " ***** Test Step 284 : Read attribute NULLABLE_INT64S null Value & not\n"); + err = TestReadAttributeNullableInt64sNullValueNot_284(); break; case 285: - ChipLogProgress(chipTool, " ***** Test Step 285 : Read attribute NULLABLE_SINGLE null Value\n"); - err = TestReadAttributeNullableSingleNullValue_285(); + ChipLogProgress(chipTool, " ***** Test Step 285 : Write attribute NULLABLE_INT64S Value\n"); + err = TestWriteAttributeNullableInt64sValue_285(); break; case 286: - ChipLogProgress(chipTool, " ***** Test Step 286 : Write attribute NULLABLE_SINGLE 0 Value\n"); - err = TestWriteAttributeNullableSingle0Value_286(); + ChipLogProgress(chipTool, " ***** Test Step 286 : Read attribute NULLABLE_INT64S Value in range\n"); + err = TestReadAttributeNullableInt64sValueInRange_286(); break; case 287: - ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_SINGLE 0 Value\n"); - err = TestReadAttributeNullableSingle0Value_287(); + ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_INT64S notValue OK\n"); + err = TestReadAttributeNullableInt64sNotValueOk_287(); break; case 288: - ChipLogProgress(chipTool, " ***** Test Step 288 : Write attribute NULLABLE_DOUBLE medium Value\n"); - err = TestWriteAttributeNullableDoubleMediumValue_288(); + ChipLogProgress(chipTool, " ***** Test Step 288 : Write attribute NULLABLE_SINGLE medium Value\n"); + err = TestWriteAttributeNullableSingleMediumValue_288(); break; case 289: - ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_DOUBLE medium Value\n"); - err = TestReadAttributeNullableDoubleMediumValue_289(); + ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_SINGLE medium Value\n"); + err = TestReadAttributeNullableSingleMediumValue_289(); break; case 290: - ChipLogProgress(chipTool, " ***** Test Step 290 : Write attribute NULLABLE_DOUBLE largest Value\n"); - err = TestWriteAttributeNullableDoubleLargestValue_290(); + ChipLogProgress(chipTool, " ***** Test Step 290 : Write attribute NULLABLE_SINGLE largest Value\n"); + err = TestWriteAttributeNullableSingleLargestValue_290(); break; case 291: - ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_DOUBLE largest Value\n"); - err = TestReadAttributeNullableDoubleLargestValue_291(); + ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_SINGLE largest Value\n"); + err = TestReadAttributeNullableSingleLargestValue_291(); break; case 292: - ChipLogProgress(chipTool, " ***** Test Step 292 : Write attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestWriteAttributeNullableDoubleSmallestValue_292(); + ChipLogProgress(chipTool, " ***** Test Step 292 : Write attribute NULLABLE_SINGLE smallest Value\n"); + err = TestWriteAttributeNullableSingleSmallestValue_292(); break; case 293: - ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestReadAttributeNullableDoubleSmallestValue_293(); + ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute NULLABLE_SINGLE smallest Value\n"); + err = TestReadAttributeNullableSingleSmallestValue_293(); break; case 294: - ChipLogProgress(chipTool, " ***** Test Step 294 : Write attribute NULLABLE_DOUBLE null Value\n"); - err = TestWriteAttributeNullableDoubleNullValue_294(); + ChipLogProgress(chipTool, " ***** Test Step 294 : Write attribute NULLABLE_SINGLE null Value\n"); + err = TestWriteAttributeNullableSingleNullValue_294(); break; case 295: - ChipLogProgress(chipTool, " ***** Test Step 295 : Read attribute NULLABLE_DOUBLE null Value\n"); - err = TestReadAttributeNullableDoubleNullValue_295(); + ChipLogProgress(chipTool, " ***** Test Step 295 : Read attribute NULLABLE_SINGLE null Value\n"); + err = TestReadAttributeNullableSingleNullValue_295(); break; case 296: - ChipLogProgress(chipTool, " ***** Test Step 296 : Write attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestWriteAttributeNullableDouble0Value_296(); + ChipLogProgress(chipTool, " ***** Test Step 296 : Write attribute NULLABLE_SINGLE 0 Value\n"); + err = TestWriteAttributeNullableSingle0Value_296(); break; case 297: - ChipLogProgress(chipTool, " ***** Test Step 297 : Read attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestReadAttributeNullableDouble0Value_297(); + ChipLogProgress(chipTool, " ***** Test Step 297 : Read attribute NULLABLE_SINGLE 0 Value\n"); + err = TestReadAttributeNullableSingle0Value_297(); break; case 298: - ChipLogProgress(chipTool, " ***** Test Step 298 : Write attribute NULLABLE_ENUM8 Max Value\n"); - err = TestWriteAttributeNullableEnum8MaxValue_298(); + ChipLogProgress(chipTool, " ***** Test Step 298 : Write attribute NULLABLE_DOUBLE medium Value\n"); + err = TestWriteAttributeNullableDoubleMediumValue_298(); break; case 299: - ChipLogProgress(chipTool, " ***** Test Step 299 : Read attribute NULLABLE_ENUM8 Max Value\n"); - err = TestReadAttributeNullableEnum8MaxValue_299(); + ChipLogProgress(chipTool, " ***** Test Step 299 : Read attribute NULLABLE_DOUBLE medium Value\n"); + err = TestReadAttributeNullableDoubleMediumValue_299(); break; case 300: - ChipLogProgress(chipTool, " ***** Test Step 300 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); - err = TestWriteAttributeNullableEnum8InvalidValue_300(); + ChipLogProgress(chipTool, " ***** Test Step 300 : Write attribute NULLABLE_DOUBLE largest Value\n"); + err = TestWriteAttributeNullableDoubleLargestValue_300(); break; case 301: - ChipLogProgress(chipTool, " ***** Test Step 301 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); - err = TestReadAttributeNullableEnum8UnchangedValue_301(); + ChipLogProgress(chipTool, " ***** Test Step 301 : Read attribute NULLABLE_DOUBLE largest Value\n"); + err = TestReadAttributeNullableDoubleLargestValue_301(); break; case 302: - ChipLogProgress(chipTool, " ***** Test Step 302 : Write attribute NULLABLE_ENUM8 null Value\n"); - err = TestWriteAttributeNullableEnum8NullValue_302(); + ChipLogProgress(chipTool, " ***** Test Step 302 : Write attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestWriteAttributeNullableDoubleSmallestValue_302(); break; case 303: - ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_ENUM8 null Value\n"); - err = TestReadAttributeNullableEnum8NullValue_303(); + ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestReadAttributeNullableDoubleSmallestValue_303(); break; case 304: - ChipLogProgress(chipTool, " ***** Test Step 304 : Write attribute NULLABLE_ENUM16 Max Value\n"); - err = TestWriteAttributeNullableEnum16MaxValue_304(); + ChipLogProgress(chipTool, " ***** Test Step 304 : Write attribute NULLABLE_DOUBLE null Value\n"); + err = TestWriteAttributeNullableDoubleNullValue_304(); break; case 305: - ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_ENUM16 Max Value\n"); - err = TestReadAttributeNullableEnum16MaxValue_305(); + ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_DOUBLE null Value\n"); + err = TestReadAttributeNullableDoubleNullValue_305(); break; case 306: - ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); - err = TestWriteAttributeNullableEnum16InvalidValue_306(); + ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestWriteAttributeNullableDouble0Value_306(); break; case 307: - ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); - err = TestReadAttributeNullableEnum16UnchangedValue_307(); + ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestReadAttributeNullableDouble0Value_307(); break; case 308: - ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_ENUM16 null Value\n"); - err = TestWriteAttributeNullableEnum16NullValue_308(); + ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_ENUM8 Max Value\n"); + err = TestWriteAttributeNullableEnum8MaxValue_308(); break; case 309: - ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_ENUM16 null Value\n"); - err = TestReadAttributeNullableEnum16NullValue_309(); + ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_ENUM8 Max Value\n"); + err = TestReadAttributeNullableEnum8MaxValue_309(); break; case 310: - ChipLogProgress(chipTool, " ***** Test Step 310 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); - err = TestReadAttributeNullableOctetStringDefaultValue_310(); + ChipLogProgress(chipTool, " ***** Test Step 310 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); + err = TestWriteAttributeNullableEnum8InvalidValue_310(); break; case 311: - ChipLogProgress(chipTool, " ***** Test Step 311 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_311(); + ChipLogProgress(chipTool, " ***** Test Step 311 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); + err = TestReadAttributeNullableEnum8UnchangedValue_311(); break; case 312: - ChipLogProgress(chipTool, " ***** Test Step 312 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_312(); + ChipLogProgress(chipTool, " ***** Test Step 312 : Write attribute NULLABLE_ENUM8 null Value\n"); + err = TestWriteAttributeNullableEnum8NullValue_312(); break; case 313: - ChipLogProgress(chipTool, " ***** Test Step 313 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_313(); + ChipLogProgress(chipTool, " ***** Test Step 313 : Read attribute NULLABLE_ENUM8 null Value\n"); + err = TestReadAttributeNullableEnum8NullValue_313(); break; case 314: - ChipLogProgress(chipTool, " ***** Test Step 314 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_314(); + ChipLogProgress(chipTool, " ***** Test Step 314 : Write attribute NULLABLE_ENUM16 Max Value\n"); + err = TestWriteAttributeNullableEnum16MaxValue_314(); break; case 315: - ChipLogProgress(chipTool, " ***** Test Step 315 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_315(); + ChipLogProgress(chipTool, " ***** Test Step 315 : Read attribute NULLABLE_ENUM16 Max Value\n"); + err = TestReadAttributeNullableEnum16MaxValue_315(); break; case 316: - ChipLogProgress(chipTool, " ***** Test Step 316 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_316(); + ChipLogProgress(chipTool, " ***** Test Step 316 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); + err = TestWriteAttributeNullableEnum16InvalidValue_316(); break; case 317: - ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); - err = TestReadAttributeNullableCharStringDefaultValue_317(); + ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); + err = TestReadAttributeNullableEnum16UnchangedValue_317(); break; case 318: - ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_CHAR_STRING\n"); - err = TestWriteAttributeNullableCharString_318(); + ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_ENUM16 null Value\n"); + err = TestWriteAttributeNullableEnum16NullValue_318(); break; case 319: - ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_319(); + ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_ENUM16 null Value\n"); + err = TestReadAttributeNullableEnum16NullValue_319(); break; case 320: - ChipLogProgress(chipTool, " ***** Test Step 320 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); - err = TestWriteAttributeNullableCharStringValueTooLong_320(); + ChipLogProgress(chipTool, " ***** Test Step 320 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); + err = TestReadAttributeNullableOctetStringDefaultValue_320(); break; case 321: - ChipLogProgress(chipTool, " ***** Test Step 321 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_321(); + ChipLogProgress(chipTool, " ***** Test Step 321 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_321(); break; case 322: - ChipLogProgress(chipTool, " ***** Test Step 322 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); - err = TestWriteAttributeNullableCharStringEmpty_322(); + ChipLogProgress(chipTool, " ***** Test Step 322 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_322(); break; case 323: - ChipLogProgress(chipTool, " ***** Test Step 323 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_323(); + ChipLogProgress(chipTool, " ***** Test Step 323 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_323(); break; case 324: - ChipLogProgress(chipTool, " ***** Test Step 324 : Read attribute from nonexistent endpoint.\n"); - err = TestReadAttributeFromNonexistentEndpoint_324(); + ChipLogProgress(chipTool, " ***** Test Step 324 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_324(); break; case 325: - ChipLogProgress(chipTool, " ***** Test Step 325 : Read attribute from nonexistent cluster.\n"); - err = TestReadAttributeFromNonexistentCluster_325(); + ChipLogProgress(chipTool, " ***** Test Step 325 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_325(); break; case 326: - ChipLogProgress(chipTool, - " ***** Test Step 326 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_326(); + ChipLogProgress(chipTool, " ***** Test Step 326 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_326(); break; case 327: - ChipLogProgress(chipTool, - " ***** Test Step 327 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_327(); + ChipLogProgress(chipTool, " ***** Test Step 327 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); + err = TestReadAttributeNullableCharStringDefaultValue_327(); break; case 328: - ChipLogProgress(chipTool, " ***** Test Step 328 : Report: Subscribe to list attribute\n"); - err = TestReportSubscribeToListAttribute_328(); + ChipLogProgress(chipTool, " ***** Test Step 328 : Write attribute NULLABLE_CHAR_STRING\n"); + err = TestWriteAttributeNullableCharString_328(); break; case 329: - ChipLogProgress(chipTool, " ***** Test Step 329 : Subscribe to list attribute\n"); - err = TestSubscribeToListAttribute_329(); + ChipLogProgress(chipTool, " ***** Test Step 329 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_329(); break; case 330: - ChipLogProgress(chipTool, " ***** Test Step 330 : Write subscribed-to list attribute\n"); - err = TestWriteSubscribedToListAttribute_330(); + ChipLogProgress(chipTool, " ***** Test Step 330 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); + err = TestWriteAttributeNullableCharStringValueTooLong_330(); break; case 331: - ChipLogProgress(chipTool, " ***** Test Step 331 : Check for list attribute report\n"); - err = TestCheckForListAttributeReport_331(); + ChipLogProgress(chipTool, " ***** Test Step 331 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_331(); break; case 332: - ChipLogProgress(chipTool, " ***** Test Step 332 : Read range-restricted unsigned 8-bit integer\n"); - err = TestReadRangeRestrictedUnsigned8BitInteger_332(); + ChipLogProgress(chipTool, " ***** Test Step 332 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); + err = TestWriteAttributeNullableCharStringEmpty_332(); break; case 333: - ChipLogProgress(chipTool, " ***** Test Step 333 : Write min value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_333(); + ChipLogProgress(chipTool, " ***** Test Step 333 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_333(); break; case 334: - ChipLogProgress(chipTool, - " ***** Test Step 334 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_334(); + ChipLogProgress(chipTool, " ***** Test Step 334 : Read attribute from nonexistent endpoint.\n"); + err = TestReadAttributeFromNonexistentEndpoint_334(); break; case 335: - ChipLogProgress(chipTool, - " ***** Test Step 335 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_335(); + ChipLogProgress(chipTool, " ***** Test Step 335 : Read attribute from nonexistent cluster.\n"); + err = TestReadAttributeFromNonexistentCluster_335(); break; case 336: - ChipLogProgress(chipTool, " ***** Test Step 336 : Write max value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_336(); + ChipLogProgress(chipTool, + " ***** Test Step 336 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_336(); break; case 337: ChipLogProgress(chipTool, - " ***** Test Step 337 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_337(); + " ***** Test Step 337 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_337(); break; case 338: - ChipLogProgress(chipTool, - " ***** Test Step 338 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_338(); + ChipLogProgress(chipTool, " ***** Test Step 338 : Report: Subscribe to list attribute\n"); + err = TestReportSubscribeToListAttribute_338(); break; case 339: - ChipLogProgress(chipTool, - " ***** Test Step 339 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_339(); + ChipLogProgress(chipTool, " ***** Test Step 339 : Subscribe to list attribute\n"); + err = TestSubscribeToListAttribute_339(); break; case 340: - ChipLogProgress(chipTool, - " ***** Test Step 340 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_340(); + ChipLogProgress(chipTool, " ***** Test Step 340 : Write subscribed-to list attribute\n"); + err = TestWriteSubscribedToListAttribute_340(); break; case 341: - ChipLogProgress(chipTool, - " ***** Test Step 341 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_341(); + ChipLogProgress(chipTool, " ***** Test Step 341 : Check for list attribute report\n"); + err = TestCheckForListAttributeReport_341(); break; case 342: - ChipLogProgress(chipTool, - " ***** Test Step 342 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_342(); + ChipLogProgress(chipTool, " ***** Test Step 342 : Read range-restricted unsigned 8-bit integer\n"); + err = TestReadRangeRestrictedUnsigned8BitInteger_342(); break; case 343: - ChipLogProgress(chipTool, - " ***** Test Step 343 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_343(); + ChipLogProgress(chipTool, " ***** Test Step 343 : Write min value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_343(); break; case 344: - ChipLogProgress(chipTool, " ***** Test Step 344 : Read range-restricted unsigned 16-bit integer\n"); - err = TestReadRangeRestrictedUnsigned16BitInteger_344(); + ChipLogProgress(chipTool, + " ***** Test Step 344 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_344(); break; case 345: - ChipLogProgress(chipTool, " ***** Test Step 345 : Write min value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_345(); + ChipLogProgress(chipTool, + " ***** Test Step 345 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_345(); break; case 346: - ChipLogProgress(chipTool, - " ***** Test Step 346 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_346(); + ChipLogProgress(chipTool, " ***** Test Step 346 : Write max value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_346(); break; case 347: ChipLogProgress(chipTool, - " ***** Test Step 347 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_347(); + " ***** Test Step 347 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_347(); break; case 348: - ChipLogProgress(chipTool, " ***** Test Step 348 : Write max value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_348(); + ChipLogProgress(chipTool, + " ***** Test Step 348 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_348(); break; case 349: ChipLogProgress(chipTool, - " ***** Test Step 349 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_349(); + " ***** Test Step 349 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_349(); break; case 350: ChipLogProgress(chipTool, - " ***** Test Step 350 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_350(); + " ***** Test Step 350 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_350(); break; case 351: ChipLogProgress(chipTool, - " ***** Test Step 351 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_351(); + " ***** Test Step 351 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_351(); break; case 352: ChipLogProgress(chipTool, - " ***** Test Step 352 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_352(); + " ***** Test Step 352 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_352(); break; case 353: ChipLogProgress(chipTool, - " ***** Test Step 353 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_353(); + " ***** Test Step 353 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_353(); break; case 354: - ChipLogProgress(chipTool, - " ***** Test Step 354 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_354(); + ChipLogProgress(chipTool, " ***** Test Step 354 : Read range-restricted unsigned 16-bit integer\n"); + err = TestReadRangeRestrictedUnsigned16BitInteger_354(); break; case 355: - ChipLogProgress(chipTool, - " ***** Test Step 355 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_355(); + ChipLogProgress(chipTool, " ***** Test Step 355 : Write min value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_355(); break; case 356: - ChipLogProgress(chipTool, " ***** Test Step 356 : Read range-restricted signed 8-bit integer\n"); - err = TestReadRangeRestrictedSigned8BitInteger_356(); + ChipLogProgress(chipTool, + " ***** Test Step 356 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_356(); break; case 357: - ChipLogProgress(chipTool, " ***** Test Step 357 : Write min value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_357(); + ChipLogProgress(chipTool, + " ***** Test Step 357 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_357(); break; case 358: - ChipLogProgress(chipTool, - " ***** Test Step 358 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_358(); + ChipLogProgress(chipTool, " ***** Test Step 358 : Write max value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_358(); break; case 359: ChipLogProgress(chipTool, - " ***** Test Step 359 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_359(); + " ***** Test Step 359 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_359(); break; case 360: - ChipLogProgress(chipTool, " ***** Test Step 360 : Write max value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_360(); + ChipLogProgress(chipTool, + " ***** Test Step 360 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_360(); break; case 361: ChipLogProgress(chipTool, - " ***** Test Step 361 : Verify range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_361(); + " ***** Test Step 361 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_361(); break; case 362: - ChipLogProgress(chipTool, " ***** Test Step 362 : Write min valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_362(); + ChipLogProgress(chipTool, + " ***** Test Step 362 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_362(); break; case 363: ChipLogProgress(chipTool, - " ***** Test Step 363 : Verify range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_363(); + " ***** Test Step 363 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_363(); break; case 364: - ChipLogProgress(chipTool, " ***** Test Step 364 : Write max valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_364(); + ChipLogProgress(chipTool, + " ***** Test Step 364 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_364(); break; case 365: ChipLogProgress(chipTool, - " ***** Test Step 365 : Verify range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_365(); + " ***** Test Step 365 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_365(); break; case 366: - ChipLogProgress(chipTool, - " ***** Test Step 366 : Write middle valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_366(); + ChipLogProgress(chipTool, " ***** Test Step 366 : Read range-restricted signed 8-bit integer\n"); + err = TestReadRangeRestrictedSigned8BitInteger_366(); break; case 367: - ChipLogProgress(chipTool, - " ***** Test Step 367 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_367(); + ChipLogProgress(chipTool, " ***** Test Step 367 : Write min value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_367(); break; case 368: - ChipLogProgress(chipTool, " ***** Test Step 368 : Read range-restricted signed 16-bit integer\n"); - err = TestReadRangeRestrictedSigned16BitInteger_368(); + ChipLogProgress(chipTool, + " ***** Test Step 368 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_368(); break; case 369: - ChipLogProgress(chipTool, " ***** Test Step 369 : Write min value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_369(); + ChipLogProgress(chipTool, + " ***** Test Step 369 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_369(); break; case 370: - ChipLogProgress(chipTool, - " ***** Test Step 370 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_370(); + ChipLogProgress(chipTool, " ***** Test Step 370 : Write max value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_370(); break; case 371: ChipLogProgress(chipTool, - " ***** Test Step 371 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_371(); + " ***** Test Step 371 : Verify range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_371(); break; case 372: - ChipLogProgress(chipTool, " ***** Test Step 372 : Write max value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_372(); + ChipLogProgress(chipTool, " ***** Test Step 372 : Write min valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_372(); break; case 373: ChipLogProgress(chipTool, - " ***** Test Step 373 : Verify range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_373(); + " ***** Test Step 373 : Verify range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_373(); break; case 374: - ChipLogProgress(chipTool, " ***** Test Step 374 : Write min valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_374(); + ChipLogProgress(chipTool, " ***** Test Step 374 : Write max valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_374(); break; case 375: ChipLogProgress(chipTool, - " ***** Test Step 375 : Verify range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_375(); + " ***** Test Step 375 : Verify range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_375(); break; case 376: - ChipLogProgress(chipTool, " ***** Test Step 376 : Write max valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_376(); + ChipLogProgress(chipTool, + " ***** Test Step 376 : Write middle valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_376(); break; case 377: ChipLogProgress(chipTool, - " ***** Test Step 377 : Verify range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_377(); + " ***** Test Step 377 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_377(); break; case 378: - ChipLogProgress(chipTool, - " ***** Test Step 378 : Write middle valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_378(); + ChipLogProgress(chipTool, " ***** Test Step 378 : Read range-restricted signed 16-bit integer\n"); + err = TestReadRangeRestrictedSigned16BitInteger_378(); break; case 379: - ChipLogProgress(chipTool, - " ***** Test Step 379 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_379(); + ChipLogProgress(chipTool, " ***** Test Step 379 : Write min value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_379(); break; case 380: - ChipLogProgress(chipTool, " ***** Test Step 380 : Read nullable range-restricted unsigned 8-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned8BitInteger_380(); + ChipLogProgress(chipTool, + " ***** Test Step 380 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_380(); break; case 381: ChipLogProgress(chipTool, - " ***** Test Step 381 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_381(); + " ***** Test Step 381 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_381(); break; case 382: - ChipLogProgress( - chipTool, - " ***** Test Step 382 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_382(); + ChipLogProgress(chipTool, " ***** Test Step 382 : Write max value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_382(); break; case 383: - ChipLogProgress( - chipTool, - " ***** Test Step 383 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_383(); + ChipLogProgress(chipTool, + " ***** Test Step 383 : Verify range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_383(); break; case 384: - ChipLogProgress(chipTool, - " ***** Test Step 384 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_384(); + ChipLogProgress(chipTool, " ***** Test Step 384 : Write min valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_384(); break; case 385: - ChipLogProgress( - chipTool, " ***** Test Step 385 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_385(); + ChipLogProgress(chipTool, + " ***** Test Step 385 : Verify range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_385(); break; case 386: - ChipLogProgress(chipTool, - " ***** Test Step 386 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_386(); + ChipLogProgress(chipTool, " ***** Test Step 386 : Write max valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_386(); break; case 387: - ChipLogProgress( - chipTool, " ***** Test Step 387 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_387(); + ChipLogProgress(chipTool, + " ***** Test Step 387 : Verify range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_387(); break; case 388: ChipLogProgress(chipTool, - " ***** Test Step 388 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_388(); + " ***** Test Step 388 : Write middle valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_388(); break; case 389: - ChipLogProgress( - chipTool, " ***** Test Step 389 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_389(); + ChipLogProgress(chipTool, + " ***** Test Step 389 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_389(); break; case 390: - ChipLogProgress( - chipTool, - " ***** Test Step 390 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_390(); + ChipLogProgress(chipTool, " ***** Test Step 390 : Read nullable range-restricted unsigned 8-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned8BitInteger_390(); break; case 391: - ChipLogProgress( - chipTool, " ***** Test Step 391 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_391(); + ChipLogProgress(chipTool, + " ***** Test Step 391 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_391(); break; case 392: - ChipLogProgress(chipTool, - " ***** Test Step 392 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_392(); + ChipLogProgress( + chipTool, + " ***** Test Step 392 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_392(); break; case 393: - ChipLogProgress(chipTool, - " ***** Test Step 393 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_393(); + ChipLogProgress( + chipTool, + " ***** Test Step 393 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_393(); break; case 394: - ChipLogProgress(chipTool, " ***** Test Step 394 : Read nullable range-restricted unsigned 16-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned16BitInteger_394(); + ChipLogProgress(chipTool, + " ***** Test Step 394 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_394(); break; case 395: - ChipLogProgress(chipTool, - " ***** Test Step 395 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_395(); + ChipLogProgress( + chipTool, " ***** Test Step 395 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_395(); break; case 396: - ChipLogProgress( - chipTool, - " ***** Test Step 396 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_396(); + ChipLogProgress(chipTool, + " ***** Test Step 396 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_396(); break; case 397: ChipLogProgress( - chipTool, - " ***** Test Step 397 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_397(); + chipTool, " ***** Test Step 397 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_397(); break; case 398: ChipLogProgress(chipTool, - " ***** Test Step 398 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_398(); + " ***** Test Step 398 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_398(); break; case 399: ChipLogProgress( - chipTool, - " ***** Test Step 399 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_399(); + chipTool, " ***** Test Step 399 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_399(); break; case 400: ChipLogProgress( - chipTool, " ***** Test Step 400 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_400(); + chipTool, + " ***** Test Step 400 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_400(); break; case 401: ChipLogProgress( - chipTool, - " ***** Test Step 401 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_401(); + chipTool, " ***** Test Step 401 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_401(); break; case 402: - ChipLogProgress( - chipTool, " ***** Test Step 402 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_402(); + ChipLogProgress(chipTool, + " ***** Test Step 402 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_402(); break; case 403: - ChipLogProgress( - chipTool, - " ***** Test Step 403 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_403(); + ChipLogProgress(chipTool, + " ***** Test Step 403 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_403(); break; case 404: - ChipLogProgress( - chipTool, - " ***** Test Step 404 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_404(); + ChipLogProgress(chipTool, " ***** Test Step 404 : Read nullable range-restricted unsigned 16-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned16BitInteger_404(); break; case 405: - ChipLogProgress( - chipTool, - " ***** Test Step 405 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_405(); + ChipLogProgress(chipTool, + " ***** Test Step 405 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_405(); break; case 406: - ChipLogProgress(chipTool, - " ***** Test Step 406 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_406(); + ChipLogProgress( + chipTool, + " ***** Test Step 406 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_406(); break; case 407: - ChipLogProgress(chipTool, - " ***** Test Step 407 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_407(); + ChipLogProgress( + chipTool, + " ***** Test Step 407 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_407(); break; case 408: - ChipLogProgress(chipTool, " ***** Test Step 408 : Read nullable range-restricted signed 8-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned8BitInteger_408(); + ChipLogProgress(chipTool, + " ***** Test Step 408 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_408(); break; case 409: - ChipLogProgress(chipTool, - " ***** Test Step 409 : Write min value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_409(); + ChipLogProgress( + chipTool, + " ***** Test Step 409 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_409(); break; case 410: ChipLogProgress( - chipTool, - " ***** Test Step 410 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_410(); + chipTool, " ***** Test Step 410 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_410(); break; case 411: ChipLogProgress( chipTool, - " ***** Test Step 411 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_411(); + " ***** Test Step 411 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_411(); break; case 412: - ChipLogProgress(chipTool, - " ***** Test Step 412 : Write max value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_412(); + ChipLogProgress( + chipTool, " ***** Test Step 412 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_412(); break; case 413: - ChipLogProgress(chipTool, - " ***** Test Step 413 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_413(); + ChipLogProgress( + chipTool, + " ***** Test Step 413 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_413(); break; case 414: - ChipLogProgress(chipTool, - " ***** Test Step 414 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_414(); + ChipLogProgress( + chipTool, + " ***** Test Step 414 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_414(); break; case 415: - ChipLogProgress(chipTool, - " ***** Test Step 415 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_415(); + ChipLogProgress( + chipTool, + " ***** Test Step 415 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_415(); break; case 416: ChipLogProgress(chipTool, - " ***** Test Step 416 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_416(); + " ***** Test Step 416 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_416(); break; case 417: ChipLogProgress(chipTool, - " ***** Test Step 417 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_417(); + " ***** Test Step 417 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_417(); break; case 418: - ChipLogProgress( - chipTool, " ***** Test Step 418 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_418(); + ChipLogProgress(chipTool, " ***** Test Step 418 : Read nullable range-restricted signed 8-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned8BitInteger_418(); break; case 419: ChipLogProgress(chipTool, - " ***** Test Step 419 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_419(); + " ***** Test Step 419 : Write min value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_419(); break; case 420: - ChipLogProgress(chipTool, - " ***** Test Step 420 : Write null value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_420(); + ChipLogProgress( + chipTool, + " ***** Test Step 420 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_420(); break; case 421: - ChipLogProgress(chipTool, - " ***** Test Step 421 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_421(); + ChipLogProgress( + chipTool, + " ***** Test Step 421 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_421(); break; case 422: - ChipLogProgress(chipTool, " ***** Test Step 422 : Read nullable range-restricted signed 16-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned16BitInteger_422(); + ChipLogProgress(chipTool, + " ***** Test Step 422 : Write max value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_422(); break; case 423: ChipLogProgress(chipTool, - " ***** Test Step 423 : Write min value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_423(); + " ***** Test Step 423 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_423(); break; case 424: - ChipLogProgress( - chipTool, - " ***** Test Step 424 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_424(); + ChipLogProgress(chipTool, + " ***** Test Step 424 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_424(); break; case 425: - ChipLogProgress( - chipTool, - " ***** Test Step 425 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_425(); + ChipLogProgress(chipTool, + " ***** Test Step 425 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_425(); break; case 426: ChipLogProgress(chipTool, - " ***** Test Step 426 : Write max value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_426(); + " ***** Test Step 426 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_426(); break; case 427: - ChipLogProgress( - chipTool, " ***** Test Step 427 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_427(); + ChipLogProgress(chipTool, + " ***** Test Step 427 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_427(); break; case 428: - ChipLogProgress(chipTool, - " ***** Test Step 428 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_428(); + ChipLogProgress( + chipTool, " ***** Test Step 428 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_428(); break; case 429: - ChipLogProgress( - chipTool, " ***** Test Step 429 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_429(); + ChipLogProgress(chipTool, + " ***** Test Step 429 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_429(); break; case 430: ChipLogProgress(chipTool, - " ***** Test Step 430 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_430(); + " ***** Test Step 430 : Write null value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_430(); break; case 431: - ChipLogProgress( - chipTool, " ***** Test Step 431 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_431(); + ChipLogProgress(chipTool, + " ***** Test Step 431 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_431(); break; case 432: - ChipLogProgress( - chipTool, " ***** Test Step 432 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_432(); + ChipLogProgress(chipTool, " ***** Test Step 432 : Read nullable range-restricted signed 16-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned16BitInteger_432(); break; case 433: - ChipLogProgress( - chipTool, " ***** Test Step 433 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_433(); + ChipLogProgress(chipTool, + " ***** Test Step 433 : Write min value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_433(); break; case 434: - ChipLogProgress(chipTool, - " ***** Test Step 434 : Write null value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_434(); + ChipLogProgress( + chipTool, + " ***** Test Step 434 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_434(); break; case 435: + ChipLogProgress( + chipTool, + " ***** Test Step 435 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_435(); + break; + case 436: ChipLogProgress(chipTool, - " ***** Test Step 435 : Verify nullable range-restricted signed 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_435(); + " ***** Test Step 436 : Write max value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_436(); + break; + case 437: + ChipLogProgress( + chipTool, " ***** Test Step 437 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_437(); + break; + case 438: + ChipLogProgress(chipTool, + " ***** Test Step 438 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_438(); + break; + case 439: + ChipLogProgress( + chipTool, " ***** Test Step 439 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_439(); + break; + case 440: + ChipLogProgress(chipTool, + " ***** Test Step 440 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_440(); + break; + case 441: + ChipLogProgress( + chipTool, " ***** Test Step 441 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_441(); + break; + case 442: + ChipLogProgress( + chipTool, " ***** Test Step 442 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_442(); + break; + case 443: + ChipLogProgress( + chipTool, " ***** Test Step 443 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_443(); + break; + case 444: + ChipLogProgress(chipTool, + " ***** Test Step 444 : Write null value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_444(); + break; + case 445: + ChipLogProgress(chipTool, + " ***** Test Step 445 : Verify nullable range-restricted signed 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_445(); break; } @@ -36330,7 +36370,7 @@ class TestCluster : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 436; + const uint16_t mTestCount = 446; typedef void (*Test_TestCluster_list_int8u_ReportCallback)(void * context, const chip::app::DataModel::DecodableList & value); @@ -38199,16 +38239,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_239(status); } - static void OnSuccessCallback_239(void * context) { (static_cast(context))->OnSuccessResponse_239(); } + static void OnSuccessCallback_239(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_239(nullableInt64u); + } static void OnFailureCallback_240(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_240(status); } - static void OnSuccessCallback_240(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_240(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_240(nullableInt8s); + (static_cast(context))->OnSuccessResponse_240(nullableInt64u); } static void OnFailureCallback_241(void * context, EmberAfStatus status) @@ -38223,9 +38266,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_242(status); } - static void OnSuccessCallback_242(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_242(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_242(nullableInt8s); + (static_cast(context))->OnSuccessResponse_242(nullableInt64u); } static void OnFailureCallback_243(void * context, EmberAfStatus status) @@ -38233,17 +38276,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_243(status); } - static void OnSuccessCallback_243(void * context) { (static_cast(context))->OnSuccessResponse_243(); } + static void OnSuccessCallback_243(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_243(nullableInt64u); + } static void OnFailureCallback_244(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_244(status); } - static void OnSuccessCallback_244(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_244(nullableInt8s); - } + static void OnSuccessCallback_244(void * context) { (static_cast(context))->OnSuccessResponse_244(); } static void OnFailureCallback_245(void * context, EmberAfStatus status) { @@ -38260,27 +38303,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_246(status); } - static void OnSuccessCallback_246(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_246(nullableInt8s); - } + static void OnSuccessCallback_246(void * context) { (static_cast(context))->OnSuccessResponse_246(); } static void OnFailureCallback_247(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_247(status); } - static void OnSuccessCallback_247(void * context) { (static_cast(context))->OnSuccessResponse_247(); } + static void OnSuccessCallback_247(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_247(nullableInt8s); + } static void OnFailureCallback_248(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_248(status); } - static void OnSuccessCallback_248(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_248(nullableInt8s); - } + static void OnSuccessCallback_248(void * context) { (static_cast(context))->OnSuccessResponse_248(); } static void OnFailureCallback_249(void * context, EmberAfStatus status) { @@ -38297,16 +38337,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_250(status); } - static void OnSuccessCallback_250(void * context) { (static_cast(context))->OnSuccessResponse_250(); } + static void OnSuccessCallback_250(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_250(nullableInt8s); + } static void OnFailureCallback_251(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_251(status); } - static void OnSuccessCallback_251(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_251(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_251(nullableInt16s); + (static_cast(context))->OnSuccessResponse_251(nullableInt8s); } static void OnFailureCallback_252(void * context, EmberAfStatus status) @@ -38321,9 +38364,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_253(status); } - static void OnSuccessCallback_253(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_253(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_253(nullableInt16s); + (static_cast(context))->OnSuccessResponse_253(nullableInt8s); } static void OnFailureCallback_254(void * context, EmberAfStatus status) @@ -38331,17 +38374,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_254(status); } - static void OnSuccessCallback_254(void * context) { (static_cast(context))->OnSuccessResponse_254(); } + static void OnSuccessCallback_254(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_254(nullableInt8s); + } static void OnFailureCallback_255(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_255(status); } - static void OnSuccessCallback_255(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_255(nullableInt16s); - } + static void OnSuccessCallback_255(void * context) { (static_cast(context))->OnSuccessResponse_255(); } static void OnFailureCallback_256(void * context, EmberAfStatus status) { @@ -38358,27 +38401,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_257(status); } - static void OnSuccessCallback_257(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_257(nullableInt16s); - } + static void OnSuccessCallback_257(void * context) { (static_cast(context))->OnSuccessResponse_257(); } static void OnFailureCallback_258(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_258(status); } - static void OnSuccessCallback_258(void * context) { (static_cast(context))->OnSuccessResponse_258(); } + static void OnSuccessCallback_258(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_258(nullableInt16s); + } static void OnFailureCallback_259(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_259(status); } - static void OnSuccessCallback_259(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_259(nullableInt16s); - } + static void OnSuccessCallback_259(void * context) { (static_cast(context))->OnSuccessResponse_259(); } static void OnFailureCallback_260(void * context, EmberAfStatus status) { @@ -38395,16 +38435,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_261(status); } - static void OnSuccessCallback_261(void * context) { (static_cast(context))->OnSuccessResponse_261(); } + static void OnSuccessCallback_261(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_261(nullableInt16s); + } static void OnFailureCallback_262(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_262(status); } - static void OnSuccessCallback_262(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_262(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_262(nullableInt32s); + (static_cast(context))->OnSuccessResponse_262(nullableInt16s); } static void OnFailureCallback_263(void * context, EmberAfStatus status) @@ -38419,9 +38462,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_264(status); } - static void OnSuccessCallback_264(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_264(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_264(nullableInt32s); + (static_cast(context))->OnSuccessResponse_264(nullableInt16s); } static void OnFailureCallback_265(void * context, EmberAfStatus status) @@ -38429,17 +38472,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_265(status); } - static void OnSuccessCallback_265(void * context) { (static_cast(context))->OnSuccessResponse_265(); } + static void OnSuccessCallback_265(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_265(nullableInt16s); + } static void OnFailureCallback_266(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_266(status); } - static void OnSuccessCallback_266(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_266(nullableInt32s); - } + static void OnSuccessCallback_266(void * context) { (static_cast(context))->OnSuccessResponse_266(); } static void OnFailureCallback_267(void * context, EmberAfStatus status) { @@ -38456,27 +38499,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_268(status); } - static void OnSuccessCallback_268(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_268(nullableInt32s); - } + static void OnSuccessCallback_268(void * context) { (static_cast(context))->OnSuccessResponse_268(); } static void OnFailureCallback_269(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_269(status); } - static void OnSuccessCallback_269(void * context) { (static_cast(context))->OnSuccessResponse_269(); } + static void OnSuccessCallback_269(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_269(nullableInt32s); + } static void OnFailureCallback_270(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_270(status); } - static void OnSuccessCallback_270(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_270(nullableInt32s); - } + static void OnSuccessCallback_270(void * context) { (static_cast(context))->OnSuccessResponse_270(); } static void OnFailureCallback_271(void * context, EmberAfStatus status) { @@ -38493,16 +38533,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_272(status); } - static void OnSuccessCallback_272(void * context) { (static_cast(context))->OnSuccessResponse_272(); } + static void OnSuccessCallback_272(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_272(nullableInt32s); + } static void OnFailureCallback_273(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_273(status); } - static void OnSuccessCallback_273(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_273(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_273(nullableInt64s); + (static_cast(context))->OnSuccessResponse_273(nullableInt32s); } static void OnFailureCallback_274(void * context, EmberAfStatus status) @@ -38517,9 +38560,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_275(status); } - static void OnSuccessCallback_275(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_275(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_275(nullableInt64s); + (static_cast(context))->OnSuccessResponse_275(nullableInt32s); } static void OnFailureCallback_276(void * context, EmberAfStatus status) @@ -38527,67 +38570,70 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_276(status); } - static void OnSuccessCallback_276(void * context) { (static_cast(context))->OnSuccessResponse_276(); } + static void OnSuccessCallback_276(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_276(nullableInt32s); + } static void OnFailureCallback_277(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_277(status); } - static void OnSuccessCallback_277(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_277(nullableInt64s); - } + static void OnSuccessCallback_277(void * context) { (static_cast(context))->OnSuccessResponse_277(); } static void OnFailureCallback_278(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_278(status); } - static void OnSuccessCallback_278(void * context) { (static_cast(context))->OnSuccessResponse_278(); } + static void OnSuccessCallback_278(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_278(nullableInt64s); + } static void OnFailureCallback_279(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_279(status); } - static void OnSuccessCallback_279(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) - { - (static_cast(context))->OnSuccessResponse_279(nullableFloatSingle); - } + static void OnSuccessCallback_279(void * context) { (static_cast(context))->OnSuccessResponse_279(); } static void OnFailureCallback_280(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_280(status); } - static void OnSuccessCallback_280(void * context) { (static_cast(context))->OnSuccessResponse_280(); } + static void OnSuccessCallback_280(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_280(nullableInt64s); + } static void OnFailureCallback_281(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_281(status); } - static void OnSuccessCallback_281(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) - { - (static_cast(context))->OnSuccessResponse_281(nullableFloatSingle); - } + static void OnSuccessCallback_281(void * context) { (static_cast(context))->OnSuccessResponse_281(); } static void OnFailureCallback_282(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_282(status); } - static void OnSuccessCallback_282(void * context) { (static_cast(context))->OnSuccessResponse_282(); } + static void OnSuccessCallback_282(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_282(nullableInt64s); + } static void OnFailureCallback_283(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_283(status); } - static void OnSuccessCallback_283(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_283(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_283(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_283(nullableInt64s); } static void OnFailureCallback_284(void * context, EmberAfStatus status) @@ -38595,33 +38641,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_284(status); } - static void OnSuccessCallback_284(void * context) { (static_cast(context))->OnSuccessResponse_284(); } + static void OnSuccessCallback_284(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_284(nullableInt64s); + } static void OnFailureCallback_285(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_285(status); } - static void OnSuccessCallback_285(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) - { - (static_cast(context))->OnSuccessResponse_285(nullableFloatSingle); - } + static void OnSuccessCallback_285(void * context) { (static_cast(context))->OnSuccessResponse_285(); } static void OnFailureCallback_286(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_286(status); } - static void OnSuccessCallback_286(void * context) { (static_cast(context))->OnSuccessResponse_286(); } + static void OnSuccessCallback_286(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_286(nullableInt64s); + } static void OnFailureCallback_287(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_287(status); } - static void OnSuccessCallback_287(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_287(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_287(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_287(nullableInt64s); } static void OnFailureCallback_288(void * context, EmberAfStatus status) @@ -38636,9 +38685,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_289(status); } - static void OnSuccessCallback_289(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_289(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_289(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_289(nullableFloatSingle); } static void OnFailureCallback_290(void * context, EmberAfStatus status) @@ -38653,9 +38702,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_291(status); } - static void OnSuccessCallback_291(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_291(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_291(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_291(nullableFloatSingle); } static void OnFailureCallback_292(void * context, EmberAfStatus status) @@ -38670,9 +38719,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_293(status); } - static void OnSuccessCallback_293(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_293(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_293(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_293(nullableFloatSingle); } static void OnFailureCallback_294(void * context, EmberAfStatus status) @@ -38687,9 +38736,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_295(status); } - static void OnSuccessCallback_295(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_295(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_295(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_295(nullableFloatSingle); } static void OnFailureCallback_296(void * context, EmberAfStatus status) @@ -38704,9 +38753,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_297(status); } - static void OnSuccessCallback_297(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_297(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_297(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_297(nullableFloatSingle); } static void OnFailureCallback_298(void * context, EmberAfStatus status) @@ -38721,9 +38770,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_299(status); } - static void OnSuccessCallback_299(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_299(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_299(nullableEnum8); + (static_cast(context))->OnSuccessResponse_299(nullableFloatDouble); } static void OnFailureCallback_300(void * context, EmberAfStatus status) @@ -38738,9 +38787,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_301(status); } - static void OnSuccessCallback_301(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_301(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_301(nullableEnum8); + (static_cast(context))->OnSuccessResponse_301(nullableFloatDouble); } static void OnFailureCallback_302(void * context, EmberAfStatus status) @@ -38755,9 +38804,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_303(status); } - static void OnSuccessCallback_303(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_303(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_303(nullableEnum8); + (static_cast(context))->OnSuccessResponse_303(nullableFloatDouble); } static void OnFailureCallback_304(void * context, EmberAfStatus status) @@ -38772,9 +38821,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_305(status); } - static void OnSuccessCallback_305(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_305(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_305(nullableEnum16); + (static_cast(context))->OnSuccessResponse_305(nullableFloatDouble); } static void OnFailureCallback_306(void * context, EmberAfStatus status) @@ -38789,9 +38838,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_307(status); } - static void OnSuccessCallback_307(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_307(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_307(nullableEnum16); + (static_cast(context))->OnSuccessResponse_307(nullableFloatDouble); } static void OnFailureCallback_308(void * context, EmberAfStatus status) @@ -38806,9 +38855,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_309(status); } - static void OnSuccessCallback_309(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_309(void * context, const chip::app::DataModel::Nullable & nullableEnum8) { - (static_cast(context))->OnSuccessResponse_309(nullableEnum16); + (static_cast(context))->OnSuccessResponse_309(nullableEnum8); } static void OnFailureCallback_310(void * context, EmberAfStatus status) @@ -38816,70 +38865,67 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_310(status); } - static void OnSuccessCallback_310(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_310(nullableOctetString); - } + static void OnSuccessCallback_310(void * context) { (static_cast(context))->OnSuccessResponse_310(); } static void OnFailureCallback_311(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_311(status); } - static void OnSuccessCallback_311(void * context) { (static_cast(context))->OnSuccessResponse_311(); } + static void OnSuccessCallback_311(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_311(nullableEnum8); + } static void OnFailureCallback_312(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_312(status); } - static void OnSuccessCallback_312(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_312(nullableOctetString); - } + static void OnSuccessCallback_312(void * context) { (static_cast(context))->OnSuccessResponse_312(); } static void OnFailureCallback_313(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_313(status); } - static void OnSuccessCallback_313(void * context) { (static_cast(context))->OnSuccessResponse_313(); } + static void OnSuccessCallback_313(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_313(nullableEnum8); + } static void OnFailureCallback_314(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_314(status); } - static void OnSuccessCallback_314(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_314(nullableOctetString); - } + static void OnSuccessCallback_314(void * context) { (static_cast(context))->OnSuccessResponse_314(); } static void OnFailureCallback_315(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_315(status); } - static void OnSuccessCallback_315(void * context) { (static_cast(context))->OnSuccessResponse_315(); } + static void OnSuccessCallback_315(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_315(nullableEnum16); + } static void OnFailureCallback_316(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_316(status); } - static void OnSuccessCallback_316(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_316(nullableOctetString); - } + static void OnSuccessCallback_316(void * context) { (static_cast(context))->OnSuccessResponse_316(); } static void OnFailureCallback_317(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_317(status); } - static void OnSuccessCallback_317(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_317(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_317(nullableCharString); + (static_cast(context))->OnSuccessResponse_317(nullableEnum16); } static void OnFailureCallback_318(void * context, EmberAfStatus status) @@ -38894,9 +38940,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_319(status); } - static void OnSuccessCallback_319(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_319(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_319(nullableCharString); + (static_cast(context))->OnSuccessResponse_319(nullableEnum16); } static void OnFailureCallback_320(void * context, EmberAfStatus status) @@ -38904,43 +38950,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_320(status); } - static void OnSuccessCallback_320(void * context) { (static_cast(context))->OnSuccessResponse_320(); } + static void OnSuccessCallback_320(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_320(nullableOctetString); + } static void OnFailureCallback_321(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_321(status); } - static void OnSuccessCallback_321(void * context, const chip::app::DataModel::Nullable & nullableCharString) - { - (static_cast(context))->OnSuccessResponse_321(nullableCharString); - } + static void OnSuccessCallback_321(void * context) { (static_cast(context))->OnSuccessResponse_321(); } static void OnFailureCallback_322(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_322(status); } - static void OnSuccessCallback_322(void * context) { (static_cast(context))->OnSuccessResponse_322(); } + static void OnSuccessCallback_322(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_322(nullableOctetString); + } static void OnFailureCallback_323(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_323(status); } - static void OnSuccessCallback_323(void * context, const chip::app::DataModel::Nullable & nullableCharString) - { - (static_cast(context))->OnSuccessResponse_323(nullableCharString); - } + static void OnSuccessCallback_323(void * context) { (static_cast(context))->OnSuccessResponse_323(); } static void OnFailureCallback_324(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_324(status); } - static void OnSuccessCallback_324(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_324(void * context, const chip::app::DataModel::Nullable & nullableOctetString) { - (static_cast(context))->OnSuccessResponse_324(listInt8u); + (static_cast(context))->OnSuccessResponse_324(nullableOctetString); } static void OnFailureCallback_325(void * context, EmberAfStatus status) @@ -38948,36 +38994,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_325(status); } - static void OnSuccessCallback_325(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_325(void * context) { (static_cast(context))->OnSuccessResponse_325(); } + + static void OnFailureCallback_326(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_325(listInt8u); + (static_cast(context))->OnFailureResponse_326(status); } - static void OnFailureCallback_328(void * context, EmberAfStatus status) + static void OnSuccessCallback_326(void * context, const chip::app::DataModel::Nullable & nullableOctetString) { - (static_cast(context))->OnFailureResponse_328(status); + (static_cast(context))->OnSuccessResponse_326(nullableOctetString); } - static void OnSuccessCallback_328(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnFailureCallback_327(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_328(listInt8u); + (static_cast(context))->OnFailureResponse_327(status); } - bool mReceivedReport_328 = false; + static void OnSuccessCallback_327(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_327(nullableCharString); + } - static void OnFailureCallback_329(void * context, EmberAfStatus status) + static void OnFailureCallback_328(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_329(status); + (static_cast(context))->OnFailureResponse_328(status); } - static void OnSuccessCallback_329(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_328(void * context) { (static_cast(context))->OnSuccessResponse_328(); } + + static void OnFailureCallback_329(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_329(listInt8u); + (static_cast(context))->OnFailureResponse_329(status); } - static void OnSubscriptionEstablished_329(void * context) + static void OnSuccessCallback_329(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSubscriptionEstablishedResponse_329(); + (static_cast(context))->OnSuccessResponse_329(nullableCharString); } static void OnFailureCallback_330(void * context, EmberAfStatus status) @@ -38992,81 +39045,78 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_331(status); } - static void OnSuccessCallback_331(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_331(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_331(listInt8u); + (static_cast(context))->OnSuccessResponse_331(nullableCharString); } - bool mReceivedReport_331 = false; - static void OnFailureCallback_332(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_332(status); } - static void OnSuccessCallback_332(void * context, uint8_t rangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_332(rangeRestrictedInt8u); - } + static void OnSuccessCallback_332(void * context) { (static_cast(context))->OnSuccessResponse_332(); } static void OnFailureCallback_333(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_333(status); } - static void OnSuccessCallback_333(void * context) { (static_cast(context))->OnSuccessResponse_333(); } + static void OnSuccessCallback_333(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_333(nullableCharString); + } static void OnFailureCallback_334(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_334(status); } - static void OnSuccessCallback_334(void * context) { (static_cast(context))->OnSuccessResponse_334(); } - - static void OnFailureCallback_335(void * context, EmberAfStatus status) + static void OnSuccessCallback_334(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnFailureResponse_335(status); + (static_cast(context))->OnSuccessResponse_334(listInt8u); } - static void OnSuccessCallback_335(void * context) { (static_cast(context))->OnSuccessResponse_335(); } - - static void OnFailureCallback_336(void * context, EmberAfStatus status) + static void OnFailureCallback_335(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_336(status); + (static_cast(context))->OnFailureResponse_335(status); } - static void OnSuccessCallback_336(void * context) { (static_cast(context))->OnSuccessResponse_336(); } - - static void OnFailureCallback_337(void * context, EmberAfStatus status) + static void OnSuccessCallback_335(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnFailureResponse_337(status); + (static_cast(context))->OnSuccessResponse_335(listInt8u); } - static void OnSuccessCallback_337(void * context, uint8_t rangeRestrictedInt8u) + static void OnFailureCallback_338(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_337(rangeRestrictedInt8u); + (static_cast(context))->OnFailureResponse_338(status); } - static void OnFailureCallback_338(void * context, EmberAfStatus status) + static void OnSuccessCallback_338(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnFailureResponse_338(status); + (static_cast(context))->OnSuccessResponse_338(listInt8u); } - static void OnSuccessCallback_338(void * context) { (static_cast(context))->OnSuccessResponse_338(); } + bool mReceivedReport_338 = false; static void OnFailureCallback_339(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_339(status); } - static void OnSuccessCallback_339(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_339(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_339(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_339(listInt8u); } - static void OnFailureCallback_340(void * context, EmberAfStatus status) + static void OnSubscriptionEstablished_339(void * context) { - (static_cast(context))->OnFailureResponse_340(status); + (static_cast(context))->OnSubscriptionEstablishedResponse_339(); + } + + static void OnFailureCallback_340(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_340(status); } static void OnSuccessCallback_340(void * context) { (static_cast(context))->OnSuccessResponse_340(); } @@ -39076,37 +39126,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_341(status); } - static void OnSuccessCallback_341(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_341(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_341(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_341(listInt8u); } + bool mReceivedReport_341 = false; + static void OnFailureCallback_342(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_342(status); } - static void OnSuccessCallback_342(void * context) { (static_cast(context))->OnSuccessResponse_342(); } + static void OnSuccessCallback_342(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_342(rangeRestrictedInt8u); + } static void OnFailureCallback_343(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_343(status); } - static void OnSuccessCallback_343(void * context, uint8_t rangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_343(rangeRestrictedInt8u); - } + static void OnSuccessCallback_343(void * context) { (static_cast(context))->OnSuccessResponse_343(); } static void OnFailureCallback_344(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_344(status); } - static void OnSuccessCallback_344(void * context, uint16_t rangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_344(rangeRestrictedInt16u); - } + static void OnSuccessCallback_344(void * context) { (static_cast(context))->OnSuccessResponse_344(); } static void OnFailureCallback_345(void * context, EmberAfStatus status) { @@ -39127,7 +39176,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_347(status); } - static void OnSuccessCallback_347(void * context) { (static_cast(context))->OnSuccessResponse_347(); } + static void OnSuccessCallback_347(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_347(rangeRestrictedInt8u); + } static void OnFailureCallback_348(void * context, EmberAfStatus status) { @@ -39141,9 +39193,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_349(status); } - static void OnSuccessCallback_349(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_349(void * context, uint8_t rangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_349(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_349(rangeRestrictedInt8u); } static void OnFailureCallback_350(void * context, EmberAfStatus status) @@ -39158,9 +39210,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_351(status); } - static void OnSuccessCallback_351(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_351(void * context, uint8_t rangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_351(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_351(rangeRestrictedInt8u); } static void OnFailureCallback_352(void * context, EmberAfStatus status) @@ -39175,9 +39227,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_353(status); } - static void OnSuccessCallback_353(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_353(void * context, uint8_t rangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_353(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_353(rangeRestrictedInt8u); } static void OnFailureCallback_354(void * context, EmberAfStatus status) @@ -39185,27 +39237,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_354(status); } - static void OnSuccessCallback_354(void * context) { (static_cast(context))->OnSuccessResponse_354(); } + static void OnSuccessCallback_354(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_354(rangeRestrictedInt16u); + } static void OnFailureCallback_355(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_355(status); } - static void OnSuccessCallback_355(void * context, uint16_t rangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_355(rangeRestrictedInt16u); - } + static void OnSuccessCallback_355(void * context) { (static_cast(context))->OnSuccessResponse_355(); } static void OnFailureCallback_356(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_356(status); } - static void OnSuccessCallback_356(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_356(rangeRestrictedInt8s); - } + static void OnSuccessCallback_356(void * context) { (static_cast(context))->OnSuccessResponse_356(); } static void OnFailureCallback_357(void * context, EmberAfStatus status) { @@ -39226,7 +39275,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_359(status); } - static void OnSuccessCallback_359(void * context) { (static_cast(context))->OnSuccessResponse_359(); } + static void OnSuccessCallback_359(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_359(rangeRestrictedInt16u); + } static void OnFailureCallback_360(void * context, EmberAfStatus status) { @@ -39240,9 +39292,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_361(status); } - static void OnSuccessCallback_361(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_361(void * context, uint16_t rangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_361(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_361(rangeRestrictedInt16u); } static void OnFailureCallback_362(void * context, EmberAfStatus status) @@ -39257,9 +39309,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_363(status); } - static void OnSuccessCallback_363(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_363(void * context, uint16_t rangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_363(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_363(rangeRestrictedInt16u); } static void OnFailureCallback_364(void * context, EmberAfStatus status) @@ -39274,9 +39326,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_365(status); } - static void OnSuccessCallback_365(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_365(void * context, uint16_t rangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_365(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_365(rangeRestrictedInt16u); } static void OnFailureCallback_366(void * context, EmberAfStatus status) @@ -39284,27 +39336,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_366(status); } - static void OnSuccessCallback_366(void * context) { (static_cast(context))->OnSuccessResponse_366(); } + static void OnSuccessCallback_366(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_366(rangeRestrictedInt8s); + } static void OnFailureCallback_367(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_367(status); } - static void OnSuccessCallback_367(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_367(rangeRestrictedInt8s); - } + static void OnSuccessCallback_367(void * context) { (static_cast(context))->OnSuccessResponse_367(); } static void OnFailureCallback_368(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_368(status); } - static void OnSuccessCallback_368(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_368(rangeRestrictedInt16s); - } + static void OnSuccessCallback_368(void * context) { (static_cast(context))->OnSuccessResponse_368(); } static void OnFailureCallback_369(void * context, EmberAfStatus status) { @@ -39325,7 +39374,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_371(status); } - static void OnSuccessCallback_371(void * context) { (static_cast(context))->OnSuccessResponse_371(); } + static void OnSuccessCallback_371(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_371(rangeRestrictedInt8s); + } static void OnFailureCallback_372(void * context, EmberAfStatus status) { @@ -39339,9 +39391,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_373(status); } - static void OnSuccessCallback_373(void * context, int16_t rangeRestrictedInt16s) + static void OnSuccessCallback_373(void * context, int8_t rangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_373(rangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_373(rangeRestrictedInt8s); } static void OnFailureCallback_374(void * context, EmberAfStatus status) @@ -39356,9 +39408,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_375(status); } - static void OnSuccessCallback_375(void * context, int16_t rangeRestrictedInt16s) + static void OnSuccessCallback_375(void * context, int8_t rangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_375(rangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_375(rangeRestrictedInt8s); } static void OnFailureCallback_376(void * context, EmberAfStatus status) @@ -39373,9 +39425,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_377(status); } - static void OnSuccessCallback_377(void * context, int16_t rangeRestrictedInt16s) + static void OnSuccessCallback_377(void * context, int8_t rangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_377(rangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_377(rangeRestrictedInt8s); } static void OnFailureCallback_378(void * context, EmberAfStatus status) @@ -39383,27 +39435,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_378(status); } - static void OnSuccessCallback_378(void * context) { (static_cast(context))->OnSuccessResponse_378(); } + static void OnSuccessCallback_378(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_378(rangeRestrictedInt16s); + } static void OnFailureCallback_379(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_379(status); } - static void OnSuccessCallback_379(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_379(rangeRestrictedInt16s); - } + static void OnSuccessCallback_379(void * context) { (static_cast(context))->OnSuccessResponse_379(); } static void OnFailureCallback_380(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_380(status); } - static void OnSuccessCallback_380(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_380(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_380(void * context) { (static_cast(context))->OnSuccessResponse_380(); } static void OnFailureCallback_381(void * context, EmberAfStatus status) { @@ -39424,7 +39473,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_383(status); } - static void OnSuccessCallback_383(void * context) { (static_cast(context))->OnSuccessResponse_383(); } + static void OnSuccessCallback_383(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_383(rangeRestrictedInt16s); + } static void OnFailureCallback_384(void * context, EmberAfStatus status) { @@ -39438,9 +39490,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_385(status); } - static void OnSuccessCallback_385(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_385(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_385(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_385(rangeRestrictedInt16s); } static void OnFailureCallback_386(void * context, EmberAfStatus status) @@ -39455,9 +39507,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_387(status); } - static void OnSuccessCallback_387(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_387(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_387(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_387(rangeRestrictedInt16s); } static void OnFailureCallback_388(void * context, EmberAfStatus status) @@ -39472,9 +39524,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_389(status); } - static void OnSuccessCallback_389(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_389(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_389(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_389(rangeRestrictedInt16s); } static void OnFailureCallback_390(void * context, EmberAfStatus status) @@ -39482,17 +39534,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_390(status); } - static void OnSuccessCallback_390(void * context) { (static_cast(context))->OnSuccessResponse_390(); } + static void OnSuccessCallback_390(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_390(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_391(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_391(status); } - static void OnSuccessCallback_391(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_391(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_391(void * context) { (static_cast(context))->OnSuccessResponse_391(); } static void OnFailureCallback_392(void * context, EmberAfStatus status) { @@ -39506,28 +39558,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_393(status); } - static void OnSuccessCallback_393(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_393(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_393(void * context) { (static_cast(context))->OnSuccessResponse_393(); } static void OnFailureCallback_394(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_394(status); } - static void OnSuccessCallback_394(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_394(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_394(void * context) { (static_cast(context))->OnSuccessResponse_394(); } static void OnFailureCallback_395(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_395(status); } - static void OnSuccessCallback_395(void * context) { (static_cast(context))->OnSuccessResponse_395(); } + static void OnSuccessCallback_395(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_395(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_396(void * context, EmberAfStatus status) { @@ -39541,7 +39589,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_397(status); } - static void OnSuccessCallback_397(void * context) { (static_cast(context))->OnSuccessResponse_397(); } + static void OnSuccessCallback_397(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_397(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_398(void * context, EmberAfStatus status) { @@ -39555,10 +39606,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_399(status); } - static void OnSuccessCallback_399(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_399(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_399(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_399(nullableRangeRestrictedInt8u); } static void OnFailureCallback_400(void * context, EmberAfStatus status) @@ -39573,10 +39623,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_401(status); } - static void OnSuccessCallback_401(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_401(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_401(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_401(nullableRangeRestrictedInt8u); } static void OnFailureCallback_402(void * context, EmberAfStatus status) @@ -39591,10 +39640,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_403(status); } - static void OnSuccessCallback_403(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_403(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_403(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_403(nullableRangeRestrictedInt8u); } static void OnFailureCallback_404(void * context, EmberAfStatus status) @@ -39602,18 +39650,18 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_404(status); } - static void OnSuccessCallback_404(void * context) { (static_cast(context))->OnSuccessResponse_404(); } + static void OnSuccessCallback_404(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_404(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_405(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_405(status); } - static void OnSuccessCallback_405(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_405(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_405(void * context) { (static_cast(context))->OnSuccessResponse_405(); } static void OnFailureCallback_406(void * context, EmberAfStatus status) { @@ -39627,28 +39675,25 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_407(status); } - static void OnSuccessCallback_407(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_407(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_407(void * context) { (static_cast(context))->OnSuccessResponse_407(); } static void OnFailureCallback_408(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_408(status); } - static void OnSuccessCallback_408(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_408(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_408(void * context) { (static_cast(context))->OnSuccessResponse_408(); } static void OnFailureCallback_409(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_409(status); } - static void OnSuccessCallback_409(void * context) { (static_cast(context))->OnSuccessResponse_409(); } + static void OnSuccessCallback_409(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_409(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_410(void * context, EmberAfStatus status) { @@ -39662,7 +39707,11 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_411(status); } - static void OnSuccessCallback_411(void * context) { (static_cast(context))->OnSuccessResponse_411(); } + static void OnSuccessCallback_411(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_411(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_412(void * context, EmberAfStatus status) { @@ -39676,9 +39725,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_413(status); } - static void OnSuccessCallback_413(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_413(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_413(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_413(nullableRangeRestrictedInt16u); } static void OnFailureCallback_414(void * context, EmberAfStatus status) @@ -39693,9 +39743,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_415(status); } - static void OnSuccessCallback_415(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_415(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_415(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_415(nullableRangeRestrictedInt16u); } static void OnFailureCallback_416(void * context, EmberAfStatus status) @@ -39710,9 +39761,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_417(status); } - static void OnSuccessCallback_417(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_417(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_417(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_417(nullableRangeRestrictedInt16u); } static void OnFailureCallback_418(void * context, EmberAfStatus status) @@ -39720,17 +39772,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_418(status); } - static void OnSuccessCallback_418(void * context) { (static_cast(context))->OnSuccessResponse_418(); } + static void OnSuccessCallback_418(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_418(nullableRangeRestrictedInt8s); + } static void OnFailureCallback_419(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_419(status); } - static void OnSuccessCallback_419(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_419(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_419(void * context) { (static_cast(context))->OnSuccessResponse_419(); } static void OnFailureCallback_420(void * context, EmberAfStatus status) { @@ -39744,27 +39796,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_421(status); } - static void OnSuccessCallback_421(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_421(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_421(void * context) { (static_cast(context))->OnSuccessResponse_421(); } static void OnFailureCallback_422(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_422(status); } - static void OnSuccessCallback_422(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_422(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_422(void * context) { (static_cast(context))->OnSuccessResponse_422(); } static void OnFailureCallback_423(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_423(status); } - static void OnSuccessCallback_423(void * context) { (static_cast(context))->OnSuccessResponse_423(); } + static void OnSuccessCallback_423(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_423(nullableRangeRestrictedInt8s); + } static void OnFailureCallback_424(void * context, EmberAfStatus status) { @@ -39778,7 +39827,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_425(status); } - static void OnSuccessCallback_425(void * context) { (static_cast(context))->OnSuccessResponse_425(); } + static void OnSuccessCallback_425(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_425(nullableRangeRestrictedInt8s); + } static void OnFailureCallback_426(void * context, EmberAfStatus status) { @@ -39792,9 +39844,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_427(status); } - static void OnSuccessCallback_427(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_427(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_427(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_427(nullableRangeRestrictedInt8s); } static void OnFailureCallback_428(void * context, EmberAfStatus status) @@ -39809,9 +39861,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_429(status); } - static void OnSuccessCallback_429(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_429(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_429(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_429(nullableRangeRestrictedInt8s); } static void OnFailureCallback_430(void * context, EmberAfStatus status) @@ -39826,9 +39878,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_431(status); } - static void OnSuccessCallback_431(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_431(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_431(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_431(nullableRangeRestrictedInt8s); } static void OnFailureCallback_432(void * context, EmberAfStatus status) @@ -39836,17 +39888,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_432(status); } - static void OnSuccessCallback_432(void * context) { (static_cast(context))->OnSuccessResponse_432(); } + static void OnSuccessCallback_432(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_432(nullableRangeRestrictedInt16s); + } static void OnFailureCallback_433(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_433(status); } - static void OnSuccessCallback_433(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_433(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_433(void * context) { (static_cast(context))->OnSuccessResponse_433(); } static void OnFailureCallback_434(void * context, EmberAfStatus status) { @@ -39860,9 +39912,91 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_435(status); } - static void OnSuccessCallback_435(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_435(void * context) { (static_cast(context))->OnSuccessResponse_435(); } + + static void OnFailureCallback_436(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_436(status); + } + + static void OnSuccessCallback_436(void * context) { (static_cast(context))->OnSuccessResponse_436(); } + + static void OnFailureCallback_437(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_437(status); + } + + static void OnSuccessCallback_437(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_437(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_438(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_438(status); + } + + static void OnSuccessCallback_438(void * context) { (static_cast(context))->OnSuccessResponse_438(); } + + static void OnFailureCallback_439(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_439(status); + } + + static void OnSuccessCallback_439(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_439(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_440(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_440(status); + } + + static void OnSuccessCallback_440(void * context) { (static_cast(context))->OnSuccessResponse_440(); } + + static void OnFailureCallback_441(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_441(status); + } + + static void OnSuccessCallback_441(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_441(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_442(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_442(status); + } + + static void OnSuccessCallback_442(void * context) { (static_cast(context))->OnSuccessResponse_442(); } + + static void OnFailureCallback_443(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_443(status); + } + + static void OnSuccessCallback_443(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_435(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_443(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_444(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_444(status); + } + + static void OnSuccessCallback_444(void * context) { (static_cast(context))->OnSuccessResponse_444(); } + + static void OnFailureCallback_445(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_445(status); + } + + static void OnSuccessCallback_445(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_445(nullableRangeRestrictedInt16s); } // @@ -45244,7 +45378,105 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_239() + CHIP_ERROR TestReadAttributeNullableInt64uNullValueRange_239() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_239, OnFailureCallback_239)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_239(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_239(const chip::app::DataModel::Nullable & nullableInt64u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt64uNullValueNot_240() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_240, OnFailureCallback_240)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_240(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableInt64u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt64uValue_241() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt64uArgument; + nullableInt64uArgument.SetNonNull() = 18000000000000000000ULL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt64uArgument, this, OnSuccessCallback_241, OnFailureCallback_241)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_241(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_241() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt64uValueInRange_242() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_242, OnFailureCallback_242)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_242(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_242(const chip::app::DataModel::Nullable & nullableInt64u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt64uNotValueOk_243() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_243, OnFailureCallback_243)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_243(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_243(const chip::app::DataModel::Nullable & nullableInt64u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18000000000000000001ULL)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_244() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45254,28 +45486,28 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -127; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_239, OnFailureCallback_239)); + nullableInt8sArgument, this, OnSuccessCallback_244, OnFailureCallback_244)); return CHIP_NO_ERROR; } - void OnFailureResponse_239(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_244(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_239() { NextTest(); } + void OnSuccessResponse_244() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sMinValue_240() + CHIP_ERROR TestReadAttributeNullableInt8sMinValue_245() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_240, OnFailureCallback_240)); + this, OnSuccessCallback_245, OnFailureCallback_245)); return CHIP_NO_ERROR; } - void OnFailureResponse_240(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_245(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_245(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -45283,7 +45515,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_241() + CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_246() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45293,32 +45525,32 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -128; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_241, OnFailureCallback_241)); + nullableInt8sArgument, this, OnSuccessCallback_246, OnFailureCallback_246)); return CHIP_NO_ERROR; } - void OnFailureResponse_241(EmberAfStatus status) + void OnFailureResponse_246(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_241() { ThrowSuccessResponse(); } + void OnSuccessResponse_246() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_242() + CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_247() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_242, OnFailureCallback_242)); + this, OnSuccessCallback_247, OnFailureCallback_247)); return CHIP_NO_ERROR; } - void OnFailureResponse_242(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_247(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_242(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_247(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -45326,7 +45558,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_243() + CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_248() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45336,48 +45568,48 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_243, OnFailureCallback_243)); + nullableInt8sArgument, this, OnSuccessCallback_248, OnFailureCallback_248)); return CHIP_NO_ERROR; } - void OnFailureResponse_243(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_248(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_243() { NextTest(); } + void OnSuccessResponse_248() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValue_244() + CHIP_ERROR TestReadAttributeNullableInt8sNullValue_249() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_244, OnFailureCallback_244)); + this, OnSuccessCallback_249, OnFailureCallback_249)); return CHIP_NO_ERROR; } - void OnFailureResponse_244(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_249(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_244(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_249(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNull("nullableInt8s", nullableInt8s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_245() + CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_250() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_245, OnFailureCallback_245)); + this, OnSuccessCallback_250, OnFailureCallback_250)); return CHIP_NO_ERROR; } - void OnFailureResponse_245(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_250(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_245(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_250(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); @@ -45385,27 +45617,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_246() + CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_251() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_246, OnFailureCallback_246)); + this, OnSuccessCallback_251, OnFailureCallback_251)); return CHIP_NO_ERROR; } - void OnFailureResponse_246(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_251(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_246(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_251(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -127)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sValue_247() + CHIP_ERROR TestWriteAttributeNullableInt8sValue_252() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45415,28 +45647,28 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -127; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_247, OnFailureCallback_247)); + nullableInt8sArgument, this, OnSuccessCallback_252, OnFailureCallback_252)); return CHIP_NO_ERROR; } - void OnFailureResponse_247(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_252(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_247() { NextTest(); } + void OnSuccessResponse_252() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_248() + CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_253() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_248, OnFailureCallback_248)); + this, OnSuccessCallback_253, OnFailureCallback_253)); return CHIP_NO_ERROR; } - void OnFailureResponse_248(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_253(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_248(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_253(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); @@ -45444,27 +45676,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_249() + CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_254() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_249, OnFailureCallback_249)); + this, OnSuccessCallback_254, OnFailureCallback_254)); return CHIP_NO_ERROR; } - void OnFailureResponse_249(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_254(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_249(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_254(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -126)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_250() + CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_255() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45474,28 +45706,28 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32767; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_250, OnFailureCallback_250)); + nullableInt16sArgument, this, OnSuccessCallback_255, OnFailureCallback_255)); return CHIP_NO_ERROR; } - void OnFailureResponse_250(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_255(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_250() { NextTest(); } + void OnSuccessResponse_255() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sMinValue_251() + CHIP_ERROR TestReadAttributeNullableInt16sMinValue_256() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_251, OnFailureCallback_251)); + this, OnSuccessCallback_256, OnFailureCallback_256)); return CHIP_NO_ERROR; } - void OnFailureResponse_251(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_256(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_251(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_256(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -45503,7 +45735,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_252() + CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_257() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45513,32 +45745,32 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_252, OnFailureCallback_252)); + nullableInt16sArgument, this, OnSuccessCallback_257, OnFailureCallback_257)); return CHIP_NO_ERROR; } - void OnFailureResponse_252(EmberAfStatus status) + void OnFailureResponse_257(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_252() { ThrowSuccessResponse(); } + void OnSuccessResponse_257() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_253() + CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_258() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_253, OnFailureCallback_253)); + this, OnSuccessCallback_258, OnFailureCallback_258)); return CHIP_NO_ERROR; } - void OnFailureResponse_253(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_258(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_253(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_258(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -45546,7 +45778,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_254() + CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_259() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45556,48 +45788,48 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_254, OnFailureCallback_254)); + nullableInt16sArgument, this, OnSuccessCallback_259, OnFailureCallback_259)); return CHIP_NO_ERROR; } - void OnFailureResponse_254(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_259(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_254() { NextTest(); } + void OnSuccessResponse_259() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValue_255() + CHIP_ERROR TestReadAttributeNullableInt16sNullValue_260() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_255, OnFailureCallback_255)); + this, OnSuccessCallback_260, OnFailureCallback_260)); return CHIP_NO_ERROR; } - void OnFailureResponse_255(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_260(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_255(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_260(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNull("nullableInt16s", nullableInt16s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_256() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_261() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_256, OnFailureCallback_256)); + this, OnSuccessCallback_261, OnFailureCallback_261)); return CHIP_NO_ERROR; } - void OnFailureResponse_256(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_261(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_256(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_261(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); @@ -45605,27 +45837,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_257() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_262() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_257, OnFailureCallback_257)); + this, OnSuccessCallback_262, OnFailureCallback_262)); return CHIP_NO_ERROR; } - void OnFailureResponse_257(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_262(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_257(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_262(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32767)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sValue_258() + CHIP_ERROR TestWriteAttributeNullableInt16sValue_263() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45635,28 +45867,28 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32767; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_258, OnFailureCallback_258)); + nullableInt16sArgument, this, OnSuccessCallback_263, OnFailureCallback_263)); return CHIP_NO_ERROR; } - void OnFailureResponse_258(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_263(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_258() { NextTest(); } + void OnSuccessResponse_263() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_259() + CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_264() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_259, OnFailureCallback_259)); + this, OnSuccessCallback_264, OnFailureCallback_264)); return CHIP_NO_ERROR; } - void OnFailureResponse_259(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_264(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_259(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_264(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); @@ -45664,27 +45896,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_260() + CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_265() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_260, OnFailureCallback_260)); + this, OnSuccessCallback_265, OnFailureCallback_265)); return CHIP_NO_ERROR; } - void OnFailureResponse_260(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_265(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_260(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_265(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32766)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_261() + CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_266() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45694,28 +45926,28 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483647L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_261, OnFailureCallback_261)); + nullableInt32sArgument, this, OnSuccessCallback_266, OnFailureCallback_266)); return CHIP_NO_ERROR; } - void OnFailureResponse_261(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_266(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_261() { NextTest(); } + void OnSuccessResponse_266() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sMinValue_262() + CHIP_ERROR TestReadAttributeNullableInt32sMinValue_267() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_262, OnFailureCallback_262)); + this, OnSuccessCallback_267, OnFailureCallback_267)); return CHIP_NO_ERROR; } - void OnFailureResponse_262(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_267(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_262(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_267(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -45723,7 +45955,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_263() + CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_268() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45733,32 +45965,32 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483648L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_263, OnFailureCallback_263)); + nullableInt32sArgument, this, OnSuccessCallback_268, OnFailureCallback_268)); return CHIP_NO_ERROR; } - void OnFailureResponse_263(EmberAfStatus status) + void OnFailureResponse_268(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_263() { ThrowSuccessResponse(); } + void OnSuccessResponse_268() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_264() + CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_269() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_264, OnFailureCallback_264)); + this, OnSuccessCallback_269, OnFailureCallback_269)); return CHIP_NO_ERROR; } - void OnFailureResponse_264(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_269(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_264(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_269(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -45766,7 +45998,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_265() + CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_270() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45776,48 +46008,48 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_265, OnFailureCallback_265)); + nullableInt32sArgument, this, OnSuccessCallback_270, OnFailureCallback_270)); return CHIP_NO_ERROR; } - void OnFailureResponse_265(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_270(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_265() { NextTest(); } + void OnSuccessResponse_270() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValue_266() + CHIP_ERROR TestReadAttributeNullableInt32sNullValue_271() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_266, OnFailureCallback_266)); + this, OnSuccessCallback_271, OnFailureCallback_271)); return CHIP_NO_ERROR; } - void OnFailureResponse_266(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_271(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_266(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_271(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNull("nullableInt32s", nullableInt32s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_267() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_272() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_267, OnFailureCallback_267)); + this, OnSuccessCallback_272, OnFailureCallback_272)); return CHIP_NO_ERROR; } - void OnFailureResponse_267(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_272(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_267(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_272(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); @@ -45825,27 +46057,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_268() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_273() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_268, OnFailureCallback_268)); + this, OnSuccessCallback_273, OnFailureCallback_273)); return CHIP_NO_ERROR; } - void OnFailureResponse_268(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_273(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_268(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_273(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483647L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sValue_269() + CHIP_ERROR TestWriteAttributeNullableInt32sValue_274() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45855,28 +46087,28 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483647L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_269, OnFailureCallback_269)); + nullableInt32sArgument, this, OnSuccessCallback_274, OnFailureCallback_274)); return CHIP_NO_ERROR; } - void OnFailureResponse_269(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_274(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_269() { NextTest(); } + void OnSuccessResponse_274() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_270() + CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_275() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_270, OnFailureCallback_270)); + this, OnSuccessCallback_275, OnFailureCallback_275)); return CHIP_NO_ERROR; } - void OnFailureResponse_270(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_275(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_270(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_275(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); @@ -45884,27 +46116,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_271() + CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_276() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_271, OnFailureCallback_271)); + this, OnSuccessCallback_276, OnFailureCallback_276)); return CHIP_NO_ERROR; } - void OnFailureResponse_271(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_276(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_271(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_276(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483646L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_272() + CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_277() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45914,28 +46146,28 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_272, OnFailureCallback_272)); + nullableInt64sArgument, this, OnSuccessCallback_277, OnFailureCallback_277)); return CHIP_NO_ERROR; } - void OnFailureResponse_272(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_277(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_272() { NextTest(); } + void OnSuccessResponse_277() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sMinValue_273() + CHIP_ERROR TestReadAttributeNullableInt64sMinValue_278() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_273, OnFailureCallback_273)); + this, OnSuccessCallback_278, OnFailureCallback_278)); return CHIP_NO_ERROR; } - void OnFailureResponse_273(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_278(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_273(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_278(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -45943,7 +46175,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_274() + CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_279() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45953,32 +46185,32 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL - 1; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_274, OnFailureCallback_274)); + nullableInt64sArgument, this, OnSuccessCallback_279, OnFailureCallback_279)); return CHIP_NO_ERROR; } - void OnFailureResponse_274(EmberAfStatus status) + void OnFailureResponse_279(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_274() { ThrowSuccessResponse(); } + void OnSuccessResponse_279() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_275() + CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_280() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_275, OnFailureCallback_275)); + this, OnSuccessCallback_280, OnFailureCallback_280)); return CHIP_NO_ERROR; } - void OnFailureResponse_275(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_280(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_275(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_280(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -45986,7 +46218,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_276() + CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_281() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45996,35 +46228,135 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_276, OnFailureCallback_276)); + nullableInt64sArgument, this, OnSuccessCallback_281, OnFailureCallback_281)); return CHIP_NO_ERROR; } - void OnFailureResponse_276(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_281(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_276() { NextTest(); } + void OnSuccessResponse_281() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValue_277() + CHIP_ERROR TestReadAttributeNullableInt64sNullValue_282() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_277, OnFailureCallback_277)); + this, OnSuccessCallback_282, OnFailureCallback_282)); return CHIP_NO_ERROR; } - void OnFailureResponse_277(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_282(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_277(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_282(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNull("nullableInt64s", nullableInt64s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_278() + CHIP_ERROR TestReadAttributeNullableInt64sNullValueRange_283() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_283, OnFailureCallback_283)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_283(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableInt64s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt64s", nullableInt64s, 9223372036854775807LL)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt64sNullValueNot_284() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_284, OnFailureCallback_284)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_284(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_284(const chip::app::DataModel::Nullable & nullableInt64s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt64sValue_285() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt64sArgument; + nullableInt64sArgument.SetNonNull() = -9223372036854775807LL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt64sArgument, this, OnSuccessCallback_285, OnFailureCallback_285)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_285(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_285() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt64sValueInRange_286() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_286, OnFailureCallback_286)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_286(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_286(const chip::app::DataModel::Nullable & nullableInt64s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt64s", nullableInt64s, 9223372036854775807LL)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt64sNotValueOk_287() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_287, OnFailureCallback_287)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_287(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_287(const chip::app::DataModel::Nullable & nullableInt64s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt64s", nullableInt64s, -9223372036854775806LL)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_288() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46034,28 +46366,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = 0.1f; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_278, OnFailureCallback_278)); + nullableFloatSingleArgument, this, OnSuccessCallback_288, OnFailureCallback_288)); return CHIP_NO_ERROR; } - void OnFailureResponse_278(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_288(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_278() { NextTest(); } + void OnSuccessResponse_288() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleMediumValue_279() + CHIP_ERROR TestReadAttributeNullableSingleMediumValue_289() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_279, OnFailureCallback_279)); + this, OnSuccessCallback_289, OnFailureCallback_289)); return CHIP_NO_ERROR; } - void OnFailureResponse_279(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_289(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_279(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_289(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.1f)); @@ -46063,7 +46395,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_280() + CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_290() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46073,28 +46405,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_280, OnFailureCallback_280)); + nullableFloatSingleArgument, this, OnSuccessCallback_290, OnFailureCallback_290)); return CHIP_NO_ERROR; } - void OnFailureResponse_280(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_290(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_280() { NextTest(); } + void OnSuccessResponse_290() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleLargestValue_281() + CHIP_ERROR TestReadAttributeNullableSingleLargestValue_291() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_281, OnFailureCallback_281)); + this, OnSuccessCallback_291, OnFailureCallback_291)); return CHIP_NO_ERROR; } - void OnFailureResponse_281(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_291(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_281(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_291(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), INFINITY)); @@ -46102,7 +46434,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_282() + CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_292() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46112,28 +46444,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_282, OnFailureCallback_282)); + nullableFloatSingleArgument, this, OnSuccessCallback_292, OnFailureCallback_292)); return CHIP_NO_ERROR; } - void OnFailureResponse_282(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_292(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_282() { NextTest(); } + void OnSuccessResponse_292() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_283() + CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_293() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_283, OnFailureCallback_283)); + this, OnSuccessCallback_293, OnFailureCallback_293)); return CHIP_NO_ERROR; } - void OnFailureResponse_283(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_293(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_293(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), -INFINITY)); @@ -46141,7 +46473,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleNullValue_284() + CHIP_ERROR TestWriteAttributeNullableSingleNullValue_294() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46151,35 +46483,35 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_284, OnFailureCallback_284)); + nullableFloatSingleArgument, this, OnSuccessCallback_294, OnFailureCallback_294)); return CHIP_NO_ERROR; } - void OnFailureResponse_284(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_294(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_284() { NextTest(); } + void OnSuccessResponse_294() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleNullValue_285() + CHIP_ERROR TestReadAttributeNullableSingleNullValue_295() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_285, OnFailureCallback_285)); + this, OnSuccessCallback_295, OnFailureCallback_295)); return CHIP_NO_ERROR; } - void OnFailureResponse_285(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_295(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_285(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_295(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNull("nullableFloatSingle", nullableFloatSingle)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingle0Value_286() + CHIP_ERROR TestWriteAttributeNullableSingle0Value_296() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46189,28 +46521,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = 0.0f; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_286, OnFailureCallback_286)); + nullableFloatSingleArgument, this, OnSuccessCallback_296, OnFailureCallback_296)); return CHIP_NO_ERROR; } - void OnFailureResponse_286(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_296(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_286() { NextTest(); } + void OnSuccessResponse_296() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingle0Value_287() + CHIP_ERROR TestReadAttributeNullableSingle0Value_297() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_287, OnFailureCallback_287)); + this, OnSuccessCallback_297, OnFailureCallback_297)); return CHIP_NO_ERROR; } - void OnFailureResponse_287(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_297(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_287(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_297(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.0f)); @@ -46218,7 +46550,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_288() + CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_298() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46228,28 +46560,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = 0.1234567890123; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_288, OnFailureCallback_288)); + nullableFloatDoubleArgument, this, OnSuccessCallback_298, OnFailureCallback_298)); return CHIP_NO_ERROR; } - void OnFailureResponse_288(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_298(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_288() { NextTest(); } + void OnSuccessResponse_298() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_289() + CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_299() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_289, OnFailureCallback_289)); + this, OnSuccessCallback_299, OnFailureCallback_299)); return CHIP_NO_ERROR; } - void OnFailureResponse_289(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_299(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_289(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_299(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0.1234567890123)); @@ -46257,7 +46589,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_290() + CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_300() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46267,28 +46599,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_290, OnFailureCallback_290)); + nullableFloatDoubleArgument, this, OnSuccessCallback_300, OnFailureCallback_300)); return CHIP_NO_ERROR; } - void OnFailureResponse_290(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_300(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_290() { NextTest(); } + void OnSuccessResponse_300() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_291() + CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_301() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_291, OnFailureCallback_291)); + this, OnSuccessCallback_301, OnFailureCallback_301)); return CHIP_NO_ERROR; } - void OnFailureResponse_291(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_301(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_291(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_301(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), INFINITY)); @@ -46296,7 +46628,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_292() + CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_302() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46306,28 +46638,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_292, OnFailureCallback_292)); + nullableFloatDoubleArgument, this, OnSuccessCallback_302, OnFailureCallback_302)); return CHIP_NO_ERROR; } - void OnFailureResponse_292(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_302(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_292() { NextTest(); } + void OnSuccessResponse_302() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_293() + CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_303() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_293, OnFailureCallback_293)); + this, OnSuccessCallback_303, OnFailureCallback_303)); return CHIP_NO_ERROR; } - void OnFailureResponse_293(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_303(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_293(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_303(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), -INFINITY)); @@ -46335,7 +46667,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_294() + CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_304() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46345,35 +46677,35 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_294, OnFailureCallback_294)); + nullableFloatDoubleArgument, this, OnSuccessCallback_304, OnFailureCallback_304)); return CHIP_NO_ERROR; } - void OnFailureResponse_294(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_304(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_294() { NextTest(); } + void OnSuccessResponse_304() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleNullValue_295() + CHIP_ERROR TestReadAttributeNullableDoubleNullValue_305() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_295, OnFailureCallback_295)); + this, OnSuccessCallback_305, OnFailureCallback_305)); return CHIP_NO_ERROR; } - void OnFailureResponse_295(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_305(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_295(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_305(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNull("nullableFloatDouble", nullableFloatDouble)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDouble0Value_296() + CHIP_ERROR TestWriteAttributeNullableDouble0Value_306() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46383,28 +46715,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_296, OnFailureCallback_296)); + nullableFloatDoubleArgument, this, OnSuccessCallback_306, OnFailureCallback_306)); return CHIP_NO_ERROR; } - void OnFailureResponse_296(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_306(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_296() { NextTest(); } + void OnSuccessResponse_306() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDouble0Value_297() + CHIP_ERROR TestReadAttributeNullableDouble0Value_307() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_297, OnFailureCallback_297)); + this, OnSuccessCallback_307, OnFailureCallback_307)); return CHIP_NO_ERROR; } - void OnFailureResponse_297(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_307(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_297(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_307(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0)); @@ -46412,7 +46744,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_298() + CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_308() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46422,28 +46754,28 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = 254; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_298, OnFailureCallback_298)); + nullableEnum8Argument, this, OnSuccessCallback_308, OnFailureCallback_308)); return CHIP_NO_ERROR; } - void OnFailureResponse_298(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_308(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_298() { NextTest(); } + void OnSuccessResponse_308() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_299() + CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_309() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_299, OnFailureCallback_299)); + this, OnSuccessCallback_309, OnFailureCallback_309)); return CHIP_NO_ERROR; } - void OnFailureResponse_299(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_309(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_299(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_309(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); @@ -46451,7 +46783,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_300() + CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_310() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46461,32 +46793,32 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_300, OnFailureCallback_300)); + nullableEnum8Argument, this, OnSuccessCallback_310, OnFailureCallback_310)); return CHIP_NO_ERROR; } - void OnFailureResponse_300(EmberAfStatus status) + void OnFailureResponse_310(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_300() { ThrowSuccessResponse(); } + void OnSuccessResponse_310() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_301() + CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_311() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_301, OnFailureCallback_301)); + this, OnSuccessCallback_311, OnFailureCallback_311)); return CHIP_NO_ERROR; } - void OnFailureResponse_301(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_311(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_301(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_311(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); @@ -46494,7 +46826,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_302() + CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_312() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46504,35 +46836,35 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_302, OnFailureCallback_302)); + nullableEnum8Argument, this, OnSuccessCallback_312, OnFailureCallback_312)); return CHIP_NO_ERROR; } - void OnFailureResponse_302(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_312(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_302() { NextTest(); } + void OnSuccessResponse_312() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8NullValue_303() + CHIP_ERROR TestReadAttributeNullableEnum8NullValue_313() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_303, OnFailureCallback_303)); + this, OnSuccessCallback_313, OnFailureCallback_313)); return CHIP_NO_ERROR; } - void OnFailureResponse_303(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_313(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_303(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_313(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_304() + CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_314() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46542,28 +46874,28 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = 65534U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_304, OnFailureCallback_304)); + nullableEnum16Argument, this, OnSuccessCallback_314, OnFailureCallback_314)); return CHIP_NO_ERROR; } - void OnFailureResponse_304(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_314(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_304() { NextTest(); } + void OnSuccessResponse_314() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_305() + CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_315() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_305, OnFailureCallback_305)); + this, OnSuccessCallback_315, OnFailureCallback_315)); return CHIP_NO_ERROR; } - void OnFailureResponse_305(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_315(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_305(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_315(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); @@ -46571,7 +46903,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_306() + CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_316() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46581,32 +46913,32 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_306, OnFailureCallback_306)); + nullableEnum16Argument, this, OnSuccessCallback_316, OnFailureCallback_316)); return CHIP_NO_ERROR; } - void OnFailureResponse_306(EmberAfStatus status) + void OnFailureResponse_316(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_306() { ThrowSuccessResponse(); } + void OnSuccessResponse_316() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_307() + CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_317() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_307, OnFailureCallback_307)); + this, OnSuccessCallback_317, OnFailureCallback_317)); return CHIP_NO_ERROR; } - void OnFailureResponse_307(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_317(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_307(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_317(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); @@ -46614,7 +46946,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_308() + CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_318() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46624,48 +46956,48 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_308, OnFailureCallback_308)); + nullableEnum16Argument, this, OnSuccessCallback_318, OnFailureCallback_318)); return CHIP_NO_ERROR; } - void OnFailureResponse_308(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_318(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_308() { NextTest(); } + void OnSuccessResponse_318() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16NullValue_309() + CHIP_ERROR TestReadAttributeNullableEnum16NullValue_319() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_309, OnFailureCallback_309)); + this, OnSuccessCallback_319, OnFailureCallback_319)); return CHIP_NO_ERROR; } - void OnFailureResponse_309(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_319(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_309(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_319(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_310() + CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_320() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_310, OnFailureCallback_310)); + this, OnSuccessCallback_320, OnFailureCallback_320)); return CHIP_NO_ERROR; } - void OnFailureResponse_310(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_320(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_310(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_320(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -46674,7 +47006,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_311() + CHIP_ERROR TestWriteAttributeNullableOctetString_321() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46685,28 +47017,28 @@ class TestCluster : public TestCommand chip::ByteSpan(chip::Uint8::from_const_char("TestValuegarbage: not in length on purpose"), 9); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_311, OnFailureCallback_311)); + nullableOctetStringArgument, this, OnSuccessCallback_321, OnFailureCallback_321)); return CHIP_NO_ERROR; } - void OnFailureResponse_311(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_321(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_311() { NextTest(); } + void OnSuccessResponse_321() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_312() + CHIP_ERROR TestReadAttributeNullableOctetString_322() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_312, OnFailureCallback_312)); + this, OnSuccessCallback_322, OnFailureCallback_322)); return CHIP_NO_ERROR; } - void OnFailureResponse_312(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_322(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_312(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_322(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -46715,7 +47047,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_313() + CHIP_ERROR TestWriteAttributeNullableOctetString_323() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46725,35 +47057,35 @@ class TestCluster : public TestCommand nullableOctetStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_313, OnFailureCallback_313)); + nullableOctetStringArgument, this, OnSuccessCallback_323, OnFailureCallback_323)); return CHIP_NO_ERROR; } - void OnFailureResponse_313(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_323(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_313() { NextTest(); } + void OnSuccessResponse_323() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_314() + CHIP_ERROR TestReadAttributeNullableOctetString_324() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_314, OnFailureCallback_314)); + this, OnSuccessCallback_324, OnFailureCallback_324)); return CHIP_NO_ERROR; } - void OnFailureResponse_314(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_324(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_314(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_324(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNull("nullableOctetString", nullableOctetString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_315() + CHIP_ERROR TestWriteAttributeNullableOctetString_325() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46764,28 +47096,28 @@ class TestCluster : public TestCommand chip::ByteSpan(chip::Uint8::from_const_char("garbage: not in length on purpose"), 0); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_315, OnFailureCallback_315)); + nullableOctetStringArgument, this, OnSuccessCallback_325, OnFailureCallback_325)); return CHIP_NO_ERROR; } - void OnFailureResponse_315(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_325(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_315() { NextTest(); } + void OnSuccessResponse_325() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_316() + CHIP_ERROR TestReadAttributeNullableOctetString_326() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_316, OnFailureCallback_316)); + this, OnSuccessCallback_326, OnFailureCallback_326)); return CHIP_NO_ERROR; } - void OnFailureResponse_316(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_326(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_316(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_326(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -46794,20 +47126,20 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_317() + CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_327() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_317, OnFailureCallback_317)); + this, OnSuccessCallback_327, OnFailureCallback_327)); return CHIP_NO_ERROR; } - void OnFailureResponse_317(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_327(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_317(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_327(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -46815,7 +47147,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharString_318() + CHIP_ERROR TestWriteAttributeNullableCharString_328() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46825,28 +47157,28 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("☉T☉garbage: not in length on purpose", 7); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_318, OnFailureCallback_318)); + nullableCharStringArgument, this, OnSuccessCallback_328, OnFailureCallback_328)); return CHIP_NO_ERROR; } - void OnFailureResponse_318(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_328(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_318() { NextTest(); } + void OnSuccessResponse_328() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_319() + CHIP_ERROR TestReadAttributeNullableCharString_329() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_319, OnFailureCallback_319)); + this, OnSuccessCallback_329, OnFailureCallback_329)); return CHIP_NO_ERROR; } - void OnFailureResponse_319(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_329(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_319(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_329(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("☉T☉", 7))); @@ -46854,7 +47186,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_320() + CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_330() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46864,35 +47196,35 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_320, OnFailureCallback_320)); + nullableCharStringArgument, this, OnSuccessCallback_330, OnFailureCallback_330)); return CHIP_NO_ERROR; } - void OnFailureResponse_320(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_330(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_320() { NextTest(); } + void OnSuccessResponse_330() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_321() + CHIP_ERROR TestReadAttributeNullableCharString_331() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_321, OnFailureCallback_321)); + this, OnSuccessCallback_331, OnFailureCallback_331)); return CHIP_NO_ERROR; } - void OnFailureResponse_321(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_331(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_321(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_331(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNull("nullableCharString", nullableCharString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_322() + CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_332() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46902,28 +47234,28 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("garbage: not in length on purpose", 0); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_322, OnFailureCallback_322)); + nullableCharStringArgument, this, OnSuccessCallback_332, OnFailureCallback_332)); return CHIP_NO_ERROR; } - void OnFailureResponse_322(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_332(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_322() { NextTest(); } + void OnSuccessResponse_332() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_323() + CHIP_ERROR TestReadAttributeNullableCharString_333() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_323, OnFailureCallback_323)); + this, OnSuccessCallback_333, OnFailureCallback_333)); return CHIP_NO_ERROR; } - void OnFailureResponse_323(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_333(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_323(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_333(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -46931,45 +47263,45 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_324() + CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_334() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 200; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_324, OnFailureCallback_324)); + this, OnSuccessCallback_334, OnFailureCallback_334)); return CHIP_NO_ERROR; } - void OnFailureResponse_324(EmberAfStatus status) + void OnFailureResponse_334(EmberAfStatus status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_324(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_334(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeFromNonexistentCluster_325() + CHIP_ERROR TestReadAttributeFromNonexistentCluster_335() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 0; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_325, OnFailureCallback_325)); + this, OnSuccessCallback_335, OnFailureCallback_335)); return CHIP_NO_ERROR; } - void OnFailureResponse_325(EmberAfStatus status) + void OnFailureResponse_335(EmberAfStatus status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_325(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_335(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_326() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_336() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -46977,26 +47309,26 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_326(); + (static_cast(context))->OnSuccessResponse_336(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_326(status); + (static_cast(context))->OnFailureResponse_336(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_326(EmberAfStatus status) + void OnFailureResponse_336(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_INVALID_VALUE)); NextTest(); } - void OnSuccessResponse_326() { ThrowSuccessResponse(); } + void OnSuccessResponse_336() { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_327() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_337() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -47005,36 +47337,36 @@ class TestCluster : public TestCommand request.arg1.Emplace() = 1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_327(); + (static_cast(context))->OnSuccessResponse_337(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_327(status); + (static_cast(context))->OnFailureResponse_337(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_327(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_337(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_327() { NextTest(); } + void OnSuccessResponse_337() { NextTest(); } - CHIP_ERROR TestReportSubscribeToListAttribute_328() + CHIP_ERROR TestReportSubscribeToListAttribute_338() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_328; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_338; return WaitForMs(0); } - void OnFailureResponse_328(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_338(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_328(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_338(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_328 = true; + mReceivedReport_338 = true; auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); @@ -47048,7 +47380,7 @@ class TestCluster : public TestCommand VerifyOrReturn(CheckNoMoreListItems("listInt8u", iter, 4)); } - CHIP_ERROR TestSubscribeToListAttribute_329() + CHIP_ERROR TestSubscribeToListAttribute_339() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47060,14 +47392,14 @@ class TestCluster : public TestCommand maxIntervalArgument = 10U; ReturnErrorOnFailure(cluster.SubscribeAttribute( - this, OnSuccessCallback_329, OnFailureCallback_329, minIntervalArgument, maxIntervalArgument, - OnSubscriptionEstablished_329)); + this, OnSuccessCallback_339, OnFailureCallback_339, minIntervalArgument, maxIntervalArgument, + OnSubscriptionEstablished_339)); return CHIP_NO_ERROR; } - void OnFailureResponse_329(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_339(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_329(const chip::app::DataModel::DecodableList & value) + void OnSuccessResponse_339(const chip::app::DataModel::DecodableList & value) { if (mTest_TestCluster_list_int8u_Reported) { @@ -47077,13 +47409,13 @@ class TestCluster : public TestCommand } } - void OnSubscriptionEstablishedResponse_329() + void OnSubscriptionEstablishedResponse_339() { - VerifyOrReturn(mReceivedReport_328, Exit("Initial report not received!")); + VerifyOrReturn(mReceivedReport_338, Exit("Initial report not received!")); NextTest(); } - CHIP_ERROR TestWriteSubscribedToListAttribute_330() + CHIP_ERROR TestWriteSubscribedToListAttribute_340() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47099,29 +47431,29 @@ class TestCluster : public TestCommand listInt8uArgument = listInt8uList; ReturnErrorOnFailure(cluster.WriteAttribute( - listInt8uArgument, this, OnSuccessCallback_330, OnFailureCallback_330)); + listInt8uArgument, this, OnSuccessCallback_340, OnFailureCallback_340)); return CHIP_NO_ERROR; } - void OnFailureResponse_330(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_340(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_330() { NextTest(); } + void OnSuccessResponse_340() { NextTest(); } - CHIP_ERROR TestCheckForListAttributeReport_331() + CHIP_ERROR TestCheckForListAttributeReport_341() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_331; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_341; return CHIP_NO_ERROR; } - void OnFailureResponse_331(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_341(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_331(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_341(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_331 = true; + mReceivedReport_341 = true; auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); @@ -47137,27 +47469,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_332() + CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_342() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_332, OnFailureCallback_332)); + this, OnSuccessCallback_342, OnFailureCallback_342)); return CHIP_NO_ERROR; } - void OnFailureResponse_332(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_342(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_332(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_342(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_333() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_343() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47167,19 +47499,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_333, OnFailureCallback_333)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_343, OnFailureCallback_343)); return CHIP_NO_ERROR; } - void OnFailureResponse_333(EmberAfStatus status) + void OnFailureResponse_343(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_333() { ThrowSuccessResponse(); } + void OnSuccessResponse_343() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_334() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_344() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47189,19 +47521,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 19; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_334, OnFailureCallback_334)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_344, OnFailureCallback_344)); return CHIP_NO_ERROR; } - void OnFailureResponse_334(EmberAfStatus status) + void OnFailureResponse_344(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_334() { ThrowSuccessResponse(); } + void OnSuccessResponse_344() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_335() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_345() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47211,19 +47543,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 101; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_335, OnFailureCallback_335)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_345, OnFailureCallback_345)); return CHIP_NO_ERROR; } - void OnFailureResponse_335(EmberAfStatus status) + void OnFailureResponse_345(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_335() { ThrowSuccessResponse(); } + void OnSuccessResponse_345() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_336() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_346() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47233,39 +47565,39 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_336, OnFailureCallback_336)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_346, OnFailureCallback_346)); return CHIP_NO_ERROR; } - void OnFailureResponse_336(EmberAfStatus status) + void OnFailureResponse_346(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_336() { ThrowSuccessResponse(); } + void OnSuccessResponse_346() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_337() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_347() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_337, OnFailureCallback_337)); + this, OnSuccessCallback_347, OnFailureCallback_347)); return CHIP_NO_ERROR; } - void OnFailureResponse_337(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_347(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_337(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_347(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_338() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_348() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47275,35 +47607,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 20; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_338, OnFailureCallback_338)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_348, OnFailureCallback_348)); return CHIP_NO_ERROR; } - void OnFailureResponse_338(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_348(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_338() { NextTest(); } + void OnSuccessResponse_348() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_339() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_349() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_339, OnFailureCallback_339)); + this, OnSuccessCallback_349, OnFailureCallback_349)); return CHIP_NO_ERROR; } - void OnFailureResponse_339(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_349(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_339(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_349(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 20)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_340() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_350() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47313,35 +47645,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 100; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_340, OnFailureCallback_340)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_350, OnFailureCallback_350)); return CHIP_NO_ERROR; } - void OnFailureResponse_340(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_350(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_340() { NextTest(); } + void OnSuccessResponse_350() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_341() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_351() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_341, OnFailureCallback_341)); + this, OnSuccessCallback_351, OnFailureCallback_351)); return CHIP_NO_ERROR; } - void OnFailureResponse_341(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_351(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_341(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_351(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 100)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_342() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_352() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47351,55 +47683,55 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_342, OnFailureCallback_342)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_352, OnFailureCallback_352)); return CHIP_NO_ERROR; } - void OnFailureResponse_342(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_352(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_342() { NextTest(); } + void OnSuccessResponse_352() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_343() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_353() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_343, OnFailureCallback_343)); + this, OnSuccessCallback_353, OnFailureCallback_353)); return CHIP_NO_ERROR; } - void OnFailureResponse_343(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_353(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_343(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_353(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 50)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_344() + CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_354() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_344, OnFailureCallback_344)); + this, OnSuccessCallback_354, OnFailureCallback_354)); return CHIP_NO_ERROR; } - void OnFailureResponse_344(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_354(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_344(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_354(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_345() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_355() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47409,19 +47741,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 0U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_345, OnFailureCallback_345)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_355, OnFailureCallback_355)); return CHIP_NO_ERROR; } - void OnFailureResponse_345(EmberAfStatus status) + void OnFailureResponse_355(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_345() { ThrowSuccessResponse(); } + void OnSuccessResponse_355() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_346() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_356() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47431,19 +47763,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 99U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_346, OnFailureCallback_346)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_356, OnFailureCallback_356)); return CHIP_NO_ERROR; } - void OnFailureResponse_346(EmberAfStatus status) + void OnFailureResponse_356(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_346() { ThrowSuccessResponse(); } + void OnSuccessResponse_356() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_347() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_357() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47453,19 +47785,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1001U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_347, OnFailureCallback_347)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_357, OnFailureCallback_357)); return CHIP_NO_ERROR; } - void OnFailureResponse_347(EmberAfStatus status) + void OnFailureResponse_357(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_347() { ThrowSuccessResponse(); } + void OnSuccessResponse_357() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_348() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_358() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47475,39 +47807,39 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_348, OnFailureCallback_348)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_358, OnFailureCallback_358)); return CHIP_NO_ERROR; } - void OnFailureResponse_348(EmberAfStatus status) + void OnFailureResponse_358(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_348() { ThrowSuccessResponse(); } + void OnSuccessResponse_358() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_349() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_359() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_349, OnFailureCallback_349)); + this, OnSuccessCallback_359, OnFailureCallback_359)); return CHIP_NO_ERROR; } - void OnFailureResponse_349(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_359(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_349(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_359(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_350() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_360() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47517,35 +47849,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 100U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_350, OnFailureCallback_350)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_360, OnFailureCallback_360)); return CHIP_NO_ERROR; } - void OnFailureResponse_350(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_360(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_350() { NextTest(); } + void OnSuccessResponse_360() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_351() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_361() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_351, OnFailureCallback_351)); + this, OnSuccessCallback_361, OnFailureCallback_361)); return CHIP_NO_ERROR; } - void OnFailureResponse_351(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_361(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_351(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_361(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 100U)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_352() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_362() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47555,35 +47887,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1000U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_352, OnFailureCallback_352)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_362, OnFailureCallback_362)); return CHIP_NO_ERROR; } - void OnFailureResponse_352(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_362(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_352() { NextTest(); } + void OnSuccessResponse_362() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_353() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_363() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_353, OnFailureCallback_353)); + this, OnSuccessCallback_363, OnFailureCallback_363)); return CHIP_NO_ERROR; } - void OnFailureResponse_353(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_363(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_353(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_363(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 1000U)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_354() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_364() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47593,55 +47925,55 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 500U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_354, OnFailureCallback_354)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_364, OnFailureCallback_364)); return CHIP_NO_ERROR; } - void OnFailureResponse_354(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_364(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_354() { NextTest(); } + void OnSuccessResponse_364() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_355() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_365() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_355, OnFailureCallback_355)); + this, OnSuccessCallback_365, OnFailureCallback_365)); return CHIP_NO_ERROR; } - void OnFailureResponse_355(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_365(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_355(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_365(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 500U)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_356() + CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_366() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_356, OnFailureCallback_356)); + this, OnSuccessCallback_366, OnFailureCallback_366)); return CHIP_NO_ERROR; } - void OnFailureResponse_356(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_366(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_356(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_366(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_357() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_367() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47651,19 +47983,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -128; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_357, OnFailureCallback_357)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_367, OnFailureCallback_367)); return CHIP_NO_ERROR; } - void OnFailureResponse_357(EmberAfStatus status) + void OnFailureResponse_367(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_357() { ThrowSuccessResponse(); } + void OnSuccessResponse_367() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_358() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_368() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47673,19 +48005,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -41; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_358, OnFailureCallback_358)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_368, OnFailureCallback_368)); return CHIP_NO_ERROR; } - void OnFailureResponse_358(EmberAfStatus status) + void OnFailureResponse_368(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_358() { ThrowSuccessResponse(); } + void OnSuccessResponse_368() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_359() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_369() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47695,19 +48027,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 51; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_359, OnFailureCallback_359)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_369, OnFailureCallback_369)); return CHIP_NO_ERROR; } - void OnFailureResponse_359(EmberAfStatus status) + void OnFailureResponse_369(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_359() { ThrowSuccessResponse(); } + void OnSuccessResponse_369() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_360() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_370() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47717,39 +48049,39 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 127; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_360, OnFailureCallback_360)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_370, OnFailureCallback_370)); return CHIP_NO_ERROR; } - void OnFailureResponse_360(EmberAfStatus status) + void OnFailureResponse_370(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_360() { ThrowSuccessResponse(); } + void OnSuccessResponse_370() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_361() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_371() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_361, OnFailureCallback_361)); + this, OnSuccessCallback_371, OnFailureCallback_371)); return CHIP_NO_ERROR; } - void OnFailureResponse_361(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_371(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_361(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_371(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_362() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_372() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47759,35 +48091,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -40; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_362, OnFailureCallback_362)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); return CHIP_NO_ERROR; } - void OnFailureResponse_362(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_372(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_362() { NextTest(); } + void OnSuccessResponse_372() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_363() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_373() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_363, OnFailureCallback_363)); + this, OnSuccessCallback_373, OnFailureCallback_373)); return CHIP_NO_ERROR; } - void OnFailureResponse_363(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_373(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_363(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_373(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, -40)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_364() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_374() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47797,35 +48129,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_364, OnFailureCallback_364)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_374, OnFailureCallback_374)); return CHIP_NO_ERROR; } - void OnFailureResponse_364(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_374(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_364() { NextTest(); } + void OnSuccessResponse_374() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_365() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_375() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_365, OnFailureCallback_365)); + this, OnSuccessCallback_375, OnFailureCallback_375)); return CHIP_NO_ERROR; } - void OnFailureResponse_365(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_375(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_365(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_375(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 50)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_366() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_376() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47835,55 +48167,55 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 6; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_366, OnFailureCallback_366)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); return CHIP_NO_ERROR; } - void OnFailureResponse_366(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_376(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_366() { NextTest(); } + void OnSuccessResponse_376() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_367() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_377() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_367, OnFailureCallback_367)); + this, OnSuccessCallback_377, OnFailureCallback_377)); return CHIP_NO_ERROR; } - void OnFailureResponse_367(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_377(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_367(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_377(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 6)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_368() + CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_378() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_368, OnFailureCallback_368)); + this, OnSuccessCallback_378, OnFailureCallback_378)); return CHIP_NO_ERROR; } - void OnFailureResponse_368(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_378(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_368(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_378(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_369() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_379() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47893,19 +48225,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_369, OnFailureCallback_369)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_379, OnFailureCallback_379)); return CHIP_NO_ERROR; } - void OnFailureResponse_369(EmberAfStatus status) + void OnFailureResponse_379(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_369() { ThrowSuccessResponse(); } + void OnSuccessResponse_379() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_370() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_380() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47915,19 +48247,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -151; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_370, OnFailureCallback_370)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_380, OnFailureCallback_380)); return CHIP_NO_ERROR; } - void OnFailureResponse_370(EmberAfStatus status) + void OnFailureResponse_380(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_370() { ThrowSuccessResponse(); } + void OnSuccessResponse_380() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_371() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_381() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47937,19 +48269,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 201; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_371, OnFailureCallback_371)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_381, OnFailureCallback_381)); return CHIP_NO_ERROR; } - void OnFailureResponse_371(EmberAfStatus status) + void OnFailureResponse_381(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_371() { ThrowSuccessResponse(); } + void OnSuccessResponse_381() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_372() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_382() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47959,39 +48291,39 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 32767; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_382, OnFailureCallback_382)); return CHIP_NO_ERROR; } - void OnFailureResponse_372(EmberAfStatus status) + void OnFailureResponse_382(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_372() { ThrowSuccessResponse(); } + void OnSuccessResponse_382() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_373() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_383() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_373, OnFailureCallback_373)); + this, OnSuccessCallback_383, OnFailureCallback_383)); return CHIP_NO_ERROR; } - void OnFailureResponse_373(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_383(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_373(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_383(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_374() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_384() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48001,35 +48333,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -150; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_374, OnFailureCallback_374)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); return CHIP_NO_ERROR; } - void OnFailureResponse_374(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_384(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_374() { NextTest(); } + void OnSuccessResponse_384() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_375() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_385() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_375, OnFailureCallback_375)); + this, OnSuccessCallback_385, OnFailureCallback_385)); return CHIP_NO_ERROR; } - void OnFailureResponse_375(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_385(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_375(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_385(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, -150)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_376() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_386() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48039,35 +48371,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 200; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_386, OnFailureCallback_386)); return CHIP_NO_ERROR; } - void OnFailureResponse_376(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_386(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_376() { NextTest(); } + void OnSuccessResponse_386() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_377() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_387() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_377, OnFailureCallback_377)); + this, OnSuccessCallback_387, OnFailureCallback_387)); return CHIP_NO_ERROR; } - void OnFailureResponse_377(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_387(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_377(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_387(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 200)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_378() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_388() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48077,35 +48409,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 7; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_378, OnFailureCallback_378)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); return CHIP_NO_ERROR; } - void OnFailureResponse_378(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_388(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_378() { NextTest(); } + void OnSuccessResponse_388() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_379() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_389() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_379, OnFailureCallback_379)); + this, OnSuccessCallback_389, OnFailureCallback_389)); return CHIP_NO_ERROR; } - void OnFailureResponse_379(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_389(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_379(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_389(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 7)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_380() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_390() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48113,13 +48445,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_380, OnFailureCallback_380)); + this, OnSuccessCallback_390, OnFailureCallback_390)); return CHIP_NO_ERROR; } - void OnFailureResponse_380(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_390(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_380(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_390(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -48127,7 +48459,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_381() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_391() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48138,19 +48470,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_381, OnFailureCallback_381)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_391, OnFailureCallback_391)); return CHIP_NO_ERROR; } - void OnFailureResponse_381(EmberAfStatus status) + void OnFailureResponse_391(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_381() { ThrowSuccessResponse(); } + void OnSuccessResponse_391() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_382() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_392() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48161,19 +48493,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_382, OnFailureCallback_382)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_392, OnFailureCallback_392)); return CHIP_NO_ERROR; } - void OnFailureResponse_382(EmberAfStatus status) + void OnFailureResponse_392(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_382() { ThrowSuccessResponse(); } + void OnSuccessResponse_392() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_383() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_393() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48184,19 +48516,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_383, OnFailureCallback_383)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_393, OnFailureCallback_393)); return CHIP_NO_ERROR; } - void OnFailureResponse_383(EmberAfStatus status) + void OnFailureResponse_393(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_383() { ThrowSuccessResponse(); } + void OnSuccessResponse_393() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_384() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_394() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48207,19 +48539,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_394, OnFailureCallback_394)); return CHIP_NO_ERROR; } - void OnFailureResponse_384(EmberAfStatus status) + void OnFailureResponse_394(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_384() { ThrowSuccessResponse(); } + void OnSuccessResponse_394() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_385() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_395() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48227,13 +48559,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_385, OnFailureCallback_385)); + this, OnSuccessCallback_395, OnFailureCallback_395)); return CHIP_NO_ERROR; } - void OnFailureResponse_385(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_395(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_385(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_395(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -48241,7 +48573,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_386() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_396() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48252,15 +48584,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_386, OnFailureCallback_386)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); return CHIP_NO_ERROR; } - void OnFailureResponse_386(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_396(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_386() { NextTest(); } + void OnSuccessResponse_396() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_387() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_397() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48268,13 +48600,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_387, OnFailureCallback_387)); + this, OnSuccessCallback_397, OnFailureCallback_397)); return CHIP_NO_ERROR; } - void OnFailureResponse_387(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_397(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_387(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_397(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 20)); @@ -48282,7 +48614,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_388() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_398() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48293,15 +48625,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_398, OnFailureCallback_398)); return CHIP_NO_ERROR; } - void OnFailureResponse_388(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_398(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_388() { NextTest(); } + void OnSuccessResponse_398() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_389() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_399() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48309,13 +48641,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_389, OnFailureCallback_389)); + this, OnSuccessCallback_399, OnFailureCallback_399)); return CHIP_NO_ERROR; } - void OnFailureResponse_389(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_399(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_389(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_399(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 100)); @@ -48323,7 +48655,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_390() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_400() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48334,15 +48666,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_390, OnFailureCallback_390)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); return CHIP_NO_ERROR; } - void OnFailureResponse_390(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_400(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_390() { NextTest(); } + void OnSuccessResponse_400() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_391() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_401() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48350,13 +48682,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_391, OnFailureCallback_391)); + this, OnSuccessCallback_401, OnFailureCallback_401)); return CHIP_NO_ERROR; } - void OnFailureResponse_391(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_401(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_391(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_401(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 50)); @@ -48364,7 +48696,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_392() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_402() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48375,15 +48707,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_392, OnFailureCallback_392)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); return CHIP_NO_ERROR; } - void OnFailureResponse_392(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_402(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_392() { NextTest(); } + void OnSuccessResponse_402() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_393() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_403() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48391,20 +48723,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_393, OnFailureCallback_393)); + this, OnSuccessCallback_403, OnFailureCallback_403)); return CHIP_NO_ERROR; } - void OnFailureResponse_393(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_403(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_393(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_403(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_394() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_404() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48412,13 +48744,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_394, OnFailureCallback_394)); + this, OnSuccessCallback_404, OnFailureCallback_404)); return CHIP_NO_ERROR; } - void OnFailureResponse_394(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_404(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_394(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_404(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -48426,7 +48758,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_395() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_405() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48437,19 +48769,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_395, OnFailureCallback_395)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_405, OnFailureCallback_405)); return CHIP_NO_ERROR; } - void OnFailureResponse_395(EmberAfStatus status) + void OnFailureResponse_405(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_395() { ThrowSuccessResponse(); } + void OnSuccessResponse_405() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_396() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_406() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48460,19 +48792,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_406, OnFailureCallback_406)); return CHIP_NO_ERROR; } - void OnFailureResponse_396(EmberAfStatus status) + void OnFailureResponse_406(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_396() { ThrowSuccessResponse(); } + void OnSuccessResponse_406() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_397() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_407() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48483,19 +48815,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_397, OnFailureCallback_397)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_407, OnFailureCallback_407)); return CHIP_NO_ERROR; } - void OnFailureResponse_397(EmberAfStatus status) + void OnFailureResponse_407(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_397() { ThrowSuccessResponse(); } + void OnSuccessResponse_407() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_398() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_408() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48506,19 +48838,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_398, OnFailureCallback_398)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_408, OnFailureCallback_408)); return CHIP_NO_ERROR; } - void OnFailureResponse_398(EmberAfStatus status) + void OnFailureResponse_408(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_398() { ThrowSuccessResponse(); } + void OnSuccessResponse_408() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_399() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_409() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48526,13 +48858,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_399, OnFailureCallback_399)); + this, OnSuccessCallback_409, OnFailureCallback_409)); return CHIP_NO_ERROR; } - void OnFailureResponse_399(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_409(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_399(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_409(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -48540,7 +48872,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_400() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_410() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48551,15 +48883,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_410, OnFailureCallback_410)); return CHIP_NO_ERROR; } - void OnFailureResponse_400(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_410(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_400() { NextTest(); } + void OnSuccessResponse_410() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_401() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_411() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48567,13 +48899,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_401, OnFailureCallback_401)); + this, OnSuccessCallback_411, OnFailureCallback_411)); return CHIP_NO_ERROR; } - void OnFailureResponse_401(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_411(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_401(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_411(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 100U)); @@ -48581,7 +48913,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_402() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_412() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48592,15 +48924,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_412, OnFailureCallback_412)); return CHIP_NO_ERROR; } - void OnFailureResponse_402(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_412(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_402() { NextTest(); } + void OnSuccessResponse_412() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_403() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_413() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48608,13 +48940,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_403, OnFailureCallback_403)); + this, OnSuccessCallback_413, OnFailureCallback_413)); return CHIP_NO_ERROR; } - void OnFailureResponse_403(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_413(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_403(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_413(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 1000U)); @@ -48622,7 +48954,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_404() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_414() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48633,15 +48965,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_404, OnFailureCallback_404)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_414, OnFailureCallback_414)); return CHIP_NO_ERROR; } - void OnFailureResponse_404(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_414(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_404() { NextTest(); } + void OnSuccessResponse_414() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_405() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_415() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48649,13 +48981,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_405, OnFailureCallback_405)); + this, OnSuccessCallback_415, OnFailureCallback_415)); return CHIP_NO_ERROR; } - void OnFailureResponse_405(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_415(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_405(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_415(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 500U)); @@ -48663,7 +48995,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_406() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_416() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48674,15 +49006,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_406, OnFailureCallback_406)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_416, OnFailureCallback_416)); return CHIP_NO_ERROR; } - void OnFailureResponse_406(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_416(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_406() { NextTest(); } + void OnSuccessResponse_416() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_407() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_417() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48690,20 +49022,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_407, OnFailureCallback_407)); + this, OnSuccessCallback_417, OnFailureCallback_417)); return CHIP_NO_ERROR; } - void OnFailureResponse_407(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_417(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_407(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_417(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_408() + CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_418() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48711,13 +49043,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_408, OnFailureCallback_408)); + this, OnSuccessCallback_418, OnFailureCallback_418)); return CHIP_NO_ERROR; } - void OnFailureResponse_408(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_418(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_408(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_418(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 0)); @@ -48725,7 +49057,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_409() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_419() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48736,19 +49068,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_409, OnFailureCallback_409)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_419, OnFailureCallback_419)); return CHIP_NO_ERROR; } - void OnFailureResponse_409(EmberAfStatus status) + void OnFailureResponse_419(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_409() { ThrowSuccessResponse(); } + void OnSuccessResponse_419() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_410() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_420() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48759,19 +49091,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_410, OnFailureCallback_410)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_420, OnFailureCallback_420)); return CHIP_NO_ERROR; } - void OnFailureResponse_410(EmberAfStatus status) + void OnFailureResponse_420(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_410() { ThrowSuccessResponse(); } + void OnSuccessResponse_420() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_411() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_421() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48782,19 +49114,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_411, OnFailureCallback_411)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_421, OnFailureCallback_421)); return CHIP_NO_ERROR; } - void OnFailureResponse_411(EmberAfStatus status) + void OnFailureResponse_421(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_411() { ThrowSuccessResponse(); } + void OnSuccessResponse_421() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_412() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_422() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48805,19 +49137,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_412, OnFailureCallback_412)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_422, OnFailureCallback_422)); return CHIP_NO_ERROR; } - void OnFailureResponse_412(EmberAfStatus status) + void OnFailureResponse_422(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_412() { ThrowSuccessResponse(); } + void OnSuccessResponse_422() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_413() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_423() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48825,13 +49157,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_413, OnFailureCallback_413)); + this, OnSuccessCallback_423, OnFailureCallback_423)); return CHIP_NO_ERROR; } - void OnFailureResponse_413(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_423(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_413(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_423(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 0)); @@ -48839,7 +49171,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_414() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_424() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48850,15 +49182,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_414, OnFailureCallback_414)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_424, OnFailureCallback_424)); return CHIP_NO_ERROR; } - void OnFailureResponse_414(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_424(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_414() { NextTest(); } + void OnSuccessResponse_424() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_415() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_425() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48866,13 +49198,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_415, OnFailureCallback_415)); + this, OnSuccessCallback_425, OnFailureCallback_425)); return CHIP_NO_ERROR; } - void OnFailureResponse_415(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_425(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_415(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_425(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), -40)); @@ -48880,7 +49212,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_416() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_426() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48891,15 +49223,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_416, OnFailureCallback_416)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_426, OnFailureCallback_426)); return CHIP_NO_ERROR; } - void OnFailureResponse_416(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_426(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_416() { NextTest(); } + void OnSuccessResponse_426() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_417() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_427() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48907,13 +49239,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_417, OnFailureCallback_417)); + this, OnSuccessCallback_427, OnFailureCallback_427)); return CHIP_NO_ERROR; } - void OnFailureResponse_417(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_427(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_417(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_427(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 50)); @@ -48921,7 +49253,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_418() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_428() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48932,15 +49264,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_418, OnFailureCallback_418)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_428, OnFailureCallback_428)); return CHIP_NO_ERROR; } - void OnFailureResponse_418(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_428(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_418() { NextTest(); } + void OnSuccessResponse_428() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_419() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_429() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48948,13 +49280,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_419, OnFailureCallback_419)); + this, OnSuccessCallback_429, OnFailureCallback_429)); return CHIP_NO_ERROR; } - void OnFailureResponse_419(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_429(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_419(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_429(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 6)); @@ -48962,7 +49294,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_420() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_430() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48973,15 +49305,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_420, OnFailureCallback_420)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_430, OnFailureCallback_430)); return CHIP_NO_ERROR; } - void OnFailureResponse_420(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_430(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_420() { NextTest(); } + void OnSuccessResponse_430() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_421() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_431() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48989,20 +49321,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_421, OnFailureCallback_421)); + this, OnSuccessCallback_431, OnFailureCallback_431)); return CHIP_NO_ERROR; } - void OnFailureResponse_421(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_431(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_421(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_431(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_422() + CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_432() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49010,13 +49342,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_422, OnFailureCallback_422)); + this, OnSuccessCallback_432, OnFailureCallback_432)); return CHIP_NO_ERROR; } - void OnFailureResponse_422(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_432(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_422(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_432(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 0)); @@ -49024,7 +49356,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_423() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_433() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49035,19 +49367,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_423, OnFailureCallback_423)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_433, OnFailureCallback_433)); return CHIP_NO_ERROR; } - void OnFailureResponse_423(EmberAfStatus status) + void OnFailureResponse_433(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_423() { ThrowSuccessResponse(); } + void OnSuccessResponse_433() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_424() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_434() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49058,19 +49390,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_424, OnFailureCallback_424)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_434, OnFailureCallback_434)); return CHIP_NO_ERROR; } - void OnFailureResponse_424(EmberAfStatus status) + void OnFailureResponse_434(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_424() { ThrowSuccessResponse(); } + void OnSuccessResponse_434() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_425() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_435() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49081,19 +49413,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_425, OnFailureCallback_425)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_435, OnFailureCallback_435)); return CHIP_NO_ERROR; } - void OnFailureResponse_425(EmberAfStatus status) + void OnFailureResponse_435(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_425() { ThrowSuccessResponse(); } + void OnSuccessResponse_435() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_426() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_436() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49104,19 +49436,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_426, OnFailureCallback_426)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_436, OnFailureCallback_436)); return CHIP_NO_ERROR; } - void OnFailureResponse_426(EmberAfStatus status) + void OnFailureResponse_436(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_426() { ThrowSuccessResponse(); } + void OnSuccessResponse_436() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_427() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_437() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49124,13 +49456,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_427, OnFailureCallback_427)); + this, OnSuccessCallback_437, OnFailureCallback_437)); return CHIP_NO_ERROR; } - void OnFailureResponse_427(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_437(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_427(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_437(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 0)); @@ -49138,7 +49470,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_428() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_438() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49149,15 +49481,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_428, OnFailureCallback_428)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_438, OnFailureCallback_438)); return CHIP_NO_ERROR; } - void OnFailureResponse_428(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_438(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_428() { NextTest(); } + void OnSuccessResponse_438() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_429() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_439() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49165,13 +49497,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_429, OnFailureCallback_429)); + this, OnSuccessCallback_439, OnFailureCallback_439)); return CHIP_NO_ERROR; } - void OnFailureResponse_429(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_439(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_429(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_439(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), -150)); @@ -49179,7 +49511,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_430() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_440() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49190,15 +49522,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_430, OnFailureCallback_430)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_440, OnFailureCallback_440)); return CHIP_NO_ERROR; } - void OnFailureResponse_430(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_440(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_430() { NextTest(); } + void OnSuccessResponse_440() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_431() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_441() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49206,13 +49538,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_431, OnFailureCallback_431)); + this, OnSuccessCallback_441, OnFailureCallback_441)); return CHIP_NO_ERROR; } - void OnFailureResponse_431(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_441(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_431(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_441(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 200)); @@ -49220,7 +49552,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_432() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_442() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49231,15 +49563,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_432, OnFailureCallback_432)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_442, OnFailureCallback_442)); return CHIP_NO_ERROR; } - void OnFailureResponse_432(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_442(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_432() { NextTest(); } + void OnSuccessResponse_442() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_433() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_443() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49247,13 +49579,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_433, OnFailureCallback_433)); + this, OnSuccessCallback_443, OnFailureCallback_443)); return CHIP_NO_ERROR; } - void OnFailureResponse_433(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_443(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_433(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_443(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 7)); @@ -49261,7 +49593,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_434() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_444() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49272,15 +49604,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_434, OnFailureCallback_434)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_444, OnFailureCallback_444)); return CHIP_NO_ERROR; } - void OnFailureResponse_434(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_444(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_434() { NextTest(); } + void OnSuccessResponse_444() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_435() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_445() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49288,13 +49620,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_435, OnFailureCallback_435)); + this, OnSuccessCallback_445, OnFailureCallback_445)); return CHIP_NO_ERROR; } - void OnFailureResponse_435(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_445(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_435(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_445(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s));