From 10706485329d300460931928806b241d1b7a26e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonathan=20M=C3=A9gevand?= <77852424+jmeg-sfy@users.noreply.github.com> Date: Wed, 15 Dec 2021 21:54:09 +0100 Subject: [PATCH] YAML : Constraints with nullable types fixed for Min, Max & NotValue (#12958) * Fix: Constraintswith nullable type fixed for Min Max NotValue * Restyled by clang-format * DEV: Add constraint checks on nullable * DEV: Update darwin test_cluster.zapt * Restyled by prettier-yaml * Darwin compile remove large integer u64x tests Co-authored-by: Restyled.io --- .../chip-tool/commands/tests/TestCommand.h | 27 + .../templates/partials/test_cluster.zapt | 4 +- src/app/tests/suites/TestCluster.yaml | 302 +- .../CHIP/templates/partials/test_cluster.zapt | 12 +- .../Framework/CHIPTests/CHIPClustersTests.m | 1722 +++++-- .../chip-tool/zap-generated/test/Commands.h | 4348 ++++++++++------- 6 files changed, 4394 insertions(+), 2021 deletions(-) diff --git a/examples/chip-tool/commands/tests/TestCommand.h b/examples/chip-tool/commands/tests/TestCommand.h index c314699e0e7a59..81fbe3a0159d4a 100644 --- a/examples/chip-tool/commands/tests/TestCommand.h +++ b/examples/chip-tool/commands/tests/TestCommand.h @@ -92,6 +92,15 @@ class TestCommand : public CHIPCommand return true; } + template + bool CheckConstraintMinValue(const char * itemName, const chip::app::DataModel::Nullable & current, U expected) + { + if (current.IsNull()) + { + return true; + } + return CheckConstraintMinValue(itemName, current.Value(), static_cast(expected)); + } template bool CheckConstraintMaxValue(const char * itemName, T current, T expected) { @@ -104,6 +113,15 @@ class TestCommand : public CHIPCommand return true; } template + bool CheckConstraintMaxValue(const char * itemName, const chip::app::DataModel::Nullable & current, U expected) + { + if (current.IsNull()) + { + return true; + } + return CheckConstraintMaxValue(itemName, current.Value(), static_cast(expected)); + } + template bool CheckConstraintNotValue(const char * itemName, T current, U expected) { if (current == expected) @@ -114,6 +132,15 @@ class TestCommand : public CHIPCommand return true; } + template + bool CheckConstraintNotValue(const char * itemName, const chip::app::DataModel::Nullable & current, U expected) + { + if (current.IsNull()) + { + return true; + } + return CheckConstraintNotValue(itemName, current.Value(), expected); + } bool CheckConstraintNotValue(const char * itemName, chip::CharSpan current, chip::CharSpan expected) { diff --git a/examples/chip-tool/templates/partials/test_cluster.zapt b/examples/chip-tool/templates/partials/test_cluster.zapt index 3c8d0b95baae03..8b04d912df3cb8 100644 --- a/examples/chip-tool/templates/partials/test_cluster.zapt +++ b/examples/chip-tool/templates/partials/test_cluster.zapt @@ -318,8 +318,8 @@ class {{filename}}: public TestCommand {{~#if expectedConstraints.endsWith}}VerifyOrReturn(CheckConstraintEndsWith("{{>item}}", {{>item}}, "{{expectedConstraints.endsWith}}"));{{/if}} {{~#if expectedConstraints.minLength}}VerifyOrReturn(CheckConstraintMinLength("{{>item}}", {{>item}}.size(), {{expectedConstraints.minLength}}));{{/if}} {{~#if expectedConstraints.maxLength}}VerifyOrReturn(CheckConstraintMaxLength("{{>item}}", {{>item}}.size(), {{expectedConstraints.maxLength}}));{{/if}} - {{~#if expectedConstraints.minValue}}VerifyOrReturn(CheckConstraintMinValue<{{chipType}}>("{{>item}}", {{>item}}, {{expectedConstraints.minValue}}));{{/if}} - {{~#if expectedConstraints.maxValue}}VerifyOrReturn(CheckConstraintMaxValue<{{chipType}}>("{{>item}}", {{>item}}, {{expectedConstraints.maxValue}}));{{/if}} + {{~#if expectedConstraints.minValue}}VerifyOrReturn(CheckConstraintMinValue<{{chipType}}>("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.minValue type}}));{{/if}} + {{~#if expectedConstraints.maxValue}}VerifyOrReturn(CheckConstraintMaxValue<{{chipType}}>("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.maxValue type}}));{{/if}} {{~#if expectedConstraints.notValue}}VerifyOrReturn(CheckConstraintNotValue("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.notValue type}}));{{/if}} {{/if}} diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml index a16cb7dfb01167..22486acfd425db 100644 --- a/src/app/tests/suites/TestCluster.yaml +++ b/src/app/tests/suites/TestCluster.yaml @@ -1743,7 +1743,7 @@ tests: response: value: null - # Tests for UInt8 attribute + # Tests for nullable UInt8 attribute - label: "Write attribute NULLABLE_INT8U Max Value" command: "writeAttribute" @@ -1783,7 +1783,43 @@ tests: response: value: null - # Tests for UInt16 attribute + - label: "Read attribute NULLABLE_INT8U null Value & range" + command: "readAttribute" + attribute: "nullable_int8u" + response: + constraints: + minValue: 0 + maxValue: 254 + + - label: "Read attribute NULLABLE_INT8U null Value & not" + command: "readAttribute" + attribute: "nullable_int8u" + response: + constraints: + notValue: 254 + + - label: "Write attribute NULLABLE_INT8U Value" + command: "writeAttribute" + attribute: "nullable_int8u" + arguments: + value: 128 + + - label: "Read attribute NULLABLE_INT8U Value in range" + command: "readAttribute" + attribute: "nullable_int8u" + response: + constraints: + minValue: 0 + maxValue: 254 + + - label: "Read attribute NULLABLE_INT8U notValue OK" + command: "readAttribute" + attribute: "nullable_int8u" + response: + constraints: + notValue: 129 + + # Tests for nullable UInt16 attribute - label: "Write attribute NULLABLE_INT16U Max Value" command: "writeAttribute" @@ -1823,7 +1859,43 @@ tests: response: value: null - # Tests for UInt32 attribute + - label: "Read attribute NULLABLE_INT16U null Value & range" + command: "readAttribute" + attribute: "nullable_int16u" + response: + constraints: + minValue: 0 + maxValue: 65534 + + - label: "Read attribute NULLABLE_INT16U null Value & not" + command: "readAttribute" + attribute: "nullable_int16u" + response: + constraints: + notValue: 65534 + + - label: "Write attribute NULLABLE_INT16U Value" + command: "writeAttribute" + attribute: "nullable_int16u" + arguments: + value: 32000 + + - label: "Read attribute NULLABLE_INT16U Value in range" + command: "readAttribute" + attribute: "nullable_int16u" + response: + constraints: + minValue: 0 + maxValue: 65534 + + - label: "Read attribute NULLABLE_INT16U notValue OK" + command: "readAttribute" + attribute: "nullable_int16u" + response: + constraints: + notValue: 32001 + + # Tests for nullable UInt32 attribute - label: "Write attribute NULLABLE_INT32U Max Value" command: "writeAttribute" @@ -1863,7 +1935,43 @@ tests: response: value: null - # Tests for UInt64 attribute + - label: "Read attribute NULLABLE_INT32U null Value & range" + command: "readAttribute" + attribute: "nullable_int32u" + response: + constraints: + minValue: 0 + maxValue: 4294967294 + + - label: "Read attribute NULLABLE_INT32U null Value & not" + command: "readAttribute" + attribute: "nullable_int32u" + response: + constraints: + notValue: 4294967294 + + - label: "Write attribute NULLABLE_INT32U Value" + command: "writeAttribute" + attribute: "nullable_int32u" + arguments: + value: 2147483647 + + - label: "Read attribute NULLABLE_INT32U Value in range" + command: "readAttribute" + attribute: "nullable_int32u" + response: + constraints: + minValue: 0 + maxValue: 4294967294 + + - label: "Read attribute NULLABLE_INT32U notValue OK" + command: "readAttribute" + attribute: "nullable_int32u" + response: + constraints: + notValue: 2147483648 + + # Tests for nullable UInt64 attribute - label: "Write attribute NULLABLE_INT64U Max Value" command: "writeAttribute" @@ -1903,7 +2011,44 @@ tests: response: value: null - # Tests for Int8 attribute + # 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" + + # Tests for nullable Int8 attribute - label: "Write attribute NULLABLE_INT8S Min Value" command: "writeAttribute" @@ -1943,7 +2088,43 @@ tests: response: value: null - # Tests for Int16 attribute + - label: "Read attribute NULLABLE_INT8S null Value & range" + command: "readAttribute" + attribute: "nullable_int8s" + response: + constraints: + minValue: -127 + maxValue: 127 + + - label: "Read attribute NULLABLE_INT8S null Value & not" + command: "readAttribute" + attribute: "nullable_int8s" + response: + constraints: + notValue: -127 + + - label: "Write attribute NULLABLE_INT8S Value" + command: "writeAttribute" + attribute: "nullable_int8s" + arguments: + value: -127 + + - label: "Read attribute NULLABLE_INT8S Value in range" + command: "readAttribute" + attribute: "nullable_int8s" + response: + constraints: + minValue: -127 + maxValue: 127 + + - label: "Read attribute NULLABLE_INT8S notValue OK" + command: "readAttribute" + attribute: "nullable_int8s" + response: + constraints: + notValue: -126 + + # Tests for nullable Int16 attribute - label: "Write attribute NULLABLE_INT16S Min Value" command: "writeAttribute" @@ -1983,6 +2164,42 @@ tests: response: value: null + - label: "Read attribute NULLABLE_INT16S null Value & range" + command: "readAttribute" + attribute: "nullable_int16s" + response: + constraints: + minValue: -32767 + maxValue: 32767 + + - label: "Read attribute NULLABLE_INT16S null Value & not" + command: "readAttribute" + attribute: "nullable_int16s" + response: + constraints: + notValue: -32767 + + - label: "Write attribute NULLABLE_INT16S Value" + command: "writeAttribute" + attribute: "nullable_int16s" + arguments: + value: -32767 + + - label: "Read attribute NULLABLE_INT16S Value in range" + command: "readAttribute" + attribute: "nullable_int16s" + response: + constraints: + minValue: -32767 + maxValue: 32767 + + - label: "Read attribute NULLABLE_INT16S notValue OK" + command: "readAttribute" + attribute: "nullable_int16s" + response: + constraints: + notValue: -32766 + # Tests for Int32 attribute - label: "Write attribute NULLABLE_INT32S Min Value" @@ -2023,6 +2240,42 @@ tests: response: value: null + - label: "Read attribute NULLABLE_INT32S null Value & range" + command: "readAttribute" + attribute: "nullable_int32s" + response: + constraints: + minValue: -2147483647 + maxValue: 2147483647 + + - label: "Read attribute NULLABLE_INT32S null Value & not" + command: "readAttribute" + attribute: "nullable_int32s" + response: + constraints: + notValue: -2147483647 + + - label: "Write attribute NULLABLE_INT32S Value" + command: "writeAttribute" + attribute: "nullable_int32s" + arguments: + value: -2147483647 + + - label: "Read attribute NULLABLE_INT32S Value in range" + command: "readAttribute" + attribute: "nullable_int32s" + response: + constraints: + minValue: -2147483647 + maxValue: 2147483647 + + - label: "Read attribute NULLABLE_INT32S notValue OK" + command: "readAttribute" + attribute: "nullable_int32s" + response: + constraints: + notValue: -2147483646 + # Tests for Int64 attribute - label: "Write attribute NULLABLE_INT64S Min Value" @@ -2066,6 +2319,43 @@ 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" + # Tests for float attribute - label: "Write attribute NULLABLE_SINGLE medium Value" diff --git a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt index 22546e86d60d4b..9e66246521cd56 100644 --- a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt @@ -135,19 +135,25 @@ ResponseHandler {{> subscribeDataCallback}} = nil; {{#if expectedConstraints.minValue}} { {{> actualValue}} - XCTAssertGreaterThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.minValue}}); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.minValue}}); + } } {{/if}} {{#if expectedConstraints.maxValue}} { {{> actualValue}} - XCTAssertLessThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.maxValue}}); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.maxValue}}); + } } {{/if}} {{#if expectedConstraints.notValue}} { {{> actualValue}} - XCTAssertNotEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.notValue}}); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{expectedConstraints.notValue}}); + } } {{/if}} {{/if}} diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 18b3d6cee6d0f6..59a195869c5013 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -530,7 +530,9 @@ - (void)testSendClusterTest_TC_BI_2_1_000009_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 15); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 15); + } } [expectation fulfill]; @@ -1085,7 +1087,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000002_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 254); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 254); + } } [expectation fulfill]; @@ -1179,7 +1183,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000006_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 254); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 254); + } } [expectation fulfill]; @@ -1274,7 +1280,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000010_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -1367,7 +1375,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000014_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -1438,7 +1448,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000017_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -1462,7 +1474,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000018_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 2); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 2); + } } [expectation fulfill]; @@ -2168,7 +2182,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000049_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -2264,7 +2280,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000053_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -2364,7 +2382,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000057_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -2513,7 +2533,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000063_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -2612,7 +2634,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000067_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 254); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 254); + } } [expectation fulfill]; @@ -2683,7 +2707,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000070_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 4); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 4); + } } [expectation fulfill]; @@ -2778,7 +2804,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000074_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 6); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 6); + } } [expectation fulfill]; @@ -2848,7 +2876,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000077_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -2917,7 +2947,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000080_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3005,7 +3037,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000084_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3074,7 +3108,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000087_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3162,7 +3198,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000091_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3231,7 +3269,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000094_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3319,7 +3359,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000098_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3388,7 +3430,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000101_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3476,7 +3520,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000105_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3545,7 +3591,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000108_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3633,7 +3681,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000112_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3702,7 +3752,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000115_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3790,7 +3842,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000119_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3860,7 +3914,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000122_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -3930,7 +3986,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000125_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -4000,7 +4058,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000128_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -4089,7 +4149,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000132_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -4159,7 +4221,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000135_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -4248,7 +4312,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000139_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -4318,7 +4384,9 @@ - (void)testSendClusterTest_TC_CC_2_1_000142_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65279); + } } [expectation fulfill]; @@ -10586,7 +10654,9 @@ - (void)testSendClusterTest_TC_LVL_3_1_000014_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], 255); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 255); + } } [expectation fulfill]; @@ -11230,7 +11300,9 @@ - (void)testSendClusterTest_TC_OCC_2_1_000001_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 1); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 1); + } } [expectation fulfill]; @@ -11301,7 +11373,9 @@ - (void)testSendClusterTest_TC_OCC_2_1_000004_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 3); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 3); + } } [expectation fulfill]; @@ -11375,11 +11449,15 @@ - (void)testSendClusterTest_TC_OCC_2_1_000007_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 1); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 1); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 7); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 7); + } } [expectation fulfill]; @@ -14057,7 +14135,9 @@ - (void)testSendClusterTest_TC_RH_2_1_000002_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 9999); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 9999); + } } [expectation fulfill]; @@ -14446,11 +14526,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000003_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + } } [expectation fulfill]; @@ -14550,11 +14634,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000007_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + } } [expectation fulfill]; @@ -14654,11 +14742,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000011_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + } } [expectation fulfill]; @@ -14758,11 +14850,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000015_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + } } [expectation fulfill]; @@ -14862,11 +14958,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000019_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 2600); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 2600); + } } [expectation fulfill]; @@ -14966,11 +15066,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000023_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 2600); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 2600); + } } [expectation fulfill]; @@ -15070,11 +15174,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000027_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + } } [expectation fulfill]; @@ -15174,11 +15282,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000031_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 700); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3000); + } } [expectation fulfill]; @@ -15278,11 +15390,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000035_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + } } [expectation fulfill]; @@ -15382,11 +15498,15 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000039_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], 1600); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 3200); + } } [expectation fulfill]; @@ -15486,7 +15606,9 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000043_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 5); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 5); + } } [expectation fulfill]; @@ -15586,7 +15708,9 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000047_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 9); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 9); + } } [expectation fulfill]; @@ -15683,7 +15807,9 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000051_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue charValue], 25); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue charValue], 25); + } } [expectation fulfill]; @@ -15758,7 +15884,9 @@ - (void)testSendClusterTest_TC_TSTAT_2_1_000054_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 6); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 6); + } } [expectation fulfill]; @@ -17913,11 +18041,15 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000001_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue unsignedShortValue], 5); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue unsignedShortValue], 5); + } } { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 200); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 200); + } } [expectation fulfill]; @@ -17964,7 +18096,9 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000003_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], 201); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 201); + } } [expectation fulfill]; @@ -17988,7 +18122,9 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000004_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 32768); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 32768); + } } [expectation fulfill]; @@ -18034,7 +18170,9 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000006_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedIntValue], 32769); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedIntValue], 32769); + } } [expectation fulfill]; @@ -18067,7 +18205,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000001_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 9); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 9); + } } [expectation fulfill]; @@ -18112,7 +18252,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000003_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], 250); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 250); + } } [expectation fulfill]; @@ -18136,7 +18278,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000004_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 63); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 63); + } } [expectation fulfill]; @@ -18182,7 +18326,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000006_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], 128); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 128); + } } [expectation fulfill]; @@ -18207,7 +18353,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000007_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 63); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 63); + } } [expectation fulfill]; @@ -18255,7 +18403,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000009_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], 128); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 128); + } } [expectation fulfill]; @@ -18280,7 +18430,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000010_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 23); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 23); + } } [expectation fulfill]; @@ -18328,7 +18480,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000012_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], 250); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 250); + } } [expectation fulfill]; @@ -18352,7 +18506,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000013_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 15); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 15); + } } [expectation fulfill]; @@ -18424,7 +18580,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000016_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + } } [expectation fulfill]; @@ -18475,7 +18633,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000018_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + } } [expectation fulfill]; @@ -18501,7 +18661,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000019_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + } } [expectation fulfill]; @@ -18552,7 +18714,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000021_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + } } [expectation fulfill]; @@ -18578,7 +18742,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000022_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + } } [expectation fulfill]; @@ -18629,7 +18795,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000024_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + } } [expectation fulfill]; @@ -18655,7 +18823,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000025_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 10000); + } } [expectation fulfill]; @@ -18706,7 +18876,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000027_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 20000); + } } [expectation fulfill]; @@ -18731,7 +18903,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000028_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -18781,7 +18955,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000030_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -18806,7 +18982,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000031_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -18856,7 +19034,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000033_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -18881,7 +19061,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000034_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -18931,7 +19113,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000036_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -18956,7 +19140,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000037_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -19006,7 +19192,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000039_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -19030,7 +19218,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000040_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 2047); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 2047); + } } [expectation fulfill]; @@ -19076,7 +19266,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000042_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], 4096); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 4096); + } } [expectation fulfill]; @@ -19101,7 +19293,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000043_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -19150,7 +19344,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000045_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -19175,7 +19371,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000046_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -19224,7 +19422,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000048_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65535); + } } [expectation fulfill]; @@ -19250,7 +19450,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000049_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 100); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 100); + } } [expectation fulfill]; @@ -19301,7 +19503,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000051_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], 200); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 200); + } } [expectation fulfill]; @@ -19327,7 +19531,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000052_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 100); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 100); + } } [expectation fulfill]; @@ -19378,7 +19584,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000054_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], 200); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 200); + } } [expectation fulfill]; @@ -19444,7 +19652,9 @@ - (void)testSendClusterTest_TC_WNCV_2_4_000002_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 9); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 9); + } } [expectation fulfill]; @@ -19501,7 +19711,9 @@ - (void)testSendClusterTest_TC_WNCV_2_5_000002_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 23); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 23); + } } [expectation fulfill]; @@ -25161,7 +25373,133 @@ - (void)testSendClusterTestCluster_000205_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000206_WriteAttribute +- (void)testSendClusterTestCluster_000206_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U 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 readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8U null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 254); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000207_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U 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 readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8U null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 254); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000208_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U 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 nullableInt8uArgument; + nullableInt8uArgument = [NSNumber numberWithUnsignedChar:128]; + [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8U Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000209_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U 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 readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8U Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedCharValue], 254); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000210_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U 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 readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8U notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], 129); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000211_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Max Value"]; @@ -25183,7 +25521,7 @@ - (void)testSendClusterTestCluster_000206_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000207_ReadAttribute +- (void)testSendClusterTestCluster_000212_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Max Value"]; @@ -25208,7 +25546,7 @@ - (void)testSendClusterTestCluster_000207_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000208_WriteAttribute +- (void)testSendClusterTestCluster_000213_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Invalid Value"]; @@ -25230,7 +25568,7 @@ - (void)testSendClusterTestCluster_000208_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000209_ReadAttribute +- (void)testSendClusterTestCluster_000214_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U unchanged Value"]; @@ -25255,7 +25593,7 @@ - (void)testSendClusterTestCluster_000209_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000210_WriteAttribute +- (void)testSendClusterTestCluster_000215_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U null Value"]; @@ -25277,7 +25615,7 @@ - (void)testSendClusterTestCluster_000210_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000211_ReadAttribute +- (void)testSendClusterTestCluster_000216_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value"]; @@ -25301,7 +25639,133 @@ - (void)testSendClusterTestCluster_000211_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000212_WriteAttribute +- (void)testSendClusterTestCluster_000217_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U 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 readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16U null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65534); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000218_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U 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 readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16U null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 65534); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000219_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U 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 nullableInt16uArgument; + nullableInt16uArgument = [NSNumber numberWithUnsignedShort:32000U]; + [cluster writeAttributeNullableInt16uWithValue:nullableInt16uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT16U Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000220_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U 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 readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16U Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedShortValue], 65534); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000221_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U 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 readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16U notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], 32001); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000222_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Max Value"]; @@ -25323,7 +25787,7 @@ - (void)testSendClusterTestCluster_000212_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000213_ReadAttribute +- (void)testSendClusterTestCluster_000223_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Max Value"]; @@ -25348,7 +25812,7 @@ - (void)testSendClusterTestCluster_000213_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000214_WriteAttribute +- (void)testSendClusterTestCluster_000224_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Invalid Value"]; @@ -25370,7 +25834,7 @@ - (void)testSendClusterTestCluster_000214_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000215_ReadAttribute +- (void)testSendClusterTestCluster_000225_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U unchanged Value"]; @@ -25395,7 +25859,7 @@ - (void)testSendClusterTestCluster_000215_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000216_WriteAttribute +- (void)testSendClusterTestCluster_000226_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U null Value"]; @@ -25417,7 +25881,7 @@ - (void)testSendClusterTestCluster_000216_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000217_ReadAttribute +- (void)testSendClusterTestCluster_000227_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value"]; @@ -25441,7 +25905,133 @@ - (void)testSendClusterTestCluster_000217_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000218_WriteAttribute +- (void)testSendClusterTestCluster_000228_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U 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 readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32U null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 4294967294); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000229_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U 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 readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32U null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedIntValue], 4294967294); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000230_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U 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 nullableInt32uArgument; + nullableInt32uArgument = [NSNumber numberWithUnsignedInt:2147483647UL]; + [cluster writeAttributeNullableInt32uWithValue:nullableInt32uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT32U Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000231_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U 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 readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32U Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 4294967294); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000232_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U 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 readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32U notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedIntValue], 2147483648); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000233_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Max Value"]; @@ -25463,7 +26053,7 @@ - (void)testSendClusterTestCluster_000218_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000219_ReadAttribute +- (void)testSendClusterTestCluster_000234_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Max Value"]; @@ -25488,7 +26078,7 @@ - (void)testSendClusterTestCluster_000219_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000220_WriteAttribute +- (void)testSendClusterTestCluster_000235_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Invalid Value"]; @@ -25510,7 +26100,7 @@ - (void)testSendClusterTestCluster_000220_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000221_ReadAttribute +- (void)testSendClusterTestCluster_000236_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U unchanged Value"]; @@ -25535,7 +26125,7 @@ - (void)testSendClusterTestCluster_000221_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000222_WriteAttribute +- (void)testSendClusterTestCluster_000237_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U null Value"]; @@ -25557,7 +26147,7 @@ - (void)testSendClusterTestCluster_000222_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000223_ReadAttribute +- (void)testSendClusterTestCluster_000238_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value"]; @@ -25581,7 +26171,7 @@ - (void)testSendClusterTestCluster_000223_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000224_WriteAttribute +- (void)testSendClusterTestCluster_000239_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Min Value"]; @@ -25603,7 +26193,7 @@ - (void)testSendClusterTestCluster_000224_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000225_ReadAttribute +- (void)testSendClusterTestCluster_000240_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Min Value"]; @@ -25628,7 +26218,7 @@ - (void)testSendClusterTestCluster_000225_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000226_WriteAttribute +- (void)testSendClusterTestCluster_000241_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Invalid Value"]; @@ -25649,7 +26239,7 @@ - (void)testSendClusterTestCluster_000226_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000227_ReadAttribute +- (void)testSendClusterTestCluster_000242_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S unchanged Value"]; @@ -25674,7 +26264,7 @@ - (void)testSendClusterTestCluster_000227_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000228_WriteAttribute +- (void)testSendClusterTestCluster_000243_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S null Value"]; @@ -25696,7 +26286,7 @@ - (void)testSendClusterTestCluster_000228_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000229_ReadAttribute +- (void)testSendClusterTestCluster_000244_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value"]; @@ -25720,7 +26310,145 @@ - (void)testSendClusterTestCluster_000229_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000230_WriteAttribute +- (void)testSendClusterTestCluster_000245_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S 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 readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8S null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue charValue], -127); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue charValue], 127); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000246_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S 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 readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8S null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue charValue], -127); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000247_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S 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 nullableInt8sArgument; + nullableInt8sArgument = [NSNumber numberWithChar:-127]; + [cluster writeAttributeNullableInt8sWithValue:nullableInt8sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8S Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000248_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S 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 readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8S Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue charValue], -127); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue charValue], 127); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000249_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S 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 readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8S notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue charValue], -126); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000250_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Min Value"]; @@ -25742,7 +26470,7 @@ - (void)testSendClusterTestCluster_000230_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000231_ReadAttribute +- (void)testSendClusterTestCluster_000251_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Min Value"]; @@ -25767,7 +26495,7 @@ - (void)testSendClusterTestCluster_000231_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000232_WriteAttribute +- (void)testSendClusterTestCluster_000252_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Invalid Value"]; @@ -25789,7 +26517,7 @@ - (void)testSendClusterTestCluster_000232_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000233_ReadAttribute +- (void)testSendClusterTestCluster_000253_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S unchanged Value"]; @@ -25814,7 +26542,7 @@ - (void)testSendClusterTestCluster_000233_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000234_WriteAttribute +- (void)testSendClusterTestCluster_000254_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S null Value"]; @@ -25836,7 +26564,7 @@ - (void)testSendClusterTestCluster_000234_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000235_ReadAttribute +- (void)testSendClusterTestCluster_000255_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value"]; @@ -25860,7 +26588,145 @@ - (void)testSendClusterTestCluster_000235_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000236_WriteAttribute +- (void)testSendClusterTestCluster_000256_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S 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 readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16S null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], -32767); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 32767); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000257_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S 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 readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16S null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue shortValue], -32767); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000258_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S 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 nullableInt16sArgument; + nullableInt16sArgument = [NSNumber numberWithShort:-32767]; + [cluster writeAttributeNullableInt16sWithValue:nullableInt16sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT16S Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000259_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S 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 readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16S Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue shortValue], -32767); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue shortValue], 32767); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000260_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S 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 readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16S notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue shortValue], -32766); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000261_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Min Value"]; @@ -25882,7 +26748,7 @@ - (void)testSendClusterTestCluster_000236_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000237_ReadAttribute +- (void)testSendClusterTestCluster_000262_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Min Value"]; @@ -25907,7 +26773,7 @@ - (void)testSendClusterTestCluster_000237_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000238_WriteAttribute +- (void)testSendClusterTestCluster_000263_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Invalid Value"]; @@ -25929,7 +26795,7 @@ - (void)testSendClusterTestCluster_000238_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000239_ReadAttribute +- (void)testSendClusterTestCluster_000264_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S unchanged Value"]; @@ -25954,7 +26820,7 @@ - (void)testSendClusterTestCluster_000239_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000240_WriteAttribute +- (void)testSendClusterTestCluster_000265_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S null Value"]; @@ -25976,7 +26842,7 @@ - (void)testSendClusterTestCluster_000240_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000241_ReadAttribute +- (void)testSendClusterTestCluster_000266_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value"]; @@ -26000,7 +26866,145 @@ - (void)testSendClusterTestCluster_000241_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000242_WriteAttribute +- (void)testSendClusterTestCluster_000267_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S 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 readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32S null Value & range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue intValue], -2147483647); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue intValue], 2147483647); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000268_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S 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 readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32S null Value & not Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue intValue], -2147483647); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000269_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S 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 nullableInt32sArgument; + nullableInt32sArgument = [NSNumber numberWithInt:-2147483647L]; + [cluster writeAttributeNullableInt32sWithValue:nullableInt32sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT32S Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000270_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S 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 readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32S Value in range Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue intValue], -2147483647); + } + } + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue intValue], 2147483647); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000271_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S 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 readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32S notValue OK Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + if (actualValue != nil) { + XCTAssertNotEqual([actualValue intValue], -2147483646); + } + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000272_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Min Value"]; @@ -26022,7 +27026,7 @@ - (void)testSendClusterTestCluster_000242_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000243_ReadAttribute +- (void)testSendClusterTestCluster_000273_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Min Value"]; @@ -26047,7 +27051,7 @@ - (void)testSendClusterTestCluster_000243_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000244_WriteAttribute +- (void)testSendClusterTestCluster_000274_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Invalid Value"]; @@ -26069,7 +27073,7 @@ - (void)testSendClusterTestCluster_000244_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000245_ReadAttribute +- (void)testSendClusterTestCluster_000275_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S unchanged Value"]; @@ -26094,7 +27098,7 @@ - (void)testSendClusterTestCluster_000245_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000246_WriteAttribute +- (void)testSendClusterTestCluster_000276_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S null Value"]; @@ -26116,7 +27120,7 @@ - (void)testSendClusterTestCluster_000246_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000247_ReadAttribute +- (void)testSendClusterTestCluster_000277_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value"]; @@ -26140,7 +27144,7 @@ - (void)testSendClusterTestCluster_000247_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000248_WriteAttribute +- (void)testSendClusterTestCluster_000278_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE medium Value"]; @@ -26162,7 +27166,7 @@ - (void)testSendClusterTestCluster_000248_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000249_ReadAttribute +- (void)testSendClusterTestCluster_000279_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE medium Value"]; @@ -26187,7 +27191,7 @@ - (void)testSendClusterTestCluster_000249_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000250_WriteAttribute +- (void)testSendClusterTestCluster_000280_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE largest Value"]; @@ -26209,7 +27213,7 @@ - (void)testSendClusterTestCluster_000250_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000251_ReadAttribute +- (void)testSendClusterTestCluster_000281_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE largest Value"]; @@ -26234,7 +27238,7 @@ - (void)testSendClusterTestCluster_000251_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000252_WriteAttribute +- (void)testSendClusterTestCluster_000282_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE smallest Value"]; @@ -26256,7 +27260,7 @@ - (void)testSendClusterTestCluster_000252_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000253_ReadAttribute +- (void)testSendClusterTestCluster_000283_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE smallest Value"]; @@ -26281,7 +27285,7 @@ - (void)testSendClusterTestCluster_000253_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000254_WriteAttribute +- (void)testSendClusterTestCluster_000284_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE null Value"]; @@ -26303,7 +27307,7 @@ - (void)testSendClusterTestCluster_000254_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000255_ReadAttribute +- (void)testSendClusterTestCluster_000285_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE null Value"]; @@ -26327,7 +27331,7 @@ - (void)testSendClusterTestCluster_000255_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000256_WriteAttribute +- (void)testSendClusterTestCluster_000286_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE 0 Value"]; @@ -26349,7 +27353,7 @@ - (void)testSendClusterTestCluster_000256_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000257_ReadAttribute +- (void)testSendClusterTestCluster_000287_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE 0 Value"]; @@ -26374,7 +27378,7 @@ - (void)testSendClusterTestCluster_000257_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000258_WriteAttribute +- (void)testSendClusterTestCluster_000288_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE medium Value"]; @@ -26396,7 +27400,7 @@ - (void)testSendClusterTestCluster_000258_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000259_ReadAttribute +- (void)testSendClusterTestCluster_000289_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE medium Value"]; @@ -26421,7 +27425,7 @@ - (void)testSendClusterTestCluster_000259_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000260_WriteAttribute +- (void)testSendClusterTestCluster_000290_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE largest Value"]; @@ -26443,7 +27447,7 @@ - (void)testSendClusterTestCluster_000260_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000261_ReadAttribute +- (void)testSendClusterTestCluster_000291_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE largest Value"]; @@ -26468,7 +27472,7 @@ - (void)testSendClusterTestCluster_000261_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000262_WriteAttribute +- (void)testSendClusterTestCluster_000292_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE smallest Value"]; @@ -26490,7 +27494,7 @@ - (void)testSendClusterTestCluster_000262_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000263_ReadAttribute +- (void)testSendClusterTestCluster_000293_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE smallest Value"]; @@ -26515,7 +27519,7 @@ - (void)testSendClusterTestCluster_000263_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000264_WriteAttribute +- (void)testSendClusterTestCluster_000294_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE null Value"]; @@ -26537,7 +27541,7 @@ - (void)testSendClusterTestCluster_000264_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000265_ReadAttribute +- (void)testSendClusterTestCluster_000295_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE null Value"]; @@ -26561,7 +27565,7 @@ - (void)testSendClusterTestCluster_000265_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000266_WriteAttribute +- (void)testSendClusterTestCluster_000296_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE 0 Value"]; @@ -26583,7 +27587,7 @@ - (void)testSendClusterTestCluster_000266_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000267_ReadAttribute +- (void)testSendClusterTestCluster_000297_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE 0 Value"]; @@ -26608,7 +27612,7 @@ - (void)testSendClusterTestCluster_000267_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000268_WriteAttribute +- (void)testSendClusterTestCluster_000298_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Max Value"]; @@ -26630,7 +27634,7 @@ - (void)testSendClusterTestCluster_000268_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000269_ReadAttribute +- (void)testSendClusterTestCluster_000299_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Max Value"]; @@ -26655,7 +27659,7 @@ - (void)testSendClusterTestCluster_000269_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000270_WriteAttribute +- (void)testSendClusterTestCluster_000300_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Invalid Value"]; @@ -26676,7 +27680,7 @@ - (void)testSendClusterTestCluster_000270_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000271_ReadAttribute +- (void)testSendClusterTestCluster_000301_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 unchanged Value"]; @@ -26701,7 +27705,7 @@ - (void)testSendClusterTestCluster_000271_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000272_WriteAttribute +- (void)testSendClusterTestCluster_000302_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 null Value"]; @@ -26723,7 +27727,7 @@ - (void)testSendClusterTestCluster_000272_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000273_ReadAttribute +- (void)testSendClusterTestCluster_000303_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 null Value"]; @@ -26747,7 +27751,7 @@ - (void)testSendClusterTestCluster_000273_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000274_WriteAttribute +- (void)testSendClusterTestCluster_000304_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Max Value"]; @@ -26769,7 +27773,7 @@ - (void)testSendClusterTestCluster_000274_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000275_ReadAttribute +- (void)testSendClusterTestCluster_000305_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Max Value"]; @@ -26794,7 +27798,7 @@ - (void)testSendClusterTestCluster_000275_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000276_WriteAttribute +- (void)testSendClusterTestCluster_000306_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Invalid Value"]; @@ -26816,7 +27820,7 @@ - (void)testSendClusterTestCluster_000276_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000277_ReadAttribute +- (void)testSendClusterTestCluster_000307_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 unchanged Value"]; @@ -26841,7 +27845,7 @@ - (void)testSendClusterTestCluster_000277_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000278_WriteAttribute +- (void)testSendClusterTestCluster_000308_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 null Value"]; @@ -26863,7 +27867,7 @@ - (void)testSendClusterTestCluster_000278_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000279_ReadAttribute +- (void)testSendClusterTestCluster_000309_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 null Value"]; @@ -26887,7 +27891,7 @@ - (void)testSendClusterTestCluster_000279_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000280_ReadAttribute +- (void)testSendClusterTestCluster_000310_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING Default Value"]; @@ -26912,7 +27916,7 @@ - (void)testSendClusterTestCluster_000280_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000281_WriteAttribute +- (void)testSendClusterTestCluster_000311_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -26934,7 +27938,7 @@ - (void)testSendClusterTestCluster_000281_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000282_ReadAttribute +- (void)testSendClusterTestCluster_000312_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -26959,7 +27963,7 @@ - (void)testSendClusterTestCluster_000282_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000283_WriteAttribute +- (void)testSendClusterTestCluster_000313_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -26981,7 +27985,7 @@ - (void)testSendClusterTestCluster_000283_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000284_ReadAttribute +- (void)testSendClusterTestCluster_000314_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -27005,7 +28009,7 @@ - (void)testSendClusterTestCluster_000284_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000285_WriteAttribute +- (void)testSendClusterTestCluster_000315_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -27027,7 +28031,7 @@ - (void)testSendClusterTestCluster_000285_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000286_ReadAttribute +- (void)testSendClusterTestCluster_000316_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -27052,7 +28056,7 @@ - (void)testSendClusterTestCluster_000286_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000287_ReadAttribute +- (void)testSendClusterTestCluster_000317_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING Default Value"]; @@ -27077,7 +28081,7 @@ - (void)testSendClusterTestCluster_000287_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000288_WriteAttribute +- (void)testSendClusterTestCluster_000318_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING"]; @@ -27099,7 +28103,7 @@ - (void)testSendClusterTestCluster_000288_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000289_ReadAttribute +- (void)testSendClusterTestCluster_000319_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -27124,7 +28128,7 @@ - (void)testSendClusterTestCluster_000289_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000290_WriteAttribute +- (void)testSendClusterTestCluster_000320_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Value too long"]; @@ -27146,7 +28150,7 @@ - (void)testSendClusterTestCluster_000290_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000291_ReadAttribute +- (void)testSendClusterTestCluster_000321_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -27170,7 +28174,7 @@ - (void)testSendClusterTestCluster_000291_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000292_WriteAttribute +- (void)testSendClusterTestCluster_000322_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Empty"]; @@ -27192,7 +28196,7 @@ - (void)testSendClusterTestCluster_000292_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000293_ReadAttribute +- (void)testSendClusterTestCluster_000323_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -27217,7 +28221,7 @@ - (void)testSendClusterTestCluster_000293_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000294_ReadAttribute +- (void)testSendClusterTestCluster_000324_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent endpoint."]; @@ -27235,7 +28239,7 @@ - (void)testSendClusterTestCluster_000294_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000295_ReadAttribute +- (void)testSendClusterTestCluster_000325_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent cluster."]; @@ -27253,7 +28257,7 @@ - (void)testSendClusterTestCluster_000295_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000296_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000326_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -27275,7 +28279,7 @@ - (void)testSendClusterTestCluster_000296_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000297_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000327_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -27299,9 +28303,9 @@ - (void)testSendClusterTestCluster_000297_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -bool testSendClusterTestCluster_000298_WaitForReport_Fulfilled = false; +bool testSendClusterTestCluster_000328_WaitForReport_Fulfilled = false; ResponseHandler test_TestCluster_list_int8u_Reported = nil; -- (void)testSendClusterTestCluster_000298_WaitForReport +- (void)testSendClusterTestCluster_000328_WaitForReport { CHIPDevice * device = GetConnectedDevice(); @@ -27323,10 +28327,10 @@ - (void)testSendClusterTestCluster_000298_WaitForReport XCTAssertEqual([actualValue[3] unsignedCharValue], 4); } - testSendClusterTestCluster_000298_WaitForReport_Fulfilled = true; + testSendClusterTestCluster_000328_WaitForReport_Fulfilled = true; }; } -- (void)testSendClusterTestCluster_000299_SubscribeAttribute +- (void)testSendClusterTestCluster_000329_SubscribeAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Subscribe to list attribute"]; @@ -27340,7 +28344,7 @@ - (void)testSendClusterTestCluster_000299_SubscribeAttribute [cluster subscribeAttributeListInt8uWithMinInterval:minIntervalArgument maxInterval:maxIntervalArgument subscriptionEstablished:^{ - XCTAssertEqual(testSendClusterTestCluster_000298_WaitForReport_Fulfilled, true); + XCTAssertEqual(testSendClusterTestCluster_000328_WaitForReport_Fulfilled, true); [expectation fulfill]; } reportHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { @@ -27356,7 +28360,7 @@ - (void)testSendClusterTestCluster_000299_SubscribeAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000300_WriteAttribute +- (void)testSendClusterTestCluster_000330_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write subscribed-to list attribute"]; @@ -27385,7 +28389,7 @@ - (void)testSendClusterTestCluster_000300_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000301_WaitForReport +- (void)testSendClusterTestCluster_000331_WaitForReport { XCTestExpectation * expectation = [self expectationWithDescription:@"Check for list attribute report"]; @@ -27413,7 +28417,7 @@ - (void)testSendClusterTestCluster_000301_WaitForReport [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000302_ReadAttribute +- (void)testSendClusterTestCluster_000332_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 8-bit integer"]; @@ -27437,7 +28441,7 @@ - (void)testSendClusterTestCluster_000302_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000303_WriteAttribute +- (void)testSendClusterTestCluster_000333_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 8-bit integer"]; @@ -27460,7 +28464,7 @@ - (void)testSendClusterTestCluster_000303_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000304_WriteAttribute +- (void)testSendClusterTestCluster_000334_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 8-bit integer"]; @@ -27485,7 +28489,7 @@ - (void)testSendClusterTestCluster_000304_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000305_WriteAttribute +- (void)testSendClusterTestCluster_000335_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 8-bit integer"]; @@ -27510,7 +28514,7 @@ - (void)testSendClusterTestCluster_000305_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000306_WriteAttribute +- (void)testSendClusterTestCluster_000336_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 8-bit integer"]; @@ -27533,7 +28537,7 @@ - (void)testSendClusterTestCluster_000306_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000307_ReadAttribute +- (void)testSendClusterTestCluster_000337_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value has not changed"]; @@ -27558,7 +28562,7 @@ - (void)testSendClusterTestCluster_000307_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000308_WriteAttribute +- (void)testSendClusterTestCluster_000338_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 8-bit integer"]; @@ -27582,7 +28586,7 @@ - (void)testSendClusterTestCluster_000308_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000309_ReadAttribute +- (void)testSendClusterTestCluster_000339_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at min valid"]; @@ -27607,7 +28611,7 @@ - (void)testSendClusterTestCluster_000309_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000310_WriteAttribute +- (void)testSendClusterTestCluster_000340_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 8-bit integer"]; @@ -27631,7 +28635,7 @@ - (void)testSendClusterTestCluster_000310_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000311_ReadAttribute +- (void)testSendClusterTestCluster_000341_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at max valid"]; @@ -27656,7 +28660,7 @@ - (void)testSendClusterTestCluster_000311_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000312_WriteAttribute +- (void)testSendClusterTestCluster_000342_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 8-bit integer"]; @@ -27680,7 +28684,7 @@ - (void)testSendClusterTestCluster_000312_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000313_ReadAttribute +- (void)testSendClusterTestCluster_000343_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -27705,7 +28709,7 @@ - (void)testSendClusterTestCluster_000313_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000314_ReadAttribute +- (void)testSendClusterTestCluster_000344_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 16-bit integer"]; @@ -27729,7 +28733,7 @@ - (void)testSendClusterTestCluster_000314_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000315_WriteAttribute +- (void)testSendClusterTestCluster_000345_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 16-bit integer"]; @@ -27752,7 +28756,7 @@ - (void)testSendClusterTestCluster_000315_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000316_WriteAttribute +- (void)testSendClusterTestCluster_000346_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 16-bit integer"]; @@ -27778,7 +28782,7 @@ - (void)testSendClusterTestCluster_000316_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000317_WriteAttribute +- (void)testSendClusterTestCluster_000347_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 16-bit integer"]; @@ -27804,7 +28808,7 @@ - (void)testSendClusterTestCluster_000317_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000318_WriteAttribute +- (void)testSendClusterTestCluster_000348_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 16-bit integer"]; @@ -27827,7 +28831,7 @@ - (void)testSendClusterTestCluster_000318_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000319_ReadAttribute +- (void)testSendClusterTestCluster_000349_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value has not changed"]; @@ -27852,7 +28856,7 @@ - (void)testSendClusterTestCluster_000319_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000320_WriteAttribute +- (void)testSendClusterTestCluster_000350_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 16-bit integer"]; @@ -27876,7 +28880,7 @@ - (void)testSendClusterTestCluster_000320_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000321_ReadAttribute +- (void)testSendClusterTestCluster_000351_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at min valid"]; @@ -27901,7 +28905,7 @@ - (void)testSendClusterTestCluster_000321_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000322_WriteAttribute +- (void)testSendClusterTestCluster_000352_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 16-bit integer"]; @@ -27925,7 +28929,7 @@ - (void)testSendClusterTestCluster_000322_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000323_ReadAttribute +- (void)testSendClusterTestCluster_000353_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at max valid"]; @@ -27950,7 +28954,7 @@ - (void)testSendClusterTestCluster_000323_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000324_WriteAttribute +- (void)testSendClusterTestCluster_000354_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 16-bit integer"]; @@ -27975,7 +28979,7 @@ - (void)testSendClusterTestCluster_000324_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000325_ReadAttribute +- (void)testSendClusterTestCluster_000355_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -28000,7 +29004,7 @@ - (void)testSendClusterTestCluster_000325_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000326_ReadAttribute +- (void)testSendClusterTestCluster_000356_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 8-bit integer"]; @@ -28024,7 +29028,7 @@ - (void)testSendClusterTestCluster_000326_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000327_WriteAttribute +- (void)testSendClusterTestCluster_000357_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 8-bit integer"]; @@ -28047,7 +29051,7 @@ - (void)testSendClusterTestCluster_000327_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000328_WriteAttribute +- (void)testSendClusterTestCluster_000358_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 8-bit integer"]; @@ -28072,7 +29076,7 @@ - (void)testSendClusterTestCluster_000328_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000329_WriteAttribute +- (void)testSendClusterTestCluster_000359_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 8-bit integer"]; @@ -28097,7 +29101,7 @@ - (void)testSendClusterTestCluster_000329_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000330_WriteAttribute +- (void)testSendClusterTestCluster_000360_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 8-bit integer"]; @@ -28120,7 +29124,7 @@ - (void)testSendClusterTestCluster_000330_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000331_ReadAttribute +- (void)testSendClusterTestCluster_000361_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value has not changed"]; @@ -28145,7 +29149,7 @@ - (void)testSendClusterTestCluster_000331_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000332_WriteAttribute +- (void)testSendClusterTestCluster_000362_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 8-bit integer"]; @@ -28169,7 +29173,7 @@ - (void)testSendClusterTestCluster_000332_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000333_ReadAttribute +- (void)testSendClusterTestCluster_000363_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at min valid"]; @@ -28194,7 +29198,7 @@ - (void)testSendClusterTestCluster_000333_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000334_WriteAttribute +- (void)testSendClusterTestCluster_000364_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 8-bit integer"]; @@ -28218,7 +29222,7 @@ - (void)testSendClusterTestCluster_000334_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000335_ReadAttribute +- (void)testSendClusterTestCluster_000365_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at max valid"]; @@ -28243,7 +29247,7 @@ - (void)testSendClusterTestCluster_000335_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000336_WriteAttribute +- (void)testSendClusterTestCluster_000366_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 8-bit integer"]; @@ -28267,7 +29271,7 @@ - (void)testSendClusterTestCluster_000336_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000337_ReadAttribute +- (void)testSendClusterTestCluster_000367_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at mid valid"]; @@ -28292,7 +29296,7 @@ - (void)testSendClusterTestCluster_000337_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000338_ReadAttribute +- (void)testSendClusterTestCluster_000368_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 16-bit integer"]; @@ -28316,7 +29320,7 @@ - (void)testSendClusterTestCluster_000338_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000339_WriteAttribute +- (void)testSendClusterTestCluster_000369_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 16-bit integer"]; @@ -28339,7 +29343,7 @@ - (void)testSendClusterTestCluster_000339_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000340_WriteAttribute +- (void)testSendClusterTestCluster_000370_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 16-bit integer"]; @@ -28364,7 +29368,7 @@ - (void)testSendClusterTestCluster_000340_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000341_WriteAttribute +- (void)testSendClusterTestCluster_000371_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 16-bit integer"]; @@ -28389,7 +29393,7 @@ - (void)testSendClusterTestCluster_000341_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000342_WriteAttribute +- (void)testSendClusterTestCluster_000372_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 16-bit integer"]; @@ -28412,7 +29416,7 @@ - (void)testSendClusterTestCluster_000342_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000343_ReadAttribute +- (void)testSendClusterTestCluster_000373_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value has not changed"]; @@ -28437,7 +29441,7 @@ - (void)testSendClusterTestCluster_000343_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000344_WriteAttribute +- (void)testSendClusterTestCluster_000374_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 16-bit integer"]; @@ -28461,7 +29465,7 @@ - (void)testSendClusterTestCluster_000344_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000345_ReadAttribute +- (void)testSendClusterTestCluster_000375_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at min valid"]; @@ -28486,7 +29490,7 @@ - (void)testSendClusterTestCluster_000345_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000346_WriteAttribute +- (void)testSendClusterTestCluster_000376_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 16-bit integer"]; @@ -28510,7 +29514,7 @@ - (void)testSendClusterTestCluster_000346_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000347_ReadAttribute +- (void)testSendClusterTestCluster_000377_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at max valid"]; @@ -28535,7 +29539,7 @@ - (void)testSendClusterTestCluster_000347_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000348_WriteAttribute +- (void)testSendClusterTestCluster_000378_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 16-bit integer"]; @@ -28559,7 +29563,7 @@ - (void)testSendClusterTestCluster_000348_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000349_ReadAttribute +- (void)testSendClusterTestCluster_000379_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at mid valid"]; @@ -28584,7 +29588,7 @@ - (void)testSendClusterTestCluster_000349_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000350_ReadAttribute +- (void)testSendClusterTestCluster_000380_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 8-bit integer"]; @@ -28609,7 +29613,7 @@ - (void)testSendClusterTestCluster_000350_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000351_WriteAttribute +- (void)testSendClusterTestCluster_000381_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28634,7 +29638,7 @@ - (void)testSendClusterTestCluster_000351_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000352_WriteAttribute +- (void)testSendClusterTestCluster_000382_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28659,7 +29663,7 @@ - (void)testSendClusterTestCluster_000352_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000353_WriteAttribute +- (void)testSendClusterTestCluster_000383_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28684,7 +29688,7 @@ - (void)testSendClusterTestCluster_000353_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000354_WriteAttribute +- (void)testSendClusterTestCluster_000384_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28709,7 +29713,7 @@ - (void)testSendClusterTestCluster_000354_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000355_ReadAttribute +- (void)testSendClusterTestCluster_000385_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value has not changed"]; @@ -28735,7 +29739,7 @@ - (void)testSendClusterTestCluster_000355_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000356_WriteAttribute +- (void)testSendClusterTestCluster_000386_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28760,7 +29764,7 @@ - (void)testSendClusterTestCluster_000356_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000357_ReadAttribute +- (void)testSendClusterTestCluster_000387_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at min valid"]; @@ -28786,7 +29790,7 @@ - (void)testSendClusterTestCluster_000357_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000358_WriteAttribute +- (void)testSendClusterTestCluster_000388_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28811,7 +29815,7 @@ - (void)testSendClusterTestCluster_000358_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000359_ReadAttribute +- (void)testSendClusterTestCluster_000389_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at max valid"]; @@ -28837,7 +29841,7 @@ - (void)testSendClusterTestCluster_000359_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000360_WriteAttribute +- (void)testSendClusterTestCluster_000390_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28862,7 +29866,7 @@ - (void)testSendClusterTestCluster_000360_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000361_ReadAttribute +- (void)testSendClusterTestCluster_000391_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -28888,7 +29892,7 @@ - (void)testSendClusterTestCluster_000361_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000362_WriteAttribute +- (void)testSendClusterTestCluster_000392_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 8-bit integer"]; @@ -28913,7 +29917,7 @@ - (void)testSendClusterTestCluster_000362_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000363_ReadAttribute +- (void)testSendClusterTestCluster_000393_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is null"]; @@ -28938,7 +29942,7 @@ - (void)testSendClusterTestCluster_000363_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000364_ReadAttribute +- (void)testSendClusterTestCluster_000394_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 16-bit integer"]; @@ -28964,7 +29968,7 @@ - (void)testSendClusterTestCluster_000364_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000365_WriteAttribute +- (void)testSendClusterTestCluster_000395_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 16-bit integer"]; @@ -28989,7 +29993,7 @@ - (void)testSendClusterTestCluster_000365_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000366_WriteAttribute +- (void)testSendClusterTestCluster_000396_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29014,7 +30018,7 @@ - (void)testSendClusterTestCluster_000366_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000367_WriteAttribute +- (void)testSendClusterTestCluster_000397_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29039,7 +30043,7 @@ - (void)testSendClusterTestCluster_000367_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000368_WriteAttribute +- (void)testSendClusterTestCluster_000398_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29064,7 +30068,7 @@ - (void)testSendClusterTestCluster_000368_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000369_ReadAttribute +- (void)testSendClusterTestCluster_000399_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value has not changed"]; @@ -29091,7 +30095,7 @@ - (void)testSendClusterTestCluster_000369_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000370_WriteAttribute +- (void)testSendClusterTestCluster_000400_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29116,7 +30120,7 @@ - (void)testSendClusterTestCluster_000370_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000371_ReadAttribute +- (void)testSendClusterTestCluster_000401_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at min valid"]; @@ -29143,7 +30147,7 @@ - (void)testSendClusterTestCluster_000371_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000372_WriteAttribute +- (void)testSendClusterTestCluster_000402_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29168,7 +30172,7 @@ - (void)testSendClusterTestCluster_000372_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000373_ReadAttribute +- (void)testSendClusterTestCluster_000403_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at max valid"]; @@ -29195,7 +30199,7 @@ - (void)testSendClusterTestCluster_000373_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000374_WriteAttribute +- (void)testSendClusterTestCluster_000404_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29220,7 +30224,7 @@ - (void)testSendClusterTestCluster_000374_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000375_ReadAttribute +- (void)testSendClusterTestCluster_000405_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -29247,7 +30251,7 @@ - (void)testSendClusterTestCluster_000375_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000376_WriteAttribute +- (void)testSendClusterTestCluster_000406_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 16-bit integer"]; @@ -29272,7 +30276,7 @@ - (void)testSendClusterTestCluster_000376_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000377_ReadAttribute +- (void)testSendClusterTestCluster_000407_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is null"]; @@ -29298,7 +30302,7 @@ - (void)testSendClusterTestCluster_000377_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000378_ReadAttribute +- (void)testSendClusterTestCluster_000408_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 8-bit integer"]; @@ -29323,7 +30327,7 @@ - (void)testSendClusterTestCluster_000378_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000379_WriteAttribute +- (void)testSendClusterTestCluster_000409_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 8-bit integer"]; @@ -29349,7 +30353,7 @@ - (void)testSendClusterTestCluster_000379_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000380_WriteAttribute +- (void)testSendClusterTestCluster_000410_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 8-bit integer"]; @@ -29374,7 +30378,7 @@ - (void)testSendClusterTestCluster_000380_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000381_WriteAttribute +- (void)testSendClusterTestCluster_000411_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 8-bit integer"]; @@ -29399,7 +30403,7 @@ - (void)testSendClusterTestCluster_000381_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000382_WriteAttribute +- (void)testSendClusterTestCluster_000412_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 8-bit integer"]; @@ -29425,7 +30429,7 @@ - (void)testSendClusterTestCluster_000382_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000383_ReadAttribute +- (void)testSendClusterTestCluster_000413_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value has not changed"]; @@ -29451,7 +30455,7 @@ - (void)testSendClusterTestCluster_000383_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000384_WriteAttribute +- (void)testSendClusterTestCluster_000414_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 8-bit integer"]; @@ -29476,7 +30480,7 @@ - (void)testSendClusterTestCluster_000384_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000385_ReadAttribute +- (void)testSendClusterTestCluster_000415_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at min valid"]; @@ -29502,7 +30506,7 @@ - (void)testSendClusterTestCluster_000385_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000386_WriteAttribute +- (void)testSendClusterTestCluster_000416_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 8-bit integer"]; @@ -29527,7 +30531,7 @@ - (void)testSendClusterTestCluster_000386_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000387_ReadAttribute +- (void)testSendClusterTestCluster_000417_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at max valid"]; @@ -29553,7 +30557,7 @@ - (void)testSendClusterTestCluster_000387_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000388_WriteAttribute +- (void)testSendClusterTestCluster_000418_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 8-bit integer"]; @@ -29578,7 +30582,7 @@ - (void)testSendClusterTestCluster_000388_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000389_ReadAttribute +- (void)testSendClusterTestCluster_000419_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at mid valid"]; @@ -29604,7 +30608,7 @@ - (void)testSendClusterTestCluster_000389_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000390_WriteAttribute +- (void)testSendClusterTestCluster_000420_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 8-bit integer"]; @@ -29630,7 +30634,7 @@ - (void)testSendClusterTestCluster_000390_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000391_ReadAttribute +- (void)testSendClusterTestCluster_000421_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at null"]; @@ -29655,7 +30659,7 @@ - (void)testSendClusterTestCluster_000391_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000392_ReadAttribute +- (void)testSendClusterTestCluster_000422_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 16-bit integer"]; @@ -29681,7 +30685,7 @@ - (void)testSendClusterTestCluster_000392_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000393_WriteAttribute +- (void)testSendClusterTestCluster_000423_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 16-bit integer"]; @@ -29706,7 +30710,7 @@ - (void)testSendClusterTestCluster_000393_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000394_WriteAttribute +- (void)testSendClusterTestCluster_000424_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 16-bit integer"]; @@ -29731,7 +30735,7 @@ - (void)testSendClusterTestCluster_000394_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000395_WriteAttribute +- (void)testSendClusterTestCluster_000425_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 16-bit integer"]; @@ -29756,7 +30760,7 @@ - (void)testSendClusterTestCluster_000395_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000396_WriteAttribute +- (void)testSendClusterTestCluster_000426_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 16-bit integer"]; @@ -29781,7 +30785,7 @@ - (void)testSendClusterTestCluster_000396_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000397_ReadAttribute +- (void)testSendClusterTestCluster_000427_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value has not changed"]; @@ -29808,7 +30812,7 @@ - (void)testSendClusterTestCluster_000397_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000398_WriteAttribute +- (void)testSendClusterTestCluster_000428_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 16-bit integer"]; @@ -29833,7 +30837,7 @@ - (void)testSendClusterTestCluster_000398_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000399_ReadAttribute +- (void)testSendClusterTestCluster_000429_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at min valid"]; @@ -29860,7 +30864,7 @@ - (void)testSendClusterTestCluster_000399_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000400_WriteAttribute +- (void)testSendClusterTestCluster_000430_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 16-bit integer"]; @@ -29885,7 +30889,7 @@ - (void)testSendClusterTestCluster_000400_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000401_ReadAttribute +- (void)testSendClusterTestCluster_000431_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at max valid"]; @@ -29912,7 +30916,7 @@ - (void)testSendClusterTestCluster_000401_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000402_WriteAttribute +- (void)testSendClusterTestCluster_000432_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 16-bit integer"]; @@ -29937,7 +30941,7 @@ - (void)testSendClusterTestCluster_000402_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000403_ReadAttribute +- (void)testSendClusterTestCluster_000433_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at mid valid"]; @@ -29964,7 +30968,7 @@ - (void)testSendClusterTestCluster_000403_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000404_WriteAttribute +- (void)testSendClusterTestCluster_000434_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 16-bit integer"]; @@ -29989,7 +30993,7 @@ - (void)testSendClusterTestCluster_000404_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000405_ReadAttribute +- (void)testSendClusterTestCluster_000435_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is null"]; @@ -30105,7 +31109,9 @@ - (void)testSendClusterTestSaveAs_000003_TestAddArguments { id actualValue = values.returnValue; - XCTAssertNotEqual([actualValue unsignedCharValue], TestAddArgumentDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], TestAddArgumentDefaultValue); + } } [expectation fulfill]; @@ -30177,7 +31183,9 @@ - (void)testSendClusterTestSaveAs_000006_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue boolValue], readAttributeBooleanDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue boolValue], readAttributeBooleanDefaultValue); + } } [expectation fulfill]; @@ -30295,7 +31303,9 @@ - (void)testSendClusterTestSaveAs_000011_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], readAttributeBitmap8DefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], readAttributeBitmap8DefaultValue); + } } [expectation fulfill]; @@ -30413,7 +31423,9 @@ - (void)testSendClusterTestSaveAs_000016_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeBitmap16DefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeBitmap16DefaultValue); + } } [expectation fulfill]; @@ -30531,7 +31543,9 @@ - (void)testSendClusterTestSaveAs_000021_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedIntValue], readAttributeBitmap32DefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedIntValue], readAttributeBitmap32DefaultValue); + } } [expectation fulfill]; @@ -30649,7 +31663,9 @@ - (void)testSendClusterTestSaveAs_000026_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedLongLongValue], readAttributeBitmap64DefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedLongLongValue], readAttributeBitmap64DefaultValue); + } } [expectation fulfill]; @@ -30767,7 +31783,9 @@ - (void)testSendClusterTestSaveAs_000031_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], readAttributeInt8uDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], readAttributeInt8uDefaultValue); + } } [expectation fulfill]; @@ -30885,7 +31903,9 @@ - (void)testSendClusterTestSaveAs_000036_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeInt16uDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeInt16uDefaultValue); + } } [expectation fulfill]; @@ -31003,7 +32023,9 @@ - (void)testSendClusterTestSaveAs_000041_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedIntValue], readAttributeInt32uDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedIntValue], readAttributeInt32uDefaultValue); + } } [expectation fulfill]; @@ -31121,7 +32143,9 @@ - (void)testSendClusterTestSaveAs_000046_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedLongLongValue], readAttributeInt64uDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedLongLongValue], readAttributeInt64uDefaultValue); + } } [expectation fulfill]; @@ -31239,7 +32263,9 @@ - (void)testSendClusterTestSaveAs_000051_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue charValue], readAttributeInt8sDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue charValue], readAttributeInt8sDefaultValue); + } } [expectation fulfill]; @@ -31357,7 +32383,9 @@ - (void)testSendClusterTestSaveAs_000056_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue shortValue], readAttributeInt16sDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue shortValue], readAttributeInt16sDefaultValue); + } } [expectation fulfill]; @@ -31475,7 +32503,9 @@ - (void)testSendClusterTestSaveAs_000061_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue intValue], readAttributeInt32sDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue intValue], readAttributeInt32sDefaultValue); + } } [expectation fulfill]; @@ -31593,7 +32623,9 @@ - (void)testSendClusterTestSaveAs_000066_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue longLongValue], readAttributeInt64sDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue longLongValue], readAttributeInt64sDefaultValue); + } } [expectation fulfill]; @@ -31711,7 +32743,9 @@ - (void)testSendClusterTestSaveAs_000071_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedCharValue], readAttributeEnum8DefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedCharValue], readAttributeEnum8DefaultValue); + } } [expectation fulfill]; @@ -31829,7 +32863,9 @@ - (void)testSendClusterTestSaveAs_000076_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeEnum16DefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeEnum16DefaultValue); + } } [expectation fulfill]; @@ -31947,7 +32983,9 @@ - (void)testSendClusterTestSaveAs_000081_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedLongLongValue], readAttributeEpochUSDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedLongLongValue], readAttributeEpochUSDefaultValue); + } } [expectation fulfill]; @@ -32065,7 +33103,9 @@ - (void)testSendClusterTestSaveAs_000086_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedIntValue], readAttributeEpochSDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedIntValue], readAttributeEpochSDefaultValue); + } } [expectation fulfill]; @@ -32183,7 +33223,9 @@ - (void)testSendClusterTestSaveAs_000091_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeVendorIdDefaultValue); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedShortValue], readAttributeVendorIdDefaultValue); + } } [expectation fulfill]; @@ -32284,7 +33326,9 @@ - (void)testSendClusterTestConstraints_000002_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue unsignedIntValue], 5); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue unsignedIntValue], 5); + } } [expectation fulfill]; @@ -32308,7 +33352,9 @@ - (void)testSendClusterTestConstraints_000003_ReadAttribute { id actualValue = value; - XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 5); + if (actualValue != nil) { + XCTAssertLessThanOrEqual([actualValue unsignedIntValue], 5); + } } [expectation fulfill]; @@ -32332,7 +33378,9 @@ - (void)testSendClusterTestConstraints_000004_ReadAttribute { id actualValue = value; - XCTAssertNotEqual([actualValue unsignedIntValue], 6); + if (actualValue != nil) { + XCTAssertNotEqual([actualValue unsignedIntValue], 6); + } } [expectation fulfill]; @@ -33745,7 +34793,9 @@ - (void)testSendClusterTestOperationalCredentialsCluster_000001_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 4); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 4); + } } [expectation fulfill]; @@ -33771,7 +34821,9 @@ - (void)testSendClusterTestOperationalCredentialsCluster_000002_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 1); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 1); + } } [expectation fulfill]; @@ -33797,7 +34849,9 @@ - (void)testSendClusterTestOperationalCredentialsCluster_000003_ReadAttribute { id actualValue = value; - XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 1); + if (actualValue != nil) { + XCTAssertGreaterThanOrEqual([actualValue unsignedCharValue], 1); + } } [expectation fulfill]; diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 2fff62c684da06..095aeb6fee7a82 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -3797,7 +3797,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_10(uint16_t currentX) { VerifyOrReturn(CheckConstraintType("currentX", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("currentX", currentX, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("currentX", currentX, 65279U)); NextTest(); } @@ -3880,7 +3880,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_14(uint16_t currentY) { VerifyOrReturn(CheckConstraintType("currentY", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("currentY", currentY, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("currentY", currentY, 65279U)); NextTest(); } @@ -3943,7 +3943,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_17(uint16_t colorTemperature) { VerifyOrReturn(CheckConstraintType("colorTemperature", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorTemperature", colorTemperature, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorTemperature", colorTemperature, 65279U)); NextTest(); } @@ -4603,7 +4603,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_49(uint16_t colorCapabilities) { VerifyOrReturn(CheckConstraintType("colorCapabilities", "", "map16")); - VerifyOrReturn(CheckConstraintMaxValue("colorCapabilities", colorCapabilities, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorCapabilities", colorCapabilities, 65279U)); NextTest(); } @@ -4686,7 +4686,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_53(uint16_t colorTempPhysicalMin) { VerifyOrReturn(CheckConstraintType("colorTempPhysicalMin", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorTempPhysicalMin", colorTempPhysicalMin, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorTempPhysicalMin", colorTempPhysicalMin, 65279U)); NextTest(); } @@ -4769,7 +4769,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_57(uint16_t colorTempPhysicalMax) { VerifyOrReturn(CheckConstraintType("colorTempPhysicalMax", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorTempPhysicalMax", colorTempPhysicalMax, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorTempPhysicalMax", colorTempPhysicalMax, 65279U)); NextTest(); } @@ -4898,7 +4898,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_63(uint16_t startUpColorTemperatureMireds) { VerifyOrReturn(CheckConstraintType("startUpColorTemperatureMireds", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("startUpColorTemperatureMireds", startUpColorTemperatureMireds, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("startUpColorTemperatureMireds", startUpColorTemperatureMireds, 65279U)); NextTest(); } @@ -4979,7 +4979,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_67(uint16_t remainingTime) { VerifyOrReturn(CheckConstraintType("remainingTime", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("remainingTime", remainingTime, 254)); + VerifyOrReturn(CheckConstraintMaxValue("remainingTime", remainingTime, 254U)); NextTest(); } @@ -5189,7 +5189,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_77(uint16_t primary1X) { VerifyOrReturn(CheckConstraintType("primary1X", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary1X", primary1X, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary1X", primary1X, 65279U)); NextTest(); } @@ -5252,7 +5252,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_80(uint16_t primary1Y) { VerifyOrReturn(CheckConstraintType("primary1Y", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary1Y", primary1Y, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary1Y", primary1Y, 65279U)); NextTest(); } @@ -5335,7 +5335,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_84(uint16_t primary2X) { VerifyOrReturn(CheckConstraintType("primary2X", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary2X", primary2X, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary2X", primary2X, 65279U)); NextTest(); } @@ -5398,7 +5398,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_87(uint16_t primary2Y) { VerifyOrReturn(CheckConstraintType("primary2Y", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary2Y", primary2Y, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary2Y", primary2Y, 65279U)); NextTest(); } @@ -5481,7 +5481,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_91(uint16_t primary3X) { VerifyOrReturn(CheckConstraintType("primary3X", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary3X", primary3X, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary3X", primary3X, 65279U)); NextTest(); } @@ -5544,7 +5544,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_94(uint16_t primary3Y) { VerifyOrReturn(CheckConstraintType("primary3Y", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary3Y", primary3Y, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary3Y", primary3Y, 65279U)); NextTest(); } @@ -5627,7 +5627,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_98(uint16_t primary4X) { VerifyOrReturn(CheckConstraintType("primary4X", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary4X", primary4X, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary4X", primary4X, 65279U)); NextTest(); } @@ -5690,7 +5690,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_101(uint16_t primary4Y) { VerifyOrReturn(CheckConstraintType("primary4Y", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary4Y", primary4Y, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary4Y", primary4Y, 65279U)); NextTest(); } @@ -5773,7 +5773,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_105(uint16_t primary5X) { VerifyOrReturn(CheckConstraintType("primary5X", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary5X", primary5X, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary5X", primary5X, 65279U)); NextTest(); } @@ -5836,7 +5836,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_108(uint16_t primary5Y) { VerifyOrReturn(CheckConstraintType("primary5Y", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary5Y", primary5Y, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary5Y", primary5Y, 65279U)); NextTest(); } @@ -5919,7 +5919,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_112(uint16_t primary6X) { VerifyOrReturn(CheckConstraintType("primary6X", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary6X", primary6X, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary6X", primary6X, 65279U)); NextTest(); } @@ -5982,7 +5982,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_115(uint16_t primary6Y) { VerifyOrReturn(CheckConstraintType("primary6Y", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("primary6Y", primary6Y, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("primary6Y", primary6Y, 65279U)); NextTest(); } @@ -6065,7 +6065,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_119(uint16_t whitePointX) { VerifyOrReturn(CheckConstraintType("whitePointX", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("whitePointX", whitePointX, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("whitePointX", whitePointX, 65279U)); NextTest(); } @@ -6124,7 +6124,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_122(uint16_t whitePointY) { VerifyOrReturn(CheckConstraintType("whitePointY", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("whitePointY", whitePointY, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("whitePointY", whitePointY, 65279U)); NextTest(); } @@ -6183,7 +6183,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_125(uint16_t colorPointRX) { VerifyOrReturn(CheckConstraintType("colorPointRX", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorPointRX", colorPointRX, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorPointRX", colorPointRX, 65279U)); NextTest(); } @@ -6242,7 +6242,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_128(uint16_t colorPointRY) { VerifyOrReturn(CheckConstraintType("colorPointRY", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorPointRY", colorPointRY, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorPointRY", colorPointRY, 65279U)); NextTest(); } @@ -6321,7 +6321,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_132(uint16_t colorPointGX) { VerifyOrReturn(CheckConstraintType("colorPointGX", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorPointGX", colorPointGX, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorPointGX", colorPointGX, 65279U)); NextTest(); } @@ -6380,7 +6380,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_135(uint16_t colorPointGY) { VerifyOrReturn(CheckConstraintType("colorPointGY", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorPointGY", colorPointGY, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorPointGY", colorPointGY, 65279U)); NextTest(); } @@ -6459,7 +6459,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_139(uint16_t colorPointBX) { VerifyOrReturn(CheckConstraintType("colorPointBX", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorPointBX", colorPointBX, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorPointBX", colorPointBX, 65279U)); NextTest(); } @@ -6518,7 +6518,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_142(uint16_t colorPointBY) { VerifyOrReturn(CheckConstraintType("colorPointBY", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("colorPointBY", colorPointBY, 65279)); + VerifyOrReturn(CheckConstraintMaxValue("colorPointBY", colorPointBY, 65279U)); NextTest(); } @@ -23053,7 +23053,7 @@ class Test_TC_RH_2_1 : public TestCommand void OnSuccessResponse_2(uint16_t minMeasuredValue) { VerifyOrReturn(CheckConstraintType("minMeasuredValue", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("minMeasuredValue", minMeasuredValue, 9999)); + VerifyOrReturn(CheckConstraintMaxValue("minMeasuredValue", minMeasuredValue, 9999U)); NextTest(); } @@ -29016,8 +29016,8 @@ class Test_TC_WNCV_1_1 : public TestCommand void OnSuccessResponse_1(uint16_t clusterRevision) { VerifyOrReturn(CheckConstraintType("clusterRevision", "", "uint16")); - VerifyOrReturn(CheckConstraintMinValue("clusterRevision", clusterRevision, 5)); - VerifyOrReturn(CheckConstraintMaxValue("clusterRevision", clusterRevision, 200)); + VerifyOrReturn(CheckConstraintMinValue("clusterRevision", clusterRevision, 5U)); + VerifyOrReturn(CheckConstraintMaxValue("clusterRevision", clusterRevision, 200U)); NextTest(); } @@ -29081,7 +29081,7 @@ class Test_TC_WNCV_1_1 : public TestCommand void OnSuccessResponse_4(uint32_t featureMap) { VerifyOrReturn(CheckConstraintType("featureMap", "", "uint32")); - VerifyOrReturn(CheckConstraintMaxValue("featureMap", featureMap, 32768)); + VerifyOrReturn(CheckConstraintMaxValue("featureMap", featureMap, 32768UL)); NextTest(); } @@ -30255,7 +30255,7 @@ class Test_TC_WNCV_2_1 : public TestCommand { VerifyOrReturn(CheckConstraintType("targetPositionLiftPercent100ths", "", "uint16")); VerifyOrReturn( - CheckConstraintMaxValue("targetPositionLiftPercent100ths", targetPositionLiftPercent100ths, 10000)); + CheckConstraintMaxValue("targetPositionLiftPercent100ths", targetPositionLiftPercent100ths, 10000U)); NextTest(); } @@ -30323,7 +30323,7 @@ class Test_TC_WNCV_2_1 : public TestCommand { VerifyOrReturn(CheckConstraintType("targetPositionTiltPercent100ths", "", "uint16")); VerifyOrReturn( - CheckConstraintMaxValue("targetPositionTiltPercent100ths", targetPositionTiltPercent100ths, 10000)); + CheckConstraintMaxValue("targetPositionTiltPercent100ths", targetPositionTiltPercent100ths, 10000U)); NextTest(); } @@ -30391,7 +30391,7 @@ class Test_TC_WNCV_2_1 : public TestCommand { VerifyOrReturn(CheckConstraintType("currentPositionLiftPercent100ths", "", "uint16")); VerifyOrReturn( - CheckConstraintMaxValue("currentPositionLiftPercent100ths", currentPositionLiftPercent100ths, 10000)); + CheckConstraintMaxValue("currentPositionLiftPercent100ths", currentPositionLiftPercent100ths, 10000U)); NextTest(); } @@ -30459,7 +30459,7 @@ class Test_TC_WNCV_2_1 : public TestCommand { VerifyOrReturn(CheckConstraintType("currentPositionTiltPercent100ths", "", "uint16")); VerifyOrReturn( - CheckConstraintMaxValue("currentPositionTiltPercent100ths", currentPositionTiltPercent100ths, 10000)); + CheckConstraintMaxValue("currentPositionTiltPercent100ths", currentPositionTiltPercent100ths, 10000U)); NextTest(); } @@ -30526,7 +30526,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_28(uint16_t installedOpenLimitLift) { VerifyOrReturn(CheckConstraintType("installedOpenLimitLift", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitLift", installedOpenLimitLift, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitLift", installedOpenLimitLift, 65535U)); NextTest(); } @@ -30571,7 +30571,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_30(uint16_t installedOpenLimitLift) { VerifyOrReturn(CheckConstraintType("installedOpenLimitLift", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitLift", installedOpenLimitLift, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitLift", installedOpenLimitLift, 65535U)); NextTest(); } @@ -30593,7 +30593,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_31(uint16_t installedClosedLimitLift) { VerifyOrReturn(CheckConstraintType("installedClosedLimitLift", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitLift", installedClosedLimitLift, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitLift", installedClosedLimitLift, 65535U)); NextTest(); } @@ -30638,7 +30638,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_33(uint16_t installedClosedLimitLift) { VerifyOrReturn(CheckConstraintType("installedClosedLimitLift", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitLift", installedClosedLimitLift, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitLift", installedClosedLimitLift, 65535U)); NextTest(); } @@ -30660,7 +30660,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_34(uint16_t installedOpenLimitTilt) { VerifyOrReturn(CheckConstraintType("installedOpenLimitTilt", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitTilt", installedOpenLimitTilt, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitTilt", installedOpenLimitTilt, 65535U)); NextTest(); } @@ -30705,7 +30705,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_36(uint16_t installedOpenLimitTilt) { VerifyOrReturn(CheckConstraintType("installedOpenLimitTilt", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitTilt", installedOpenLimitTilt, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitTilt", installedOpenLimitTilt, 65535U)); NextTest(); } @@ -30727,7 +30727,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_37(uint16_t installedClosedLimitTilt) { VerifyOrReturn(CheckConstraintType("installedClosedLimitTilt", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitTilt", installedClosedLimitTilt, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitTilt", installedClosedLimitTilt, 65535U)); NextTest(); } @@ -30772,7 +30772,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_39(uint16_t installedClosedLimitTilt) { VerifyOrReturn(CheckConstraintType("installedClosedLimitTilt", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitTilt", installedClosedLimitTilt, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitTilt", installedClosedLimitTilt, 65535U)); NextTest(); } @@ -30793,7 +30793,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_40(uint16_t safetyStatus) { VerifyOrReturn(CheckConstraintType("safetyStatus", "", "map16")); - VerifyOrReturn(CheckConstraintMaxValue("safetyStatus", safetyStatus, 2047)); + VerifyOrReturn(CheckConstraintMaxValue("safetyStatus", safetyStatus, 2047U)); NextTest(); } @@ -30857,7 +30857,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_43(uint16_t currentPositionLift) { VerifyOrReturn(CheckConstraintType("currentPositionLift", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("currentPositionLift", currentPositionLift, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionLift", currentPositionLift, 65535U)); NextTest(); } @@ -30900,7 +30900,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_45(uint16_t currentPositionLift) { VerifyOrReturn(CheckConstraintType("currentPositionLift", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("currentPositionLift", currentPositionLift, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionLift", currentPositionLift, 65535U)); NextTest(); } @@ -30921,7 +30921,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_46(uint16_t currentPositionTilt) { VerifyOrReturn(CheckConstraintType("currentPositionTilt", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("currentPositionTilt", currentPositionTilt, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionTilt", currentPositionTilt, 65535U)); NextTest(); } @@ -30964,7 +30964,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_48(uint16_t currentPositionTilt) { VerifyOrReturn(CheckConstraintType("currentPositionTilt", "", "uint16")); - VerifyOrReturn(CheckConstraintMaxValue("currentPositionTilt", currentPositionTilt, 65535)); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionTilt", currentPositionTilt, 65535U)); NextTest(); } @@ -35092,904 +35092,1024 @@ class TestCluster : public TestCommand err = TestReadAttributeNullableInt8uNullValue_205(); break; case 206: - ChipLogProgress(chipTool, " ***** Test Step 206 : Write attribute NULLABLE_INT16U Max Value\n"); - err = TestWriteAttributeNullableInt16uMaxValue_206(); + ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_INT8U null Value & range\n"); + err = TestReadAttributeNullableInt8uNullValueRange_206(); break; case 207: - ChipLogProgress(chipTool, " ***** Test Step 207 : Read attribute NULLABLE_INT16U Max Value\n"); - err = TestReadAttributeNullableInt16uMaxValue_207(); + ChipLogProgress(chipTool, " ***** Test Step 207 : Read attribute NULLABLE_INT8U null Value & not\n"); + err = TestReadAttributeNullableInt8uNullValueNot_207(); break; case 208: - ChipLogProgress(chipTool, " ***** Test Step 208 : Write attribute NULLABLE_INT16U Invalid Value\n"); - err = TestWriteAttributeNullableInt16uInvalidValue_208(); + ChipLogProgress(chipTool, " ***** Test Step 208 : Write attribute NULLABLE_INT8U Value\n"); + err = TestWriteAttributeNullableInt8uValue_208(); break; case 209: - ChipLogProgress(chipTool, " ***** Test Step 209 : Read attribute NULLABLE_INT16U unchanged Value\n"); - err = TestReadAttributeNullableInt16uUnchangedValue_209(); + ChipLogProgress(chipTool, " ***** Test Step 209 : Read attribute NULLABLE_INT8U Value in range\n"); + err = TestReadAttributeNullableInt8uValueInRange_209(); break; case 210: - ChipLogProgress(chipTool, " ***** Test Step 210 : Write attribute NULLABLE_INT16U null Value\n"); - err = TestWriteAttributeNullableInt16uNullValue_210(); + ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_INT8U notValue OK\n"); + err = TestReadAttributeNullableInt8uNotValueOk_210(); break; case 211: - ChipLogProgress(chipTool, " ***** Test Step 211 : Read attribute NULLABLE_INT16U null Value\n"); - err = TestReadAttributeNullableInt16uNullValue_211(); + ChipLogProgress(chipTool, " ***** Test Step 211 : Write attribute NULLABLE_INT16U Max Value\n"); + err = TestWriteAttributeNullableInt16uMaxValue_211(); break; case 212: - ChipLogProgress(chipTool, " ***** Test Step 212 : Write attribute NULLABLE_INT32U Max Value\n"); - err = TestWriteAttributeNullableInt32uMaxValue_212(); + ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT16U Max Value\n"); + err = TestReadAttributeNullableInt16uMaxValue_212(); break; case 213: - ChipLogProgress(chipTool, " ***** Test Step 213 : Read attribute NULLABLE_INT32U Max Value\n"); - err = TestReadAttributeNullableInt32uMaxValue_213(); + ChipLogProgress(chipTool, " ***** Test Step 213 : Write attribute NULLABLE_INT16U Invalid Value\n"); + err = TestWriteAttributeNullableInt16uInvalidValue_213(); break; case 214: - ChipLogProgress(chipTool, " ***** Test Step 214 : Write attribute NULLABLE_INT32U Invalid Value\n"); - err = TestWriteAttributeNullableInt32uInvalidValue_214(); + ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT16U unchanged Value\n"); + err = TestReadAttributeNullableInt16uUnchangedValue_214(); break; case 215: - ChipLogProgress(chipTool, " ***** Test Step 215 : Read attribute NULLABLE_INT32U unchanged Value\n"); - err = TestReadAttributeNullableInt32uUnchangedValue_215(); + ChipLogProgress(chipTool, " ***** Test Step 215 : Write attribute NULLABLE_INT16U null Value\n"); + err = TestWriteAttributeNullableInt16uNullValue_215(); break; case 216: - ChipLogProgress(chipTool, " ***** Test Step 216 : Write attribute NULLABLE_INT32U null Value\n"); - err = TestWriteAttributeNullableInt32uNullValue_216(); + ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT16U null Value\n"); + err = TestReadAttributeNullableInt16uNullValue_216(); break; case 217: - ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT32U null Value\n"); - err = TestReadAttributeNullableInt32uNullValue_217(); + ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT16U null Value & range\n"); + err = TestReadAttributeNullableInt16uNullValueRange_217(); break; case 218: - ChipLogProgress(chipTool, " ***** Test Step 218 : Write attribute NULLABLE_INT64U Max Value\n"); - err = TestWriteAttributeNullableInt64uMaxValue_218(); + ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT16U null Value & not\n"); + err = TestReadAttributeNullableInt16uNullValueNot_218(); break; case 219: - ChipLogProgress(chipTool, " ***** Test Step 219 : Read attribute NULLABLE_INT64U Max Value\n"); - err = TestReadAttributeNullableInt64uMaxValue_219(); + ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_INT16U Value\n"); + err = TestWriteAttributeNullableInt16uValue_219(); break; case 220: - ChipLogProgress(chipTool, " ***** Test Step 220 : Write attribute NULLABLE_INT64U Invalid Value\n"); - err = TestWriteAttributeNullableInt64uInvalidValue_220(); + ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT16U Value in range\n"); + err = TestReadAttributeNullableInt16uValueInRange_220(); break; case 221: - ChipLogProgress(chipTool, " ***** Test Step 221 : Read attribute NULLABLE_INT64U unchanged Value\n"); - err = TestReadAttributeNullableInt64uUnchangedValue_221(); + ChipLogProgress(chipTool, " ***** Test Step 221 : Read attribute NULLABLE_INT16U notValue OK\n"); + err = TestReadAttributeNullableInt16uNotValueOk_221(); break; case 222: - ChipLogProgress(chipTool, " ***** Test Step 222 : Write attribute NULLABLE_INT64U null Value\n"); - err = TestWriteAttributeNullableInt64uNullValue_222(); + ChipLogProgress(chipTool, " ***** Test Step 222 : Write attribute NULLABLE_INT32U Max Value\n"); + err = TestWriteAttributeNullableInt32uMaxValue_222(); break; case 223: - ChipLogProgress(chipTool, " ***** Test Step 223 : Read attribute NULLABLE_INT64U null Value\n"); - err = TestReadAttributeNullableInt64uNullValue_223(); + ChipLogProgress(chipTool, " ***** Test Step 223 : Read attribute NULLABLE_INT32U Max Value\n"); + err = TestReadAttributeNullableInt32uMaxValue_223(); break; case 224: - ChipLogProgress(chipTool, " ***** Test Step 224 : Write attribute NULLABLE_INT8S Min Value\n"); - err = TestWriteAttributeNullableInt8sMinValue_224(); + ChipLogProgress(chipTool, " ***** Test Step 224 : Write attribute NULLABLE_INT32U Invalid Value\n"); + err = TestWriteAttributeNullableInt32uInvalidValue_224(); break; case 225: - ChipLogProgress(chipTool, " ***** Test Step 225 : Read attribute NULLABLE_INT8S Min Value\n"); - err = TestReadAttributeNullableInt8sMinValue_225(); + ChipLogProgress(chipTool, " ***** Test Step 225 : Read attribute NULLABLE_INT32U unchanged Value\n"); + err = TestReadAttributeNullableInt32uUnchangedValue_225(); break; case 226: - ChipLogProgress(chipTool, " ***** Test Step 226 : Write attribute NULLABLE_INT8S Invalid Value\n"); - err = TestWriteAttributeNullableInt8sInvalidValue_226(); + ChipLogProgress(chipTool, " ***** Test Step 226 : Write attribute NULLABLE_INT32U null Value\n"); + err = TestWriteAttributeNullableInt32uNullValue_226(); break; case 227: - ChipLogProgress(chipTool, " ***** Test Step 227 : Read attribute NULLABLE_INT8S unchanged Value\n"); - err = TestReadAttributeNullableInt8sUnchangedValue_227(); + ChipLogProgress(chipTool, " ***** Test Step 227 : Read attribute NULLABLE_INT32U null Value\n"); + err = TestReadAttributeNullableInt32uNullValue_227(); break; case 228: - ChipLogProgress(chipTool, " ***** Test Step 228 : Write attribute NULLABLE_INT8S null Value\n"); - err = TestWriteAttributeNullableInt8sNullValue_228(); + ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_INT32U null Value & range\n"); + err = TestReadAttributeNullableInt32uNullValueRange_228(); break; case 229: - ChipLogProgress(chipTool, " ***** Test Step 229 : Read attribute NULLABLE_INT8S null Value\n"); - err = TestReadAttributeNullableInt8sNullValue_229(); + ChipLogProgress(chipTool, " ***** Test Step 229 : Read attribute NULLABLE_INT32U null Value & not\n"); + err = TestReadAttributeNullableInt32uNullValueNot_229(); break; case 230: - ChipLogProgress(chipTool, " ***** Test Step 230 : Write attribute NULLABLE_INT16S Min Value\n"); - err = TestWriteAttributeNullableInt16sMinValue_230(); + ChipLogProgress(chipTool, " ***** Test Step 230 : Write attribute NULLABLE_INT32U Value\n"); + err = TestWriteAttributeNullableInt32uValue_230(); break; case 231: - ChipLogProgress(chipTool, " ***** Test Step 231 : Read attribute NULLABLE_INT16S Min Value\n"); - err = TestReadAttributeNullableInt16sMinValue_231(); + ChipLogProgress(chipTool, " ***** Test Step 231 : Read attribute NULLABLE_INT32U Value in range\n"); + err = TestReadAttributeNullableInt32uValueInRange_231(); break; case 232: - ChipLogProgress(chipTool, " ***** Test Step 232 : Write attribute NULLABLE_INT16S Invalid Value\n"); - err = TestWriteAttributeNullableInt16sInvalidValue_232(); + ChipLogProgress(chipTool, " ***** Test Step 232 : Read attribute NULLABLE_INT32U notValue OK\n"); + err = TestReadAttributeNullableInt32uNotValueOk_232(); break; case 233: - ChipLogProgress(chipTool, " ***** Test Step 233 : Read attribute NULLABLE_INT16S unchanged Value\n"); - err = TestReadAttributeNullableInt16sUnchangedValue_233(); + ChipLogProgress(chipTool, " ***** Test Step 233 : Write attribute NULLABLE_INT64U Max Value\n"); + err = TestWriteAttributeNullableInt64uMaxValue_233(); break; case 234: - ChipLogProgress(chipTool, " ***** Test Step 234 : Write attribute NULLABLE_INT16S null Value\n"); - err = TestWriteAttributeNullableInt16sNullValue_234(); + ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_INT64U Max Value\n"); + err = TestReadAttributeNullableInt64uMaxValue_234(); break; case 235: - ChipLogProgress(chipTool, " ***** Test Step 235 : Read attribute NULLABLE_INT16S null Value\n"); - err = TestReadAttributeNullableInt16sNullValue_235(); + ChipLogProgress(chipTool, " ***** Test Step 235 : Write attribute NULLABLE_INT64U Invalid Value\n"); + err = TestWriteAttributeNullableInt64uInvalidValue_235(); break; case 236: - ChipLogProgress(chipTool, " ***** Test Step 236 : Write attribute NULLABLE_INT32S Min Value\n"); - err = TestWriteAttributeNullableInt32sMinValue_236(); + ChipLogProgress(chipTool, " ***** Test Step 236 : Read attribute NULLABLE_INT64U unchanged Value\n"); + err = TestReadAttributeNullableInt64uUnchangedValue_236(); break; case 237: - ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_INT32S Min Value\n"); - err = TestReadAttributeNullableInt32sMinValue_237(); + ChipLogProgress(chipTool, " ***** Test Step 237 : Write attribute NULLABLE_INT64U null Value\n"); + err = TestWriteAttributeNullableInt64uNullValue_237(); break; case 238: - ChipLogProgress(chipTool, " ***** Test Step 238 : Write attribute NULLABLE_INT32S Invalid Value\n"); - err = TestWriteAttributeNullableInt32sInvalidValue_238(); + ChipLogProgress(chipTool, " ***** Test Step 238 : Read attribute NULLABLE_INT64U null Value\n"); + err = TestReadAttributeNullableInt64uNullValue_238(); break; case 239: - ChipLogProgress(chipTool, " ***** Test Step 239 : Read attribute NULLABLE_INT32S unchanged Value\n"); - err = TestReadAttributeNullableInt32sUnchangedValue_239(); + ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_INT8S Min Value\n"); + err = TestWriteAttributeNullableInt8sMinValue_239(); break; case 240: - ChipLogProgress(chipTool, " ***** Test Step 240 : Write attribute NULLABLE_INT32S null Value\n"); - err = TestWriteAttributeNullableInt32sNullValue_240(); + ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT8S Min Value\n"); + err = TestReadAttributeNullableInt8sMinValue_240(); break; case 241: - ChipLogProgress(chipTool, " ***** Test Step 241 : Read attribute NULLABLE_INT32S null Value\n"); - err = TestReadAttributeNullableInt32sNullValue_241(); + ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_INT8S Invalid Value\n"); + err = TestWriteAttributeNullableInt8sInvalidValue_241(); break; case 242: - ChipLogProgress(chipTool, " ***** Test Step 242 : Write attribute NULLABLE_INT64S Min Value\n"); - err = TestWriteAttributeNullableInt64sMinValue_242(); + ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT8S unchanged Value\n"); + err = TestReadAttributeNullableInt8sUnchangedValue_242(); break; case 243: - ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_INT64S Min Value\n"); - err = TestReadAttributeNullableInt64sMinValue_243(); + ChipLogProgress(chipTool, " ***** Test Step 243 : Write attribute NULLABLE_INT8S null Value\n"); + err = TestWriteAttributeNullableInt8sNullValue_243(); break; case 244: - ChipLogProgress(chipTool, " ***** Test Step 244 : Write attribute NULLABLE_INT64S Invalid Value\n"); - err = TestWriteAttributeNullableInt64sInvalidValue_244(); + ChipLogProgress(chipTool, " ***** Test Step 244 : Read attribute NULLABLE_INT8S null Value\n"); + err = TestReadAttributeNullableInt8sNullValue_244(); break; case 245: - ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_INT64S unchanged Value\n"); - err = TestReadAttributeNullableInt64sUnchangedValue_245(); + ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_INT8S null Value & range\n"); + err = TestReadAttributeNullableInt8sNullValueRange_245(); break; case 246: - ChipLogProgress(chipTool, " ***** Test Step 246 : Write attribute NULLABLE_INT64S null Value\n"); - err = TestWriteAttributeNullableInt64sNullValue_246(); + ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT8S null Value & not\n"); + err = TestReadAttributeNullableInt8sNullValueNot_246(); break; case 247: - ChipLogProgress(chipTool, " ***** Test Step 247 : Read attribute NULLABLE_INT64S null Value\n"); - err = TestReadAttributeNullableInt64sNullValue_247(); + ChipLogProgress(chipTool, " ***** Test Step 247 : Write attribute NULLABLE_INT8S Value\n"); + err = TestWriteAttributeNullableInt8sValue_247(); break; case 248: - ChipLogProgress(chipTool, " ***** Test Step 248 : Write attribute NULLABLE_SINGLE medium Value\n"); - err = TestWriteAttributeNullableSingleMediumValue_248(); + ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_INT8S Value in range\n"); + err = TestReadAttributeNullableInt8sValueInRange_248(); break; case 249: - ChipLogProgress(chipTool, " ***** Test Step 249 : Read attribute NULLABLE_SINGLE medium Value\n"); - err = TestReadAttributeNullableSingleMediumValue_249(); + ChipLogProgress(chipTool, " ***** Test Step 249 : Read attribute NULLABLE_INT8S notValue OK\n"); + err = TestReadAttributeNullableInt8sNotValueOk_249(); break; case 250: - ChipLogProgress(chipTool, " ***** Test Step 250 : Write attribute NULLABLE_SINGLE largest Value\n"); - err = TestWriteAttributeNullableSingleLargestValue_250(); + ChipLogProgress(chipTool, " ***** Test Step 250 : Write attribute NULLABLE_INT16S Min Value\n"); + err = TestWriteAttributeNullableInt16sMinValue_250(); break; case 251: - ChipLogProgress(chipTool, " ***** Test Step 251 : Read attribute NULLABLE_SINGLE largest Value\n"); - err = TestReadAttributeNullableSingleLargestValue_251(); + ChipLogProgress(chipTool, " ***** Test Step 251 : Read attribute NULLABLE_INT16S Min Value\n"); + err = TestReadAttributeNullableInt16sMinValue_251(); break; case 252: - ChipLogProgress(chipTool, " ***** Test Step 252 : Write attribute NULLABLE_SINGLE smallest Value\n"); - err = TestWriteAttributeNullableSingleSmallestValue_252(); + ChipLogProgress(chipTool, " ***** Test Step 252 : Write attribute NULLABLE_INT16S Invalid Value\n"); + err = TestWriteAttributeNullableInt16sInvalidValue_252(); break; case 253: - ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_SINGLE smallest Value\n"); - err = TestReadAttributeNullableSingleSmallestValue_253(); + ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_INT16S unchanged Value\n"); + err = TestReadAttributeNullableInt16sUnchangedValue_253(); break; case 254: - ChipLogProgress(chipTool, " ***** Test Step 254 : Write attribute NULLABLE_SINGLE null Value\n"); - err = TestWriteAttributeNullableSingleNullValue_254(); + ChipLogProgress(chipTool, " ***** Test Step 254 : Write attribute NULLABLE_INT16S null Value\n"); + err = TestWriteAttributeNullableInt16sNullValue_254(); break; case 255: - ChipLogProgress(chipTool, " ***** Test Step 255 : Read attribute NULLABLE_SINGLE null Value\n"); - err = TestReadAttributeNullableSingleNullValue_255(); + ChipLogProgress(chipTool, " ***** Test Step 255 : Read attribute NULLABLE_INT16S null Value\n"); + err = TestReadAttributeNullableInt16sNullValue_255(); break; case 256: - ChipLogProgress(chipTool, " ***** Test Step 256 : Write attribute NULLABLE_SINGLE 0 Value\n"); - err = TestWriteAttributeNullableSingle0Value_256(); + ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_INT16S null Value & range\n"); + err = TestReadAttributeNullableInt16sNullValueRange_256(); break; case 257: - ChipLogProgress(chipTool, " ***** Test Step 257 : Read attribute NULLABLE_SINGLE 0 Value\n"); - err = TestReadAttributeNullableSingle0Value_257(); + ChipLogProgress(chipTool, " ***** Test Step 257 : Read attribute NULLABLE_INT16S null Value & not\n"); + err = TestReadAttributeNullableInt16sNullValueNot_257(); break; case 258: - ChipLogProgress(chipTool, " ***** Test Step 258 : Write attribute NULLABLE_DOUBLE medium Value\n"); - err = TestWriteAttributeNullableDoubleMediumValue_258(); + ChipLogProgress(chipTool, " ***** Test Step 258 : Write attribute NULLABLE_INT16S Value\n"); + err = TestWriteAttributeNullableInt16sValue_258(); break; case 259: - ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_DOUBLE medium Value\n"); - err = TestReadAttributeNullableDoubleMediumValue_259(); + ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_INT16S Value in range\n"); + err = TestReadAttributeNullableInt16sValueInRange_259(); break; case 260: - ChipLogProgress(chipTool, " ***** Test Step 260 : Write attribute NULLABLE_DOUBLE largest Value\n"); - err = TestWriteAttributeNullableDoubleLargestValue_260(); + ChipLogProgress(chipTool, " ***** Test Step 260 : Read attribute NULLABLE_INT16S notValue OK\n"); + err = TestReadAttributeNullableInt16sNotValueOk_260(); break; case 261: - ChipLogProgress(chipTool, " ***** Test Step 261 : Read attribute NULLABLE_DOUBLE largest Value\n"); - err = TestReadAttributeNullableDoubleLargestValue_261(); + ChipLogProgress(chipTool, " ***** Test Step 261 : Write attribute NULLABLE_INT32S Min Value\n"); + err = TestWriteAttributeNullableInt32sMinValue_261(); break; case 262: - ChipLogProgress(chipTool, " ***** Test Step 262 : Write attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestWriteAttributeNullableDoubleSmallestValue_262(); + ChipLogProgress(chipTool, " ***** Test Step 262 : Read attribute NULLABLE_INT32S Min Value\n"); + err = TestReadAttributeNullableInt32sMinValue_262(); break; case 263: - ChipLogProgress(chipTool, " ***** Test Step 263 : Read attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestReadAttributeNullableDoubleSmallestValue_263(); + ChipLogProgress(chipTool, " ***** Test Step 263 : Write attribute NULLABLE_INT32S Invalid Value\n"); + err = TestWriteAttributeNullableInt32sInvalidValue_263(); break; case 264: - ChipLogProgress(chipTool, " ***** Test Step 264 : Write attribute NULLABLE_DOUBLE null Value\n"); - err = TestWriteAttributeNullableDoubleNullValue_264(); + ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_INT32S unchanged Value\n"); + err = TestReadAttributeNullableInt32sUnchangedValue_264(); break; case 265: - ChipLogProgress(chipTool, " ***** Test Step 265 : Read attribute NULLABLE_DOUBLE null Value\n"); - err = TestReadAttributeNullableDoubleNullValue_265(); + ChipLogProgress(chipTool, " ***** Test Step 265 : Write attribute NULLABLE_INT32S null Value\n"); + err = TestWriteAttributeNullableInt32sNullValue_265(); break; case 266: - ChipLogProgress(chipTool, " ***** Test Step 266 : Write attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestWriteAttributeNullableDouble0Value_266(); + ChipLogProgress(chipTool, " ***** Test Step 266 : Read attribute NULLABLE_INT32S null Value\n"); + err = TestReadAttributeNullableInt32sNullValue_266(); break; case 267: - ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestReadAttributeNullableDouble0Value_267(); + ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_INT32S null Value & range\n"); + err = TestReadAttributeNullableInt32sNullValueRange_267(); break; case 268: - ChipLogProgress(chipTool, " ***** Test Step 268 : Write attribute NULLABLE_ENUM8 Max Value\n"); - err = TestWriteAttributeNullableEnum8MaxValue_268(); + ChipLogProgress(chipTool, " ***** Test Step 268 : Read attribute NULLABLE_INT32S null Value & not\n"); + err = TestReadAttributeNullableInt32sNullValueNot_268(); break; case 269: - ChipLogProgress(chipTool, " ***** Test Step 269 : Read attribute NULLABLE_ENUM8 Max Value\n"); - err = TestReadAttributeNullableEnum8MaxValue_269(); + ChipLogProgress(chipTool, " ***** Test Step 269 : Write attribute NULLABLE_INT32S Value\n"); + err = TestWriteAttributeNullableInt32sValue_269(); break; case 270: - ChipLogProgress(chipTool, " ***** Test Step 270 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); - err = TestWriteAttributeNullableEnum8InvalidValue_270(); + ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_INT32S Value in range\n"); + err = TestReadAttributeNullableInt32sValueInRange_270(); break; case 271: - ChipLogProgress(chipTool, " ***** Test Step 271 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); - err = TestReadAttributeNullableEnum8UnchangedValue_271(); + ChipLogProgress(chipTool, " ***** Test Step 271 : Read attribute NULLABLE_INT32S notValue OK\n"); + err = TestReadAttributeNullableInt32sNotValueOk_271(); break; case 272: - ChipLogProgress(chipTool, " ***** Test Step 272 : Write attribute NULLABLE_ENUM8 null Value\n"); - err = TestWriteAttributeNullableEnum8NullValue_272(); + ChipLogProgress(chipTool, " ***** Test Step 272 : Write attribute NULLABLE_INT64S Min Value\n"); + err = TestWriteAttributeNullableInt64sMinValue_272(); break; case 273: - ChipLogProgress(chipTool, " ***** Test Step 273 : Read attribute NULLABLE_ENUM8 null Value\n"); - err = TestReadAttributeNullableEnum8NullValue_273(); + ChipLogProgress(chipTool, " ***** Test Step 273 : Read attribute NULLABLE_INT64S Min Value\n"); + err = TestReadAttributeNullableInt64sMinValue_273(); break; case 274: - ChipLogProgress(chipTool, " ***** Test Step 274 : Write attribute NULLABLE_ENUM16 Max Value\n"); - err = TestWriteAttributeNullableEnum16MaxValue_274(); + ChipLogProgress(chipTool, " ***** Test Step 274 : Write attribute NULLABLE_INT64S Invalid Value\n"); + err = TestWriteAttributeNullableInt64sInvalidValue_274(); break; case 275: - ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_ENUM16 Max Value\n"); - err = TestReadAttributeNullableEnum16MaxValue_275(); + ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_INT64S unchanged Value\n"); + err = TestReadAttributeNullableInt64sUnchangedValue_275(); break; case 276: - ChipLogProgress(chipTool, " ***** Test Step 276 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); - err = TestWriteAttributeNullableEnum16InvalidValue_276(); + ChipLogProgress(chipTool, " ***** Test Step 276 : Write attribute NULLABLE_INT64S null Value\n"); + err = TestWriteAttributeNullableInt64sNullValue_276(); break; case 277: - ChipLogProgress(chipTool, " ***** Test Step 277 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); - err = TestReadAttributeNullableEnum16UnchangedValue_277(); + ChipLogProgress(chipTool, " ***** Test Step 277 : Read attribute NULLABLE_INT64S null Value\n"); + err = TestReadAttributeNullableInt64sNullValue_277(); break; case 278: - ChipLogProgress(chipTool, " ***** Test Step 278 : Write attribute NULLABLE_ENUM16 null Value\n"); - err = TestWriteAttributeNullableEnum16NullValue_278(); + ChipLogProgress(chipTool, " ***** Test Step 278 : Write attribute NULLABLE_SINGLE medium Value\n"); + err = TestWriteAttributeNullableSingleMediumValue_278(); break; case 279: - ChipLogProgress(chipTool, " ***** Test Step 279 : Read attribute NULLABLE_ENUM16 null Value\n"); - err = TestReadAttributeNullableEnum16NullValue_279(); + ChipLogProgress(chipTool, " ***** Test Step 279 : Read attribute NULLABLE_SINGLE medium Value\n"); + err = TestReadAttributeNullableSingleMediumValue_279(); break; case 280: - ChipLogProgress(chipTool, " ***** Test Step 280 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); - err = TestReadAttributeNullableOctetStringDefaultValue_280(); + ChipLogProgress(chipTool, " ***** Test Step 280 : Write attribute NULLABLE_SINGLE largest Value\n"); + err = TestWriteAttributeNullableSingleLargestValue_280(); break; case 281: - ChipLogProgress(chipTool, " ***** Test Step 281 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_281(); + ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_SINGLE largest Value\n"); + err = TestReadAttributeNullableSingleLargestValue_281(); break; case 282: - ChipLogProgress(chipTool, " ***** Test Step 282 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_282(); + ChipLogProgress(chipTool, " ***** Test Step 282 : Write attribute NULLABLE_SINGLE smallest Value\n"); + err = TestWriteAttributeNullableSingleSmallestValue_282(); break; case 283: - ChipLogProgress(chipTool, " ***** Test Step 283 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_283(); + ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_SINGLE smallest Value\n"); + err = TestReadAttributeNullableSingleSmallestValue_283(); break; case 284: - ChipLogProgress(chipTool, " ***** Test Step 284 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_284(); + ChipLogProgress(chipTool, " ***** Test Step 284 : Write attribute NULLABLE_SINGLE null Value\n"); + err = TestWriteAttributeNullableSingleNullValue_284(); break; case 285: - ChipLogProgress(chipTool, " ***** Test Step 285 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_285(); + ChipLogProgress(chipTool, " ***** Test Step 285 : Read attribute NULLABLE_SINGLE null Value\n"); + err = TestReadAttributeNullableSingleNullValue_285(); break; case 286: - ChipLogProgress(chipTool, " ***** Test Step 286 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_286(); + ChipLogProgress(chipTool, " ***** Test Step 286 : Write attribute NULLABLE_SINGLE 0 Value\n"); + err = TestWriteAttributeNullableSingle0Value_286(); break; case 287: - ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); - err = TestReadAttributeNullableCharStringDefaultValue_287(); + ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_SINGLE 0 Value\n"); + err = TestReadAttributeNullableSingle0Value_287(); break; case 288: - ChipLogProgress(chipTool, " ***** Test Step 288 : Write attribute NULLABLE_CHAR_STRING\n"); - err = TestWriteAttributeNullableCharString_288(); + ChipLogProgress(chipTool, " ***** Test Step 288 : Write attribute NULLABLE_DOUBLE medium Value\n"); + err = TestWriteAttributeNullableDoubleMediumValue_288(); break; case 289: - ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_289(); + ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_DOUBLE medium Value\n"); + err = TestReadAttributeNullableDoubleMediumValue_289(); break; case 290: - ChipLogProgress(chipTool, " ***** Test Step 290 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); - err = TestWriteAttributeNullableCharStringValueTooLong_290(); + ChipLogProgress(chipTool, " ***** Test Step 290 : Write attribute NULLABLE_DOUBLE largest Value\n"); + err = TestWriteAttributeNullableDoubleLargestValue_290(); break; case 291: - ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_291(); + ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_DOUBLE largest Value\n"); + err = TestReadAttributeNullableDoubleLargestValue_291(); break; case 292: - ChipLogProgress(chipTool, " ***** Test Step 292 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); - err = TestWriteAttributeNullableCharStringEmpty_292(); + ChipLogProgress(chipTool, " ***** Test Step 292 : Write attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestWriteAttributeNullableDoubleSmallestValue_292(); break; case 293: - ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_293(); + ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestReadAttributeNullableDoubleSmallestValue_293(); break; case 294: - ChipLogProgress(chipTool, " ***** Test Step 294 : Read attribute from nonexistent endpoint.\n"); - err = TestReadAttributeFromNonexistentEndpoint_294(); + ChipLogProgress(chipTool, " ***** Test Step 294 : Write attribute NULLABLE_DOUBLE null Value\n"); + err = TestWriteAttributeNullableDoubleNullValue_294(); break; case 295: - ChipLogProgress(chipTool, " ***** Test Step 295 : Read attribute from nonexistent cluster.\n"); - err = TestReadAttributeFromNonexistentCluster_295(); + ChipLogProgress(chipTool, " ***** Test Step 295 : Read attribute NULLABLE_DOUBLE null Value\n"); + err = TestReadAttributeNullableDoubleNullValue_295(); break; case 296: - ChipLogProgress(chipTool, - " ***** Test Step 296 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_296(); + ChipLogProgress(chipTool, " ***** Test Step 296 : Write attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestWriteAttributeNullableDouble0Value_296(); break; case 297: - ChipLogProgress(chipTool, - " ***** Test Step 297 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_297(); + ChipLogProgress(chipTool, " ***** Test Step 297 : Read attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestReadAttributeNullableDouble0Value_297(); break; case 298: - ChipLogProgress(chipTool, " ***** Test Step 298 : Report: Subscribe to list attribute\n"); - err = TestReportSubscribeToListAttribute_298(); + ChipLogProgress(chipTool, " ***** Test Step 298 : Write attribute NULLABLE_ENUM8 Max Value\n"); + err = TestWriteAttributeNullableEnum8MaxValue_298(); break; case 299: - ChipLogProgress(chipTool, " ***** Test Step 299 : Subscribe to list attribute\n"); - err = TestSubscribeToListAttribute_299(); + ChipLogProgress(chipTool, " ***** Test Step 299 : Read attribute NULLABLE_ENUM8 Max Value\n"); + err = TestReadAttributeNullableEnum8MaxValue_299(); break; case 300: - ChipLogProgress(chipTool, " ***** Test Step 300 : Write subscribed-to list attribute\n"); - err = TestWriteSubscribedToListAttribute_300(); + ChipLogProgress(chipTool, " ***** Test Step 300 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); + err = TestWriteAttributeNullableEnum8InvalidValue_300(); break; case 301: - ChipLogProgress(chipTool, " ***** Test Step 301 : Check for list attribute report\n"); - err = TestCheckForListAttributeReport_301(); + ChipLogProgress(chipTool, " ***** Test Step 301 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); + err = TestReadAttributeNullableEnum8UnchangedValue_301(); break; case 302: - ChipLogProgress(chipTool, " ***** Test Step 302 : Read range-restricted unsigned 8-bit integer\n"); - err = TestReadRangeRestrictedUnsigned8BitInteger_302(); + ChipLogProgress(chipTool, " ***** Test Step 302 : Write attribute NULLABLE_ENUM8 null Value\n"); + err = TestWriteAttributeNullableEnum8NullValue_302(); break; case 303: - ChipLogProgress(chipTool, " ***** Test Step 303 : Write min value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_303(); + ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_ENUM8 null Value\n"); + err = TestReadAttributeNullableEnum8NullValue_303(); break; case 304: - ChipLogProgress(chipTool, - " ***** Test Step 304 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_304(); + ChipLogProgress(chipTool, " ***** Test Step 304 : Write attribute NULLABLE_ENUM16 Max Value\n"); + err = TestWriteAttributeNullableEnum16MaxValue_304(); break; case 305: - ChipLogProgress(chipTool, - " ***** Test Step 305 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_305(); + ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_ENUM16 Max Value\n"); + err = TestReadAttributeNullableEnum16MaxValue_305(); break; case 306: - ChipLogProgress(chipTool, " ***** Test Step 306 : Write max value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_306(); + ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); + err = TestWriteAttributeNullableEnum16InvalidValue_306(); break; case 307: - ChipLogProgress(chipTool, - " ***** Test Step 307 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_307(); + ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); + err = TestReadAttributeNullableEnum16UnchangedValue_307(); break; case 308: - ChipLogProgress(chipTool, - " ***** Test Step 308 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_308(); + ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_ENUM16 null Value\n"); + err = TestWriteAttributeNullableEnum16NullValue_308(); break; case 309: - ChipLogProgress(chipTool, - " ***** Test Step 309 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_309(); + ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_ENUM16 null Value\n"); + err = TestReadAttributeNullableEnum16NullValue_309(); break; case 310: - ChipLogProgress(chipTool, - " ***** Test Step 310 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_310(); + ChipLogProgress(chipTool, " ***** Test Step 310 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); + err = TestReadAttributeNullableOctetStringDefaultValue_310(); break; case 311: - ChipLogProgress(chipTool, - " ***** Test Step 311 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_311(); + ChipLogProgress(chipTool, " ***** Test Step 311 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_311(); break; case 312: - ChipLogProgress(chipTool, - " ***** Test Step 312 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_312(); + ChipLogProgress(chipTool, " ***** Test Step 312 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_312(); break; case 313: - ChipLogProgress(chipTool, - " ***** Test Step 313 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_313(); + ChipLogProgress(chipTool, " ***** Test Step 313 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_313(); break; case 314: - ChipLogProgress(chipTool, " ***** Test Step 314 : Read range-restricted unsigned 16-bit integer\n"); - err = TestReadRangeRestrictedUnsigned16BitInteger_314(); + ChipLogProgress(chipTool, " ***** Test Step 314 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_314(); break; case 315: - ChipLogProgress(chipTool, " ***** Test Step 315 : Write min value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_315(); + ChipLogProgress(chipTool, " ***** Test Step 315 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_315(); break; case 316: - ChipLogProgress(chipTool, - " ***** Test Step 316 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_316(); + ChipLogProgress(chipTool, " ***** Test Step 316 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_316(); break; case 317: - ChipLogProgress(chipTool, - " ***** Test Step 317 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_317(); + ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); + err = TestReadAttributeNullableCharStringDefaultValue_317(); break; case 318: - ChipLogProgress(chipTool, " ***** Test Step 318 : Write max value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_318(); + ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_CHAR_STRING\n"); + err = TestWriteAttributeNullableCharString_318(); break; case 319: - ChipLogProgress(chipTool, - " ***** Test Step 319 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_319(); + ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_319(); break; case 320: - ChipLogProgress(chipTool, - " ***** Test Step 320 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_320(); + ChipLogProgress(chipTool, " ***** Test Step 320 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); + err = TestWriteAttributeNullableCharStringValueTooLong_320(); break; case 321: - ChipLogProgress(chipTool, - " ***** Test Step 321 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_321(); + ChipLogProgress(chipTool, " ***** Test Step 321 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_321(); break; case 322: - ChipLogProgress(chipTool, - " ***** Test Step 322 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_322(); + ChipLogProgress(chipTool, " ***** Test Step 322 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); + err = TestWriteAttributeNullableCharStringEmpty_322(); break; case 323: - ChipLogProgress(chipTool, - " ***** Test Step 323 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_323(); + ChipLogProgress(chipTool, " ***** Test Step 323 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_323(); break; case 324: - ChipLogProgress(chipTool, - " ***** Test Step 324 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_324(); + ChipLogProgress(chipTool, " ***** Test Step 324 : Read attribute from nonexistent endpoint.\n"); + err = TestReadAttributeFromNonexistentEndpoint_324(); break; case 325: - ChipLogProgress(chipTool, - " ***** Test Step 325 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_325(); + ChipLogProgress(chipTool, " ***** Test Step 325 : Read attribute from nonexistent cluster.\n"); + err = TestReadAttributeFromNonexistentCluster_325(); break; case 326: - ChipLogProgress(chipTool, " ***** Test Step 326 : Read range-restricted signed 8-bit integer\n"); - err = TestReadRangeRestrictedSigned8BitInteger_326(); + ChipLogProgress(chipTool, + " ***** Test Step 326 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_326(); break; case 327: - ChipLogProgress(chipTool, " ***** Test Step 327 : Write min value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_327(); + ChipLogProgress(chipTool, + " ***** Test Step 327 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_327(); break; case 328: - ChipLogProgress(chipTool, - " ***** Test Step 328 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_328(); + ChipLogProgress(chipTool, " ***** Test Step 328 : Report: Subscribe to list attribute\n"); + err = TestReportSubscribeToListAttribute_328(); break; case 329: - ChipLogProgress(chipTool, - " ***** Test Step 329 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_329(); + ChipLogProgress(chipTool, " ***** Test Step 329 : Subscribe to list attribute\n"); + err = TestSubscribeToListAttribute_329(); break; case 330: - ChipLogProgress(chipTool, " ***** Test Step 330 : Write max value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_330(); + ChipLogProgress(chipTool, " ***** Test Step 330 : Write subscribed-to list attribute\n"); + err = TestWriteSubscribedToListAttribute_330(); break; case 331: - ChipLogProgress(chipTool, - " ***** Test Step 331 : Verify range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_331(); + ChipLogProgress(chipTool, " ***** Test Step 331 : Check for list attribute report\n"); + err = TestCheckForListAttributeReport_331(); break; case 332: - ChipLogProgress(chipTool, " ***** Test Step 332 : Write min valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_332(); + ChipLogProgress(chipTool, " ***** Test Step 332 : Read range-restricted unsigned 8-bit integer\n"); + err = TestReadRangeRestrictedUnsigned8BitInteger_332(); break; case 333: - ChipLogProgress(chipTool, - " ***** Test Step 333 : Verify range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_333(); + ChipLogProgress(chipTool, " ***** Test Step 333 : Write min value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_333(); break; case 334: - ChipLogProgress(chipTool, " ***** Test Step 334 : Write max valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_334(); + ChipLogProgress(chipTool, + " ***** Test Step 334 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_334(); break; case 335: ChipLogProgress(chipTool, - " ***** Test Step 335 : Verify range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_335(); + " ***** Test Step 335 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_335(); break; case 336: - ChipLogProgress(chipTool, - " ***** Test Step 336 : Write middle valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_336(); + ChipLogProgress(chipTool, " ***** Test Step 336 : Write max value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_336(); break; case 337: ChipLogProgress(chipTool, - " ***** Test Step 337 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_337(); + " ***** Test Step 337 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_337(); break; case 338: - ChipLogProgress(chipTool, " ***** Test Step 338 : Read range-restricted signed 16-bit integer\n"); - err = TestReadRangeRestrictedSigned16BitInteger_338(); + ChipLogProgress(chipTool, + " ***** Test Step 338 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_338(); break; case 339: - ChipLogProgress(chipTool, " ***** Test Step 339 : Write min value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_339(); + ChipLogProgress(chipTool, + " ***** Test Step 339 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_339(); break; case 340: ChipLogProgress(chipTool, - " ***** Test Step 340 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_340(); + " ***** Test Step 340 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_340(); break; case 341: ChipLogProgress(chipTool, - " ***** Test Step 341 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_341(); + " ***** Test Step 341 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_341(); break; case 342: - ChipLogProgress(chipTool, " ***** Test Step 342 : Write max value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_342(); + ChipLogProgress(chipTool, + " ***** Test Step 342 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_342(); break; case 343: ChipLogProgress(chipTool, - " ***** Test Step 343 : Verify range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_343(); + " ***** Test Step 343 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_343(); break; case 344: - ChipLogProgress(chipTool, " ***** Test Step 344 : Write min valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_344(); + ChipLogProgress(chipTool, " ***** Test Step 344 : Read range-restricted unsigned 16-bit integer\n"); + err = TestReadRangeRestrictedUnsigned16BitInteger_344(); break; case 345: - ChipLogProgress(chipTool, - " ***** Test Step 345 : Verify range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_345(); + ChipLogProgress(chipTool, " ***** Test Step 345 : Write min value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_345(); break; case 346: - ChipLogProgress(chipTool, " ***** Test Step 346 : Write max valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_346(); + ChipLogProgress(chipTool, + " ***** Test Step 346 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_346(); break; case 347: ChipLogProgress(chipTool, - " ***** Test Step 347 : Verify range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_347(); + " ***** Test Step 347 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_347(); break; case 348: - ChipLogProgress(chipTool, - " ***** Test Step 348 : Write middle valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_348(); + ChipLogProgress(chipTool, " ***** Test Step 348 : Write max value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_348(); break; case 349: ChipLogProgress(chipTool, - " ***** Test Step 349 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_349(); + " ***** Test Step 349 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_349(); break; case 350: - ChipLogProgress(chipTool, " ***** Test Step 350 : Read nullable range-restricted unsigned 8-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned8BitInteger_350(); + ChipLogProgress(chipTool, + " ***** Test Step 350 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_350(); break; case 351: ChipLogProgress(chipTool, - " ***** Test Step 351 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_351(); + " ***** Test Step 351 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_351(); break; case 352: - ChipLogProgress( - chipTool, - " ***** Test Step 352 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_352(); + ChipLogProgress(chipTool, + " ***** Test Step 352 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_352(); break; case 353: - ChipLogProgress( - chipTool, - " ***** Test Step 353 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_353(); + ChipLogProgress(chipTool, + " ***** Test Step 353 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_353(); break; case 354: ChipLogProgress(chipTool, - " ***** Test Step 354 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_354(); + " ***** Test Step 354 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_354(); break; case 355: - ChipLogProgress( - chipTool, " ***** Test Step 355 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_355(); + ChipLogProgress(chipTool, + " ***** Test Step 355 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_355(); break; case 356: - ChipLogProgress(chipTool, - " ***** Test Step 356 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_356(); + ChipLogProgress(chipTool, " ***** Test Step 356 : Read range-restricted signed 8-bit integer\n"); + err = TestReadRangeRestrictedSigned8BitInteger_356(); break; case 357: - ChipLogProgress( - chipTool, " ***** Test Step 357 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_357(); + ChipLogProgress(chipTool, " ***** Test Step 357 : Write min value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_357(); break; case 358: ChipLogProgress(chipTool, - " ***** Test Step 358 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_358(); + " ***** Test Step 358 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_358(); break; case 359: - ChipLogProgress( - chipTool, " ***** Test Step 359 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_359(); + ChipLogProgress(chipTool, + " ***** Test Step 359 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_359(); break; case 360: - ChipLogProgress( - chipTool, - " ***** Test Step 360 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_360(); + ChipLogProgress(chipTool, " ***** Test Step 360 : Write max value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_360(); break; case 361: - ChipLogProgress( - chipTool, " ***** Test Step 361 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_361(); + ChipLogProgress(chipTool, + " ***** Test Step 361 : Verify range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_361(); break; case 362: - ChipLogProgress(chipTool, - " ***** Test Step 362 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_362(); + ChipLogProgress(chipTool, " ***** Test Step 362 : Write min valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_362(); break; case 363: ChipLogProgress(chipTool, - " ***** Test Step 363 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_363(); + " ***** Test Step 363 : Verify range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_363(); break; case 364: - ChipLogProgress(chipTool, " ***** Test Step 364 : Read nullable range-restricted unsigned 16-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned16BitInteger_364(); + ChipLogProgress(chipTool, " ***** Test Step 364 : Write max valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_364(); break; case 365: ChipLogProgress(chipTool, - " ***** Test Step 365 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_365(); + " ***** Test Step 365 : Verify range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_365(); break; case 366: - ChipLogProgress( - chipTool, - " ***** Test Step 366 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_366(); + ChipLogProgress(chipTool, + " ***** Test Step 366 : Write middle valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_366(); break; case 367: - ChipLogProgress( - chipTool, - " ***** Test Step 367 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_367(); + ChipLogProgress(chipTool, + " ***** Test Step 367 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_367(); break; case 368: - ChipLogProgress(chipTool, - " ***** Test Step 368 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_368(); + ChipLogProgress(chipTool, " ***** Test Step 368 : Read range-restricted signed 16-bit integer\n"); + err = TestReadRangeRestrictedSigned16BitInteger_368(); break; case 369: - ChipLogProgress( - chipTool, - " ***** Test Step 369 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_369(); + ChipLogProgress(chipTool, " ***** Test Step 369 : Write min value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_369(); break; case 370: - ChipLogProgress( - chipTool, " ***** Test Step 370 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_370(); + ChipLogProgress(chipTool, + " ***** Test Step 370 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_370(); break; case 371: - ChipLogProgress( - chipTool, - " ***** Test Step 371 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_371(); + ChipLogProgress(chipTool, + " ***** Test Step 371 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_371(); break; case 372: - ChipLogProgress( - chipTool, " ***** Test Step 372 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_372(); + ChipLogProgress(chipTool, " ***** Test Step 372 : Write max value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_372(); break; case 373: - ChipLogProgress( - chipTool, - " ***** Test Step 373 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_373(); + ChipLogProgress(chipTool, + " ***** Test Step 373 : Verify range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_373(); break; case 374: - ChipLogProgress( - chipTool, - " ***** Test Step 374 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_374(); + ChipLogProgress(chipTool, " ***** Test Step 374 : Write min valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_374(); break; case 375: - ChipLogProgress( - chipTool, - " ***** Test Step 375 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_375(); + ChipLogProgress(chipTool, + " ***** Test Step 375 : Verify range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_375(); break; case 376: - ChipLogProgress(chipTool, - " ***** Test Step 376 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_376(); + ChipLogProgress(chipTool, " ***** Test Step 376 : Write max valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_376(); break; case 377: ChipLogProgress(chipTool, - " ***** Test Step 377 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_377(); + " ***** Test Step 377 : Verify range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_377(); break; case 378: - ChipLogProgress(chipTool, " ***** Test Step 378 : Read nullable range-restricted signed 8-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned8BitInteger_378(); + ChipLogProgress(chipTool, + " ***** Test Step 378 : Write middle valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_378(); break; case 379: ChipLogProgress(chipTool, - " ***** Test Step 379 : Write min value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_379(); + " ***** Test Step 379 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_379(); break; case 380: - ChipLogProgress( - chipTool, - " ***** Test Step 380 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_380(); + ChipLogProgress(chipTool, " ***** Test Step 380 : Read nullable range-restricted unsigned 8-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned8BitInteger_380(); break; case 381: - ChipLogProgress( - chipTool, - " ***** Test Step 381 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_381(); + ChipLogProgress(chipTool, + " ***** Test Step 381 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_381(); break; case 382: - ChipLogProgress(chipTool, - " ***** Test Step 382 : Write max value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_382(); + ChipLogProgress( + chipTool, + " ***** Test Step 382 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_382(); break; case 383: - ChipLogProgress(chipTool, - " ***** Test Step 383 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_383(); + ChipLogProgress( + chipTool, + " ***** Test Step 383 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_383(); break; case 384: ChipLogProgress(chipTool, - " ***** Test Step 384 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_384(); + " ***** Test Step 384 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_384(); break; case 385: - ChipLogProgress(chipTool, - " ***** Test Step 385 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_385(); + ChipLogProgress( + chipTool, " ***** Test Step 385 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_385(); break; case 386: ChipLogProgress(chipTool, - " ***** Test Step 386 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_386(); + " ***** Test Step 386 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_386(); break; case 387: - ChipLogProgress(chipTool, - " ***** Test Step 387 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_387(); + ChipLogProgress( + chipTool, " ***** Test Step 387 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_387(); break; case 388: - ChipLogProgress( - chipTool, " ***** Test Step 388 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_388(); + ChipLogProgress(chipTool, + " ***** Test Step 388 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_388(); break; case 389: - ChipLogProgress(chipTool, - " ***** Test Step 389 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_389(); + ChipLogProgress( + chipTool, " ***** Test Step 389 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_389(); break; case 390: - ChipLogProgress(chipTool, - " ***** Test Step 390 : Write null value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_390(); + ChipLogProgress( + chipTool, + " ***** Test Step 390 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_390(); break; case 391: - ChipLogProgress(chipTool, - " ***** Test Step 391 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_391(); + ChipLogProgress( + chipTool, " ***** Test Step 391 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_391(); break; case 392: - ChipLogProgress(chipTool, " ***** Test Step 392 : Read nullable range-restricted signed 16-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned16BitInteger_392(); + ChipLogProgress(chipTool, + " ***** Test Step 392 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_392(); break; case 393: ChipLogProgress(chipTool, - " ***** Test Step 393 : Write min value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_393(); + " ***** Test Step 393 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_393(); break; case 394: - ChipLogProgress( - chipTool, - " ***** Test Step 394 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_394(); + ChipLogProgress(chipTool, " ***** Test Step 394 : Read nullable range-restricted unsigned 16-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned16BitInteger_394(); break; case 395: - ChipLogProgress( - chipTool, - " ***** Test Step 395 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_395(); + ChipLogProgress(chipTool, + " ***** Test Step 395 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_395(); break; case 396: - ChipLogProgress(chipTool, - " ***** Test Step 396 : Write max value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_396(); + ChipLogProgress( + chipTool, + " ***** Test Step 396 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_396(); break; case 397: ChipLogProgress( - chipTool, " ***** Test Step 397 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_397(); + chipTool, + " ***** Test Step 397 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_397(); break; case 398: ChipLogProgress(chipTool, - " ***** Test Step 398 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_398(); + " ***** Test Step 398 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_398(); break; case 399: ChipLogProgress( - chipTool, " ***** Test Step 399 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_399(); + chipTool, + " ***** Test Step 399 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_399(); break; case 400: - ChipLogProgress(chipTool, - " ***** Test Step 400 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_400(); + ChipLogProgress( + chipTool, " ***** Test Step 400 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_400(); break; case 401: ChipLogProgress( - chipTool, " ***** Test Step 401 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_401(); + chipTool, + " ***** Test Step 401 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_401(); break; case 402: ChipLogProgress( - chipTool, " ***** Test Step 402 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_402(); + chipTool, " ***** Test Step 402 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_402(); break; case 403: ChipLogProgress( - chipTool, " ***** Test Step 403 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_403(); + chipTool, + " ***** Test Step 403 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_403(); break; case 404: - ChipLogProgress(chipTool, - " ***** Test Step 404 : Write null value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_404(); + ChipLogProgress( + chipTool, + " ***** Test Step 404 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_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(); + break; + case 406: + ChipLogProgress(chipTool, + " ***** Test Step 406 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_406(); + break; + case 407: + ChipLogProgress(chipTool, + " ***** Test Step 407 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_407(); + break; + case 408: + ChipLogProgress(chipTool, " ***** Test Step 408 : Read nullable range-restricted signed 8-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned8BitInteger_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(); + 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(); + 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(); + break; + case 412: + ChipLogProgress(chipTool, + " ***** Test Step 412 : Write max value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_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(); + break; + case 414: ChipLogProgress(chipTool, - " ***** Test Step 405 : Verify nullable range-restricted signed 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_405(); + " ***** Test Step 414 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_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(); + 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(); + 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(); + 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(); + 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(); + break; + case 420: + ChipLogProgress(chipTool, + " ***** Test Step 420 : Write null value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_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(); + break; + case 422: + ChipLogProgress(chipTool, " ***** Test Step 422 : Read nullable range-restricted signed 16-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned16BitInteger_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(); + 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(); + 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(); + break; + case 426: + ChipLogProgress(chipTool, + " ***** Test Step 426 : Write max value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + break; + case 434: + ChipLogProgress(chipTool, + " ***** Test Step 434 : Write null value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_434(); + break; + case 435: + ChipLogProgress(chipTool, + " ***** Test Step 435 : Verify nullable range-restricted signed 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_435(); break; } @@ -36002,7 +36122,7 @@ class TestCluster : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 406; + const uint16_t mTestCount = 436; typedef void (*Test_TestCluster_list_int8u_ReportCallback)(void * context, const chip::app::DataModel::DecodableList & value); @@ -37577,16 +37697,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_206(status); } - static void OnSuccessCallback_206(void * context) { (static_cast(context))->OnSuccessResponse_206(); } + static void OnSuccessCallback_206(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_206(nullableInt8u); + } static void OnFailureCallback_207(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_207(status); } - static void OnSuccessCallback_207(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + static void OnSuccessCallback_207(void * context, const chip::app::DataModel::Nullable & nullableInt8u) { - (static_cast(context))->OnSuccessResponse_207(nullableInt16u); + (static_cast(context))->OnSuccessResponse_207(nullableInt8u); } static void OnFailureCallback_208(void * context, EmberAfStatus status) @@ -37601,9 +37724,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_209(status); } - static void OnSuccessCallback_209(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + static void OnSuccessCallback_209(void * context, const chip::app::DataModel::Nullable & nullableInt8u) { - (static_cast(context))->OnSuccessResponse_209(nullableInt16u); + (static_cast(context))->OnSuccessResponse_209(nullableInt8u); } static void OnFailureCallback_210(void * context, EmberAfStatus status) @@ -37611,67 +37734,70 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_210(status); } - static void OnSuccessCallback_210(void * context) { (static_cast(context))->OnSuccessResponse_210(); } + static void OnSuccessCallback_210(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_210(nullableInt8u); + } static void OnFailureCallback_211(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_211(status); } - static void OnSuccessCallback_211(void * context, const chip::app::DataModel::Nullable & nullableInt16u) - { - (static_cast(context))->OnSuccessResponse_211(nullableInt16u); - } + static void OnSuccessCallback_211(void * context) { (static_cast(context))->OnSuccessResponse_211(); } static void OnFailureCallback_212(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_212(status); } - static void OnSuccessCallback_212(void * context) { (static_cast(context))->OnSuccessResponse_212(); } + static void OnSuccessCallback_212(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_212(nullableInt16u); + } static void OnFailureCallback_213(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_213(status); } - static void OnSuccessCallback_213(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_213(nullableInt32u); - } + static void OnSuccessCallback_213(void * context) { (static_cast(context))->OnSuccessResponse_213(); } static void OnFailureCallback_214(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_214(status); } - static void OnSuccessCallback_214(void * context) { (static_cast(context))->OnSuccessResponse_214(); } + static void OnSuccessCallback_214(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_214(nullableInt16u); + } static void OnFailureCallback_215(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_215(status); } - static void OnSuccessCallback_215(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_215(nullableInt32u); - } + static void OnSuccessCallback_215(void * context) { (static_cast(context))->OnSuccessResponse_215(); } static void OnFailureCallback_216(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_216(status); } - static void OnSuccessCallback_216(void * context) { (static_cast(context))->OnSuccessResponse_216(); } + static void OnSuccessCallback_216(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_216(nullableInt16u); + } static void OnFailureCallback_217(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_217(status); } - static void OnSuccessCallback_217(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + static void OnSuccessCallback_217(void * context, const chip::app::DataModel::Nullable & nullableInt16u) { - (static_cast(context))->OnSuccessResponse_217(nullableInt32u); + (static_cast(context))->OnSuccessResponse_217(nullableInt16u); } static void OnFailureCallback_218(void * context, EmberAfStatus status) @@ -37679,33 +37805,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_218(status); } - static void OnSuccessCallback_218(void * context) { (static_cast(context))->OnSuccessResponse_218(); } + static void OnSuccessCallback_218(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_218(nullableInt16u); + } static void OnFailureCallback_219(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_219(status); } - static void OnSuccessCallback_219(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_219(nullableInt64u); - } + static void OnSuccessCallback_219(void * context) { (static_cast(context))->OnSuccessResponse_219(); } static void OnFailureCallback_220(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_220(status); } - static void OnSuccessCallback_220(void * context) { (static_cast(context))->OnSuccessResponse_220(); } + static void OnSuccessCallback_220(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_220(nullableInt16u); + } static void OnFailureCallback_221(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_221(status); } - static void OnSuccessCallback_221(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_221(void * context, const chip::app::DataModel::Nullable & nullableInt16u) { - (static_cast(context))->OnSuccessResponse_221(nullableInt64u); + (static_cast(context))->OnSuccessResponse_221(nullableInt16u); } static void OnFailureCallback_222(void * context, EmberAfStatus status) @@ -37720,9 +37849,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_223(status); } - static void OnSuccessCallback_223(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_223(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_223(nullableInt64u); + (static_cast(context))->OnSuccessResponse_223(nullableInt32u); } static void OnFailureCallback_224(void * context, EmberAfStatus status) @@ -37737,9 +37866,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_225(status); } - static void OnSuccessCallback_225(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_225(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_225(nullableInt8s); + (static_cast(context))->OnSuccessResponse_225(nullableInt32u); } static void OnFailureCallback_226(void * context, EmberAfStatus status) @@ -37754,9 +37883,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_227(status); } - static void OnSuccessCallback_227(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_227(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_227(nullableInt8s); + (static_cast(context))->OnSuccessResponse_227(nullableInt32u); } static void OnFailureCallback_228(void * context, EmberAfStatus status) @@ -37764,16 +37893,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_228(status); } - static void OnSuccessCallback_228(void * context) { (static_cast(context))->OnSuccessResponse_228(); } + static void OnSuccessCallback_228(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_228(nullableInt32u); + } static void OnFailureCallback_229(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_229(status); } - static void OnSuccessCallback_229(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_229(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_229(nullableInt8s); + (static_cast(context))->OnSuccessResponse_229(nullableInt32u); } static void OnFailureCallback_230(void * context, EmberAfStatus status) @@ -37788,9 +37920,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_231(status); } - static void OnSuccessCallback_231(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_231(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_231(nullableInt16s); + (static_cast(context))->OnSuccessResponse_231(nullableInt32u); } static void OnFailureCallback_232(void * context, EmberAfStatus status) @@ -37798,118 +37930,121 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_232(status); } - static void OnSuccessCallback_232(void * context) { (static_cast(context))->OnSuccessResponse_232(); } + static void OnSuccessCallback_232(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_232(nullableInt32u); + } static void OnFailureCallback_233(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_233(status); } - static void OnSuccessCallback_233(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_233(nullableInt16s); - } + static void OnSuccessCallback_233(void * context) { (static_cast(context))->OnSuccessResponse_233(); } static void OnFailureCallback_234(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_234(status); } - static void OnSuccessCallback_234(void * context) { (static_cast(context))->OnSuccessResponse_234(); } + static void OnSuccessCallback_234(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_234(nullableInt64u); + } static void OnFailureCallback_235(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_235(status); } - static void OnSuccessCallback_235(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_235(nullableInt16s); - } + static void OnSuccessCallback_235(void * context) { (static_cast(context))->OnSuccessResponse_235(); } static void OnFailureCallback_236(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_236(status); } - static void OnSuccessCallback_236(void * context) { (static_cast(context))->OnSuccessResponse_236(); } + static void OnSuccessCallback_236(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_236(nullableInt64u); + } static void OnFailureCallback_237(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_237(status); } - static void OnSuccessCallback_237(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_237(nullableInt32s); - } + static void OnSuccessCallback_237(void * context) { (static_cast(context))->OnSuccessResponse_237(); } static void OnFailureCallback_238(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_238(status); } - static void OnSuccessCallback_238(void * context) { (static_cast(context))->OnSuccessResponse_238(); } + static void OnSuccessCallback_238(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_238(nullableInt64u); + } static void OnFailureCallback_239(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_239(status); } - static void OnSuccessCallback_239(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_239(nullableInt32s); - } + static void OnSuccessCallback_239(void * context) { (static_cast(context))->OnSuccessResponse_239(); } static void OnFailureCallback_240(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_240(status); } - static void OnSuccessCallback_240(void * context) { (static_cast(context))->OnSuccessResponse_240(); } + static void OnSuccessCallback_240(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_240(nullableInt8s); + } static void OnFailureCallback_241(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_241(status); } - static void OnSuccessCallback_241(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_241(nullableInt32s); - } + static void OnSuccessCallback_241(void * context) { (static_cast(context))->OnSuccessResponse_241(); } static void OnFailureCallback_242(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_242(status); } - static void OnSuccessCallback_242(void * context) { (static_cast(context))->OnSuccessResponse_242(); } + static void OnSuccessCallback_242(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_242(nullableInt8s); + } static void OnFailureCallback_243(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_243(status); } - static void OnSuccessCallback_243(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_243(nullableInt64s); - } + static void OnSuccessCallback_243(void * context) { (static_cast(context))->OnSuccessResponse_243(); } static void OnFailureCallback_244(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_244(status); } - static void OnSuccessCallback_244(void * context) { (static_cast(context))->OnSuccessResponse_244(); } + static void OnSuccessCallback_244(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_244(nullableInt8s); + } static void OnFailureCallback_245(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_245(status); } - static void OnSuccessCallback_245(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_245(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_245(nullableInt64s); + (static_cast(context))->OnSuccessResponse_245(nullableInt8s); } static void OnFailureCallback_246(void * context, EmberAfStatus status) @@ -37917,33 +38052,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_246(status); } - static void OnSuccessCallback_246(void * context) { (static_cast(context))->OnSuccessResponse_246(); } + static void OnSuccessCallback_246(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_246(nullableInt8s); + } static void OnFailureCallback_247(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_247(status); } - static void OnSuccessCallback_247(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_247(nullableInt64s); - } + static void OnSuccessCallback_247(void * context) { (static_cast(context))->OnSuccessResponse_247(); } static void OnFailureCallback_248(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_248(status); } - static void OnSuccessCallback_248(void * context) { (static_cast(context))->OnSuccessResponse_248(); } + static void OnSuccessCallback_248(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_248(nullableInt8s); + } static void OnFailureCallback_249(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_249(status); } - static void OnSuccessCallback_249(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_249(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_249(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_249(nullableInt8s); } static void OnFailureCallback_250(void * context, EmberAfStatus status) @@ -37958,9 +38096,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_251(status); } - static void OnSuccessCallback_251(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_251(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_251(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_251(nullableInt16s); } static void OnFailureCallback_252(void * context, EmberAfStatus status) @@ -37975,9 +38113,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_253(status); } - static void OnSuccessCallback_253(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_253(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_253(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_253(nullableInt16s); } static void OnFailureCallback_254(void * context, EmberAfStatus status) @@ -37992,9 +38130,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_255(status); } - static void OnSuccessCallback_255(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_255(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_255(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_255(nullableInt16s); } static void OnFailureCallback_256(void * context, EmberAfStatus status) @@ -38002,16 +38140,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_256(status); } - static void OnSuccessCallback_256(void * context) { (static_cast(context))->OnSuccessResponse_256(); } + static void OnSuccessCallback_256(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_256(nullableInt16s); + } static void OnFailureCallback_257(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_257(status); } - static void OnSuccessCallback_257(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_257(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_257(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_257(nullableInt16s); } static void OnFailureCallback_258(void * context, EmberAfStatus status) @@ -38026,9 +38167,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_259(status); } - static void OnSuccessCallback_259(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_259(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_259(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_259(nullableInt16s); } static void OnFailureCallback_260(void * context, EmberAfStatus status) @@ -38036,67 +38177,70 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_260(status); } - static void OnSuccessCallback_260(void * context) { (static_cast(context))->OnSuccessResponse_260(); } + static void OnSuccessCallback_260(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_260(nullableInt16s); + } static void OnFailureCallback_261(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_261(status); } - static void OnSuccessCallback_261(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) - { - (static_cast(context))->OnSuccessResponse_261(nullableFloatDouble); - } + static void OnSuccessCallback_261(void * context) { (static_cast(context))->OnSuccessResponse_261(); } static void OnFailureCallback_262(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_262(status); } - static void OnSuccessCallback_262(void * context) { (static_cast(context))->OnSuccessResponse_262(); } + static void OnSuccessCallback_262(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_262(nullableInt32s); + } static void OnFailureCallback_263(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_263(status); } - static void OnSuccessCallback_263(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) - { - (static_cast(context))->OnSuccessResponse_263(nullableFloatDouble); - } + static void OnSuccessCallback_263(void * context) { (static_cast(context))->OnSuccessResponse_263(); } static void OnFailureCallback_264(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_264(status); } - static void OnSuccessCallback_264(void * context) { (static_cast(context))->OnSuccessResponse_264(); } + static void OnSuccessCallback_264(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_264(nullableInt32s); + } static void OnFailureCallback_265(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_265(status); } - static void OnSuccessCallback_265(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) - { - (static_cast(context))->OnSuccessResponse_265(nullableFloatDouble); - } + static void OnSuccessCallback_265(void * context) { (static_cast(context))->OnSuccessResponse_265(); } static void OnFailureCallback_266(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_266(status); } - static void OnSuccessCallback_266(void * context) { (static_cast(context))->OnSuccessResponse_266(); } + static void OnSuccessCallback_266(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_266(nullableInt32s); + } static void OnFailureCallback_267(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_267(status); } - static void OnSuccessCallback_267(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_267(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_267(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_267(nullableInt32s); } static void OnFailureCallback_268(void * context, EmberAfStatus status) @@ -38104,33 +38248,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_268(status); } - static void OnSuccessCallback_268(void * context) { (static_cast(context))->OnSuccessResponse_268(); } + static void OnSuccessCallback_268(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_268(nullableInt32s); + } static void OnFailureCallback_269(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_269(status); } - static void OnSuccessCallback_269(void * context, const chip::app::DataModel::Nullable & nullableEnum8) - { - (static_cast(context))->OnSuccessResponse_269(nullableEnum8); - } + static void OnSuccessCallback_269(void * context) { (static_cast(context))->OnSuccessResponse_269(); } static void OnFailureCallback_270(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_270(status); } - static void OnSuccessCallback_270(void * context) { (static_cast(context))->OnSuccessResponse_270(); } + static void OnSuccessCallback_270(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_270(nullableInt32s); + } static void OnFailureCallback_271(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_271(status); } - static void OnSuccessCallback_271(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_271(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_271(nullableEnum8); + (static_cast(context))->OnSuccessResponse_271(nullableInt32s); } static void OnFailureCallback_272(void * context, EmberAfStatus status) @@ -38145,9 +38292,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_273(status); } - static void OnSuccessCallback_273(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_273(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_273(nullableEnum8); + (static_cast(context))->OnSuccessResponse_273(nullableInt64s); } static void OnFailureCallback_274(void * context, EmberAfStatus status) @@ -38162,9 +38309,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_275(status); } - static void OnSuccessCallback_275(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_275(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_275(nullableEnum16); + (static_cast(context))->OnSuccessResponse_275(nullableInt64s); } static void OnFailureCallback_276(void * context, EmberAfStatus status) @@ -38179,9 +38326,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_277(status); } - static void OnSuccessCallback_277(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_277(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_277(nullableEnum16); + (static_cast(context))->OnSuccessResponse_277(nullableInt64s); } static void OnFailureCallback_278(void * context, EmberAfStatus status) @@ -38196,9 +38343,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_279(status); } - static void OnSuccessCallback_279(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_279(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_279(nullableEnum16); + (static_cast(context))->OnSuccessResponse_279(nullableFloatSingle); } static void OnFailureCallback_280(void * context, EmberAfStatus status) @@ -38206,70 +38353,67 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_280(status); } - static void OnSuccessCallback_280(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_280(nullableOctetString); - } + static void OnSuccessCallback_280(void * context) { (static_cast(context))->OnSuccessResponse_280(); } static void OnFailureCallback_281(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_281(status); } - static void OnSuccessCallback_281(void * context) { (static_cast(context))->OnSuccessResponse_281(); } + static void OnSuccessCallback_281(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + { + (static_cast(context))->OnSuccessResponse_281(nullableFloatSingle); + } static void OnFailureCallback_282(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_282(status); } - static void OnSuccessCallback_282(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_282(nullableOctetString); - } + static void OnSuccessCallback_282(void * context) { (static_cast(context))->OnSuccessResponse_282(); } static void OnFailureCallback_283(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_283(status); } - static void OnSuccessCallback_283(void * context) { (static_cast(context))->OnSuccessResponse_283(); } + static void OnSuccessCallback_283(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + { + (static_cast(context))->OnSuccessResponse_283(nullableFloatSingle); + } static void OnFailureCallback_284(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_284(status); } - static void OnSuccessCallback_284(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_284(nullableOctetString); - } + static void OnSuccessCallback_284(void * context) { (static_cast(context))->OnSuccessResponse_284(); } static void OnFailureCallback_285(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_285(status); } - static void OnSuccessCallback_285(void * context) { (static_cast(context))->OnSuccessResponse_285(); } + static void OnSuccessCallback_285(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + { + (static_cast(context))->OnSuccessResponse_285(nullableFloatSingle); + } static void OnFailureCallback_286(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_286(status); } - static void OnSuccessCallback_286(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_286(nullableOctetString); - } + static void OnSuccessCallback_286(void * context) { (static_cast(context))->OnSuccessResponse_286(); } 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 & nullableCharString) + static void OnSuccessCallback_287(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_287(nullableCharString); + (static_cast(context))->OnSuccessResponse_287(nullableFloatSingle); } static void OnFailureCallback_288(void * context, EmberAfStatus status) @@ -38284,9 +38428,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_289(status); } - static void OnSuccessCallback_289(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_289(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_289(nullableCharString); + (static_cast(context))->OnSuccessResponse_289(nullableFloatDouble); } static void OnFailureCallback_290(void * context, EmberAfStatus status) @@ -38301,9 +38445,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_291(status); } - static void OnSuccessCallback_291(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_291(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_291(nullableCharString); + (static_cast(context))->OnSuccessResponse_291(nullableFloatDouble); } static void OnFailureCallback_292(void * context, EmberAfStatus status) @@ -38318,9 +38462,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_293(status); } - static void OnSuccessCallback_293(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_293(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_293(nullableCharString); + (static_cast(context))->OnSuccessResponse_293(nullableFloatDouble); } static void OnFailureCallback_294(void * context, EmberAfStatus status) @@ -38328,46 +38472,50 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_294(status); } - static void OnSuccessCallback_294(void * context, const chip::app::DataModel::DecodableList & listInt8u) - { - (static_cast(context))->OnSuccessResponse_294(listInt8u); - } + static void OnSuccessCallback_294(void * context) { (static_cast(context))->OnSuccessResponse_294(); } static void OnFailureCallback_295(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_295(status); } - static void OnSuccessCallback_295(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_295(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_295(listInt8u); + (static_cast(context))->OnSuccessResponse_295(nullableFloatDouble); } - static void OnFailureCallback_298(void * context, EmberAfStatus status) + static void OnFailureCallback_296(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_298(status); + (static_cast(context))->OnFailureResponse_296(status); } - static void OnSuccessCallback_298(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_296(void * context) { (static_cast(context))->OnSuccessResponse_296(); } + + static void OnFailureCallback_297(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_298(listInt8u); + (static_cast(context))->OnFailureResponse_297(status); } - bool mReceivedReport_298 = false; + static void OnSuccessCallback_297(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + { + (static_cast(context))->OnSuccessResponse_297(nullableFloatDouble); + } - static void OnFailureCallback_299(void * context, EmberAfStatus status) + static void OnFailureCallback_298(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_299(status); + (static_cast(context))->OnFailureResponse_298(status); } - static void OnSuccessCallback_299(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_298(void * context) { (static_cast(context))->OnSuccessResponse_298(); } + + static void OnFailureCallback_299(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_299(listInt8u); + (static_cast(context))->OnFailureResponse_299(status); } - static void OnSubscriptionEstablished_299(void * context) + static void OnSuccessCallback_299(void * context, const chip::app::DataModel::Nullable & nullableEnum8) { - (static_cast(context))->OnSubscriptionEstablishedResponse_299(); + (static_cast(context))->OnSuccessResponse_299(nullableEnum8); } static void OnFailureCallback_300(void * context, EmberAfStatus status) @@ -38382,29 +38530,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_301(status); } - static void OnSuccessCallback_301(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_301(void * context, const chip::app::DataModel::Nullable & nullableEnum8) { - (static_cast(context))->OnSuccessResponse_301(listInt8u); + (static_cast(context))->OnSuccessResponse_301(nullableEnum8); } - bool mReceivedReport_301 = false; - static void OnFailureCallback_302(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_302(status); } - static void OnSuccessCallback_302(void * context, uint8_t rangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_302(rangeRestrictedInt8u); - } + static void OnSuccessCallback_302(void * context) { (static_cast(context))->OnSuccessResponse_302(); } static void OnFailureCallback_303(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_303(status); } - static void OnSuccessCallback_303(void * context) { (static_cast(context))->OnSuccessResponse_303(); } + static void OnSuccessCallback_303(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_303(nullableEnum8); + } static void OnFailureCallback_304(void * context, EmberAfStatus status) { @@ -38418,7 +38564,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_305(status); } - static void OnSuccessCallback_305(void * context) { (static_cast(context))->OnSuccessResponse_305(); } + static void OnSuccessCallback_305(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_305(nullableEnum16); + } static void OnFailureCallback_306(void * context, EmberAfStatus status) { @@ -38432,9 +38581,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_307(status); } - static void OnSuccessCallback_307(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_307(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_307(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_307(nullableEnum16); } static void OnFailureCallback_308(void * context, EmberAfStatus status) @@ -38449,9 +38598,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_309(status); } - static void OnSuccessCallback_309(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_309(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_309(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_309(nullableEnum16); } static void OnFailureCallback_310(void * context, EmberAfStatus status) @@ -38459,43 +38608,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_310(status); } - static void OnSuccessCallback_310(void * context) { (static_cast(context))->OnSuccessResponse_310(); } + static void OnSuccessCallback_310(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_310(nullableOctetString); + } static void OnFailureCallback_311(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_311(status); } - static void OnSuccessCallback_311(void * context, uint8_t rangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_311(rangeRestrictedInt8u); - } + static void OnSuccessCallback_311(void * context) { (static_cast(context))->OnSuccessResponse_311(); } static void OnFailureCallback_312(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_312(status); } - static void OnSuccessCallback_312(void * context) { (static_cast(context))->OnSuccessResponse_312(); } + static void OnSuccessCallback_312(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_312(nullableOctetString); + } static void OnFailureCallback_313(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_313(status); } - static void OnSuccessCallback_313(void * context, uint8_t rangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_313(rangeRestrictedInt8u); - } + static void OnSuccessCallback_313(void * context) { (static_cast(context))->OnSuccessResponse_313(); } static void OnFailureCallback_314(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_314(status); } - static void OnSuccessCallback_314(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_314(void * context, const chip::app::DataModel::Nullable & nullableOctetString) { - (static_cast(context))->OnSuccessResponse_314(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_314(nullableOctetString); } static void OnFailureCallback_315(void * context, EmberAfStatus status) @@ -38510,14 +38659,20 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_316(status); } - static void OnSuccessCallback_316(void * context) { (static_cast(context))->OnSuccessResponse_316(); } + static void OnSuccessCallback_316(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_316(nullableOctetString); + } static void OnFailureCallback_317(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_317(status); } - static void OnSuccessCallback_317(void * context) { (static_cast(context))->OnSuccessResponse_317(); } + static void OnSuccessCallback_317(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_317(nullableCharString); + } static void OnFailureCallback_318(void * context, EmberAfStatus status) { @@ -38531,9 +38686,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_319(status); } - static void OnSuccessCallback_319(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_319(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_319(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_319(nullableCharString); } static void OnFailureCallback_320(void * context, EmberAfStatus status) @@ -38548,9 +38703,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_321(status); } - static void OnSuccessCallback_321(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_321(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_321(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_321(nullableCharString); } static void OnFailureCallback_322(void * context, EmberAfStatus status) @@ -38565,9 +38720,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_323(status); } - static void OnSuccessCallback_323(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_323(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_323(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_323(nullableCharString); } static void OnFailureCallback_324(void * context, EmberAfStatus status) @@ -38575,49 +38730,48 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_324(status); } - static void OnSuccessCallback_324(void * context) { (static_cast(context))->OnSuccessResponse_324(); } + static void OnSuccessCallback_324(void * context, const chip::app::DataModel::DecodableList & listInt8u) + { + (static_cast(context))->OnSuccessResponse_324(listInt8u); + } static void OnFailureCallback_325(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_325(status); } - static void OnSuccessCallback_325(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_325(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_325(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_325(listInt8u); } - static void OnFailureCallback_326(void * context, EmberAfStatus status) + static void OnFailureCallback_328(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_326(status); + (static_cast(context))->OnFailureResponse_328(status); } - static void OnSuccessCallback_326(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_328(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_326(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_328(listInt8u); } - static void OnFailureCallback_327(void * context, EmberAfStatus status) + bool mReceivedReport_328 = false; + + static void OnFailureCallback_329(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_327(status); + (static_cast(context))->OnFailureResponse_329(status); } - static void OnSuccessCallback_327(void * context) { (static_cast(context))->OnSuccessResponse_327(); } - - static void OnFailureCallback_328(void * context, EmberAfStatus status) + static void OnSuccessCallback_329(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnFailureResponse_328(status); + (static_cast(context))->OnSuccessResponse_329(listInt8u); } - static void OnSuccessCallback_328(void * context) { (static_cast(context))->OnSuccessResponse_328(); } - - static void OnFailureCallback_329(void * context, EmberAfStatus status) + static void OnSubscriptionEstablished_329(void * context) { - (static_cast(context))->OnFailureResponse_329(status); + (static_cast(context))->OnSubscriptionEstablishedResponse_329(); } - static void OnSuccessCallback_329(void * context) { (static_cast(context))->OnSuccessResponse_329(); } - static void OnFailureCallback_330(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_330(status); @@ -38630,27 +38784,29 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_331(status); } - static void OnSuccessCallback_331(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_331(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_331(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_331(listInt8u); } + bool mReceivedReport_331 = false; + static void OnFailureCallback_332(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_332(status); } - static void OnSuccessCallback_332(void * context) { (static_cast(context))->OnSuccessResponse_332(); } + static void OnSuccessCallback_332(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_332(rangeRestrictedInt8u); + } static void OnFailureCallback_333(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_333(status); } - static void OnSuccessCallback_333(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_333(rangeRestrictedInt8s); - } + static void OnSuccessCallback_333(void * context) { (static_cast(context))->OnSuccessResponse_333(); } static void OnFailureCallback_334(void * context, EmberAfStatus status) { @@ -38664,10 +38820,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_335(status); } - static void OnSuccessCallback_335(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_335(rangeRestrictedInt8s); - } + static void OnSuccessCallback_335(void * context) { (static_cast(context))->OnSuccessResponse_335(); } static void OnFailureCallback_336(void * context, EmberAfStatus status) { @@ -38681,9 +38834,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_337(status); } - static void OnSuccessCallback_337(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_337(void * context, uint8_t rangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_337(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_337(rangeRestrictedInt8u); } static void OnFailureCallback_338(void * context, EmberAfStatus status) @@ -38691,17 +38844,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_338(status); } - static void OnSuccessCallback_338(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_338(rangeRestrictedInt16s); - } + static void OnSuccessCallback_338(void * context) { (static_cast(context))->OnSuccessResponse_338(); } static void OnFailureCallback_339(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_339(status); } - static void OnSuccessCallback_339(void * context) { (static_cast(context))->OnSuccessResponse_339(); } + static void OnSuccessCallback_339(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_339(rangeRestrictedInt8u); + } static void OnFailureCallback_340(void * context, EmberAfStatus status) { @@ -38715,7 +38868,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_341(status); } - static void OnSuccessCallback_341(void * context) { (static_cast(context))->OnSuccessResponse_341(); } + static void OnSuccessCallback_341(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_341(rangeRestrictedInt8u); + } static void OnFailureCallback_342(void * context, EmberAfStatus status) { @@ -38729,9 +38885,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_343(status); } - static void OnSuccessCallback_343(void * context, int16_t rangeRestrictedInt16s) + static void OnSuccessCallback_343(void * context, uint8_t rangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_343(rangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_343(rangeRestrictedInt8u); } static void OnFailureCallback_344(void * context, EmberAfStatus status) @@ -38739,17 +38895,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_344(status); } - static void OnSuccessCallback_344(void * context) { (static_cast(context))->OnSuccessResponse_344(); } + static void OnSuccessCallback_344(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_344(rangeRestrictedInt16u); + } static void OnFailureCallback_345(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_345(status); } - static void OnSuccessCallback_345(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_345(rangeRestrictedInt16s); - } + static void OnSuccessCallback_345(void * context) { (static_cast(context))->OnSuccessResponse_345(); } static void OnFailureCallback_346(void * context, EmberAfStatus status) { @@ -38763,10 +38919,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_347(status); } - static void OnSuccessCallback_347(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_347(rangeRestrictedInt16s); - } + static void OnSuccessCallback_347(void * context) { (static_cast(context))->OnSuccessResponse_347(); } static void OnFailureCallback_348(void * context, EmberAfStatus status) { @@ -38780,9 +38933,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_349(status); } - static void OnSuccessCallback_349(void * context, int16_t rangeRestrictedInt16s) + static void OnSuccessCallback_349(void * context, uint16_t rangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_349(rangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_349(rangeRestrictedInt16u); } static void OnFailureCallback_350(void * context, EmberAfStatus status) @@ -38790,17 +38943,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_350(status); } - static void OnSuccessCallback_350(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_350(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_350(void * context) { (static_cast(context))->OnSuccessResponse_350(); } static void OnFailureCallback_351(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_351(status); } - static void OnSuccessCallback_351(void * context) { (static_cast(context))->OnSuccessResponse_351(); } + static void OnSuccessCallback_351(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_351(rangeRestrictedInt16u); + } static void OnFailureCallback_352(void * context, EmberAfStatus status) { @@ -38814,7 +38967,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_353(status); } - static void OnSuccessCallback_353(void * context) { (static_cast(context))->OnSuccessResponse_353(); } + static void OnSuccessCallback_353(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_353(rangeRestrictedInt16u); + } static void OnFailureCallback_354(void * context, EmberAfStatus status) { @@ -38828,9 +38984,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_355(status); } - static void OnSuccessCallback_355(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_355(void * context, uint16_t rangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_355(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_355(rangeRestrictedInt16u); } static void OnFailureCallback_356(void * context, EmberAfStatus status) @@ -38838,17 +38994,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_356(status); } - static void OnSuccessCallback_356(void * context) { (static_cast(context))->OnSuccessResponse_356(); } + static void OnSuccessCallback_356(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_356(rangeRestrictedInt8s); + } static void OnFailureCallback_357(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_357(status); } - static void OnSuccessCallback_357(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_357(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_357(void * context) { (static_cast(context))->OnSuccessResponse_357(); } static void OnFailureCallback_358(void * context, EmberAfStatus status) { @@ -38862,10 +39018,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_359(status); } - static void OnSuccessCallback_359(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_359(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_359(void * context) { (static_cast(context))->OnSuccessResponse_359(); } static void OnFailureCallback_360(void * context, EmberAfStatus status) { @@ -38879,9 +39032,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_361(status); } - static void OnSuccessCallback_361(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_361(void * context, int8_t rangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_361(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_361(rangeRestrictedInt8s); } static void OnFailureCallback_362(void * context, EmberAfStatus status) @@ -38896,9 +39049,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_363(status); } - static void OnSuccessCallback_363(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_363(void * context, int8_t rangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_363(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_363(rangeRestrictedInt8s); } static void OnFailureCallback_364(void * context, EmberAfStatus status) @@ -38906,18 +39059,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_364(status); } - static void OnSuccessCallback_364(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_364(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_364(void * context) { (static_cast(context))->OnSuccessResponse_364(); } static void OnFailureCallback_365(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_365(status); } - static void OnSuccessCallback_365(void * context) { (static_cast(context))->OnSuccessResponse_365(); } + static void OnSuccessCallback_365(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_365(rangeRestrictedInt8s); + } static void OnFailureCallback_366(void * context, EmberAfStatus status) { @@ -38931,25 +39083,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_367(status); } - static void OnSuccessCallback_367(void * context) { (static_cast(context))->OnSuccessResponse_367(); } + static void OnSuccessCallback_367(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_367(rangeRestrictedInt8s); + } static void OnFailureCallback_368(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_368(status); } - static void OnSuccessCallback_368(void * context) { (static_cast(context))->OnSuccessResponse_368(); } + static void OnSuccessCallback_368(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_368(rangeRestrictedInt16s); + } static void OnFailureCallback_369(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_369(status); } - static void OnSuccessCallback_369(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_369(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_369(void * context) { (static_cast(context))->OnSuccessResponse_369(); } static void OnFailureCallback_370(void * context, EmberAfStatus status) { @@ -38963,11 +39117,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_371(status); } - static void OnSuccessCallback_371(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_371(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_371(void * context) { (static_cast(context))->OnSuccessResponse_371(); } static void OnFailureCallback_372(void * context, EmberAfStatus status) { @@ -38981,10 +39131,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_373(status); } - static void OnSuccessCallback_373(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_373(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_373(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_373(rangeRestrictedInt16s); } static void OnFailureCallback_374(void * context, EmberAfStatus status) @@ -38999,10 +39148,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_375(status); } - static void OnSuccessCallback_375(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_375(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_375(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_375(rangeRestrictedInt16s); } static void OnFailureCallback_376(void * context, EmberAfStatus status) @@ -39017,10 +39165,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_377(status); } - static void OnSuccessCallback_377(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_377(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_377(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_377(rangeRestrictedInt16s); } static void OnFailureCallback_378(void * context, EmberAfStatus status) @@ -39028,24 +39175,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_378(status); } - static void OnSuccessCallback_378(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_378(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_378(void * context) { (static_cast(context))->OnSuccessResponse_378(); } static void OnFailureCallback_379(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_379(status); } - static void OnSuccessCallback_379(void * context) { (static_cast(context))->OnSuccessResponse_379(); } + static void OnSuccessCallback_379(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_379(rangeRestrictedInt16s); + } static void OnFailureCallback_380(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_380(status); } - static void OnSuccessCallback_380(void * context) { (static_cast(context))->OnSuccessResponse_380(); } + static void OnSuccessCallback_380(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_380(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_381(void * context, EmberAfStatus status) { @@ -39066,10 +39216,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_383(status); } - static void OnSuccessCallback_383(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_383(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_383(void * context) { (static_cast(context))->OnSuccessResponse_383(); } static void OnFailureCallback_384(void * context, EmberAfStatus status) { @@ -39083,9 +39230,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_385(status); } - static void OnSuccessCallback_385(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_385(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_385(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_385(nullableRangeRestrictedInt8u); } static void OnFailureCallback_386(void * context, EmberAfStatus status) @@ -39100,9 +39247,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_387(status); } - static void OnSuccessCallback_387(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_387(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_387(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_387(nullableRangeRestrictedInt8u); } static void OnFailureCallback_388(void * context, EmberAfStatus status) @@ -39117,9 +39264,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_389(status); } - static void OnSuccessCallback_389(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_389(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_389(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_389(nullableRangeRestrictedInt8u); } static void OnFailureCallback_390(void * context, EmberAfStatus status) @@ -39134,9 +39281,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_391(status); } - static void OnSuccessCallback_391(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_391(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_391(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_391(nullableRangeRestrictedInt8u); } static void OnFailureCallback_392(void * context, EmberAfStatus status) @@ -39144,24 +39291,28 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_392(status); } - static void OnSuccessCallback_392(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_392(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_392(void * context) { (static_cast(context))->OnSuccessResponse_392(); } static void OnFailureCallback_393(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_393(status); } - static void OnSuccessCallback_393(void * context) { (static_cast(context))->OnSuccessResponse_393(); } + static void OnSuccessCallback_393(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_393(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_394(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_394(status); } - static void OnSuccessCallback_394(void * context) { (static_cast(context))->OnSuccessResponse_394(); } + static void OnSuccessCallback_394(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_394(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_395(void * context, EmberAfStatus status) { @@ -39182,10 +39333,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_397(status); } - static void OnSuccessCallback_397(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_397(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_397(void * context) { (static_cast(context))->OnSuccessResponse_397(); } static void OnFailureCallback_398(void * context, EmberAfStatus status) { @@ -39199,9 +39347,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_399(status); } - static void OnSuccessCallback_399(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_399(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_399(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_399(nullableRangeRestrictedInt16u); } static void OnFailureCallback_400(void * context, EmberAfStatus status) @@ -39216,9 +39365,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_401(status); } - static void OnSuccessCallback_401(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_401(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_401(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_401(nullableRangeRestrictedInt16u); } static void OnFailureCallback_402(void * context, EmberAfStatus status) @@ -39233,9 +39383,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_403(status); } - static void OnSuccessCallback_403(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_403(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_403(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_403(nullableRangeRestrictedInt16u); } static void OnFailureCallback_404(void * context, EmberAfStatus status) @@ -39250,9 +39401,260 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_405(status); } - static void OnSuccessCallback_405(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_405(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_405(nullableRangeRestrictedInt16u); + } + + static void OnFailureCallback_406(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_406(status); + } + + static void OnSuccessCallback_406(void * context) { (static_cast(context))->OnSuccessResponse_406(); } + + static void OnFailureCallback_407(void * context, EmberAfStatus status) + { + (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 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 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 OnFailureCallback_410(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_410(status); + } + + static void OnSuccessCallback_410(void * context) { (static_cast(context))->OnSuccessResponse_410(); } + + static void OnFailureCallback_411(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_411(status); + } + + static void OnSuccessCallback_411(void * context) { (static_cast(context))->OnSuccessResponse_411(); } + + static void OnFailureCallback_412(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_412(status); + } + + static void OnSuccessCallback_412(void * context) { (static_cast(context))->OnSuccessResponse_412(); } + + static void OnFailureCallback_413(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_413(status); + } + + static void OnSuccessCallback_413(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_413(nullableRangeRestrictedInt8s); + } + + static void OnFailureCallback_414(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_414(status); + } + + static void OnSuccessCallback_414(void * context) { (static_cast(context))->OnSuccessResponse_414(); } + + static void OnFailureCallback_415(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_415(status); + } + + static void OnSuccessCallback_415(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_415(nullableRangeRestrictedInt8s); + } + + static void OnFailureCallback_416(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_416(status); + } + + static void OnSuccessCallback_416(void * context) { (static_cast(context))->OnSuccessResponse_416(); } + + static void OnFailureCallback_417(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_417(status); + } + + static void OnSuccessCallback_417(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_417(nullableRangeRestrictedInt8s); + } + + static void OnFailureCallback_418(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_418(status); + } + + static void OnSuccessCallback_418(void * context) { (static_cast(context))->OnSuccessResponse_418(); } + + 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 OnFailureCallback_420(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_420(status); + } + + static void OnSuccessCallback_420(void * context) { (static_cast(context))->OnSuccessResponse_420(); } + + static void OnFailureCallback_421(void * context, EmberAfStatus status) + { + (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 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 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 OnFailureCallback_424(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_424(status); + } + + static void OnSuccessCallback_424(void * context) { (static_cast(context))->OnSuccessResponse_424(); } + + static void OnFailureCallback_425(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_425(status); + } + + static void OnSuccessCallback_425(void * context) { (static_cast(context))->OnSuccessResponse_425(); } + + static void OnFailureCallback_426(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_426(status); + } + + static void OnSuccessCallback_426(void * context) { (static_cast(context))->OnSuccessResponse_426(); } + + static void OnFailureCallback_427(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_427(status); + } + + static void OnSuccessCallback_427(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_427(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_428(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_428(status); + } + + static void OnSuccessCallback_428(void * context) { (static_cast(context))->OnSuccessResponse_428(); } + + static void OnFailureCallback_429(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_429(status); + } + + static void OnSuccessCallback_429(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_429(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_430(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_430(status); + } + + static void OnSuccessCallback_430(void * context) { (static_cast(context))->OnSuccessResponse_430(); } + + static void OnFailureCallback_431(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_431(status); + } + + static void OnSuccessCallback_431(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_431(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_432(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_432(status); + } + + static void OnSuccessCallback_432(void * context) { (static_cast(context))->OnSuccessResponse_432(); } + + 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 OnFailureCallback_434(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_434(status); + } + + static void OnSuccessCallback_434(void * context) { (static_cast(context))->OnSuccessResponse_434(); } + + static void OnFailureCallback_435(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_435(status); + } + + static void OnSuccessCallback_435(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_405(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_435(nullableRangeRestrictedInt16s); } // @@ -43980,7 +44382,105 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_206() + CHIP_ERROR TestReadAttributeNullableInt8uNullValueRange_206() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_206, OnFailureCallback_206)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_206(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_206(const chip::app::DataModel::Nullable & nullableInt8u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt8u", nullableInt8u, 254)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt8uNullValueNot_207() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_207, OnFailureCallback_207)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_207(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_207(const chip::app::DataModel::Nullable & nullableInt8u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt8u", nullableInt8u, 254)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt8uValue_208() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt8uArgument; + nullableInt8uArgument.SetNonNull() = 128; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt8uArgument, this, OnSuccessCallback_208, OnFailureCallback_208)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_208(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_208() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt8uValueInRange_209() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_209, OnFailureCallback_209)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_209(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_209(const chip::app::DataModel::Nullable & nullableInt8u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt8u", nullableInt8u, 254)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt8uNotValueOk_210() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_210, OnFailureCallback_210)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_210(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_210(const chip::app::DataModel::Nullable & nullableInt8u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt8u", nullableInt8u, 129)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_211() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -43990,28 +44490,28 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNonNull() = 65534U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_206, OnFailureCallback_206)); + nullableInt16uArgument, this, OnSuccessCallback_211, OnFailureCallback_211)); return CHIP_NO_ERROR; } - void OnFailureResponse_206(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_211(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_206() { NextTest(); } + void OnSuccessResponse_211() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_207() + CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_212() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_207, OnFailureCallback_207)); + this, OnSuccessCallback_212, OnFailureCallback_212)); return CHIP_NO_ERROR; } - void OnFailureResponse_207(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_212(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_207(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_212(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); @@ -44019,7 +44519,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_208() + CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_213() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44029,32 +44529,32 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNonNull() = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_208, OnFailureCallback_208)); + nullableInt16uArgument, this, OnSuccessCallback_213, OnFailureCallback_213)); return CHIP_NO_ERROR; } - void OnFailureResponse_208(EmberAfStatus status) + void OnFailureResponse_213(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_208() { ThrowSuccessResponse(); } + void OnSuccessResponse_213() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_209() + CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_214() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_209, OnFailureCallback_209)); + this, OnSuccessCallback_214, OnFailureCallback_214)); return CHIP_NO_ERROR; } - void OnFailureResponse_209(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_214(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_209(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_214(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); @@ -44062,7 +44562,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_210() + CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_215() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44072,35 +44572,133 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_210, OnFailureCallback_210)); + nullableInt16uArgument, this, OnSuccessCallback_215, OnFailureCallback_215)); return CHIP_NO_ERROR; } - void OnFailureResponse_210(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_215(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_210() { NextTest(); } + void OnSuccessResponse_215() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValue_211() + CHIP_ERROR TestReadAttributeNullableInt16uNullValue_216() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_211, OnFailureCallback_211)); + this, OnSuccessCallback_216, OnFailureCallback_216)); return CHIP_NO_ERROR; } - void OnFailureResponse_211(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_216(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_211(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_216(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNull("nullableInt16u", nullableInt16u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_212() + CHIP_ERROR TestReadAttributeNullableInt16uNullValueRange_217() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_217, OnFailureCallback_217)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_217(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_217(const chip::app::DataModel::Nullable & nullableInt16u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt16uNullValueNot_218() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_218, OnFailureCallback_218)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_218(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_218(const chip::app::DataModel::Nullable & nullableInt16u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 65534U)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt16uValue_219() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt16uArgument; + nullableInt16uArgument.SetNonNull() = 32000U; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt16uArgument, this, OnSuccessCallback_219, OnFailureCallback_219)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_219(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_219() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt16uValueInRange_220() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_220, OnFailureCallback_220)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_220(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_220(const chip::app::DataModel::Nullable & nullableInt16u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt16uNotValueOk_221() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_221, OnFailureCallback_221)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_221(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_221(const chip::app::DataModel::Nullable & nullableInt16u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 32001U)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_222() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44110,28 +44708,28 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNonNull() = 4294967294UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_212, OnFailureCallback_212)); + nullableInt32uArgument, this, OnSuccessCallback_222, OnFailureCallback_222)); return CHIP_NO_ERROR; } - void OnFailureResponse_212(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_222(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_212() { NextTest(); } + void OnSuccessResponse_222() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_213() + CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_223() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_213, OnFailureCallback_213)); + this, OnSuccessCallback_223, OnFailureCallback_223)); return CHIP_NO_ERROR; } - void OnFailureResponse_213(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_223(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_213(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_223(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); @@ -44139,7 +44737,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_214() + CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_224() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44149,32 +44747,32 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNonNull() = 4294967295UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_214, OnFailureCallback_214)); + nullableInt32uArgument, this, OnSuccessCallback_224, OnFailureCallback_224)); return CHIP_NO_ERROR; } - void OnFailureResponse_214(EmberAfStatus status) + void OnFailureResponse_224(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_214() { ThrowSuccessResponse(); } + void OnSuccessResponse_224() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_215() + CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_225() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_215, OnFailureCallback_215)); + this, OnSuccessCallback_225, OnFailureCallback_225)); return CHIP_NO_ERROR; } - void OnFailureResponse_215(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_225(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_215(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_225(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); @@ -44182,7 +44780,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_216() + CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_226() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44192,35 +44790,133 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_216, OnFailureCallback_216)); + nullableInt32uArgument, this, OnSuccessCallback_226, OnFailureCallback_226)); return CHIP_NO_ERROR; } - void OnFailureResponse_216(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_226(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_216() { NextTest(); } + void OnSuccessResponse_226() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValue_217() + CHIP_ERROR TestReadAttributeNullableInt32uNullValue_227() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_217, OnFailureCallback_217)); + this, OnSuccessCallback_227, OnFailureCallback_227)); return CHIP_NO_ERROR; } - void OnFailureResponse_217(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_227(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_217(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_227(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNull("nullableInt32u", nullableInt32u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_218() + CHIP_ERROR TestReadAttributeNullableInt32uNullValueRange_228() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_228, OnFailureCallback_228)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_228(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_228(const chip::app::DataModel::Nullable & nullableInt32u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt32u", nullableInt32u, 4294967294UL)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt32uNullValueNot_229() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_229, OnFailureCallback_229)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_229(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_229(const chip::app::DataModel::Nullable & nullableInt32u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt32u", nullableInt32u, 4294967294UL)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt32uValue_230() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt32uArgument; + nullableInt32uArgument.SetNonNull() = 2147483647UL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt32uArgument, this, OnSuccessCallback_230, OnFailureCallback_230)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_230(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_230() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt32uValueInRange_231() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_231, OnFailureCallback_231)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_231(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_231(const chip::app::DataModel::Nullable & nullableInt32u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt32u", nullableInt32u, 4294967294UL)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt32uNotValueOk_232() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_232, OnFailureCallback_232)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_232(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_232(const chip::app::DataModel::Nullable & nullableInt32u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt32u", nullableInt32u, 2147483648UL)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_233() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44230,28 +44926,28 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNonNull() = 18446744073709551614ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_218, OnFailureCallback_218)); + nullableInt64uArgument, this, OnSuccessCallback_233, OnFailureCallback_233)); return CHIP_NO_ERROR; } - void OnFailureResponse_218(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_233(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_218() { NextTest(); } + void OnSuccessResponse_233() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_219() + CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_234() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_219, OnFailureCallback_219)); + this, OnSuccessCallback_234, OnFailureCallback_234)); return CHIP_NO_ERROR; } - void OnFailureResponse_219(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_234(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_219(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_234(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); @@ -44259,7 +44955,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_220() + CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_235() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44269,32 +44965,32 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNonNull() = 18446744073709551615ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_220, OnFailureCallback_220)); + nullableInt64uArgument, this, OnSuccessCallback_235, OnFailureCallback_235)); return CHIP_NO_ERROR; } - void OnFailureResponse_220(EmberAfStatus status) + void OnFailureResponse_235(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_220() { ThrowSuccessResponse(); } + void OnSuccessResponse_235() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_221() + CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_236() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_221, OnFailureCallback_221)); + this, OnSuccessCallback_236, OnFailureCallback_236)); return CHIP_NO_ERROR; } - void OnFailureResponse_221(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_236(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_221(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_236(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); @@ -44302,7 +44998,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_222() + CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_237() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44312,35 +45008,35 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_222, OnFailureCallback_222)); + nullableInt64uArgument, this, OnSuccessCallback_237, OnFailureCallback_237)); return CHIP_NO_ERROR; } - void OnFailureResponse_222(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_237(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_222() { NextTest(); } + void OnSuccessResponse_237() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValue_223() + CHIP_ERROR TestReadAttributeNullableInt64uNullValue_238() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_223, OnFailureCallback_223)); + this, OnSuccessCallback_238, OnFailureCallback_238)); return CHIP_NO_ERROR; } - void OnFailureResponse_223(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_238(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_223(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_238(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNull("nullableInt64u", nullableInt64u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_224() + CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_239() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44350,28 +45046,28 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -127; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_224, OnFailureCallback_224)); + nullableInt8sArgument, this, OnSuccessCallback_239, OnFailureCallback_239)); return CHIP_NO_ERROR; } - void OnFailureResponse_224(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_239(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_224() { NextTest(); } + void OnSuccessResponse_239() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sMinValue_225() + CHIP_ERROR TestReadAttributeNullableInt8sMinValue_240() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_225, OnFailureCallback_225)); + this, OnSuccessCallback_240, OnFailureCallback_240)); return CHIP_NO_ERROR; } - void OnFailureResponse_225(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_240(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_225(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -44379,7 +45075,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_226() + CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_241() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44389,32 +45085,32 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -128; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_226, OnFailureCallback_226)); + nullableInt8sArgument, this, OnSuccessCallback_241, OnFailureCallback_241)); return CHIP_NO_ERROR; } - void OnFailureResponse_226(EmberAfStatus status) + void OnFailureResponse_241(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_226() { ThrowSuccessResponse(); } + void OnSuccessResponse_241() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_227() + CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_242() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_227, OnFailureCallback_227)); + this, OnSuccessCallback_242, OnFailureCallback_242)); return CHIP_NO_ERROR; } - void OnFailureResponse_227(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_242(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_227(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_242(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -44422,7 +45118,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_228() + CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_243() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44432,35 +45128,135 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_228, OnFailureCallback_228)); + nullableInt8sArgument, this, OnSuccessCallback_243, OnFailureCallback_243)); return CHIP_NO_ERROR; } - void OnFailureResponse_228(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_243(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_228() { NextTest(); } + void OnSuccessResponse_243() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValue_229() + CHIP_ERROR TestReadAttributeNullableInt8sNullValue_244() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_229, OnFailureCallback_229)); + this, OnSuccessCallback_244, OnFailureCallback_244)); return CHIP_NO_ERROR; } - void OnFailureResponse_229(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_244(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_229(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_244(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNull("nullableInt8s", nullableInt8s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_230() + CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_245() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_245(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_245(const chip::app::DataModel::Nullable & nullableInt8s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_246() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_246(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_246(const chip::app::DataModel::Nullable & nullableInt8s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -127)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt8sValue_247() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt8sArgument; + nullableInt8sArgument.SetNonNull() = -127; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt8sArgument, this, OnSuccessCallback_247, OnFailureCallback_247)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_247(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_247() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_248() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_248(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_248(const chip::app::DataModel::Nullable & nullableInt8s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_249() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_249(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_249(const chip::app::DataModel::Nullable & nullableInt8s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -126)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_250() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44470,28 +45266,28 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32767; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_230, OnFailureCallback_230)); + nullableInt16sArgument, this, OnSuccessCallback_250, OnFailureCallback_250)); return CHIP_NO_ERROR; } - void OnFailureResponse_230(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_250(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_230() { NextTest(); } + void OnSuccessResponse_250() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sMinValue_231() + CHIP_ERROR TestReadAttributeNullableInt16sMinValue_251() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_231, OnFailureCallback_231)); + this, OnSuccessCallback_251, OnFailureCallback_251)); return CHIP_NO_ERROR; } - void OnFailureResponse_231(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_251(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_231(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_251(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -44499,7 +45295,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_232() + CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_252() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44509,32 +45305,32 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_232, OnFailureCallback_232)); + nullableInt16sArgument, this, OnSuccessCallback_252, OnFailureCallback_252)); return CHIP_NO_ERROR; } - void OnFailureResponse_232(EmberAfStatus status) + void OnFailureResponse_252(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_232() { ThrowSuccessResponse(); } + void OnSuccessResponse_252() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_233() + CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_253() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_233, OnFailureCallback_233)); + this, OnSuccessCallback_253, OnFailureCallback_253)); return CHIP_NO_ERROR; } - void OnFailureResponse_233(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_253(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_233(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_253(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -44542,7 +45338,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_234() + CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_254() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44552,35 +45348,135 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_234, OnFailureCallback_234)); + nullableInt16sArgument, this, OnSuccessCallback_254, OnFailureCallback_254)); return CHIP_NO_ERROR; } - void OnFailureResponse_234(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_254(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_234() { NextTest(); } + void OnSuccessResponse_254() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValue_235() + CHIP_ERROR TestReadAttributeNullableInt16sNullValue_255() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_235, OnFailureCallback_235)); + this, OnSuccessCallback_255, OnFailureCallback_255)); return CHIP_NO_ERROR; } - void OnFailureResponse_235(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_255(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_235(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_255(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNull("nullableInt16s", nullableInt16s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_236() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_256() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_256(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_256(const chip::app::DataModel::Nullable & nullableInt16s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_257() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_257(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_257(const chip::app::DataModel::Nullable & nullableInt16s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32767)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt16sValue_258() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt16sArgument; + nullableInt16sArgument.SetNonNull() = -32767; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt16sArgument, this, OnSuccessCallback_258, OnFailureCallback_258)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_258(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_258() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_259() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_259(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_259(const chip::app::DataModel::Nullable & nullableInt16s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_260() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_260(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_260(const chip::app::DataModel::Nullable & nullableInt16s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32766)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_261() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44590,28 +45486,28 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483647L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_236, OnFailureCallback_236)); + nullableInt32sArgument, this, OnSuccessCallback_261, OnFailureCallback_261)); return CHIP_NO_ERROR; } - void OnFailureResponse_236(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_261(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_236() { NextTest(); } + void OnSuccessResponse_261() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sMinValue_237() + CHIP_ERROR TestReadAttributeNullableInt32sMinValue_262() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_237, OnFailureCallback_237)); + this, OnSuccessCallback_262, OnFailureCallback_262)); return CHIP_NO_ERROR; } - void OnFailureResponse_237(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_262(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_237(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_262(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -44619,7 +45515,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_238() + CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_263() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44629,32 +45525,32 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483648L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_238, OnFailureCallback_238)); + nullableInt32sArgument, this, OnSuccessCallback_263, OnFailureCallback_263)); return CHIP_NO_ERROR; } - void OnFailureResponse_238(EmberAfStatus status) + void OnFailureResponse_263(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_238() { ThrowSuccessResponse(); } + void OnSuccessResponse_263() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_239() + CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_264() { 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)); + this, OnSuccessCallback_264, OnFailureCallback_264)); return CHIP_NO_ERROR; } - void OnFailureResponse_239(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_264(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_239(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_264(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -44662,7 +45558,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_240() + CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_265() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44672,35 +45568,135 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_240, OnFailureCallback_240)); + nullableInt32sArgument, this, OnSuccessCallback_265, OnFailureCallback_265)); return CHIP_NO_ERROR; } - void OnFailureResponse_240(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_265(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_240() { NextTest(); } + void OnSuccessResponse_265() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValue_241() + CHIP_ERROR TestReadAttributeNullableInt32sNullValue_266() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_241, OnFailureCallback_241)); + this, OnSuccessCallback_266, OnFailureCallback_266)); return CHIP_NO_ERROR; } - void OnFailureResponse_241(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_266(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_241(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_266(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNull("nullableInt32s", nullableInt32s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_242() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_267() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_267(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_267(const chip::app::DataModel::Nullable & nullableInt32s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_268() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_268(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_268(const chip::app::DataModel::Nullable & nullableInt32s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483647L)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt32sValue_269() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt32sArgument; + nullableInt32sArgument.SetNonNull() = -2147483647L; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt32sArgument, this, OnSuccessCallback_269, OnFailureCallback_269)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_269(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_269() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_270() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_270(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_270(const chip::app::DataModel::Nullable & nullableInt32s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_271() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_271(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_271(const chip::app::DataModel::Nullable & nullableInt32s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483646L)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_272() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44710,28 +45706,28 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_242, OnFailureCallback_242)); + nullableInt64sArgument, this, OnSuccessCallback_272, OnFailureCallback_272)); return CHIP_NO_ERROR; } - void OnFailureResponse_242(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_272(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_242() { NextTest(); } + void OnSuccessResponse_272() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sMinValue_243() + CHIP_ERROR TestReadAttributeNullableInt64sMinValue_273() { 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)); + this, OnSuccessCallback_273, OnFailureCallback_273)); return CHIP_NO_ERROR; } - void OnFailureResponse_243(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_273(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_243(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_273(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -44739,7 +45735,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_244() + CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_274() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44749,32 +45745,32 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL - 1; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_244, OnFailureCallback_244)); + nullableInt64sArgument, this, OnSuccessCallback_274, OnFailureCallback_274)); return CHIP_NO_ERROR; } - void OnFailureResponse_244(EmberAfStatus status) + void OnFailureResponse_274(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_244() { ThrowSuccessResponse(); } + void OnSuccessResponse_274() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_245() + CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_275() { 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_275, OnFailureCallback_275)); return CHIP_NO_ERROR; } - void OnFailureResponse_245(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_275(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_245(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_275(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -44782,7 +45778,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_246() + CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_276() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44792,35 +45788,35 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_246, OnFailureCallback_246)); + nullableInt64sArgument, this, OnSuccessCallback_276, OnFailureCallback_276)); return CHIP_NO_ERROR; } - void OnFailureResponse_246(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_276(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_246() { NextTest(); } + void OnSuccessResponse_276() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValue_247() + CHIP_ERROR TestReadAttributeNullableInt64sNullValue_277() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_247, OnFailureCallback_247)); + this, OnSuccessCallback_277, OnFailureCallback_277)); return CHIP_NO_ERROR; } - void OnFailureResponse_247(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_277(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_247(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_277(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNull("nullableInt64s", nullableInt64s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_248() + CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_278() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44830,28 +45826,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = 0.1f; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_248, OnFailureCallback_248)); + nullableFloatSingleArgument, this, OnSuccessCallback_278, OnFailureCallback_278)); return CHIP_NO_ERROR; } - void OnFailureResponse_248(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_278(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_248() { NextTest(); } + void OnSuccessResponse_278() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleMediumValue_249() + CHIP_ERROR TestReadAttributeNullableSingleMediumValue_279() { 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_279, OnFailureCallback_279)); return CHIP_NO_ERROR; } - void OnFailureResponse_249(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_279(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_249(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_279(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.1f)); @@ -44859,7 +45855,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_250() + CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_280() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44869,28 +45865,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_250, OnFailureCallback_250)); + nullableFloatSingleArgument, this, OnSuccessCallback_280, OnFailureCallback_280)); return CHIP_NO_ERROR; } - void OnFailureResponse_250(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_280(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_250() { NextTest(); } + void OnSuccessResponse_280() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleLargestValue_251() + CHIP_ERROR TestReadAttributeNullableSingleLargestValue_281() { 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_281, OnFailureCallback_281)); return CHIP_NO_ERROR; } - void OnFailureResponse_251(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_281(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_251(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_281(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), INFINITY)); @@ -44898,7 +45894,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_252() + CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_282() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44908,28 +45904,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_252, OnFailureCallback_252)); + nullableFloatSingleArgument, this, OnSuccessCallback_282, OnFailureCallback_282)); return CHIP_NO_ERROR; } - void OnFailureResponse_252(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_282(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_252() { NextTest(); } + void OnSuccessResponse_282() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_253() + CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_283() { 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_283, OnFailureCallback_283)); return CHIP_NO_ERROR; } - void OnFailureResponse_253(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_283(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_253(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), -INFINITY)); @@ -44937,7 +45933,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleNullValue_254() + CHIP_ERROR TestWriteAttributeNullableSingleNullValue_284() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44947,35 +45943,35 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_254, OnFailureCallback_254)); + nullableFloatSingleArgument, this, OnSuccessCallback_284, OnFailureCallback_284)); return CHIP_NO_ERROR; } - void OnFailureResponse_254(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_284(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_254() { NextTest(); } + void OnSuccessResponse_284() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleNullValue_255() + CHIP_ERROR TestReadAttributeNullableSingleNullValue_285() { 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_285, OnFailureCallback_285)); return CHIP_NO_ERROR; } - void OnFailureResponse_255(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_285(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_255(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_285(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNull("nullableFloatSingle", nullableFloatSingle)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingle0Value_256() + CHIP_ERROR TestWriteAttributeNullableSingle0Value_286() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44985,28 +45981,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = 0.0f; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_256, OnFailureCallback_256)); + nullableFloatSingleArgument, this, OnSuccessCallback_286, OnFailureCallback_286)); return CHIP_NO_ERROR; } - void OnFailureResponse_256(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_286(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_256() { NextTest(); } + void OnSuccessResponse_286() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingle0Value_257() + CHIP_ERROR TestReadAttributeNullableSingle0Value_287() { 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_287, OnFailureCallback_287)); return CHIP_NO_ERROR; } - void OnFailureResponse_257(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_287(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_257(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_287(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.0f)); @@ -45014,7 +46010,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_258() + CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_288() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45024,28 +46020,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = 0.1234567890123; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_258, OnFailureCallback_258)); + nullableFloatDoubleArgument, this, OnSuccessCallback_288, OnFailureCallback_288)); return CHIP_NO_ERROR; } - void OnFailureResponse_258(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_288(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_258() { NextTest(); } + void OnSuccessResponse_288() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_259() + CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_289() { 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_289, OnFailureCallback_289)); return CHIP_NO_ERROR; } - void OnFailureResponse_259(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_289(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_259(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_289(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0.1234567890123)); @@ -45053,7 +46049,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_260() + CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_290() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45063,28 +46059,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_260, OnFailureCallback_260)); + nullableFloatDoubleArgument, this, OnSuccessCallback_290, OnFailureCallback_290)); return CHIP_NO_ERROR; } - void OnFailureResponse_260(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_290(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_260() { NextTest(); } + void OnSuccessResponse_290() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_261() + CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_291() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_261, OnFailureCallback_261)); + this, OnSuccessCallback_291, OnFailureCallback_291)); return CHIP_NO_ERROR; } - void OnFailureResponse_261(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_291(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_261(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_291(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), INFINITY)); @@ -45092,7 +46088,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_262() + CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_292() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45102,28 +46098,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_262, OnFailureCallback_262)); + nullableFloatDoubleArgument, this, OnSuccessCallback_292, OnFailureCallback_292)); return CHIP_NO_ERROR; } - void OnFailureResponse_262(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_292(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_262() { NextTest(); } + void OnSuccessResponse_292() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_263() + CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_293() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_263, OnFailureCallback_263)); + this, OnSuccessCallback_293, OnFailureCallback_293)); return CHIP_NO_ERROR; } - void OnFailureResponse_263(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_293(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_263(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_293(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), -INFINITY)); @@ -45131,7 +46127,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_264() + CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_294() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45141,35 +46137,35 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_264, OnFailureCallback_264)); + nullableFloatDoubleArgument, this, OnSuccessCallback_294, OnFailureCallback_294)); return CHIP_NO_ERROR; } - void OnFailureResponse_264(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_294(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_264() { NextTest(); } + void OnSuccessResponse_294() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleNullValue_265() + CHIP_ERROR TestReadAttributeNullableDoubleNullValue_295() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_265, OnFailureCallback_265)); + this, OnSuccessCallback_295, OnFailureCallback_295)); return CHIP_NO_ERROR; } - void OnFailureResponse_265(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_295(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_265(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_295(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNull("nullableFloatDouble", nullableFloatDouble)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDouble0Value_266() + CHIP_ERROR TestWriteAttributeNullableDouble0Value_296() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45179,28 +46175,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_266, OnFailureCallback_266)); + nullableFloatDoubleArgument, this, OnSuccessCallback_296, OnFailureCallback_296)); return CHIP_NO_ERROR; } - void OnFailureResponse_266(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_296(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_266() { NextTest(); } + void OnSuccessResponse_296() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDouble0Value_267() + CHIP_ERROR TestReadAttributeNullableDouble0Value_297() { 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_297, OnFailureCallback_297)); return CHIP_NO_ERROR; } - void OnFailureResponse_267(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_297(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_267(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_297(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0)); @@ -45208,7 +46204,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_268() + CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_298() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45218,28 +46214,28 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = 254; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_268, OnFailureCallback_268)); + nullableEnum8Argument, this, OnSuccessCallback_298, OnFailureCallback_298)); return CHIP_NO_ERROR; } - void OnFailureResponse_268(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_298(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_268() { NextTest(); } + void OnSuccessResponse_298() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_269() + CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_299() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_269, OnFailureCallback_269)); + this, OnSuccessCallback_299, OnFailureCallback_299)); return CHIP_NO_ERROR; } - void OnFailureResponse_269(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_299(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_269(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_299(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); @@ -45247,7 +46243,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_270() + CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_300() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45257,32 +46253,32 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_270, OnFailureCallback_270)); + nullableEnum8Argument, this, OnSuccessCallback_300, OnFailureCallback_300)); return CHIP_NO_ERROR; } - void OnFailureResponse_270(EmberAfStatus status) + void OnFailureResponse_300(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_270() { ThrowSuccessResponse(); } + void OnSuccessResponse_300() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_271() + CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_301() { 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_301, OnFailureCallback_301)); return CHIP_NO_ERROR; } - void OnFailureResponse_271(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_301(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_271(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_301(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); @@ -45290,7 +46286,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_272() + CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_302() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45300,35 +46296,35 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_272, OnFailureCallback_272)); + nullableEnum8Argument, this, OnSuccessCallback_302, OnFailureCallback_302)); return CHIP_NO_ERROR; } - void OnFailureResponse_272(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_302(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_272() { NextTest(); } + void OnSuccessResponse_302() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8NullValue_273() + CHIP_ERROR TestReadAttributeNullableEnum8NullValue_303() { 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_303, OnFailureCallback_303)); return CHIP_NO_ERROR; } - void OnFailureResponse_273(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_303(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_273(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_303(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_274() + CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_304() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45338,28 +46334,28 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = 65534U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_274, OnFailureCallback_274)); + nullableEnum16Argument, this, OnSuccessCallback_304, OnFailureCallback_304)); return CHIP_NO_ERROR; } - void OnFailureResponse_274(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_304(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_274() { NextTest(); } + void OnSuccessResponse_304() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_275() + CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_305() { 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_305, OnFailureCallback_305)); return CHIP_NO_ERROR; } - void OnFailureResponse_275(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_305(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_275(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_305(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); @@ -45367,7 +46363,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_276() + CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_306() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45377,32 +46373,32 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_276, OnFailureCallback_276)); + nullableEnum16Argument, this, OnSuccessCallback_306, OnFailureCallback_306)); return CHIP_NO_ERROR; } - void OnFailureResponse_276(EmberAfStatus status) + void OnFailureResponse_306(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_276() { ThrowSuccessResponse(); } + void OnSuccessResponse_306() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_277() + CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_307() { 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_307, OnFailureCallback_307)); return CHIP_NO_ERROR; } - void OnFailureResponse_277(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_307(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_277(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_307(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); @@ -45410,7 +46406,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_278() + CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_308() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45420,48 +46416,48 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_278, OnFailureCallback_278)); + nullableEnum16Argument, this, OnSuccessCallback_308, OnFailureCallback_308)); return CHIP_NO_ERROR; } - void OnFailureResponse_278(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_308(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_278() { NextTest(); } + void OnSuccessResponse_308() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16NullValue_279() + CHIP_ERROR TestReadAttributeNullableEnum16NullValue_309() { 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_309, OnFailureCallback_309)); return CHIP_NO_ERROR; } - void OnFailureResponse_279(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_309(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_279(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_309(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_280() + CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_310() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_280, OnFailureCallback_280)); + this, OnSuccessCallback_310, OnFailureCallback_310)); return CHIP_NO_ERROR; } - void OnFailureResponse_280(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_310(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_280(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_310(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -45470,7 +46466,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_281() + CHIP_ERROR TestWriteAttributeNullableOctetString_311() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45481,28 +46477,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_281, OnFailureCallback_281)); + nullableOctetStringArgument, this, OnSuccessCallback_311, OnFailureCallback_311)); return CHIP_NO_ERROR; } - void OnFailureResponse_281(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_311(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_281() { NextTest(); } + void OnSuccessResponse_311() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_282() + CHIP_ERROR TestReadAttributeNullableOctetString_312() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_282, OnFailureCallback_282)); + this, OnSuccessCallback_312, OnFailureCallback_312)); return CHIP_NO_ERROR; } - void OnFailureResponse_282(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_312(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_282(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_312(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -45511,7 +46507,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_283() + CHIP_ERROR TestWriteAttributeNullableOctetString_313() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45521,35 +46517,35 @@ class TestCluster : public TestCommand nullableOctetStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_283, OnFailureCallback_283)); + nullableOctetStringArgument, this, OnSuccessCallback_313, OnFailureCallback_313)); return CHIP_NO_ERROR; } - void OnFailureResponse_283(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_313(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_283() { NextTest(); } + void OnSuccessResponse_313() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_284() + CHIP_ERROR TestReadAttributeNullableOctetString_314() { 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)); + this, OnSuccessCallback_314, OnFailureCallback_314)); return CHIP_NO_ERROR; } - void OnFailureResponse_284(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_314(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_284(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_314(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNull("nullableOctetString", nullableOctetString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_285() + CHIP_ERROR TestWriteAttributeNullableOctetString_315() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45560,28 +46556,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_285, OnFailureCallback_285)); + nullableOctetStringArgument, this, OnSuccessCallback_315, OnFailureCallback_315)); return CHIP_NO_ERROR; } - void OnFailureResponse_285(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_315(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_285() { NextTest(); } + void OnSuccessResponse_315() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_286() + CHIP_ERROR TestReadAttributeNullableOctetString_316() { 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)); + this, OnSuccessCallback_316, OnFailureCallback_316)); return CHIP_NO_ERROR; } - void OnFailureResponse_286(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_316(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_286(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_316(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -45590,20 +46586,20 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_287() + CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_317() { 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_317, OnFailureCallback_317)); return CHIP_NO_ERROR; } - void OnFailureResponse_287(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_317(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_287(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_317(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -45611,7 +46607,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharString_288() + CHIP_ERROR TestWriteAttributeNullableCharString_318() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45621,28 +46617,28 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("☉T☉garbage: not in length on purpose", 7); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_288, OnFailureCallback_288)); + nullableCharStringArgument, this, OnSuccessCallback_318, OnFailureCallback_318)); return CHIP_NO_ERROR; } - void OnFailureResponse_288(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_318(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_288() { NextTest(); } + void OnSuccessResponse_318() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_289() + CHIP_ERROR TestReadAttributeNullableCharString_319() { 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_319, OnFailureCallback_319)); return CHIP_NO_ERROR; } - void OnFailureResponse_289(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_319(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_289(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_319(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("☉T☉", 7))); @@ -45650,7 +46646,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_290() + CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_320() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45660,35 +46656,35 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_290, OnFailureCallback_290)); + nullableCharStringArgument, this, OnSuccessCallback_320, OnFailureCallback_320)); return CHIP_NO_ERROR; } - void OnFailureResponse_290(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_320(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_290() { NextTest(); } + void OnSuccessResponse_320() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_291() + CHIP_ERROR TestReadAttributeNullableCharString_321() { 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_321, OnFailureCallback_321)); return CHIP_NO_ERROR; } - void OnFailureResponse_291(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_321(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_291(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_321(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNull("nullableCharString", nullableCharString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_292() + CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_322() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45698,28 +46694,28 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("garbage: not in length on purpose", 0); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_292, OnFailureCallback_292)); + nullableCharStringArgument, this, OnSuccessCallback_322, OnFailureCallback_322)); return CHIP_NO_ERROR; } - void OnFailureResponse_292(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_322(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_292() { NextTest(); } + void OnSuccessResponse_322() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_293() + CHIP_ERROR TestReadAttributeNullableCharString_323() { 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_323, OnFailureCallback_323)); return CHIP_NO_ERROR; } - void OnFailureResponse_293(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_323(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_293(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_323(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -45727,45 +46723,45 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_294() + CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_324() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 200; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_294, OnFailureCallback_294)); + this, OnSuccessCallback_324, OnFailureCallback_324)); return CHIP_NO_ERROR; } - void OnFailureResponse_294(EmberAfStatus status) + void OnFailureResponse_324(EmberAfStatus status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_294(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_324(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeFromNonexistentCluster_295() + CHIP_ERROR TestReadAttributeFromNonexistentCluster_325() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 0; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_295, OnFailureCallback_295)); + this, OnSuccessCallback_325, OnFailureCallback_325)); return CHIP_NO_ERROR; } - void OnFailureResponse_295(EmberAfStatus status) + void OnFailureResponse_325(EmberAfStatus status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_295(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_325(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_296() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_326() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -45773,26 +46769,26 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_296(); + (static_cast(context))->OnSuccessResponse_326(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_296(status); + (static_cast(context))->OnFailureResponse_326(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_296(EmberAfStatus status) + void OnFailureResponse_326(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_INVALID_VALUE)); NextTest(); } - void OnSuccessResponse_296() { ThrowSuccessResponse(); } + void OnSuccessResponse_326() { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_297() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_327() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -45801,36 +46797,36 @@ class TestCluster : public TestCommand request.arg1.Emplace() = 1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_297(); + (static_cast(context))->OnSuccessResponse_327(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_297(status); + (static_cast(context))->OnFailureResponse_327(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_297(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_327(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_297() { NextTest(); } + void OnSuccessResponse_327() { NextTest(); } - CHIP_ERROR TestReportSubscribeToListAttribute_298() + CHIP_ERROR TestReportSubscribeToListAttribute_328() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_298; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_328; return WaitForMs(0); } - void OnFailureResponse_298(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_328(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_298(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_328(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_298 = true; + mReceivedReport_328 = true; auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); @@ -45844,7 +46840,7 @@ class TestCluster : public TestCommand VerifyOrReturn(CheckNoMoreListItems("listInt8u", iter, 4)); } - CHIP_ERROR TestSubscribeToListAttribute_299() + CHIP_ERROR TestSubscribeToListAttribute_329() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45856,14 +46852,14 @@ class TestCluster : public TestCommand maxIntervalArgument = 10U; ReturnErrorOnFailure(cluster.SubscribeAttribute( - this, OnSuccessCallback_299, OnFailureCallback_299, minIntervalArgument, maxIntervalArgument, - OnSubscriptionEstablished_299)); + this, OnSuccessCallback_329, OnFailureCallback_329, minIntervalArgument, maxIntervalArgument, + OnSubscriptionEstablished_329)); return CHIP_NO_ERROR; } - void OnFailureResponse_299(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_329(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_299(const chip::app::DataModel::DecodableList & value) + void OnSuccessResponse_329(const chip::app::DataModel::DecodableList & value) { if (mTest_TestCluster_list_int8u_Reported) { @@ -45873,13 +46869,13 @@ class TestCluster : public TestCommand } } - void OnSubscriptionEstablishedResponse_299() + void OnSubscriptionEstablishedResponse_329() { - VerifyOrReturn(mReceivedReport_298, Exit("Initial report not received!")); + VerifyOrReturn(mReceivedReport_328, Exit("Initial report not received!")); NextTest(); } - CHIP_ERROR TestWriteSubscribedToListAttribute_300() + CHIP_ERROR TestWriteSubscribedToListAttribute_330() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45895,29 +46891,29 @@ class TestCluster : public TestCommand listInt8uArgument = listInt8uList; ReturnErrorOnFailure(cluster.WriteAttribute( - listInt8uArgument, this, OnSuccessCallback_300, OnFailureCallback_300)); + listInt8uArgument, this, OnSuccessCallback_330, OnFailureCallback_330)); return CHIP_NO_ERROR; } - void OnFailureResponse_300(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_330(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_300() { NextTest(); } + void OnSuccessResponse_330() { NextTest(); } - CHIP_ERROR TestCheckForListAttributeReport_301() + CHIP_ERROR TestCheckForListAttributeReport_331() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_301; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_331; return CHIP_NO_ERROR; } - void OnFailureResponse_301(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_331(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_301(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_331(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_301 = true; + mReceivedReport_331 = true; auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); @@ -45933,27 +46929,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_302() + CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_332() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_302, OnFailureCallback_302)); + this, OnSuccessCallback_332, OnFailureCallback_332)); return CHIP_NO_ERROR; } - void OnFailureResponse_302(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_332(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_302(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_332(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_303() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_333() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45963,19 +46959,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_303, OnFailureCallback_303)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_333, OnFailureCallback_333)); return CHIP_NO_ERROR; } - void OnFailureResponse_303(EmberAfStatus status) + void OnFailureResponse_333(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_303() { ThrowSuccessResponse(); } + void OnSuccessResponse_333() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_304() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_334() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45985,19 +46981,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 19; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_304, OnFailureCallback_304)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_334, OnFailureCallback_334)); return CHIP_NO_ERROR; } - void OnFailureResponse_304(EmberAfStatus status) + void OnFailureResponse_334(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_304() { ThrowSuccessResponse(); } + void OnSuccessResponse_334() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_305() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_335() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46007,19 +47003,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 101; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_305, OnFailureCallback_305)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_335, OnFailureCallback_335)); return CHIP_NO_ERROR; } - void OnFailureResponse_305(EmberAfStatus status) + void OnFailureResponse_335(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_305() { ThrowSuccessResponse(); } + void OnSuccessResponse_335() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_306() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_336() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46029,39 +47025,39 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_306, OnFailureCallback_306)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_336, OnFailureCallback_336)); return CHIP_NO_ERROR; } - void OnFailureResponse_306(EmberAfStatus status) + void OnFailureResponse_336(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_306() { ThrowSuccessResponse(); } + void OnSuccessResponse_336() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_307() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_337() { 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_337, OnFailureCallback_337)); return CHIP_NO_ERROR; } - void OnFailureResponse_307(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_337(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_307(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_337(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_308() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_338() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46071,35 +47067,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 20; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_308, OnFailureCallback_308)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_338, OnFailureCallback_338)); return CHIP_NO_ERROR; } - void OnFailureResponse_308(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_338(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_308() { NextTest(); } + void OnSuccessResponse_338() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_309() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_339() { 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_339, OnFailureCallback_339)); return CHIP_NO_ERROR; } - void OnFailureResponse_309(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_339(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_309(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_339(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 20)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_310() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_340() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46109,35 +47105,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 100; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_310, OnFailureCallback_310)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_340, OnFailureCallback_340)); return CHIP_NO_ERROR; } - void OnFailureResponse_310(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_340(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_310() { NextTest(); } + void OnSuccessResponse_340() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_311() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_341() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_311, OnFailureCallback_311)); + this, OnSuccessCallback_341, OnFailureCallback_341)); return CHIP_NO_ERROR; } - void OnFailureResponse_311(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_341(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_311(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_341(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 100)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_312() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_342() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46147,55 +47143,55 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_312, OnFailureCallback_312)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_342, OnFailureCallback_342)); return CHIP_NO_ERROR; } - void OnFailureResponse_312(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_342(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_312() { NextTest(); } + void OnSuccessResponse_342() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_313() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_343() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_313, OnFailureCallback_313)); + this, OnSuccessCallback_343, OnFailureCallback_343)); return CHIP_NO_ERROR; } - void OnFailureResponse_313(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_343(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_313(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_343(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 50)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_314() + CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_344() { 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_344, OnFailureCallback_344)); return CHIP_NO_ERROR; } - void OnFailureResponse_314(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_344(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_314(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_344(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_315() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_345() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46205,19 +47201,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 0U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_315, OnFailureCallback_315)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_345, OnFailureCallback_345)); return CHIP_NO_ERROR; } - void OnFailureResponse_315(EmberAfStatus status) + void OnFailureResponse_345(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_315() { ThrowSuccessResponse(); } + void OnSuccessResponse_345() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_316() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_346() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46227,19 +47223,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 99U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_316, OnFailureCallback_316)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_346, OnFailureCallback_346)); return CHIP_NO_ERROR; } - void OnFailureResponse_316(EmberAfStatus status) + void OnFailureResponse_346(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_316() { ThrowSuccessResponse(); } + void OnSuccessResponse_346() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_317() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_347() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46249,19 +47245,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1001U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_317, OnFailureCallback_317)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_347, OnFailureCallback_347)); return CHIP_NO_ERROR; } - void OnFailureResponse_317(EmberAfStatus status) + void OnFailureResponse_347(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_317() { ThrowSuccessResponse(); } + void OnSuccessResponse_347() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_318() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_348() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46271,39 +47267,39 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_318, OnFailureCallback_318)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_348, OnFailureCallback_348)); return CHIP_NO_ERROR; } - void OnFailureResponse_318(EmberAfStatus status) + void OnFailureResponse_348(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_318() { ThrowSuccessResponse(); } + void OnSuccessResponse_348() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_319() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_349() { 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_349, OnFailureCallback_349)); return CHIP_NO_ERROR; } - void OnFailureResponse_319(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_349(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_319(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_349(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_320() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_350() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46313,35 +47309,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 100U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_320, OnFailureCallback_320)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_350, OnFailureCallback_350)); return CHIP_NO_ERROR; } - void OnFailureResponse_320(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_350(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_320() { NextTest(); } + void OnSuccessResponse_350() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_321() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_351() { 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_351, OnFailureCallback_351)); return CHIP_NO_ERROR; } - void OnFailureResponse_321(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_351(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_321(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_351(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 100U)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_322() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_352() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46351,35 +47347,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1000U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_322, OnFailureCallback_322)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_352, OnFailureCallback_352)); return CHIP_NO_ERROR; } - void OnFailureResponse_322(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_352(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_322() { NextTest(); } + void OnSuccessResponse_352() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_323() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_353() { 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_353, OnFailureCallback_353)); return CHIP_NO_ERROR; } - void OnFailureResponse_323(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_353(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_323(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_353(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 1000U)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_324() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_354() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46389,55 +47385,55 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 500U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_324, OnFailureCallback_324)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_354, OnFailureCallback_354)); return CHIP_NO_ERROR; } - void OnFailureResponse_324(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_354(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_324() { NextTest(); } + void OnSuccessResponse_354() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_325() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_355() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_325, OnFailureCallback_325)); + this, OnSuccessCallback_355, OnFailureCallback_355)); return CHIP_NO_ERROR; } - void OnFailureResponse_325(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_355(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_325(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_355(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 500U)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_326() + CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_356() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_326, OnFailureCallback_326)); + this, OnSuccessCallback_356, OnFailureCallback_356)); return CHIP_NO_ERROR; } - void OnFailureResponse_326(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_356(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_326(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_356(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_327() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_357() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46447,19 +47443,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -128; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_327, OnFailureCallback_327)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_357, OnFailureCallback_357)); return CHIP_NO_ERROR; } - void OnFailureResponse_327(EmberAfStatus status) + void OnFailureResponse_357(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_327() { ThrowSuccessResponse(); } + void OnSuccessResponse_357() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_328() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_358() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46469,19 +47465,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -41; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_328, OnFailureCallback_328)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_358, OnFailureCallback_358)); return CHIP_NO_ERROR; } - void OnFailureResponse_328(EmberAfStatus status) + void OnFailureResponse_358(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_328() { ThrowSuccessResponse(); } + void OnSuccessResponse_358() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_329() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_359() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46491,19 +47487,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 51; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_329, OnFailureCallback_329)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_359, OnFailureCallback_359)); return CHIP_NO_ERROR; } - void OnFailureResponse_329(EmberAfStatus status) + void OnFailureResponse_359(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_329() { ThrowSuccessResponse(); } + void OnSuccessResponse_359() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_330() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_360() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46513,39 +47509,39 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 127; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_330, OnFailureCallback_330)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_360, OnFailureCallback_360)); return CHIP_NO_ERROR; } - void OnFailureResponse_330(EmberAfStatus status) + void OnFailureResponse_360(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_330() { ThrowSuccessResponse(); } + void OnSuccessResponse_360() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_331() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_361() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_331, OnFailureCallback_331)); + this, OnSuccessCallback_361, OnFailureCallback_361)); return CHIP_NO_ERROR; } - void OnFailureResponse_331(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_361(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_331(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_361(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_332() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_362() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46555,35 +47551,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -40; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_332, OnFailureCallback_332)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_362, OnFailureCallback_362)); return CHIP_NO_ERROR; } - void OnFailureResponse_332(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_362(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_332() { NextTest(); } + void OnSuccessResponse_362() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_333() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_363() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_333, OnFailureCallback_333)); + this, OnSuccessCallback_363, OnFailureCallback_363)); return CHIP_NO_ERROR; } - void OnFailureResponse_333(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_363(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_333(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_363(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, -40)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_334() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_364() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46593,35 +47589,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_334, OnFailureCallback_334)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_364, OnFailureCallback_364)); return CHIP_NO_ERROR; } - void OnFailureResponse_334(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_364(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_334() { NextTest(); } + void OnSuccessResponse_364() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_335() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_365() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_335, OnFailureCallback_335)); + this, OnSuccessCallback_365, OnFailureCallback_365)); return CHIP_NO_ERROR; } - void OnFailureResponse_335(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_365(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_335(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_365(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 50)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_336() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_366() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46631,55 +47627,55 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 6; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_336, OnFailureCallback_336)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_366, OnFailureCallback_366)); return CHIP_NO_ERROR; } - void OnFailureResponse_336(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_366(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_336() { NextTest(); } + void OnSuccessResponse_366() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_337() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_367() { 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_367, OnFailureCallback_367)); return CHIP_NO_ERROR; } - void OnFailureResponse_337(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_367(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_337(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_367(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 6)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_338() + CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_368() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_338, OnFailureCallback_338)); + this, OnSuccessCallback_368, OnFailureCallback_368)); return CHIP_NO_ERROR; } - void OnFailureResponse_338(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_368(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_338(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_368(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_339() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_369() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46689,19 +47685,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_339, OnFailureCallback_339)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_369, OnFailureCallback_369)); return CHIP_NO_ERROR; } - void OnFailureResponse_339(EmberAfStatus status) + void OnFailureResponse_369(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_339() { ThrowSuccessResponse(); } + void OnSuccessResponse_369() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_340() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_370() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46711,19 +47707,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -151; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_340, OnFailureCallback_340)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_370, OnFailureCallback_370)); return CHIP_NO_ERROR; } - void OnFailureResponse_340(EmberAfStatus status) + void OnFailureResponse_370(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_340() { ThrowSuccessResponse(); } + void OnSuccessResponse_370() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_341() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_371() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46733,19 +47729,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 201; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_341, OnFailureCallback_341)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_371, OnFailureCallback_371)); return CHIP_NO_ERROR; } - void OnFailureResponse_341(EmberAfStatus status) + void OnFailureResponse_371(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_341() { ThrowSuccessResponse(); } + void OnSuccessResponse_371() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_342() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_372() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46755,39 +47751,39 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 32767; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_342, OnFailureCallback_342)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); return CHIP_NO_ERROR; } - void OnFailureResponse_342(EmberAfStatus status) + void OnFailureResponse_372(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_342() { ThrowSuccessResponse(); } + void OnSuccessResponse_372() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_343() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_373() { 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_373, OnFailureCallback_373)); return CHIP_NO_ERROR; } - void OnFailureResponse_343(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_373(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_343(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_373(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_344() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_374() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46797,35 +47793,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -150; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_344, OnFailureCallback_344)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_374, OnFailureCallback_374)); return CHIP_NO_ERROR; } - void OnFailureResponse_344(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_374(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_344() { NextTest(); } + void OnSuccessResponse_374() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_345() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_375() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_345, OnFailureCallback_345)); + this, OnSuccessCallback_375, OnFailureCallback_375)); return CHIP_NO_ERROR; } - void OnFailureResponse_345(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_375(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_345(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_375(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, -150)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_346() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_376() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46835,35 +47831,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 200; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_346, OnFailureCallback_346)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); return CHIP_NO_ERROR; } - void OnFailureResponse_346(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_376(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_346() { NextTest(); } + void OnSuccessResponse_376() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_347() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_377() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_347, OnFailureCallback_347)); + this, OnSuccessCallback_377, OnFailureCallback_377)); return CHIP_NO_ERROR; } - void OnFailureResponse_347(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_377(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_347(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_377(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 200)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_348() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_378() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46873,35 +47869,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 7; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_348, OnFailureCallback_348)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_378, OnFailureCallback_378)); return CHIP_NO_ERROR; } - void OnFailureResponse_348(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_378(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_348() { NextTest(); } + void OnSuccessResponse_378() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_349() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_379() { 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_379, OnFailureCallback_379)); return CHIP_NO_ERROR; } - void OnFailureResponse_349(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_379(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_349(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_379(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 7)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_350() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_380() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46909,13 +47905,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_350, OnFailureCallback_350)); + this, OnSuccessCallback_380, OnFailureCallback_380)); return CHIP_NO_ERROR; } - void OnFailureResponse_350(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_380(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_350(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_380(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -46923,7 +47919,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_351() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_381() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46934,19 +47930,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_351, OnFailureCallback_351)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_381, OnFailureCallback_381)); return CHIP_NO_ERROR; } - void OnFailureResponse_351(EmberAfStatus status) + void OnFailureResponse_381(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_351() { ThrowSuccessResponse(); } + void OnSuccessResponse_381() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_352() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_382() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46957,19 +47953,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_352, OnFailureCallback_352)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_382, OnFailureCallback_382)); return CHIP_NO_ERROR; } - void OnFailureResponse_352(EmberAfStatus status) + void OnFailureResponse_382(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_352() { ThrowSuccessResponse(); } + void OnSuccessResponse_382() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_353() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_383() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46980,19 +47976,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_353, OnFailureCallback_353)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_383, OnFailureCallback_383)); return CHIP_NO_ERROR; } - void OnFailureResponse_353(EmberAfStatus status) + void OnFailureResponse_383(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_353() { ThrowSuccessResponse(); } + void OnSuccessResponse_383() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_354() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_384() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47003,19 +47999,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_354, OnFailureCallback_354)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); return CHIP_NO_ERROR; } - void OnFailureResponse_354(EmberAfStatus status) + void OnFailureResponse_384(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_354() { ThrowSuccessResponse(); } + void OnSuccessResponse_384() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_355() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_385() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47023,13 +48019,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_355, OnFailureCallback_355)); + this, OnSuccessCallback_385, OnFailureCallback_385)); return CHIP_NO_ERROR; } - void OnFailureResponse_355(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_385(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_355(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_385(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -47037,7 +48033,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_356() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_386() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47048,15 +48044,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_356, OnFailureCallback_356)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_386, OnFailureCallback_386)); return CHIP_NO_ERROR; } - void OnFailureResponse_356(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_386(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_356() { NextTest(); } + void OnSuccessResponse_386() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_357() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_387() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47064,13 +48060,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_357, OnFailureCallback_357)); + this, OnSuccessCallback_387, OnFailureCallback_387)); return CHIP_NO_ERROR; } - void OnFailureResponse_357(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_387(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_357(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_387(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 20)); @@ -47078,7 +48074,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_358() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_388() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47089,15 +48085,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_358, OnFailureCallback_358)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); return CHIP_NO_ERROR; } - void OnFailureResponse_358(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_388(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_358() { NextTest(); } + void OnSuccessResponse_388() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_359() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_389() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47105,13 +48101,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_359, OnFailureCallback_359)); + this, OnSuccessCallback_389, OnFailureCallback_389)); return CHIP_NO_ERROR; } - void OnFailureResponse_359(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_389(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_359(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_389(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 100)); @@ -47119,7 +48115,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_360() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_390() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47130,15 +48126,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_360, OnFailureCallback_360)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_390, OnFailureCallback_390)); return CHIP_NO_ERROR; } - void OnFailureResponse_360(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_390(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_360() { NextTest(); } + void OnSuccessResponse_390() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_361() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_391() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47146,13 +48142,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_361, OnFailureCallback_361)); + this, OnSuccessCallback_391, OnFailureCallback_391)); return CHIP_NO_ERROR; } - void OnFailureResponse_361(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_391(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_361(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_391(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 50)); @@ -47160,7 +48156,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_362() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_392() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47171,15 +48167,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_362, OnFailureCallback_362)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_392, OnFailureCallback_392)); return CHIP_NO_ERROR; } - void OnFailureResponse_362(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_392(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_362() { NextTest(); } + void OnSuccessResponse_392() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_363() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_393() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47187,20 +48183,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_363, OnFailureCallback_363)); + this, OnSuccessCallback_393, OnFailureCallback_393)); return CHIP_NO_ERROR; } - void OnFailureResponse_363(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_393(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_363(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_393(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_364() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_394() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47208,13 +48204,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_364, OnFailureCallback_364)); + this, OnSuccessCallback_394, OnFailureCallback_394)); return CHIP_NO_ERROR; } - void OnFailureResponse_364(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_394(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_364(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_394(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -47222,7 +48218,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_365() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_395() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47233,19 +48229,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_365, OnFailureCallback_365)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_395, OnFailureCallback_395)); return CHIP_NO_ERROR; } - void OnFailureResponse_365(EmberAfStatus status) + void OnFailureResponse_395(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_365() { ThrowSuccessResponse(); } + void OnSuccessResponse_395() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_366() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_396() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47256,19 +48252,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_366, OnFailureCallback_366)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); return CHIP_NO_ERROR; } - void OnFailureResponse_366(EmberAfStatus status) + void OnFailureResponse_396(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_366() { ThrowSuccessResponse(); } + void OnSuccessResponse_396() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_367() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_397() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47279,19 +48275,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_367, OnFailureCallback_367)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_397, OnFailureCallback_397)); return CHIP_NO_ERROR; } - void OnFailureResponse_367(EmberAfStatus status) + void OnFailureResponse_397(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_367() { ThrowSuccessResponse(); } + void OnSuccessResponse_397() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_368() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_398() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47302,19 +48298,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_368, OnFailureCallback_368)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_398, OnFailureCallback_398)); return CHIP_NO_ERROR; } - void OnFailureResponse_368(EmberAfStatus status) + void OnFailureResponse_398(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_368() { ThrowSuccessResponse(); } + void OnSuccessResponse_398() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_369() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_399() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47322,13 +48318,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_369, OnFailureCallback_369)); + this, OnSuccessCallback_399, OnFailureCallback_399)); return CHIP_NO_ERROR; } - void OnFailureResponse_369(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_399(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_369(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_399(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -47336,7 +48332,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_370() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_400() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47347,15 +48343,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_370, OnFailureCallback_370)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); return CHIP_NO_ERROR; } - void OnFailureResponse_370(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_400(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_370() { NextTest(); } + void OnSuccessResponse_400() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_371() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_401() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47363,13 +48359,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_371, OnFailureCallback_371)); + this, OnSuccessCallback_401, OnFailureCallback_401)); return CHIP_NO_ERROR; } - void OnFailureResponse_371(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_401(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_371(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_401(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 100U)); @@ -47377,7 +48373,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_372() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_402() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47388,15 +48384,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); return CHIP_NO_ERROR; } - void OnFailureResponse_372(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_402(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_372() { NextTest(); } + void OnSuccessResponse_402() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_373() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_403() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47404,13 +48400,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_373, OnFailureCallback_373)); + this, OnSuccessCallback_403, OnFailureCallback_403)); return CHIP_NO_ERROR; } - void OnFailureResponse_373(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_403(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_373(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_403(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 1000U)); @@ -47418,7 +48414,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_374() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_404() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47429,15 +48425,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_374, OnFailureCallback_374)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_404, OnFailureCallback_404)); return CHIP_NO_ERROR; } - void OnFailureResponse_374(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_404(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_374() { NextTest(); } + void OnSuccessResponse_404() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_375() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_405() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47445,13 +48441,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_375, OnFailureCallback_375)); + this, OnSuccessCallback_405, OnFailureCallback_405)); return CHIP_NO_ERROR; } - void OnFailureResponse_375(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_405(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_375(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_405(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 500U)); @@ -47459,7 +48455,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_376() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_406() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47470,15 +48466,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_406, OnFailureCallback_406)); return CHIP_NO_ERROR; } - void OnFailureResponse_376(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_406(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_376() { NextTest(); } + void OnSuccessResponse_406() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_377() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_407() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47486,20 +48482,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_377, OnFailureCallback_377)); + this, OnSuccessCallback_407, OnFailureCallback_407)); return CHIP_NO_ERROR; } - void OnFailureResponse_377(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_407(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_377(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_407(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_378() + CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_408() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47507,13 +48503,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_378, OnFailureCallback_378)); + this, OnSuccessCallback_408, OnFailureCallback_408)); return CHIP_NO_ERROR; } - void OnFailureResponse_378(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_408(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_378(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_408(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 0)); @@ -47521,7 +48517,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_379() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_409() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47532,19 +48528,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_379, OnFailureCallback_379)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_409, OnFailureCallback_409)); return CHIP_NO_ERROR; } - void OnFailureResponse_379(EmberAfStatus status) + void OnFailureResponse_409(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_379() { ThrowSuccessResponse(); } + void OnSuccessResponse_409() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_380() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_410() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47555,19 +48551,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_380, OnFailureCallback_380)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_410, OnFailureCallback_410)); return CHIP_NO_ERROR; } - void OnFailureResponse_380(EmberAfStatus status) + void OnFailureResponse_410(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_380() { ThrowSuccessResponse(); } + void OnSuccessResponse_410() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_381() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_411() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47578,19 +48574,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_381, OnFailureCallback_381)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_411, OnFailureCallback_411)); return CHIP_NO_ERROR; } - void OnFailureResponse_381(EmberAfStatus status) + void OnFailureResponse_411(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_381() { ThrowSuccessResponse(); } + void OnSuccessResponse_411() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_382() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_412() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47601,19 +48597,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_382, OnFailureCallback_382)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_412, OnFailureCallback_412)); return CHIP_NO_ERROR; } - void OnFailureResponse_382(EmberAfStatus status) + void OnFailureResponse_412(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_382() { ThrowSuccessResponse(); } + void OnSuccessResponse_412() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_383() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_413() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47621,13 +48617,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_383, OnFailureCallback_383)); + this, OnSuccessCallback_413, OnFailureCallback_413)); return CHIP_NO_ERROR; } - void OnFailureResponse_383(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_413(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_383(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_413(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 0)); @@ -47635,7 +48631,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_384() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_414() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47646,15 +48642,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_414, OnFailureCallback_414)); return CHIP_NO_ERROR; } - void OnFailureResponse_384(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_414(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_384() { NextTest(); } + void OnSuccessResponse_414() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_385() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_415() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47662,13 +48658,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_385, OnFailureCallback_385)); + this, OnSuccessCallback_415, OnFailureCallback_415)); return CHIP_NO_ERROR; } - void OnFailureResponse_385(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_415(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_385(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_415(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), -40)); @@ -47676,7 +48672,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_386() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_416() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47687,15 +48683,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_386, OnFailureCallback_386)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_416, OnFailureCallback_416)); return CHIP_NO_ERROR; } - void OnFailureResponse_386(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_416(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_386() { NextTest(); } + void OnSuccessResponse_416() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_387() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_417() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47703,13 +48699,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_387, OnFailureCallback_387)); + this, OnSuccessCallback_417, OnFailureCallback_417)); return CHIP_NO_ERROR; } - void OnFailureResponse_387(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_417(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_387(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_417(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 50)); @@ -47717,7 +48713,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_388() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_418() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47728,15 +48724,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_418, OnFailureCallback_418)); return CHIP_NO_ERROR; } - void OnFailureResponse_388(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_418(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_388() { NextTest(); } + void OnSuccessResponse_418() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_389() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_419() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47744,13 +48740,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_389, OnFailureCallback_389)); + this, OnSuccessCallback_419, OnFailureCallback_419)); return CHIP_NO_ERROR; } - void OnFailureResponse_389(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_419(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_389(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_419(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 6)); @@ -47758,7 +48754,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_390() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_420() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47769,15 +48765,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_390, OnFailureCallback_390)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_420, OnFailureCallback_420)); return CHIP_NO_ERROR; } - void OnFailureResponse_390(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_420(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_390() { NextTest(); } + void OnSuccessResponse_420() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_391() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_421() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47785,20 +48781,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_391, OnFailureCallback_391)); + this, OnSuccessCallback_421, OnFailureCallback_421)); return CHIP_NO_ERROR; } - void OnFailureResponse_391(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_421(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_391(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_421(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_392() + CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_422() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47806,13 +48802,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_392, OnFailureCallback_392)); + this, OnSuccessCallback_422, OnFailureCallback_422)); return CHIP_NO_ERROR; } - void OnFailureResponse_392(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_422(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_392(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_422(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 0)); @@ -47820,7 +48816,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_393() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_423() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47831,19 +48827,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_393, OnFailureCallback_393)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_423, OnFailureCallback_423)); return CHIP_NO_ERROR; } - void OnFailureResponse_393(EmberAfStatus status) + void OnFailureResponse_423(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_393() { ThrowSuccessResponse(); } + void OnSuccessResponse_423() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_394() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_424() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47854,19 +48850,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_394, OnFailureCallback_394)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_424, OnFailureCallback_424)); return CHIP_NO_ERROR; } - void OnFailureResponse_394(EmberAfStatus status) + void OnFailureResponse_424(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_394() { ThrowSuccessResponse(); } + void OnSuccessResponse_424() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_395() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_425() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47877,19 +48873,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_395, OnFailureCallback_395)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_425, OnFailureCallback_425)); return CHIP_NO_ERROR; } - void OnFailureResponse_395(EmberAfStatus status) + void OnFailureResponse_425(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_395() { ThrowSuccessResponse(); } + void OnSuccessResponse_425() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_396() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_426() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47900,19 +48896,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_426, OnFailureCallback_426)); return CHIP_NO_ERROR; } - void OnFailureResponse_396(EmberAfStatus status) + void OnFailureResponse_426(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_396() { ThrowSuccessResponse(); } + void OnSuccessResponse_426() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_397() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_427() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47920,13 +48916,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_397, OnFailureCallback_397)); + this, OnSuccessCallback_427, OnFailureCallback_427)); return CHIP_NO_ERROR; } - void OnFailureResponse_397(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_427(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_397(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_427(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 0)); @@ -47934,7 +48930,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_398() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_428() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47945,15 +48941,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_398, OnFailureCallback_398)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_428, OnFailureCallback_428)); return CHIP_NO_ERROR; } - void OnFailureResponse_398(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_428(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_398() { NextTest(); } + void OnSuccessResponse_428() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_399() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_429() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47961,13 +48957,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_399, OnFailureCallback_399)); + this, OnSuccessCallback_429, OnFailureCallback_429)); return CHIP_NO_ERROR; } - void OnFailureResponse_399(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_429(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_399(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_429(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), -150)); @@ -47975,7 +48971,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_400() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_430() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47986,15 +48982,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_430, OnFailureCallback_430)); return CHIP_NO_ERROR; } - void OnFailureResponse_400(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_430(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_400() { NextTest(); } + void OnSuccessResponse_430() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_401() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_431() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48002,13 +48998,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_401, OnFailureCallback_401)); + this, OnSuccessCallback_431, OnFailureCallback_431)); return CHIP_NO_ERROR; } - void OnFailureResponse_401(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_431(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_401(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_431(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 200)); @@ -48016,7 +49012,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_402() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_432() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48027,15 +49023,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_432, OnFailureCallback_432)); return CHIP_NO_ERROR; } - void OnFailureResponse_402(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_432(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_402() { NextTest(); } + void OnSuccessResponse_432() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_403() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_433() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48043,13 +49039,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_403, OnFailureCallback_403)); + this, OnSuccessCallback_433, OnFailureCallback_433)); return CHIP_NO_ERROR; } - void OnFailureResponse_403(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_433(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_403(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_433(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 7)); @@ -48057,7 +49053,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_404() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_434() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48068,15 +49064,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_404, OnFailureCallback_404)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_434, OnFailureCallback_434)); return CHIP_NO_ERROR; } - void OnFailureResponse_404(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_434(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_404() { NextTest(); } + void OnSuccessResponse_434() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_405() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_435() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48084,13 +49080,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_405, OnFailureCallback_405)); + this, OnSuccessCallback_435, OnFailureCallback_435)); return CHIP_NO_ERROR; } - void OnFailureResponse_405(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_435(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_405(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_435(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); @@ -49071,7 +50067,7 @@ class TestConstraints : public TestCommand void OnSuccessResponse_2(uint32_t int32u) { - VerifyOrReturn(CheckConstraintMinValue("int32u", int32u, 5)); + VerifyOrReturn(CheckConstraintMinValue("int32u", int32u, 5UL)); NextTest(); } @@ -49091,7 +50087,7 @@ class TestConstraints : public TestCommand void OnSuccessResponse_3(uint32_t int32u) { - VerifyOrReturn(CheckConstraintMaxValue("int32u", int32u, 5)); + VerifyOrReturn(CheckConstraintMaxValue("int32u", int32u, 5UL)); NextTest(); }