From 045f399488a670bd9ef691a7cd5d2fc4dcaeb032 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Fri, 17 Dec 2021 00:02:09 -0500 Subject: [PATCH] Fix null handling for enum types. (#13091) For enum types we ended up with an incorrect null representation via NumericAttributeTraits, because while we called GetNullValue with the template argument set to our underlying type the actual implementation ignores the template argument: it's just there for the enable_if tests. As far as testing goes, the yaml tests being added would have caught this if our attribute store interaction were actually using enums, but that code switches to treating them as just bare ints very early, before instantiating the NumericAttributeTraits template. The unit test does catch this problem, though. --- src/app/tests/TestNumericAttributeTraits.cpp | 154 + src/app/tests/suites/TestCluster.yaml | 124 + .../util/attribute-storage-null-handling.h | 3 +- .../Framework/CHIPTests/CHIPClustersTests.m | 1107 ++-- .../chip-tool/zap-generated/test/Commands.h | 4729 ++++++++++------- 5 files changed, 3760 insertions(+), 2357 deletions(-) diff --git a/src/app/tests/TestNumericAttributeTraits.cpp b/src/app/tests/TestNumericAttributeTraits.cpp index e96657563a66fc..4d194a0711fa62 100644 --- a/src/app/tests/TestNumericAttributeTraits.cpp +++ b/src/app/tests/TestNumericAttributeTraits.cpp @@ -38,6 +38,156 @@ using namespace chip::app; namespace { +void Test_UINT8(nlTestSuite * apSuite, void * apContext) +{ + // Unsigned 8-bit Integer : 1 byte, endianness does not matter. + using IntType = NumericAttributeTraits; + using StorageType = typename IntType::StorageType; + using WorkingType = typename IntType::WorkingType; + + StorageType sValue; + WorkingType wValue; + StorageType sNullValue; + WorkingType wNullValue; + const StorageType storageTestData = 17; + const WorkingType workingTestUnsignedNullValue = 0xFF; + + // 1) Verify the size of the types + NL_TEST_ASSERT(apSuite, sizeof(sValue) == 1); + NL_TEST_ASSERT(apSuite, sizeof(wValue) >= 1); + + // Initialize the Storage Value with the test-buffer + memcpy(&sValue, &storageTestData, sizeof(sValue)); + + // Convert the Storage Type to Working Type and + wValue = IntType::StorageToWorking(sValue); + + // 2) Verify that the correct storage format has been used + NL_TEST_ASSERT(apSuite, wValue == 17); + + StorageType sNewValue; + + // Convert back to Storage Value + IntType::WorkingToStorage(wValue, sNewValue); + + // 3) Verify that the bytes are located as intended + NL_TEST_ASSERT(apSuite, memcmp(&storageTestData, &sNewValue, sizeof(sNewValue)) == 0); + + // Set Storage value to Null + IntType::SetNull(sNullValue); + wNullValue = IntType::StorageToWorking(sNullValue); + NL_TEST_ASSERT(apSuite, wNullValue == workingTestUnsignedNullValue); + NL_TEST_ASSERT(apSuite, (IntType::IsNullValue(sNullValue) == true)); + + // Verify that null values can fit into not nullable + NL_TEST_ASSERT(apSuite, (IntType::CanRepresentValue(false, sNullValue) == true)); + + // Verify that null values can't fit into nullable + NL_TEST_ASSERT(apSuite, (IntType::CanRepresentValue(true, sNullValue) == false)); +} + +void Test_SINT8(nlTestSuite * apSuite, void * apContext) +{ + // Signed 8-bit Integer : 1 byte, endianness does not matter. + using IntType = NumericAttributeTraits; + using StorageType = typename IntType::StorageType; + using WorkingType = typename IntType::WorkingType; + + StorageType sValue; + WorkingType wValue; + StorageType sNullValue; + WorkingType wNullValue; + const StorageType storageTestData = 17; + const WorkingType workingTestUnsignedNullValue = -128; // 0x80 + + // 1) Verify the size of the types + NL_TEST_ASSERT(apSuite, sizeof(sValue) == 1); + NL_TEST_ASSERT(apSuite, sizeof(wValue) >= 1); + + // Initialize the Storage Value with the test-buffer + memcpy(&sValue, &storageTestData, sizeof(sValue)); + + // Convert the Storage Type to Working Type and + wValue = IntType::StorageToWorking(sValue); + + // 2) Verify that the correct storage format has been used + NL_TEST_ASSERT(apSuite, wValue == 17); + + StorageType sNewValue; + + // Convert back to Storage Value + IntType::WorkingToStorage(wValue, sNewValue); + + // 3) Verify that the bytes are located as intended + NL_TEST_ASSERT(apSuite, memcmp(&storageTestData, &sNewValue, sizeof(sNewValue)) == 0); + + // Set Storage value to Null + IntType::SetNull(sNullValue); + wNullValue = IntType::StorageToWorking(sNullValue); + NL_TEST_ASSERT(apSuite, wNullValue == workingTestUnsignedNullValue); + NL_TEST_ASSERT(apSuite, (IntType::IsNullValue(sNullValue) == true)); + + // Verify that null values can fit into not nullable + NL_TEST_ASSERT(apSuite, (IntType::CanRepresentValue(false, sNullValue) == true)); + + // Verify that null values can't fit into nullable + NL_TEST_ASSERT(apSuite, (IntType::CanRepresentValue(true, sNullValue) == false)); +} + +enum class SimpleEnum : uint8_t +{ + kZero = 0, + kOne = 1, +}; + +void Test_SimpleEnum(nlTestSuite * apSuite, void * apContext) +{ + // Unsigned 8-bit Integer : 1 byte, endianness does not matter. + using IntType = NumericAttributeTraits; + using StorageType = typename IntType::StorageType; + using WorkingType = typename IntType::WorkingType; + + StorageType sValue; + WorkingType wValue; + StorageType sNullValue; + WorkingType wNullValue; + const StorageType storageTestData = SimpleEnum::kOne; + const WorkingType workingTestUnsignedNullValue = static_cast(0xFF); + + // 1) Verify the size of the types + NL_TEST_ASSERT(apSuite, sizeof(sValue) == 1); + NL_TEST_ASSERT(apSuite, sizeof(wValue) >= 1); + + // Initialize the Storage Value with the test-buffer + memcpy(&sValue, &storageTestData, sizeof(sValue)); + + // Convert the Storage Type to Working Type and + wValue = IntType::StorageToWorking(sValue); + + // 2) Verify that the correct storage format has been used + NL_TEST_ASSERT(apSuite, wValue == SimpleEnum::kOne); + + StorageType sNewValue; + + // Convert back to Storage Value + IntType::WorkingToStorage(wValue, sNewValue); + + // 3) Verify that the bytes are located as intended + NL_TEST_ASSERT(apSuite, memcmp(&storageTestData, &sNewValue, sizeof(sNewValue)) == 0); + + // Set Storage value to Null + IntType::SetNull(sNullValue); + wNullValue = IntType::StorageToWorking(sNullValue); + NL_TEST_ASSERT(apSuite, wNullValue == workingTestUnsignedNullValue); + NL_TEST_ASSERT(apSuite, (IntType::IsNullValue(sNullValue) == true)); + + // Verify that null values can fit into not nullable + NL_TEST_ASSERT(apSuite, (IntType::CanRepresentValue(false, sNullValue) == true)); + + // Verify that null values can't fit into nullable + NL_TEST_ASSERT(apSuite, (IntType::CanRepresentValue(true, sNullValue) == false)); +} + //////////////////////////////////////////////////////////// // ______ __ __ _______ ______ ________ // // / \ / | / | / \ / |/ | // @@ -1009,6 +1159,10 @@ static int TestTeardown(void * inContext) // clang-format off const nlTest sTests[] = { + NL_TEST_DEF("Test_UINT8", Test_UINT8), + NL_TEST_DEF("Test_SINT8", Test_SINT8), + NL_TEST_DEF("Test_SimpleEnum", Test_SimpleEnum), + NL_TEST_DEF("Test_UINT24_LE",Test_UINT24_LE), NL_TEST_DEF("Test_SINT24_LE",Test_SINT24_LE), NL_TEST_DEF("Test_UINT24_BE",Test_UINT24_BE), diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml index fda216b4704955..dde0eac35896f8 100644 --- a/src/app/tests/suites/TestCluster.yaml +++ b/src/app/tests/suites/TestCluster.yaml @@ -1745,6 +1745,18 @@ tests: # Tests for nullable UInt8 attribute + - label: "Write attribute NULLABLE_INT8U Min Value" + command: "writeAttribute" + attribute: "nullable_int8u" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_INT8U Min Value" + command: "readAttribute" + attribute: "nullable_int8u" + response: + value: 0 + - label: "Write attribute NULLABLE_INT8U Max Value" command: "writeAttribute" attribute: "nullable_int8u" @@ -1821,6 +1833,18 @@ tests: # Tests for nullable UInt16 attribute + - label: "Write attribute NULLABLE_INT16U Min Value" + command: "writeAttribute" + attribute: "nullable_int16u" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_INT16U Min Value" + command: "readAttribute" + attribute: "nullable_int16u" + response: + value: 0 + - label: "Write attribute NULLABLE_INT16U Max Value" command: "writeAttribute" attribute: "nullable_int16u" @@ -1897,6 +1921,18 @@ tests: # Tests for nullable UInt32 attribute + - label: "Write attribute NULLABLE_INT32U Min Value" + command: "writeAttribute" + attribute: "nullable_int32u" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_INT32U Min Value" + command: "readAttribute" + attribute: "nullable_int32u" + response: + value: 0 + - label: "Write attribute NULLABLE_INT32U Max Value" command: "writeAttribute" attribute: "nullable_int32u" @@ -1973,6 +2009,18 @@ tests: # Tests for nullable UInt64 attribute + - label: "Write attribute NULLABLE_INT64U Min Value" + command: "writeAttribute" + attribute: "nullable_int64u" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_INT64U Min Value" + command: "readAttribute" + attribute: "nullable_int64u" + response: + value: 0 + - label: "Write attribute NULLABLE_INT64U Max Value" command: "writeAttribute" attribute: "nullable_int64u" @@ -2480,6 +2528,18 @@ tests: # Tests for Enum8 attribute + - label: "Write attribute NULLABLE_ENUM8 Min Value" + command: "writeAttribute" + attribute: "nullable_enum8" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_ENUM8 Min Value" + command: "readAttribute" + attribute: "nullable_enum8" + response: + value: 0 + - label: "Write attribute NULLABLE_ENUM8 Max Value" command: "writeAttribute" attribute: "nullable_enum8" @@ -2520,6 +2580,18 @@ tests: # Tests for Enum16 attribute + - label: "Write attribute NULLABLE_ENUM16 Min Value" + command: "writeAttribute" + attribute: "nullable_enum16" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_ENUM16 Min Value" + command: "readAttribute" + attribute: "nullable_enum16" + response: + value: 0 + - label: "Write attribute NULLABLE_ENUM16 Max Value" command: "writeAttribute" attribute: "nullable_enum16" @@ -2558,6 +2630,58 @@ tests: response: value: null + # Tests for named enum attribute + + - label: "Write attribute NULLABLE_SIMPLE_ENUM Min Value" + command: "writeAttribute" + attribute: "nullable_enum_attr" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_SIMPLE_ENUM Min Value" + command: "readAttribute" + attribute: "nullable_enum_attr" + response: + value: 0 + + - label: "Write attribute NULLABLE_SIMPLE_ENUM Max Value" + command: "writeAttribute" + attribute: "nullable_enum_attr" + arguments: + value: 254 + + - label: "Read attribute NULLABLE_SIMPLE_ENUM Max Value" + command: "readAttribute" + attribute: "nullable_enum_attr" + response: + value: 254 + + - label: "Write attribute NULLABLE_SIMPLE_ENUM Invalid Value" + command: "writeAttribute" + attribute: "nullable_enum_attr" + arguments: + value: 255 + response: + error: CONSTRAINT_ERROR + + - label: "Read attribute NULLABLE_SIMPLE_ENUM unchanged Value" + command: "readAttribute" + attribute: "nullable_enum_attr" + response: + value: 254 + + - label: "Write attribute NULLABLE_SIMPLE_ENUM null Value" + command: "writeAttribute" + attribute: "nullable_enum_attr" + arguments: + value: null + + - label: "Read attribute NULLABLE_SIMPLE_ENUM null Value" + command: "readAttribute" + attribute: "nullable_enum_attr" + response: + value: null + # Tests for Octet String attribute - label: "Read attribute NULLABLE_OCTET_STRING Default Value" diff --git a/src/app/util/attribute-storage-null-handling.h b/src/app/util/attribute-storage-null-handling.h index 35dc4378cd1a04..720bfa29f91514 100644 --- a/src/app/util/attribute-storage-null-handling.h +++ b/src/app/util/attribute-storage-null-handling.h @@ -74,7 +74,8 @@ struct NumericAttributeTraits template ::value, int> = 0> static constexpr StorageType GetNullValue() { - return GetNullValue>(); + static_assert(!std::is_signed>::value, "Enums must be unsigned"); + return static_cast(std::numeric_limits>::max()); } public: diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 9865704130f531..00a9946734dfc6 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -25235,6 +25235,53 @@ - (void)testSendClusterTestCluster_000199_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } - (void)testSendClusterTestCluster_000200_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Min 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:0]; + [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8U Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000201_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Min Value"]; + + 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 Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 0); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000202_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Max Value"]; @@ -25256,7 +25303,7 @@ - (void)testSendClusterTestCluster_000200_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000201_ReadAttribute +- (void)testSendClusterTestCluster_000203_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Max Value"]; @@ -25281,7 +25328,7 @@ - (void)testSendClusterTestCluster_000201_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000202_WriteAttribute +- (void)testSendClusterTestCluster_000204_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Invalid Value"]; @@ -25302,7 +25349,7 @@ - (void)testSendClusterTestCluster_000202_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000203_ReadAttribute +- (void)testSendClusterTestCluster_000205_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U unchanged Value"]; @@ -25327,7 +25374,7 @@ - (void)testSendClusterTestCluster_000203_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000204_WriteAttribute +- (void)testSendClusterTestCluster_000206_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U null Value"]; @@ -25349,7 +25396,7 @@ - (void)testSendClusterTestCluster_000204_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000205_ReadAttribute +- (void)testSendClusterTestCluster_000207_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value"]; @@ -25373,7 +25420,7 @@ - (void)testSendClusterTestCluster_000205_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000206_ReadAttribute +- (void)testSendClusterTestCluster_000208_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value & range"]; @@ -25399,7 +25446,7 @@ - (void)testSendClusterTestCluster_000206_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000207_ReadAttribute +- (void)testSendClusterTestCluster_000209_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value & not"]; @@ -25425,7 +25472,7 @@ - (void)testSendClusterTestCluster_000207_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000208_WriteAttribute +- (void)testSendClusterTestCluster_000210_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Value"]; @@ -25447,7 +25494,7 @@ - (void)testSendClusterTestCluster_000208_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000209_ReadAttribute +- (void)testSendClusterTestCluster_000211_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Value in range"]; @@ -25473,7 +25520,7 @@ - (void)testSendClusterTestCluster_000209_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000210_ReadAttribute +- (void)testSendClusterTestCluster_000212_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U notValue OK"]; @@ -25499,7 +25546,54 @@ - (void)testSendClusterTestCluster_000210_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000211_WriteAttribute +- (void)testSendClusterTestCluster_000213_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Min 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:0U]; + [cluster writeAttributeNullableInt16uWithValue:nullableInt16uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT16U Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000214_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Min Value"]; + + 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 Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedShortValue], 0U); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000215_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Max Value"]; @@ -25521,7 +25615,7 @@ - (void)testSendClusterTestCluster_000211_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000212_ReadAttribute +- (void)testSendClusterTestCluster_000216_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Max Value"]; @@ -25546,7 +25640,7 @@ - (void)testSendClusterTestCluster_000212_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000213_WriteAttribute +- (void)testSendClusterTestCluster_000217_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Invalid Value"]; @@ -25568,7 +25662,7 @@ - (void)testSendClusterTestCluster_000213_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000214_ReadAttribute +- (void)testSendClusterTestCluster_000218_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U unchanged Value"]; @@ -25593,7 +25687,7 @@ - (void)testSendClusterTestCluster_000214_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000215_WriteAttribute +- (void)testSendClusterTestCluster_000219_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U null Value"]; @@ -25615,7 +25709,7 @@ - (void)testSendClusterTestCluster_000215_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000216_ReadAttribute +- (void)testSendClusterTestCluster_000220_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value"]; @@ -25639,7 +25733,7 @@ - (void)testSendClusterTestCluster_000216_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000217_ReadAttribute +- (void)testSendClusterTestCluster_000221_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value & range"]; @@ -25665,7 +25759,7 @@ - (void)testSendClusterTestCluster_000217_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000218_ReadAttribute +- (void)testSendClusterTestCluster_000222_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value & not"]; @@ -25691,7 +25785,7 @@ - (void)testSendClusterTestCluster_000218_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000219_WriteAttribute +- (void)testSendClusterTestCluster_000223_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Value"]; @@ -25713,7 +25807,7 @@ - (void)testSendClusterTestCluster_000219_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000220_ReadAttribute +- (void)testSendClusterTestCluster_000224_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Value in range"]; @@ -25739,7 +25833,7 @@ - (void)testSendClusterTestCluster_000220_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000221_ReadAttribute +- (void)testSendClusterTestCluster_000225_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U notValue OK"]; @@ -25765,7 +25859,54 @@ - (void)testSendClusterTestCluster_000221_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000222_WriteAttribute +- (void)testSendClusterTestCluster_000226_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Min 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:0UL]; + [cluster writeAttributeNullableInt32uWithValue:nullableInt32uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT32U Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000227_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Min Value"]; + + 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 Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedIntValue], 0UL); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000228_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Max Value"]; @@ -25787,7 +25928,7 @@ - (void)testSendClusterTestCluster_000222_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000223_ReadAttribute +- (void)testSendClusterTestCluster_000229_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Max Value"]; @@ -25812,7 +25953,7 @@ - (void)testSendClusterTestCluster_000223_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000224_WriteAttribute +- (void)testSendClusterTestCluster_000230_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Invalid Value"]; @@ -25834,7 +25975,7 @@ - (void)testSendClusterTestCluster_000224_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000225_ReadAttribute +- (void)testSendClusterTestCluster_000231_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U unchanged Value"]; @@ -25859,7 +26000,7 @@ - (void)testSendClusterTestCluster_000225_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000226_WriteAttribute +- (void)testSendClusterTestCluster_000232_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U null Value"]; @@ -25881,7 +26022,7 @@ - (void)testSendClusterTestCluster_000226_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000227_ReadAttribute +- (void)testSendClusterTestCluster_000233_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value"]; @@ -25905,7 +26046,7 @@ - (void)testSendClusterTestCluster_000227_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000228_ReadAttribute +- (void)testSendClusterTestCluster_000234_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value & range"]; @@ -25931,7 +26072,7 @@ - (void)testSendClusterTestCluster_000228_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000229_ReadAttribute +- (void)testSendClusterTestCluster_000235_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value & not"]; @@ -25957,7 +26098,7 @@ - (void)testSendClusterTestCluster_000229_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000230_WriteAttribute +- (void)testSendClusterTestCluster_000236_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Value"]; @@ -25979,7 +26120,7 @@ - (void)testSendClusterTestCluster_000230_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000231_ReadAttribute +- (void)testSendClusterTestCluster_000237_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Value in range"]; @@ -26005,7 +26146,7 @@ - (void)testSendClusterTestCluster_000231_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000232_ReadAttribute +- (void)testSendClusterTestCluster_000238_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U notValue OK"]; @@ -26031,7 +26172,54 @@ - (void)testSendClusterTestCluster_000232_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000233_WriteAttribute +- (void)testSendClusterTestCluster_000239_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Min Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableInt64uArgument; + nullableInt64uArgument = [NSNumber numberWithUnsignedLongLong:0ULL]; + [cluster writeAttributeNullableInt64uWithValue:nullableInt64uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64U Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000240_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Min Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedLongLongValue], 0ULL); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000241_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Max Value"]; @@ -26053,7 +26241,7 @@ - (void)testSendClusterTestCluster_000233_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000234_ReadAttribute +- (void)testSendClusterTestCluster_000242_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Max Value"]; @@ -26078,7 +26266,7 @@ - (void)testSendClusterTestCluster_000234_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000235_WriteAttribute +- (void)testSendClusterTestCluster_000243_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Invalid Value"]; @@ -26100,7 +26288,7 @@ - (void)testSendClusterTestCluster_000235_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000236_ReadAttribute +- (void)testSendClusterTestCluster_000244_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U unchanged Value"]; @@ -26125,7 +26313,7 @@ - (void)testSendClusterTestCluster_000236_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000237_WriteAttribute +- (void)testSendClusterTestCluster_000245_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U null Value"]; @@ -26147,7 +26335,7 @@ - (void)testSendClusterTestCluster_000237_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000238_ReadAttribute +- (void)testSendClusterTestCluster_000246_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value"]; @@ -26171,7 +26359,7 @@ - (void)testSendClusterTestCluster_000238_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000239_ReadAttribute +- (void)testSendClusterTestCluster_000247_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value & range"]; @@ -26197,7 +26385,7 @@ - (void)testSendClusterTestCluster_000239_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000240_ReadAttribute +- (void)testSendClusterTestCluster_000248_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value & not"]; @@ -26223,7 +26411,7 @@ - (void)testSendClusterTestCluster_000240_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000241_WriteAttribute +- (void)testSendClusterTestCluster_000249_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Value"]; @@ -26245,7 +26433,7 @@ - (void)testSendClusterTestCluster_000241_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000242_ReadAttribute +- (void)testSendClusterTestCluster_000250_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Value in range"]; @@ -26271,7 +26459,7 @@ - (void)testSendClusterTestCluster_000242_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000243_ReadAttribute +- (void)testSendClusterTestCluster_000251_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U notValue OK"]; @@ -26297,7 +26485,7 @@ - (void)testSendClusterTestCluster_000243_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000244_WriteAttribute +- (void)testSendClusterTestCluster_000252_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Min Value"]; @@ -26319,7 +26507,7 @@ - (void)testSendClusterTestCluster_000244_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000245_ReadAttribute +- (void)testSendClusterTestCluster_000253_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Min Value"]; @@ -26344,7 +26532,7 @@ - (void)testSendClusterTestCluster_000245_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000246_WriteAttribute +- (void)testSendClusterTestCluster_000254_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Invalid Value"]; @@ -26365,7 +26553,7 @@ - (void)testSendClusterTestCluster_000246_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000247_ReadAttribute +- (void)testSendClusterTestCluster_000255_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S unchanged Value"]; @@ -26390,7 +26578,7 @@ - (void)testSendClusterTestCluster_000247_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000248_WriteAttribute +- (void)testSendClusterTestCluster_000256_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S null Value"]; @@ -26412,7 +26600,7 @@ - (void)testSendClusterTestCluster_000248_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000249_ReadAttribute +- (void)testSendClusterTestCluster_000257_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value"]; @@ -26436,7 +26624,7 @@ - (void)testSendClusterTestCluster_000249_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000250_ReadAttribute +- (void)testSendClusterTestCluster_000258_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value & range"]; @@ -26468,7 +26656,7 @@ - (void)testSendClusterTestCluster_000250_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000251_ReadAttribute +- (void)testSendClusterTestCluster_000259_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value & not"]; @@ -26494,7 +26682,7 @@ - (void)testSendClusterTestCluster_000251_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000252_WriteAttribute +- (void)testSendClusterTestCluster_000260_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Value"]; @@ -26516,7 +26704,7 @@ - (void)testSendClusterTestCluster_000252_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000253_ReadAttribute +- (void)testSendClusterTestCluster_000261_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Value in range"]; @@ -26548,7 +26736,7 @@ - (void)testSendClusterTestCluster_000253_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000254_ReadAttribute +- (void)testSendClusterTestCluster_000262_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S notValue OK"]; @@ -26574,7 +26762,7 @@ - (void)testSendClusterTestCluster_000254_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000255_WriteAttribute +- (void)testSendClusterTestCluster_000263_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Min Value"]; @@ -26596,7 +26784,7 @@ - (void)testSendClusterTestCluster_000255_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000256_ReadAttribute +- (void)testSendClusterTestCluster_000264_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Min Value"]; @@ -26621,7 +26809,7 @@ - (void)testSendClusterTestCluster_000256_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000257_WriteAttribute +- (void)testSendClusterTestCluster_000265_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Invalid Value"]; @@ -26643,7 +26831,7 @@ - (void)testSendClusterTestCluster_000257_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000258_ReadAttribute +- (void)testSendClusterTestCluster_000266_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S unchanged Value"]; @@ -26668,7 +26856,7 @@ - (void)testSendClusterTestCluster_000258_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000259_WriteAttribute +- (void)testSendClusterTestCluster_000267_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S null Value"]; @@ -26690,7 +26878,7 @@ - (void)testSendClusterTestCluster_000259_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000260_ReadAttribute +- (void)testSendClusterTestCluster_000268_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value"]; @@ -26714,7 +26902,7 @@ - (void)testSendClusterTestCluster_000260_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000261_ReadAttribute +- (void)testSendClusterTestCluster_000269_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value & range"]; @@ -26746,7 +26934,7 @@ - (void)testSendClusterTestCluster_000261_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000262_ReadAttribute +- (void)testSendClusterTestCluster_000270_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value & not"]; @@ -26772,7 +26960,7 @@ - (void)testSendClusterTestCluster_000262_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000263_WriteAttribute +- (void)testSendClusterTestCluster_000271_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Value"]; @@ -26794,7 +26982,7 @@ - (void)testSendClusterTestCluster_000263_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000264_ReadAttribute +- (void)testSendClusterTestCluster_000272_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Value in range"]; @@ -26826,7 +27014,7 @@ - (void)testSendClusterTestCluster_000264_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000265_ReadAttribute +- (void)testSendClusterTestCluster_000273_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S notValue OK"]; @@ -26852,7 +27040,7 @@ - (void)testSendClusterTestCluster_000265_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000266_WriteAttribute +- (void)testSendClusterTestCluster_000274_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Min Value"]; @@ -26874,7 +27062,7 @@ - (void)testSendClusterTestCluster_000266_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000267_ReadAttribute +- (void)testSendClusterTestCluster_000275_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Min Value"]; @@ -26899,7 +27087,7 @@ - (void)testSendClusterTestCluster_000267_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000268_WriteAttribute +- (void)testSendClusterTestCluster_000276_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Invalid Value"]; @@ -26921,7 +27109,7 @@ - (void)testSendClusterTestCluster_000268_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000269_ReadAttribute +- (void)testSendClusterTestCluster_000277_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S unchanged Value"]; @@ -26946,7 +27134,7 @@ - (void)testSendClusterTestCluster_000269_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000270_WriteAttribute +- (void)testSendClusterTestCluster_000278_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S null Value"]; @@ -26968,7 +27156,7 @@ - (void)testSendClusterTestCluster_000270_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000271_ReadAttribute +- (void)testSendClusterTestCluster_000279_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value"]; @@ -26992,7 +27180,7 @@ - (void)testSendClusterTestCluster_000271_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000272_ReadAttribute +- (void)testSendClusterTestCluster_000280_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value & range"]; @@ -27024,7 +27212,7 @@ - (void)testSendClusterTestCluster_000272_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000273_ReadAttribute +- (void)testSendClusterTestCluster_000281_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value & not"]; @@ -27050,7 +27238,7 @@ - (void)testSendClusterTestCluster_000273_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000274_WriteAttribute +- (void)testSendClusterTestCluster_000282_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Value"]; @@ -27072,7 +27260,7 @@ - (void)testSendClusterTestCluster_000274_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000275_ReadAttribute +- (void)testSendClusterTestCluster_000283_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Value in range"]; @@ -27104,7 +27292,7 @@ - (void)testSendClusterTestCluster_000275_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000276_ReadAttribute +- (void)testSendClusterTestCluster_000284_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S notValue OK"]; @@ -27130,7 +27318,7 @@ - (void)testSendClusterTestCluster_000276_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000277_WriteAttribute +- (void)testSendClusterTestCluster_000285_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Min Value"]; @@ -27152,7 +27340,7 @@ - (void)testSendClusterTestCluster_000277_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000278_ReadAttribute +- (void)testSendClusterTestCluster_000286_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Min Value"]; @@ -27177,7 +27365,7 @@ - (void)testSendClusterTestCluster_000278_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000279_WriteAttribute +- (void)testSendClusterTestCluster_000287_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Invalid Value"]; @@ -27199,7 +27387,7 @@ - (void)testSendClusterTestCluster_000279_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000280_ReadAttribute +- (void)testSendClusterTestCluster_000288_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S unchanged Value"]; @@ -27224,7 +27412,7 @@ - (void)testSendClusterTestCluster_000280_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000281_WriteAttribute +- (void)testSendClusterTestCluster_000289_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S null Value"]; @@ -27246,7 +27434,7 @@ - (void)testSendClusterTestCluster_000281_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000282_ReadAttribute +- (void)testSendClusterTestCluster_000290_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value"]; @@ -27270,7 +27458,7 @@ - (void)testSendClusterTestCluster_000282_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000283_ReadAttribute +- (void)testSendClusterTestCluster_000291_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value & range"]; @@ -27302,7 +27490,7 @@ - (void)testSendClusterTestCluster_000283_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000284_ReadAttribute +- (void)testSendClusterTestCluster_000292_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value & not"]; @@ -27328,7 +27516,7 @@ - (void)testSendClusterTestCluster_000284_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000285_WriteAttribute +- (void)testSendClusterTestCluster_000293_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Value"]; @@ -27350,7 +27538,7 @@ - (void)testSendClusterTestCluster_000285_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000286_ReadAttribute +- (void)testSendClusterTestCluster_000294_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Value in range"]; @@ -27382,7 +27570,7 @@ - (void)testSendClusterTestCluster_000286_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000287_ReadAttribute +- (void)testSendClusterTestCluster_000295_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S notValue OK"]; @@ -27408,7 +27596,7 @@ - (void)testSendClusterTestCluster_000287_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000288_WriteAttribute +- (void)testSendClusterTestCluster_000296_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE medium Value"]; @@ -27430,7 +27618,7 @@ - (void)testSendClusterTestCluster_000288_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000289_ReadAttribute +- (void)testSendClusterTestCluster_000297_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE medium Value"]; @@ -27455,7 +27643,7 @@ - (void)testSendClusterTestCluster_000289_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000290_WriteAttribute +- (void)testSendClusterTestCluster_000298_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE largest Value"]; @@ -27477,7 +27665,7 @@ - (void)testSendClusterTestCluster_000290_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000291_ReadAttribute +- (void)testSendClusterTestCluster_000299_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE largest Value"]; @@ -27502,7 +27690,7 @@ - (void)testSendClusterTestCluster_000291_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000292_WriteAttribute +- (void)testSendClusterTestCluster_000300_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE smallest Value"]; @@ -27524,7 +27712,7 @@ - (void)testSendClusterTestCluster_000292_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000293_ReadAttribute +- (void)testSendClusterTestCluster_000301_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE smallest Value"]; @@ -27549,7 +27737,7 @@ - (void)testSendClusterTestCluster_000293_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000294_WriteAttribute +- (void)testSendClusterTestCluster_000302_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE null Value"]; @@ -27571,7 +27759,7 @@ - (void)testSendClusterTestCluster_000294_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000295_ReadAttribute +- (void)testSendClusterTestCluster_000303_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE null Value"]; @@ -27595,7 +27783,7 @@ - (void)testSendClusterTestCluster_000295_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000296_WriteAttribute +- (void)testSendClusterTestCluster_000304_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE 0 Value"]; @@ -27617,7 +27805,7 @@ - (void)testSendClusterTestCluster_000296_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000297_ReadAttribute +- (void)testSendClusterTestCluster_000305_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE 0 Value"]; @@ -27642,7 +27830,7 @@ - (void)testSendClusterTestCluster_000297_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000298_WriteAttribute +- (void)testSendClusterTestCluster_000306_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE medium Value"]; @@ -27664,7 +27852,7 @@ - (void)testSendClusterTestCluster_000298_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000299_ReadAttribute +- (void)testSendClusterTestCluster_000307_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE medium Value"]; @@ -27689,7 +27877,7 @@ - (void)testSendClusterTestCluster_000299_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000300_WriteAttribute +- (void)testSendClusterTestCluster_000308_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE largest Value"]; @@ -27711,7 +27899,7 @@ - (void)testSendClusterTestCluster_000300_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000301_ReadAttribute +- (void)testSendClusterTestCluster_000309_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE largest Value"]; @@ -27736,7 +27924,7 @@ - (void)testSendClusterTestCluster_000301_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000302_WriteAttribute +- (void)testSendClusterTestCluster_000310_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE smallest Value"]; @@ -27758,7 +27946,7 @@ - (void)testSendClusterTestCluster_000302_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000303_ReadAttribute +- (void)testSendClusterTestCluster_000311_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE smallest Value"]; @@ -27783,7 +27971,7 @@ - (void)testSendClusterTestCluster_000303_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000304_WriteAttribute +- (void)testSendClusterTestCluster_000312_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE null Value"]; @@ -27805,7 +27993,7 @@ - (void)testSendClusterTestCluster_000304_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000305_ReadAttribute +- (void)testSendClusterTestCluster_000313_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE null Value"]; @@ -27829,7 +28017,7 @@ - (void)testSendClusterTestCluster_000305_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000306_WriteAttribute +- (void)testSendClusterTestCluster_000314_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE 0 Value"]; @@ -27851,7 +28039,7 @@ - (void)testSendClusterTestCluster_000306_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000307_ReadAttribute +- (void)testSendClusterTestCluster_000315_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE 0 Value"]; @@ -27876,7 +28064,54 @@ - (void)testSendClusterTestCluster_000307_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000308_WriteAttribute +- (void)testSendClusterTestCluster_000316_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Min 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 nullableEnum8Argument; + nullableEnum8Argument = [NSNumber numberWithUnsignedChar:0]; + [cluster writeAttributeNullableEnum8WithValue:nullableEnum8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_ENUM8 Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000317_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Min Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM8 Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 0); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000318_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Max Value"]; @@ -27893,29 +28128,262 @@ - (void)testSendClusterTestCluster_000308_WriteAttribute XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000319_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Max Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM8 Max Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 254); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000320_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Invalid 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 nullableEnum8Argument; + nullableEnum8Argument = [NSNumber numberWithUnsignedChar:255]; + [cluster writeAttributeNullableEnum8WithValue:nullableEnum8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_ENUM8 Invalid Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000321_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 unchanged Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM8 unchanged Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 254); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000322_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 null 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 nullableEnum8Argument; + nullableEnum8Argument = nil; + [cluster writeAttributeNullableEnum8WithValue:nullableEnum8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_ENUM8 null Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000323_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 null Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM8 null Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertTrue(actualValue == nil); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000324_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Min 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 nullableEnum16Argument; + nullableEnum16Argument = [NSNumber numberWithUnsignedShort:0U]; + [cluster writeAttributeNullableEnum16WithValue:nullableEnum16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_ENUM16 Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000325_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Min Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM16 Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedShortValue], 0U); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000326_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Max 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 nullableEnum16Argument; + nullableEnum16Argument = [NSNumber numberWithUnsignedShort:65534U]; + [cluster writeAttributeNullableEnum16WithValue:nullableEnum16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_ENUM16 Max Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000327_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Max Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM16 Max Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedShortValue], 65534U); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000328_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Invalid 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 nullableEnum16Argument; + nullableEnum16Argument = [NSNumber numberWithUnsignedShort:65535U]; + [cluster + writeAttributeNullableEnum16WithValue:nullableEnum16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_ENUM16 Invalid Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000309_ReadAttribute +- (void)testSendClusterTestCluster_000329_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_ENUM8 Max Value Error: %@", err); + [cluster readAttributeNullableEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM16 unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedCharValue], 254); + XCTAssertEqual([actualValue unsignedShortValue], 65534U); } [expectation fulfill]; @@ -27923,45 +28391,45 @@ - (void)testSendClusterTestCluster_000309_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000310_WriteAttribute +- (void)testSendClusterTestCluster_000330_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 null 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 nullableEnum8Argument; - nullableEnum8Argument = [NSNumber numberWithUnsignedChar:255]; - [cluster writeAttributeNullableEnum8WithValue:nullableEnum8Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_ENUM8 Invalid Value Error: %@", err); + id nullableEnum16Argument; + nullableEnum16Argument = nil; + [cluster writeAttributeNullableEnum16WithValue:nullableEnum16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_ENUM16 null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000311_ReadAttribute +- (void)testSendClusterTestCluster_000331_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_ENUM8 unchanged Value Error: %@", err); + [cluster readAttributeNullableEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_ENUM16 null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedCharValue], 254); + XCTAssertTrue(actualValue == nil); } [expectation fulfill]; @@ -27969,45 +28437,46 @@ - (void)testSendClusterTestCluster_000311_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000312_WriteAttribute +- (void)testSendClusterTestCluster_000332_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM Min 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 nullableEnum8Argument; - nullableEnum8Argument = nil; - [cluster writeAttributeNullableEnum8WithValue:nullableEnum8Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_ENUM8 null Value Error: %@", err); + id nullableEnumAttrArgument; + nullableEnumAttrArgument = [NSNumber numberWithUnsignedChar:0]; + [cluster writeAttributeNullableEnumAttrWithValue:nullableEnumAttrArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SIMPLE_ENUM Min Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000313_ReadAttribute +- (void)testSendClusterTestCluster_000333_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_ENUM8 null Value Error: %@", err); + [cluster readAttributeNullableEnumAttrWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SIMPLE_ENUM Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue(actualValue == nil); + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 0); } [expectation fulfill]; @@ -28015,46 +28484,46 @@ - (void)testSendClusterTestCluster_000313_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000314_WriteAttribute +- (void)testSendClusterTestCluster_000334_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM Max 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 nullableEnum16Argument; - nullableEnum16Argument = [NSNumber numberWithUnsignedShort:65534U]; - [cluster writeAttributeNullableEnum16WithValue:nullableEnum16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_ENUM16 Max Value Error: %@", err); + id nullableEnumAttrArgument; + nullableEnumAttrArgument = [NSNumber numberWithUnsignedChar:254]; + [cluster writeAttributeNullableEnumAttrWithValue:nullableEnumAttrArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SIMPLE_ENUM Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000315_ReadAttribute +- (void)testSendClusterTestCluster_000335_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_ENUM16 Max Value Error: %@", err); + [cluster readAttributeNullableEnumAttrWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SIMPLE_ENUM Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedShortValue], 65534U); + XCTAssertEqual([actualValue unsignedCharValue], 254); } [expectation fulfill]; @@ -28062,46 +28531,46 @@ - (void)testSendClusterTestCluster_000315_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000316_WriteAttribute +- (void)testSendClusterTestCluster_000336_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM Invalid 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 nullableEnum16Argument; - nullableEnum16Argument = [NSNumber numberWithUnsignedShort:65535U]; + id nullableEnumAttrArgument; + nullableEnumAttrArgument = [NSNumber numberWithUnsignedChar:255]; [cluster - writeAttributeNullableEnum16WithValue:nullableEnum16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_ENUM16 Invalid Value Error: %@", err); + writeAttributeNullableEnumAttrWithValue:nullableEnumAttrArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SIMPLE_ENUM Invalid Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000317_ReadAttribute +- (void)testSendClusterTestCluster_000337_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_ENUM16 unchanged Value Error: %@", err); + [cluster readAttributeNullableEnumAttrWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SIMPLE_ENUM unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedShortValue], 65534U); + XCTAssertEqual([actualValue unsignedCharValue], 254); } [expectation fulfill]; @@ -28109,39 +28578,39 @@ - (void)testSendClusterTestCluster_000317_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000318_WriteAttribute +- (void)testSendClusterTestCluster_000338_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM null 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 nullableEnum16Argument; - nullableEnum16Argument = nil; - [cluster writeAttributeNullableEnum16WithValue:nullableEnum16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_ENUM16 null Value Error: %@", err); + id nullableEnumAttrArgument; + nullableEnumAttrArgument = nil; + [cluster writeAttributeNullableEnumAttrWithValue:nullableEnumAttrArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SIMPLE_ENUM null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000319_ReadAttribute +- (void)testSendClusterTestCluster_000339_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_ENUM16 null Value Error: %@", err); + [cluster readAttributeNullableEnumAttrWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SIMPLE_ENUM null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -28155,7 +28624,7 @@ - (void)testSendClusterTestCluster_000319_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000320_ReadAttribute +- (void)testSendClusterTestCluster_000340_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING Default Value"]; @@ -28180,7 +28649,7 @@ - (void)testSendClusterTestCluster_000320_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000321_WriteAttribute +- (void)testSendClusterTestCluster_000341_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -28202,7 +28671,7 @@ - (void)testSendClusterTestCluster_000321_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000322_ReadAttribute +- (void)testSendClusterTestCluster_000342_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -28227,7 +28696,7 @@ - (void)testSendClusterTestCluster_000322_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000323_WriteAttribute +- (void)testSendClusterTestCluster_000343_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -28249,7 +28718,7 @@ - (void)testSendClusterTestCluster_000323_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000324_ReadAttribute +- (void)testSendClusterTestCluster_000344_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -28273,7 +28742,7 @@ - (void)testSendClusterTestCluster_000324_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000325_WriteAttribute +- (void)testSendClusterTestCluster_000345_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -28295,7 +28764,7 @@ - (void)testSendClusterTestCluster_000325_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000326_ReadAttribute +- (void)testSendClusterTestCluster_000346_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -28320,7 +28789,7 @@ - (void)testSendClusterTestCluster_000326_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000327_ReadAttribute +- (void)testSendClusterTestCluster_000347_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING Default Value"]; @@ -28345,7 +28814,7 @@ - (void)testSendClusterTestCluster_000327_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000328_WriteAttribute +- (void)testSendClusterTestCluster_000348_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING"]; @@ -28367,7 +28836,7 @@ - (void)testSendClusterTestCluster_000328_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000329_ReadAttribute +- (void)testSendClusterTestCluster_000349_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -28392,7 +28861,7 @@ - (void)testSendClusterTestCluster_000329_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000330_WriteAttribute +- (void)testSendClusterTestCluster_000350_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Value too long"]; @@ -28414,7 +28883,7 @@ - (void)testSendClusterTestCluster_000330_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000331_ReadAttribute +- (void)testSendClusterTestCluster_000351_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -28438,7 +28907,7 @@ - (void)testSendClusterTestCluster_000331_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000332_WriteAttribute +- (void)testSendClusterTestCluster_000352_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Empty"]; @@ -28460,7 +28929,7 @@ - (void)testSendClusterTestCluster_000332_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000333_ReadAttribute +- (void)testSendClusterTestCluster_000353_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -28485,7 +28954,7 @@ - (void)testSendClusterTestCluster_000333_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000334_ReadAttribute +- (void)testSendClusterTestCluster_000354_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent endpoint."]; @@ -28503,7 +28972,7 @@ - (void)testSendClusterTestCluster_000334_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000335_ReadAttribute +- (void)testSendClusterTestCluster_000355_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent cluster."]; @@ -28521,7 +28990,7 @@ - (void)testSendClusterTestCluster_000335_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000336_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000356_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -28543,7 +29012,7 @@ - (void)testSendClusterTestCluster_000336_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000337_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000357_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -28567,9 +29036,9 @@ - (void)testSendClusterTestCluster_000337_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -bool testSendClusterTestCluster_000338_WaitForReport_Fulfilled = false; +bool testSendClusterTestCluster_000358_WaitForReport_Fulfilled = false; ResponseHandler test_TestCluster_list_int8u_Reported = nil; -- (void)testSendClusterTestCluster_000338_WaitForReport +- (void)testSendClusterTestCluster_000358_WaitForReport { CHIPDevice * device = GetConnectedDevice(); @@ -28591,10 +29060,10 @@ - (void)testSendClusterTestCluster_000338_WaitForReport XCTAssertEqual([actualValue[3] unsignedCharValue], 4); } - testSendClusterTestCluster_000338_WaitForReport_Fulfilled = true; + testSendClusterTestCluster_000358_WaitForReport_Fulfilled = true; }; } -- (void)testSendClusterTestCluster_000339_SubscribeAttribute +- (void)testSendClusterTestCluster_000359_SubscribeAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Subscribe to list attribute"]; @@ -28608,7 +29077,7 @@ - (void)testSendClusterTestCluster_000339_SubscribeAttribute [cluster subscribeAttributeListInt8uWithMinInterval:minIntervalArgument maxInterval:maxIntervalArgument subscriptionEstablished:^{ - XCTAssertEqual(testSendClusterTestCluster_000338_WaitForReport_Fulfilled, true); + XCTAssertEqual(testSendClusterTestCluster_000358_WaitForReport_Fulfilled, true); [expectation fulfill]; } reportHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { @@ -28624,7 +29093,7 @@ - (void)testSendClusterTestCluster_000339_SubscribeAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000340_WriteAttribute +- (void)testSendClusterTestCluster_000360_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write subscribed-to list attribute"]; @@ -28653,7 +29122,7 @@ - (void)testSendClusterTestCluster_000340_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000341_WaitForReport +- (void)testSendClusterTestCluster_000361_WaitForReport { XCTestExpectation * expectation = [self expectationWithDescription:@"Check for list attribute report"]; @@ -28681,7 +29150,7 @@ - (void)testSendClusterTestCluster_000341_WaitForReport [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000342_ReadAttribute +- (void)testSendClusterTestCluster_000362_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 8-bit integer"]; @@ -28705,7 +29174,7 @@ - (void)testSendClusterTestCluster_000342_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000343_WriteAttribute +- (void)testSendClusterTestCluster_000363_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 8-bit integer"]; @@ -28728,7 +29197,7 @@ - (void)testSendClusterTestCluster_000343_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000344_WriteAttribute +- (void)testSendClusterTestCluster_000364_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 8-bit integer"]; @@ -28753,7 +29222,7 @@ - (void)testSendClusterTestCluster_000344_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000345_WriteAttribute +- (void)testSendClusterTestCluster_000365_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 8-bit integer"]; @@ -28778,7 +29247,7 @@ - (void)testSendClusterTestCluster_000345_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000346_WriteAttribute +- (void)testSendClusterTestCluster_000366_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 8-bit integer"]; @@ -28801,7 +29270,7 @@ - (void)testSendClusterTestCluster_000346_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000347_ReadAttribute +- (void)testSendClusterTestCluster_000367_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value has not changed"]; @@ -28826,7 +29295,7 @@ - (void)testSendClusterTestCluster_000347_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000348_WriteAttribute +- (void)testSendClusterTestCluster_000368_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 8-bit integer"]; @@ -28850,7 +29319,7 @@ - (void)testSendClusterTestCluster_000348_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000349_ReadAttribute +- (void)testSendClusterTestCluster_000369_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at min valid"]; @@ -28875,7 +29344,7 @@ - (void)testSendClusterTestCluster_000349_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000350_WriteAttribute +- (void)testSendClusterTestCluster_000370_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 8-bit integer"]; @@ -28899,7 +29368,7 @@ - (void)testSendClusterTestCluster_000350_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000351_ReadAttribute +- (void)testSendClusterTestCluster_000371_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at max valid"]; @@ -28924,7 +29393,7 @@ - (void)testSendClusterTestCluster_000351_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000352_WriteAttribute +- (void)testSendClusterTestCluster_000372_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 8-bit integer"]; @@ -28948,7 +29417,7 @@ - (void)testSendClusterTestCluster_000352_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000353_ReadAttribute +- (void)testSendClusterTestCluster_000373_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -28973,7 +29442,7 @@ - (void)testSendClusterTestCluster_000353_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000354_ReadAttribute +- (void)testSendClusterTestCluster_000374_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 16-bit integer"]; @@ -28997,7 +29466,7 @@ - (void)testSendClusterTestCluster_000354_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000355_WriteAttribute +- (void)testSendClusterTestCluster_000375_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 16-bit integer"]; @@ -29020,7 +29489,7 @@ - (void)testSendClusterTestCluster_000355_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000356_WriteAttribute +- (void)testSendClusterTestCluster_000376_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 16-bit integer"]; @@ -29046,7 +29515,7 @@ - (void)testSendClusterTestCluster_000356_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000357_WriteAttribute +- (void)testSendClusterTestCluster_000377_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 16-bit integer"]; @@ -29072,7 +29541,7 @@ - (void)testSendClusterTestCluster_000357_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000358_WriteAttribute +- (void)testSendClusterTestCluster_000378_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 16-bit integer"]; @@ -29095,7 +29564,7 @@ - (void)testSendClusterTestCluster_000358_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000359_ReadAttribute +- (void)testSendClusterTestCluster_000379_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value has not changed"]; @@ -29120,7 +29589,7 @@ - (void)testSendClusterTestCluster_000359_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000360_WriteAttribute +- (void)testSendClusterTestCluster_000380_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 16-bit integer"]; @@ -29144,7 +29613,7 @@ - (void)testSendClusterTestCluster_000360_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000361_ReadAttribute +- (void)testSendClusterTestCluster_000381_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at min valid"]; @@ -29169,7 +29638,7 @@ - (void)testSendClusterTestCluster_000361_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000362_WriteAttribute +- (void)testSendClusterTestCluster_000382_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 16-bit integer"]; @@ -29193,7 +29662,7 @@ - (void)testSendClusterTestCluster_000362_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000363_ReadAttribute +- (void)testSendClusterTestCluster_000383_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at max valid"]; @@ -29218,7 +29687,7 @@ - (void)testSendClusterTestCluster_000363_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000364_WriteAttribute +- (void)testSendClusterTestCluster_000384_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 16-bit integer"]; @@ -29243,7 +29712,7 @@ - (void)testSendClusterTestCluster_000364_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000365_ReadAttribute +- (void)testSendClusterTestCluster_000385_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -29268,7 +29737,7 @@ - (void)testSendClusterTestCluster_000365_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000366_ReadAttribute +- (void)testSendClusterTestCluster_000386_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 8-bit integer"]; @@ -29292,7 +29761,7 @@ - (void)testSendClusterTestCluster_000366_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000367_WriteAttribute +- (void)testSendClusterTestCluster_000387_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 8-bit integer"]; @@ -29315,7 +29784,7 @@ - (void)testSendClusterTestCluster_000367_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000368_WriteAttribute +- (void)testSendClusterTestCluster_000388_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 8-bit integer"]; @@ -29340,7 +29809,7 @@ - (void)testSendClusterTestCluster_000368_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000369_WriteAttribute +- (void)testSendClusterTestCluster_000389_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 8-bit integer"]; @@ -29365,7 +29834,7 @@ - (void)testSendClusterTestCluster_000369_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000370_WriteAttribute +- (void)testSendClusterTestCluster_000390_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 8-bit integer"]; @@ -29388,7 +29857,7 @@ - (void)testSendClusterTestCluster_000370_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000371_ReadAttribute +- (void)testSendClusterTestCluster_000391_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value has not changed"]; @@ -29413,7 +29882,7 @@ - (void)testSendClusterTestCluster_000371_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000372_WriteAttribute +- (void)testSendClusterTestCluster_000392_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 8-bit integer"]; @@ -29437,7 +29906,7 @@ - (void)testSendClusterTestCluster_000372_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000373_ReadAttribute +- (void)testSendClusterTestCluster_000393_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at min valid"]; @@ -29462,7 +29931,7 @@ - (void)testSendClusterTestCluster_000373_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000374_WriteAttribute +- (void)testSendClusterTestCluster_000394_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 8-bit integer"]; @@ -29486,7 +29955,7 @@ - (void)testSendClusterTestCluster_000374_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000375_ReadAttribute +- (void)testSendClusterTestCluster_000395_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at max valid"]; @@ -29511,7 +29980,7 @@ - (void)testSendClusterTestCluster_000375_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000376_WriteAttribute +- (void)testSendClusterTestCluster_000396_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 8-bit integer"]; @@ -29535,7 +30004,7 @@ - (void)testSendClusterTestCluster_000376_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000377_ReadAttribute +- (void)testSendClusterTestCluster_000397_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at mid valid"]; @@ -29560,7 +30029,7 @@ - (void)testSendClusterTestCluster_000377_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000378_ReadAttribute +- (void)testSendClusterTestCluster_000398_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 16-bit integer"]; @@ -29584,7 +30053,7 @@ - (void)testSendClusterTestCluster_000378_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000379_WriteAttribute +- (void)testSendClusterTestCluster_000399_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 16-bit integer"]; @@ -29607,7 +30076,7 @@ - (void)testSendClusterTestCluster_000379_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000380_WriteAttribute +- (void)testSendClusterTestCluster_000400_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 16-bit integer"]; @@ -29632,7 +30101,7 @@ - (void)testSendClusterTestCluster_000380_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000381_WriteAttribute +- (void)testSendClusterTestCluster_000401_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 16-bit integer"]; @@ -29657,7 +30126,7 @@ - (void)testSendClusterTestCluster_000381_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000382_WriteAttribute +- (void)testSendClusterTestCluster_000402_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 16-bit integer"]; @@ -29680,7 +30149,7 @@ - (void)testSendClusterTestCluster_000382_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000383_ReadAttribute +- (void)testSendClusterTestCluster_000403_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value has not changed"]; @@ -29705,7 +30174,7 @@ - (void)testSendClusterTestCluster_000383_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000384_WriteAttribute +- (void)testSendClusterTestCluster_000404_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 16-bit integer"]; @@ -29729,7 +30198,7 @@ - (void)testSendClusterTestCluster_000384_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000385_ReadAttribute +- (void)testSendClusterTestCluster_000405_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at min valid"]; @@ -29754,7 +30223,7 @@ - (void)testSendClusterTestCluster_000385_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000386_WriteAttribute +- (void)testSendClusterTestCluster_000406_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 16-bit integer"]; @@ -29778,7 +30247,7 @@ - (void)testSendClusterTestCluster_000386_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000387_ReadAttribute +- (void)testSendClusterTestCluster_000407_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at max valid"]; @@ -29803,7 +30272,7 @@ - (void)testSendClusterTestCluster_000387_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000388_WriteAttribute +- (void)testSendClusterTestCluster_000408_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 16-bit integer"]; @@ -29827,7 +30296,7 @@ - (void)testSendClusterTestCluster_000388_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000389_ReadAttribute +- (void)testSendClusterTestCluster_000409_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at mid valid"]; @@ -29852,7 +30321,7 @@ - (void)testSendClusterTestCluster_000389_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000390_ReadAttribute +- (void)testSendClusterTestCluster_000410_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 8-bit integer"]; @@ -29877,7 +30346,7 @@ - (void)testSendClusterTestCluster_000390_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000391_WriteAttribute +- (void)testSendClusterTestCluster_000411_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29902,7 +30371,7 @@ - (void)testSendClusterTestCluster_000391_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000392_WriteAttribute +- (void)testSendClusterTestCluster_000412_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29927,7 +30396,7 @@ - (void)testSendClusterTestCluster_000392_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000393_WriteAttribute +- (void)testSendClusterTestCluster_000413_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29952,7 +30421,7 @@ - (void)testSendClusterTestCluster_000393_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000394_WriteAttribute +- (void)testSendClusterTestCluster_000414_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 8-bit integer"]; @@ -29977,7 +30446,7 @@ - (void)testSendClusterTestCluster_000394_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000395_ReadAttribute +- (void)testSendClusterTestCluster_000415_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value has not changed"]; @@ -30003,7 +30472,7 @@ - (void)testSendClusterTestCluster_000395_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000396_WriteAttribute +- (void)testSendClusterTestCluster_000416_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -30028,7 +30497,7 @@ - (void)testSendClusterTestCluster_000396_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000397_ReadAttribute +- (void)testSendClusterTestCluster_000417_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at min valid"]; @@ -30054,7 +30523,7 @@ - (void)testSendClusterTestCluster_000397_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000398_WriteAttribute +- (void)testSendClusterTestCluster_000418_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -30079,7 +30548,7 @@ - (void)testSendClusterTestCluster_000398_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000399_ReadAttribute +- (void)testSendClusterTestCluster_000419_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at max valid"]; @@ -30105,7 +30574,7 @@ - (void)testSendClusterTestCluster_000399_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000400_WriteAttribute +- (void)testSendClusterTestCluster_000420_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -30130,7 +30599,7 @@ - (void)testSendClusterTestCluster_000400_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000401_ReadAttribute +- (void)testSendClusterTestCluster_000421_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -30156,7 +30625,7 @@ - (void)testSendClusterTestCluster_000401_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000402_WriteAttribute +- (void)testSendClusterTestCluster_000422_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 8-bit integer"]; @@ -30181,7 +30650,7 @@ - (void)testSendClusterTestCluster_000402_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000403_ReadAttribute +- (void)testSendClusterTestCluster_000423_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is null"]; @@ -30206,7 +30675,7 @@ - (void)testSendClusterTestCluster_000403_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000404_ReadAttribute +- (void)testSendClusterTestCluster_000424_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 16-bit integer"]; @@ -30232,7 +30701,7 @@ - (void)testSendClusterTestCluster_000404_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000405_WriteAttribute +- (void)testSendClusterTestCluster_000425_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30257,7 +30726,7 @@ - (void)testSendClusterTestCluster_000405_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000406_WriteAttribute +- (void)testSendClusterTestCluster_000426_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30282,7 +30751,7 @@ - (void)testSendClusterTestCluster_000406_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000407_WriteAttribute +- (void)testSendClusterTestCluster_000427_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30307,7 +30776,7 @@ - (void)testSendClusterTestCluster_000407_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000408_WriteAttribute +- (void)testSendClusterTestCluster_000428_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30332,7 +30801,7 @@ - (void)testSendClusterTestCluster_000408_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000409_ReadAttribute +- (void)testSendClusterTestCluster_000429_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value has not changed"]; @@ -30359,7 +30828,7 @@ - (void)testSendClusterTestCluster_000409_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000410_WriteAttribute +- (void)testSendClusterTestCluster_000430_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30384,7 +30853,7 @@ - (void)testSendClusterTestCluster_000410_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000411_ReadAttribute +- (void)testSendClusterTestCluster_000431_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at min valid"]; @@ -30411,7 +30880,7 @@ - (void)testSendClusterTestCluster_000411_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000412_WriteAttribute +- (void)testSendClusterTestCluster_000432_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30436,7 +30905,7 @@ - (void)testSendClusterTestCluster_000412_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000413_ReadAttribute +- (void)testSendClusterTestCluster_000433_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at max valid"]; @@ -30463,7 +30932,7 @@ - (void)testSendClusterTestCluster_000413_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000414_WriteAttribute +- (void)testSendClusterTestCluster_000434_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30488,7 +30957,7 @@ - (void)testSendClusterTestCluster_000414_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000415_ReadAttribute +- (void)testSendClusterTestCluster_000435_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -30515,7 +30984,7 @@ - (void)testSendClusterTestCluster_000415_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000416_WriteAttribute +- (void)testSendClusterTestCluster_000436_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 16-bit integer"]; @@ -30540,7 +31009,7 @@ - (void)testSendClusterTestCluster_000416_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000417_ReadAttribute +- (void)testSendClusterTestCluster_000437_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is null"]; @@ -30566,7 +31035,7 @@ - (void)testSendClusterTestCluster_000417_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000418_ReadAttribute +- (void)testSendClusterTestCluster_000438_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 8-bit integer"]; @@ -30591,7 +31060,7 @@ - (void)testSendClusterTestCluster_000418_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000419_WriteAttribute +- (void)testSendClusterTestCluster_000439_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 8-bit integer"]; @@ -30617,7 +31086,7 @@ - (void)testSendClusterTestCluster_000419_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000420_WriteAttribute +- (void)testSendClusterTestCluster_000440_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 8-bit integer"]; @@ -30642,7 +31111,7 @@ - (void)testSendClusterTestCluster_000420_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000421_WriteAttribute +- (void)testSendClusterTestCluster_000441_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 8-bit integer"]; @@ -30667,7 +31136,7 @@ - (void)testSendClusterTestCluster_000421_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000422_WriteAttribute +- (void)testSendClusterTestCluster_000442_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 8-bit integer"]; @@ -30693,7 +31162,7 @@ - (void)testSendClusterTestCluster_000422_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000423_ReadAttribute +- (void)testSendClusterTestCluster_000443_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value has not changed"]; @@ -30719,7 +31188,7 @@ - (void)testSendClusterTestCluster_000423_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000424_WriteAttribute +- (void)testSendClusterTestCluster_000444_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 8-bit integer"]; @@ -30744,7 +31213,7 @@ - (void)testSendClusterTestCluster_000424_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000425_ReadAttribute +- (void)testSendClusterTestCluster_000445_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at min valid"]; @@ -30770,7 +31239,7 @@ - (void)testSendClusterTestCluster_000425_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000426_WriteAttribute +- (void)testSendClusterTestCluster_000446_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 8-bit integer"]; @@ -30795,7 +31264,7 @@ - (void)testSendClusterTestCluster_000426_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000427_ReadAttribute +- (void)testSendClusterTestCluster_000447_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at max valid"]; @@ -30821,7 +31290,7 @@ - (void)testSendClusterTestCluster_000427_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000428_WriteAttribute +- (void)testSendClusterTestCluster_000448_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 8-bit integer"]; @@ -30846,7 +31315,7 @@ - (void)testSendClusterTestCluster_000428_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000429_ReadAttribute +- (void)testSendClusterTestCluster_000449_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at mid valid"]; @@ -30872,7 +31341,7 @@ - (void)testSendClusterTestCluster_000429_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000430_WriteAttribute +- (void)testSendClusterTestCluster_000450_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 8-bit integer"]; @@ -30898,7 +31367,7 @@ - (void)testSendClusterTestCluster_000430_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000431_ReadAttribute +- (void)testSendClusterTestCluster_000451_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at null"]; @@ -30923,7 +31392,7 @@ - (void)testSendClusterTestCluster_000431_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000432_ReadAttribute +- (void)testSendClusterTestCluster_000452_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 16-bit integer"]; @@ -30949,7 +31418,7 @@ - (void)testSendClusterTestCluster_000432_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000433_WriteAttribute +- (void)testSendClusterTestCluster_000453_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 16-bit integer"]; @@ -30974,7 +31443,7 @@ - (void)testSendClusterTestCluster_000433_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000434_WriteAttribute +- (void)testSendClusterTestCluster_000454_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 16-bit integer"]; @@ -30999,7 +31468,7 @@ - (void)testSendClusterTestCluster_000434_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000435_WriteAttribute +- (void)testSendClusterTestCluster_000455_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 16-bit integer"]; @@ -31024,7 +31493,7 @@ - (void)testSendClusterTestCluster_000435_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000436_WriteAttribute +- (void)testSendClusterTestCluster_000456_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 16-bit integer"]; @@ -31049,7 +31518,7 @@ - (void)testSendClusterTestCluster_000436_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000437_ReadAttribute +- (void)testSendClusterTestCluster_000457_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value has not changed"]; @@ -31076,7 +31545,7 @@ - (void)testSendClusterTestCluster_000437_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000438_WriteAttribute +- (void)testSendClusterTestCluster_000458_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 16-bit integer"]; @@ -31101,7 +31570,7 @@ - (void)testSendClusterTestCluster_000438_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000439_ReadAttribute +- (void)testSendClusterTestCluster_000459_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at min valid"]; @@ -31128,7 +31597,7 @@ - (void)testSendClusterTestCluster_000439_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000440_WriteAttribute +- (void)testSendClusterTestCluster_000460_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 16-bit integer"]; @@ -31153,7 +31622,7 @@ - (void)testSendClusterTestCluster_000440_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000441_ReadAttribute +- (void)testSendClusterTestCluster_000461_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at max valid"]; @@ -31180,7 +31649,7 @@ - (void)testSendClusterTestCluster_000441_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000442_WriteAttribute +- (void)testSendClusterTestCluster_000462_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 16-bit integer"]; @@ -31205,7 +31674,7 @@ - (void)testSendClusterTestCluster_000442_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000443_ReadAttribute +- (void)testSendClusterTestCluster_000463_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at mid valid"]; @@ -31232,7 +31701,7 @@ - (void)testSendClusterTestCluster_000443_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000444_WriteAttribute +- (void)testSendClusterTestCluster_000464_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 16-bit integer"]; @@ -31257,7 +31726,7 @@ - (void)testSendClusterTestCluster_000444_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000445_ReadAttribute +- (void)testSendClusterTestCluster_000465_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is null"]; diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 46ace0f3bb842f..9e21945fc3258b 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -35276,1088 +35276,1168 @@ class TestCluster : public TestCommand err = TestReadAttributeNullableBitmap64NullValue_199(); break; case 200: - ChipLogProgress(chipTool, " ***** Test Step 200 : Write attribute NULLABLE_INT8U Max Value\n"); - err = TestWriteAttributeNullableInt8uMaxValue_200(); + ChipLogProgress(chipTool, " ***** Test Step 200 : Write attribute NULLABLE_INT8U Min Value\n"); + err = TestWriteAttributeNullableInt8uMinValue_200(); break; case 201: - ChipLogProgress(chipTool, " ***** Test Step 201 : Read attribute NULLABLE_INT8U Max Value\n"); - err = TestReadAttributeNullableInt8uMaxValue_201(); + ChipLogProgress(chipTool, " ***** Test Step 201 : Read attribute NULLABLE_INT8U Min Value\n"); + err = TestReadAttributeNullableInt8uMinValue_201(); break; case 202: - ChipLogProgress(chipTool, " ***** Test Step 202 : Write attribute NULLABLE_INT8U Invalid Value\n"); - err = TestWriteAttributeNullableInt8uInvalidValue_202(); + ChipLogProgress(chipTool, " ***** Test Step 202 : Write attribute NULLABLE_INT8U Max Value\n"); + err = TestWriteAttributeNullableInt8uMaxValue_202(); break; case 203: - ChipLogProgress(chipTool, " ***** Test Step 203 : Read attribute NULLABLE_INT8U unchanged Value\n"); - err = TestReadAttributeNullableInt8uUnchangedValue_203(); + ChipLogProgress(chipTool, " ***** Test Step 203 : Read attribute NULLABLE_INT8U Max Value\n"); + err = TestReadAttributeNullableInt8uMaxValue_203(); break; case 204: - ChipLogProgress(chipTool, " ***** Test Step 204 : Write attribute NULLABLE_INT8U null Value\n"); - err = TestWriteAttributeNullableInt8uNullValue_204(); + ChipLogProgress(chipTool, " ***** Test Step 204 : Write attribute NULLABLE_INT8U Invalid Value\n"); + err = TestWriteAttributeNullableInt8uInvalidValue_204(); break; case 205: - ChipLogProgress(chipTool, " ***** Test Step 205 : Read attribute NULLABLE_INT8U null Value\n"); - err = TestReadAttributeNullableInt8uNullValue_205(); + ChipLogProgress(chipTool, " ***** Test Step 205 : Read attribute NULLABLE_INT8U unchanged Value\n"); + err = TestReadAttributeNullableInt8uUnchangedValue_205(); break; case 206: - ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_INT8U null Value & range\n"); - err = TestReadAttributeNullableInt8uNullValueRange_206(); + ChipLogProgress(chipTool, " ***** Test Step 206 : Write attribute NULLABLE_INT8U null Value\n"); + err = TestWriteAttributeNullableInt8uNullValue_206(); break; case 207: - ChipLogProgress(chipTool, " ***** Test Step 207 : Read attribute NULLABLE_INT8U null Value & not\n"); - err = TestReadAttributeNullableInt8uNullValueNot_207(); + ChipLogProgress(chipTool, " ***** Test Step 207 : Read attribute NULLABLE_INT8U null Value\n"); + err = TestReadAttributeNullableInt8uNullValue_207(); break; case 208: - ChipLogProgress(chipTool, " ***** Test Step 208 : Write attribute NULLABLE_INT8U Value\n"); - err = TestWriteAttributeNullableInt8uValue_208(); + ChipLogProgress(chipTool, " ***** Test Step 208 : Read attribute NULLABLE_INT8U null Value & range\n"); + err = TestReadAttributeNullableInt8uNullValueRange_208(); break; case 209: - ChipLogProgress(chipTool, " ***** Test Step 209 : Read attribute NULLABLE_INT8U Value in range\n"); - err = TestReadAttributeNullableInt8uValueInRange_209(); + ChipLogProgress(chipTool, " ***** Test Step 209 : Read attribute NULLABLE_INT8U null Value & not\n"); + err = TestReadAttributeNullableInt8uNullValueNot_209(); break; case 210: - ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_INT8U notValue OK\n"); - err = TestReadAttributeNullableInt8uNotValueOk_210(); + ChipLogProgress(chipTool, " ***** Test Step 210 : Write attribute NULLABLE_INT8U Value\n"); + err = TestWriteAttributeNullableInt8uValue_210(); break; case 211: - ChipLogProgress(chipTool, " ***** Test Step 211 : Write attribute NULLABLE_INT16U Max Value\n"); - err = TestWriteAttributeNullableInt16uMaxValue_211(); + ChipLogProgress(chipTool, " ***** Test Step 211 : Read attribute NULLABLE_INT8U Value in range\n"); + err = TestReadAttributeNullableInt8uValueInRange_211(); break; case 212: - ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT16U Max Value\n"); - err = TestReadAttributeNullableInt16uMaxValue_212(); + ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT8U notValue OK\n"); + err = TestReadAttributeNullableInt8uNotValueOk_212(); break; case 213: - ChipLogProgress(chipTool, " ***** Test Step 213 : Write attribute NULLABLE_INT16U Invalid Value\n"); - err = TestWriteAttributeNullableInt16uInvalidValue_213(); + ChipLogProgress(chipTool, " ***** Test Step 213 : Write attribute NULLABLE_INT16U Min Value\n"); + err = TestWriteAttributeNullableInt16uMinValue_213(); break; case 214: - ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT16U unchanged Value\n"); - err = TestReadAttributeNullableInt16uUnchangedValue_214(); + ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT16U Min Value\n"); + err = TestReadAttributeNullableInt16uMinValue_214(); break; case 215: - ChipLogProgress(chipTool, " ***** Test Step 215 : Write attribute NULLABLE_INT16U null Value\n"); - err = TestWriteAttributeNullableInt16uNullValue_215(); + ChipLogProgress(chipTool, " ***** Test Step 215 : Write attribute NULLABLE_INT16U Max Value\n"); + err = TestWriteAttributeNullableInt16uMaxValue_215(); break; case 216: - ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT16U null Value\n"); - err = TestReadAttributeNullableInt16uNullValue_216(); + ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT16U Max Value\n"); + err = TestReadAttributeNullableInt16uMaxValue_216(); break; case 217: - ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT16U null Value & range\n"); - err = TestReadAttributeNullableInt16uNullValueRange_217(); + ChipLogProgress(chipTool, " ***** Test Step 217 : Write attribute NULLABLE_INT16U Invalid Value\n"); + err = TestWriteAttributeNullableInt16uInvalidValue_217(); break; case 218: - ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT16U null Value & not\n"); - err = TestReadAttributeNullableInt16uNullValueNot_218(); + ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT16U unchanged Value\n"); + err = TestReadAttributeNullableInt16uUnchangedValue_218(); break; case 219: - ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_INT16U Value\n"); - err = TestWriteAttributeNullableInt16uValue_219(); + ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_INT16U null Value\n"); + err = TestWriteAttributeNullableInt16uNullValue_219(); break; case 220: - ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT16U Value in range\n"); - err = TestReadAttributeNullableInt16uValueInRange_220(); + ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT16U null Value\n"); + err = TestReadAttributeNullableInt16uNullValue_220(); break; case 221: - ChipLogProgress(chipTool, " ***** Test Step 221 : Read attribute NULLABLE_INT16U notValue OK\n"); - err = TestReadAttributeNullableInt16uNotValueOk_221(); + ChipLogProgress(chipTool, " ***** Test Step 221 : Read attribute NULLABLE_INT16U null Value & range\n"); + err = TestReadAttributeNullableInt16uNullValueRange_221(); break; case 222: - ChipLogProgress(chipTool, " ***** Test Step 222 : Write attribute NULLABLE_INT32U Max Value\n"); - err = TestWriteAttributeNullableInt32uMaxValue_222(); + ChipLogProgress(chipTool, " ***** Test Step 222 : Read attribute NULLABLE_INT16U null Value & not\n"); + err = TestReadAttributeNullableInt16uNullValueNot_222(); break; case 223: - ChipLogProgress(chipTool, " ***** Test Step 223 : Read attribute NULLABLE_INT32U Max Value\n"); - err = TestReadAttributeNullableInt32uMaxValue_223(); + ChipLogProgress(chipTool, " ***** Test Step 223 : Write attribute NULLABLE_INT16U Value\n"); + err = TestWriteAttributeNullableInt16uValue_223(); break; case 224: - ChipLogProgress(chipTool, " ***** Test Step 224 : Write attribute NULLABLE_INT32U Invalid Value\n"); - err = TestWriteAttributeNullableInt32uInvalidValue_224(); + ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_INT16U Value in range\n"); + err = TestReadAttributeNullableInt16uValueInRange_224(); break; case 225: - ChipLogProgress(chipTool, " ***** Test Step 225 : Read attribute NULLABLE_INT32U unchanged Value\n"); - err = TestReadAttributeNullableInt32uUnchangedValue_225(); + ChipLogProgress(chipTool, " ***** Test Step 225 : Read attribute NULLABLE_INT16U notValue OK\n"); + err = TestReadAttributeNullableInt16uNotValueOk_225(); break; case 226: - ChipLogProgress(chipTool, " ***** Test Step 226 : Write attribute NULLABLE_INT32U null Value\n"); - err = TestWriteAttributeNullableInt32uNullValue_226(); + ChipLogProgress(chipTool, " ***** Test Step 226 : Write attribute NULLABLE_INT32U Min Value\n"); + err = TestWriteAttributeNullableInt32uMinValue_226(); break; case 227: - ChipLogProgress(chipTool, " ***** Test Step 227 : Read attribute NULLABLE_INT32U null Value\n"); - err = TestReadAttributeNullableInt32uNullValue_227(); + ChipLogProgress(chipTool, " ***** Test Step 227 : Read attribute NULLABLE_INT32U Min Value\n"); + err = TestReadAttributeNullableInt32uMinValue_227(); break; case 228: - ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_INT32U null Value & range\n"); - err = TestReadAttributeNullableInt32uNullValueRange_228(); + ChipLogProgress(chipTool, " ***** Test Step 228 : Write attribute NULLABLE_INT32U Max Value\n"); + err = TestWriteAttributeNullableInt32uMaxValue_228(); break; case 229: - ChipLogProgress(chipTool, " ***** Test Step 229 : Read attribute NULLABLE_INT32U null Value & not\n"); - err = TestReadAttributeNullableInt32uNullValueNot_229(); + ChipLogProgress(chipTool, " ***** Test Step 229 : Read attribute NULLABLE_INT32U Max Value\n"); + err = TestReadAttributeNullableInt32uMaxValue_229(); break; case 230: - ChipLogProgress(chipTool, " ***** Test Step 230 : Write attribute NULLABLE_INT32U Value\n"); - err = TestWriteAttributeNullableInt32uValue_230(); + ChipLogProgress(chipTool, " ***** Test Step 230 : Write attribute NULLABLE_INT32U Invalid Value\n"); + err = TestWriteAttributeNullableInt32uInvalidValue_230(); break; case 231: - ChipLogProgress(chipTool, " ***** Test Step 231 : Read attribute NULLABLE_INT32U Value in range\n"); - err = TestReadAttributeNullableInt32uValueInRange_231(); + ChipLogProgress(chipTool, " ***** Test Step 231 : Read attribute NULLABLE_INT32U unchanged Value\n"); + err = TestReadAttributeNullableInt32uUnchangedValue_231(); break; case 232: - ChipLogProgress(chipTool, " ***** Test Step 232 : Read attribute NULLABLE_INT32U notValue OK\n"); - err = TestReadAttributeNullableInt32uNotValueOk_232(); + ChipLogProgress(chipTool, " ***** Test Step 232 : Write attribute NULLABLE_INT32U null Value\n"); + err = TestWriteAttributeNullableInt32uNullValue_232(); break; case 233: - ChipLogProgress(chipTool, " ***** Test Step 233 : Write attribute NULLABLE_INT64U Max Value\n"); - err = TestWriteAttributeNullableInt64uMaxValue_233(); + ChipLogProgress(chipTool, " ***** Test Step 233 : Read attribute NULLABLE_INT32U null Value\n"); + err = TestReadAttributeNullableInt32uNullValue_233(); break; case 234: - ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_INT64U Max Value\n"); - err = TestReadAttributeNullableInt64uMaxValue_234(); + ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_INT32U null Value & range\n"); + err = TestReadAttributeNullableInt32uNullValueRange_234(); break; case 235: - ChipLogProgress(chipTool, " ***** Test Step 235 : Write attribute NULLABLE_INT64U Invalid Value\n"); - err = TestWriteAttributeNullableInt64uInvalidValue_235(); + ChipLogProgress(chipTool, " ***** Test Step 235 : Read attribute NULLABLE_INT32U null Value & not\n"); + err = TestReadAttributeNullableInt32uNullValueNot_235(); break; case 236: - ChipLogProgress(chipTool, " ***** Test Step 236 : Read attribute NULLABLE_INT64U unchanged Value\n"); - err = TestReadAttributeNullableInt64uUnchangedValue_236(); + ChipLogProgress(chipTool, " ***** Test Step 236 : Write attribute NULLABLE_INT32U Value\n"); + err = TestWriteAttributeNullableInt32uValue_236(); break; case 237: - ChipLogProgress(chipTool, " ***** Test Step 237 : Write attribute NULLABLE_INT64U null Value\n"); - err = TestWriteAttributeNullableInt64uNullValue_237(); + ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_INT32U Value in range\n"); + err = TestReadAttributeNullableInt32uValueInRange_237(); break; case 238: - ChipLogProgress(chipTool, " ***** Test Step 238 : Read attribute NULLABLE_INT64U null Value\n"); - err = TestReadAttributeNullableInt64uNullValue_238(); + ChipLogProgress(chipTool, " ***** Test Step 238 : Read attribute NULLABLE_INT32U notValue OK\n"); + err = TestReadAttributeNullableInt32uNotValueOk_238(); break; case 239: - ChipLogProgress(chipTool, " ***** Test Step 239 : Read attribute NULLABLE_INT64U null Value & range\n"); - err = TestReadAttributeNullableInt64uNullValueRange_239(); + ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_INT64U Min Value\n"); + err = TestWriteAttributeNullableInt64uMinValue_239(); break; case 240: - ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT64U null Value & not\n"); - err = TestReadAttributeNullableInt64uNullValueNot_240(); + ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT64U Min Value\n"); + err = TestReadAttributeNullableInt64uMinValue_240(); break; case 241: - ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_INT64U Value\n"); - err = TestWriteAttributeNullableInt64uValue_241(); + ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_INT64U Max Value\n"); + err = TestWriteAttributeNullableInt64uMaxValue_241(); break; case 242: - ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT64U Value in range\n"); - err = TestReadAttributeNullableInt64uValueInRange_242(); + ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT64U Max Value\n"); + err = TestReadAttributeNullableInt64uMaxValue_242(); break; case 243: - ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_INT64U notValue OK\n"); - err = TestReadAttributeNullableInt64uNotValueOk_243(); + ChipLogProgress(chipTool, " ***** Test Step 243 : Write attribute NULLABLE_INT64U Invalid Value\n"); + err = TestWriteAttributeNullableInt64uInvalidValue_243(); break; case 244: - ChipLogProgress(chipTool, " ***** Test Step 244 : Write attribute NULLABLE_INT8S Min Value\n"); - err = TestWriteAttributeNullableInt8sMinValue_244(); + ChipLogProgress(chipTool, " ***** Test Step 244 : Read attribute NULLABLE_INT64U unchanged Value\n"); + err = TestReadAttributeNullableInt64uUnchangedValue_244(); break; case 245: - ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_INT8S Min Value\n"); - err = TestReadAttributeNullableInt8sMinValue_245(); + ChipLogProgress(chipTool, " ***** Test Step 245 : Write attribute NULLABLE_INT64U null Value\n"); + err = TestWriteAttributeNullableInt64uNullValue_245(); break; case 246: - ChipLogProgress(chipTool, " ***** Test Step 246 : Write attribute NULLABLE_INT8S Invalid Value\n"); - err = TestWriteAttributeNullableInt8sInvalidValue_246(); + ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT64U null Value\n"); + err = TestReadAttributeNullableInt64uNullValue_246(); break; case 247: - ChipLogProgress(chipTool, " ***** Test Step 247 : Read attribute NULLABLE_INT8S unchanged Value\n"); - err = TestReadAttributeNullableInt8sUnchangedValue_247(); + ChipLogProgress(chipTool, " ***** Test Step 247 : Read attribute NULLABLE_INT64U null Value & range\n"); + err = TestReadAttributeNullableInt64uNullValueRange_247(); break; case 248: - ChipLogProgress(chipTool, " ***** Test Step 248 : Write attribute NULLABLE_INT8S null Value\n"); - err = TestWriteAttributeNullableInt8sNullValue_248(); + ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_INT64U null Value & not\n"); + err = TestReadAttributeNullableInt64uNullValueNot_248(); break; case 249: - ChipLogProgress(chipTool, " ***** Test Step 249 : Read attribute NULLABLE_INT8S null Value\n"); - err = TestReadAttributeNullableInt8sNullValue_249(); + ChipLogProgress(chipTool, " ***** Test Step 249 : Write attribute NULLABLE_INT64U Value\n"); + err = TestWriteAttributeNullableInt64uValue_249(); break; case 250: - ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_INT8S null Value & range\n"); - err = TestReadAttributeNullableInt8sNullValueRange_250(); + ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_INT64U Value in range\n"); + err = TestReadAttributeNullableInt64uValueInRange_250(); break; case 251: - ChipLogProgress(chipTool, " ***** Test Step 251 : Read attribute NULLABLE_INT8S null Value & not\n"); - err = TestReadAttributeNullableInt8sNullValueNot_251(); + ChipLogProgress(chipTool, " ***** Test Step 251 : Read attribute NULLABLE_INT64U notValue OK\n"); + err = TestReadAttributeNullableInt64uNotValueOk_251(); break; case 252: - ChipLogProgress(chipTool, " ***** Test Step 252 : Write attribute NULLABLE_INT8S Value\n"); - err = TestWriteAttributeNullableInt8sValue_252(); + ChipLogProgress(chipTool, " ***** Test Step 252 : Write attribute NULLABLE_INT8S Min Value\n"); + err = TestWriteAttributeNullableInt8sMinValue_252(); break; case 253: - ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_INT8S Value in range\n"); - err = TestReadAttributeNullableInt8sValueInRange_253(); + ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_INT8S Min Value\n"); + err = TestReadAttributeNullableInt8sMinValue_253(); break; case 254: - ChipLogProgress(chipTool, " ***** Test Step 254 : Read attribute NULLABLE_INT8S notValue OK\n"); - err = TestReadAttributeNullableInt8sNotValueOk_254(); + ChipLogProgress(chipTool, " ***** Test Step 254 : Write attribute NULLABLE_INT8S Invalid Value\n"); + err = TestWriteAttributeNullableInt8sInvalidValue_254(); break; case 255: - ChipLogProgress(chipTool, " ***** Test Step 255 : Write attribute NULLABLE_INT16S Min Value\n"); - err = TestWriteAttributeNullableInt16sMinValue_255(); + ChipLogProgress(chipTool, " ***** Test Step 255 : Read attribute NULLABLE_INT8S unchanged Value\n"); + err = TestReadAttributeNullableInt8sUnchangedValue_255(); break; case 256: - ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_INT16S Min Value\n"); - err = TestReadAttributeNullableInt16sMinValue_256(); + ChipLogProgress(chipTool, " ***** Test Step 256 : Write attribute NULLABLE_INT8S null Value\n"); + err = TestWriteAttributeNullableInt8sNullValue_256(); break; case 257: - ChipLogProgress(chipTool, " ***** Test Step 257 : Write attribute NULLABLE_INT16S Invalid Value\n"); - err = TestWriteAttributeNullableInt16sInvalidValue_257(); + ChipLogProgress(chipTool, " ***** Test Step 257 : Read attribute NULLABLE_INT8S null Value\n"); + err = TestReadAttributeNullableInt8sNullValue_257(); break; case 258: - ChipLogProgress(chipTool, " ***** Test Step 258 : Read attribute NULLABLE_INT16S unchanged Value\n"); - err = TestReadAttributeNullableInt16sUnchangedValue_258(); + ChipLogProgress(chipTool, " ***** Test Step 258 : Read attribute NULLABLE_INT8S null Value & range\n"); + err = TestReadAttributeNullableInt8sNullValueRange_258(); break; case 259: - ChipLogProgress(chipTool, " ***** Test Step 259 : Write attribute NULLABLE_INT16S null Value\n"); - err = TestWriteAttributeNullableInt16sNullValue_259(); + ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_INT8S null Value & not\n"); + err = TestReadAttributeNullableInt8sNullValueNot_259(); break; case 260: - ChipLogProgress(chipTool, " ***** Test Step 260 : Read attribute NULLABLE_INT16S null Value\n"); - err = TestReadAttributeNullableInt16sNullValue_260(); + ChipLogProgress(chipTool, " ***** Test Step 260 : Write attribute NULLABLE_INT8S Value\n"); + err = TestWriteAttributeNullableInt8sValue_260(); break; case 261: - ChipLogProgress(chipTool, " ***** Test Step 261 : Read attribute NULLABLE_INT16S null Value & range\n"); - err = TestReadAttributeNullableInt16sNullValueRange_261(); + ChipLogProgress(chipTool, " ***** Test Step 261 : Read attribute NULLABLE_INT8S Value in range\n"); + err = TestReadAttributeNullableInt8sValueInRange_261(); break; case 262: - ChipLogProgress(chipTool, " ***** Test Step 262 : Read attribute NULLABLE_INT16S null Value & not\n"); - err = TestReadAttributeNullableInt16sNullValueNot_262(); + ChipLogProgress(chipTool, " ***** Test Step 262 : Read attribute NULLABLE_INT8S notValue OK\n"); + err = TestReadAttributeNullableInt8sNotValueOk_262(); break; case 263: - ChipLogProgress(chipTool, " ***** Test Step 263 : Write attribute NULLABLE_INT16S Value\n"); - err = TestWriteAttributeNullableInt16sValue_263(); + ChipLogProgress(chipTool, " ***** Test Step 263 : Write attribute NULLABLE_INT16S Min Value\n"); + err = TestWriteAttributeNullableInt16sMinValue_263(); break; case 264: - ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_INT16S Value in range\n"); - err = TestReadAttributeNullableInt16sValueInRange_264(); + ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_INT16S Min Value\n"); + err = TestReadAttributeNullableInt16sMinValue_264(); break; case 265: - ChipLogProgress(chipTool, " ***** Test Step 265 : Read attribute NULLABLE_INT16S notValue OK\n"); - err = TestReadAttributeNullableInt16sNotValueOk_265(); + ChipLogProgress(chipTool, " ***** Test Step 265 : Write attribute NULLABLE_INT16S Invalid Value\n"); + err = TestWriteAttributeNullableInt16sInvalidValue_265(); break; case 266: - ChipLogProgress(chipTool, " ***** Test Step 266 : Write attribute NULLABLE_INT32S Min Value\n"); - err = TestWriteAttributeNullableInt32sMinValue_266(); + ChipLogProgress(chipTool, " ***** Test Step 266 : Read attribute NULLABLE_INT16S unchanged Value\n"); + err = TestReadAttributeNullableInt16sUnchangedValue_266(); break; case 267: - ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_INT32S Min Value\n"); - err = TestReadAttributeNullableInt32sMinValue_267(); + ChipLogProgress(chipTool, " ***** Test Step 267 : Write attribute NULLABLE_INT16S null Value\n"); + err = TestWriteAttributeNullableInt16sNullValue_267(); break; case 268: - ChipLogProgress(chipTool, " ***** Test Step 268 : Write attribute NULLABLE_INT32S Invalid Value\n"); - err = TestWriteAttributeNullableInt32sInvalidValue_268(); + ChipLogProgress(chipTool, " ***** Test Step 268 : Read attribute NULLABLE_INT16S null Value\n"); + err = TestReadAttributeNullableInt16sNullValue_268(); break; case 269: - ChipLogProgress(chipTool, " ***** Test Step 269 : Read attribute NULLABLE_INT32S unchanged Value\n"); - err = TestReadAttributeNullableInt32sUnchangedValue_269(); + ChipLogProgress(chipTool, " ***** Test Step 269 : Read attribute NULLABLE_INT16S null Value & range\n"); + err = TestReadAttributeNullableInt16sNullValueRange_269(); break; case 270: - ChipLogProgress(chipTool, " ***** Test Step 270 : Write attribute NULLABLE_INT32S null Value\n"); - err = TestWriteAttributeNullableInt32sNullValue_270(); + ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_INT16S null Value & not\n"); + err = TestReadAttributeNullableInt16sNullValueNot_270(); break; case 271: - ChipLogProgress(chipTool, " ***** Test Step 271 : Read attribute NULLABLE_INT32S null Value\n"); - err = TestReadAttributeNullableInt32sNullValue_271(); + ChipLogProgress(chipTool, " ***** Test Step 271 : Write attribute NULLABLE_INT16S Value\n"); + err = TestWriteAttributeNullableInt16sValue_271(); break; case 272: - ChipLogProgress(chipTool, " ***** Test Step 272 : Read attribute NULLABLE_INT32S null Value & range\n"); - err = TestReadAttributeNullableInt32sNullValueRange_272(); + ChipLogProgress(chipTool, " ***** Test Step 272 : Read attribute NULLABLE_INT16S Value in range\n"); + err = TestReadAttributeNullableInt16sValueInRange_272(); break; case 273: - ChipLogProgress(chipTool, " ***** Test Step 273 : Read attribute NULLABLE_INT32S null Value & not\n"); - err = TestReadAttributeNullableInt32sNullValueNot_273(); + ChipLogProgress(chipTool, " ***** Test Step 273 : Read attribute NULLABLE_INT16S notValue OK\n"); + err = TestReadAttributeNullableInt16sNotValueOk_273(); break; case 274: - ChipLogProgress(chipTool, " ***** Test Step 274 : Write attribute NULLABLE_INT32S Value\n"); - err = TestWriteAttributeNullableInt32sValue_274(); + ChipLogProgress(chipTool, " ***** Test Step 274 : Write attribute NULLABLE_INT32S Min Value\n"); + err = TestWriteAttributeNullableInt32sMinValue_274(); break; case 275: - ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_INT32S Value in range\n"); - err = TestReadAttributeNullableInt32sValueInRange_275(); + ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_INT32S Min Value\n"); + err = TestReadAttributeNullableInt32sMinValue_275(); break; case 276: - ChipLogProgress(chipTool, " ***** Test Step 276 : Read attribute NULLABLE_INT32S notValue OK\n"); - err = TestReadAttributeNullableInt32sNotValueOk_276(); + ChipLogProgress(chipTool, " ***** Test Step 276 : Write attribute NULLABLE_INT32S Invalid Value\n"); + err = TestWriteAttributeNullableInt32sInvalidValue_276(); break; case 277: - ChipLogProgress(chipTool, " ***** Test Step 277 : Write attribute NULLABLE_INT64S Min Value\n"); - err = TestWriteAttributeNullableInt64sMinValue_277(); + ChipLogProgress(chipTool, " ***** Test Step 277 : Read attribute NULLABLE_INT32S unchanged Value\n"); + err = TestReadAttributeNullableInt32sUnchangedValue_277(); break; case 278: - ChipLogProgress(chipTool, " ***** Test Step 278 : Read attribute NULLABLE_INT64S Min Value\n"); - err = TestReadAttributeNullableInt64sMinValue_278(); + ChipLogProgress(chipTool, " ***** Test Step 278 : Write attribute NULLABLE_INT32S null Value\n"); + err = TestWriteAttributeNullableInt32sNullValue_278(); break; case 279: - ChipLogProgress(chipTool, " ***** Test Step 279 : Write attribute NULLABLE_INT64S Invalid Value\n"); - err = TestWriteAttributeNullableInt64sInvalidValue_279(); + ChipLogProgress(chipTool, " ***** Test Step 279 : Read attribute NULLABLE_INT32S null Value\n"); + err = TestReadAttributeNullableInt32sNullValue_279(); break; case 280: - ChipLogProgress(chipTool, " ***** Test Step 280 : Read attribute NULLABLE_INT64S unchanged Value\n"); - err = TestReadAttributeNullableInt64sUnchangedValue_280(); + ChipLogProgress(chipTool, " ***** Test Step 280 : Read attribute NULLABLE_INT32S null Value & range\n"); + err = TestReadAttributeNullableInt32sNullValueRange_280(); break; case 281: - ChipLogProgress(chipTool, " ***** Test Step 281 : Write attribute NULLABLE_INT64S null Value\n"); - err = TestWriteAttributeNullableInt64sNullValue_281(); + ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_INT32S null Value & not\n"); + err = TestReadAttributeNullableInt32sNullValueNot_281(); break; case 282: - ChipLogProgress(chipTool, " ***** Test Step 282 : Read attribute NULLABLE_INT64S null Value\n"); - err = TestReadAttributeNullableInt64sNullValue_282(); + ChipLogProgress(chipTool, " ***** Test Step 282 : Write attribute NULLABLE_INT32S Value\n"); + err = TestWriteAttributeNullableInt32sValue_282(); break; case 283: - ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_INT64S null Value & range\n"); - err = TestReadAttributeNullableInt64sNullValueRange_283(); + ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_INT32S Value in range\n"); + err = TestReadAttributeNullableInt32sValueInRange_283(); break; case 284: - ChipLogProgress(chipTool, " ***** Test Step 284 : Read attribute NULLABLE_INT64S null Value & not\n"); - err = TestReadAttributeNullableInt64sNullValueNot_284(); + ChipLogProgress(chipTool, " ***** Test Step 284 : Read attribute NULLABLE_INT32S notValue OK\n"); + err = TestReadAttributeNullableInt32sNotValueOk_284(); break; case 285: - ChipLogProgress(chipTool, " ***** Test Step 285 : Write attribute NULLABLE_INT64S Value\n"); - err = TestWriteAttributeNullableInt64sValue_285(); + ChipLogProgress(chipTool, " ***** Test Step 285 : Write attribute NULLABLE_INT64S Min Value\n"); + err = TestWriteAttributeNullableInt64sMinValue_285(); break; case 286: - ChipLogProgress(chipTool, " ***** Test Step 286 : Read attribute NULLABLE_INT64S Value in range\n"); - err = TestReadAttributeNullableInt64sValueInRange_286(); + ChipLogProgress(chipTool, " ***** Test Step 286 : Read attribute NULLABLE_INT64S Min Value\n"); + err = TestReadAttributeNullableInt64sMinValue_286(); break; case 287: - ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_INT64S notValue OK\n"); - err = TestReadAttributeNullableInt64sNotValueOk_287(); + ChipLogProgress(chipTool, " ***** Test Step 287 : Write attribute NULLABLE_INT64S Invalid Value\n"); + err = TestWriteAttributeNullableInt64sInvalidValue_287(); break; case 288: - ChipLogProgress(chipTool, " ***** Test Step 288 : Write attribute NULLABLE_SINGLE medium Value\n"); - err = TestWriteAttributeNullableSingleMediumValue_288(); + ChipLogProgress(chipTool, " ***** Test Step 288 : Read attribute NULLABLE_INT64S unchanged Value\n"); + err = TestReadAttributeNullableInt64sUnchangedValue_288(); break; case 289: - ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_SINGLE medium Value\n"); - err = TestReadAttributeNullableSingleMediumValue_289(); + ChipLogProgress(chipTool, " ***** Test Step 289 : Write attribute NULLABLE_INT64S null Value\n"); + err = TestWriteAttributeNullableInt64sNullValue_289(); break; case 290: - ChipLogProgress(chipTool, " ***** Test Step 290 : Write attribute NULLABLE_SINGLE largest Value\n"); - err = TestWriteAttributeNullableSingleLargestValue_290(); + ChipLogProgress(chipTool, " ***** Test Step 290 : Read attribute NULLABLE_INT64S null Value\n"); + err = TestReadAttributeNullableInt64sNullValue_290(); break; case 291: - ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_SINGLE largest Value\n"); - err = TestReadAttributeNullableSingleLargestValue_291(); + ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_INT64S null Value & range\n"); + err = TestReadAttributeNullableInt64sNullValueRange_291(); break; case 292: - ChipLogProgress(chipTool, " ***** Test Step 292 : Write attribute NULLABLE_SINGLE smallest Value\n"); - err = TestWriteAttributeNullableSingleSmallestValue_292(); + ChipLogProgress(chipTool, " ***** Test Step 292 : Read attribute NULLABLE_INT64S null Value & not\n"); + err = TestReadAttributeNullableInt64sNullValueNot_292(); break; case 293: - ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute NULLABLE_SINGLE smallest Value\n"); - err = TestReadAttributeNullableSingleSmallestValue_293(); + ChipLogProgress(chipTool, " ***** Test Step 293 : Write attribute NULLABLE_INT64S Value\n"); + err = TestWriteAttributeNullableInt64sValue_293(); break; case 294: - ChipLogProgress(chipTool, " ***** Test Step 294 : Write attribute NULLABLE_SINGLE null Value\n"); - err = TestWriteAttributeNullableSingleNullValue_294(); + ChipLogProgress(chipTool, " ***** Test Step 294 : Read attribute NULLABLE_INT64S Value in range\n"); + err = TestReadAttributeNullableInt64sValueInRange_294(); break; case 295: - ChipLogProgress(chipTool, " ***** Test Step 295 : Read attribute NULLABLE_SINGLE null Value\n"); - err = TestReadAttributeNullableSingleNullValue_295(); + ChipLogProgress(chipTool, " ***** Test Step 295 : Read attribute NULLABLE_INT64S notValue OK\n"); + err = TestReadAttributeNullableInt64sNotValueOk_295(); break; case 296: - ChipLogProgress(chipTool, " ***** Test Step 296 : Write attribute NULLABLE_SINGLE 0 Value\n"); - err = TestWriteAttributeNullableSingle0Value_296(); + ChipLogProgress(chipTool, " ***** Test Step 296 : Write attribute NULLABLE_SINGLE medium Value\n"); + err = TestWriteAttributeNullableSingleMediumValue_296(); break; case 297: - ChipLogProgress(chipTool, " ***** Test Step 297 : Read attribute NULLABLE_SINGLE 0 Value\n"); - err = TestReadAttributeNullableSingle0Value_297(); + ChipLogProgress(chipTool, " ***** Test Step 297 : Read attribute NULLABLE_SINGLE medium Value\n"); + err = TestReadAttributeNullableSingleMediumValue_297(); break; case 298: - ChipLogProgress(chipTool, " ***** Test Step 298 : Write attribute NULLABLE_DOUBLE medium Value\n"); - err = TestWriteAttributeNullableDoubleMediumValue_298(); + ChipLogProgress(chipTool, " ***** Test Step 298 : Write attribute NULLABLE_SINGLE largest Value\n"); + err = TestWriteAttributeNullableSingleLargestValue_298(); break; case 299: - ChipLogProgress(chipTool, " ***** Test Step 299 : Read attribute NULLABLE_DOUBLE medium Value\n"); - err = TestReadAttributeNullableDoubleMediumValue_299(); + ChipLogProgress(chipTool, " ***** Test Step 299 : Read attribute NULLABLE_SINGLE largest Value\n"); + err = TestReadAttributeNullableSingleLargestValue_299(); break; case 300: - ChipLogProgress(chipTool, " ***** Test Step 300 : Write attribute NULLABLE_DOUBLE largest Value\n"); - err = TestWriteAttributeNullableDoubleLargestValue_300(); + ChipLogProgress(chipTool, " ***** Test Step 300 : Write attribute NULLABLE_SINGLE smallest Value\n"); + err = TestWriteAttributeNullableSingleSmallestValue_300(); break; case 301: - ChipLogProgress(chipTool, " ***** Test Step 301 : Read attribute NULLABLE_DOUBLE largest Value\n"); - err = TestReadAttributeNullableDoubleLargestValue_301(); + ChipLogProgress(chipTool, " ***** Test Step 301 : Read attribute NULLABLE_SINGLE smallest Value\n"); + err = TestReadAttributeNullableSingleSmallestValue_301(); break; case 302: - ChipLogProgress(chipTool, " ***** Test Step 302 : Write attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestWriteAttributeNullableDoubleSmallestValue_302(); + ChipLogProgress(chipTool, " ***** Test Step 302 : Write attribute NULLABLE_SINGLE null Value\n"); + err = TestWriteAttributeNullableSingleNullValue_302(); break; case 303: - ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestReadAttributeNullableDoubleSmallestValue_303(); + ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_SINGLE null Value\n"); + err = TestReadAttributeNullableSingleNullValue_303(); break; case 304: - ChipLogProgress(chipTool, " ***** Test Step 304 : Write attribute NULLABLE_DOUBLE null Value\n"); - err = TestWriteAttributeNullableDoubleNullValue_304(); + ChipLogProgress(chipTool, " ***** Test Step 304 : Write attribute NULLABLE_SINGLE 0 Value\n"); + err = TestWriteAttributeNullableSingle0Value_304(); break; case 305: - ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_DOUBLE null Value\n"); - err = TestReadAttributeNullableDoubleNullValue_305(); + ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_SINGLE 0 Value\n"); + err = TestReadAttributeNullableSingle0Value_305(); break; case 306: - ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestWriteAttributeNullableDouble0Value_306(); + ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_DOUBLE medium Value\n"); + err = TestWriteAttributeNullableDoubleMediumValue_306(); break; case 307: - ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestReadAttributeNullableDouble0Value_307(); + ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_DOUBLE medium Value\n"); + err = TestReadAttributeNullableDoubleMediumValue_307(); break; case 308: - ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_ENUM8 Max Value\n"); - err = TestWriteAttributeNullableEnum8MaxValue_308(); + ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_DOUBLE largest Value\n"); + err = TestWriteAttributeNullableDoubleLargestValue_308(); break; case 309: - ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_ENUM8 Max Value\n"); - err = TestReadAttributeNullableEnum8MaxValue_309(); + ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_DOUBLE largest Value\n"); + err = TestReadAttributeNullableDoubleLargestValue_309(); break; case 310: - ChipLogProgress(chipTool, " ***** Test Step 310 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); - err = TestWriteAttributeNullableEnum8InvalidValue_310(); + ChipLogProgress(chipTool, " ***** Test Step 310 : Write attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestWriteAttributeNullableDoubleSmallestValue_310(); break; case 311: - ChipLogProgress(chipTool, " ***** Test Step 311 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); - err = TestReadAttributeNullableEnum8UnchangedValue_311(); + ChipLogProgress(chipTool, " ***** Test Step 311 : Read attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestReadAttributeNullableDoubleSmallestValue_311(); break; case 312: - ChipLogProgress(chipTool, " ***** Test Step 312 : Write attribute NULLABLE_ENUM8 null Value\n"); - err = TestWriteAttributeNullableEnum8NullValue_312(); + ChipLogProgress(chipTool, " ***** Test Step 312 : Write attribute NULLABLE_DOUBLE null Value\n"); + err = TestWriteAttributeNullableDoubleNullValue_312(); break; case 313: - ChipLogProgress(chipTool, " ***** Test Step 313 : Read attribute NULLABLE_ENUM8 null Value\n"); - err = TestReadAttributeNullableEnum8NullValue_313(); + ChipLogProgress(chipTool, " ***** Test Step 313 : Read attribute NULLABLE_DOUBLE null Value\n"); + err = TestReadAttributeNullableDoubleNullValue_313(); break; case 314: - ChipLogProgress(chipTool, " ***** Test Step 314 : Write attribute NULLABLE_ENUM16 Max Value\n"); - err = TestWriteAttributeNullableEnum16MaxValue_314(); + ChipLogProgress(chipTool, " ***** Test Step 314 : Write attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestWriteAttributeNullableDouble0Value_314(); break; case 315: - ChipLogProgress(chipTool, " ***** Test Step 315 : Read attribute NULLABLE_ENUM16 Max Value\n"); - err = TestReadAttributeNullableEnum16MaxValue_315(); + ChipLogProgress(chipTool, " ***** Test Step 315 : Read attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestReadAttributeNullableDouble0Value_315(); break; case 316: - ChipLogProgress(chipTool, " ***** Test Step 316 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); - err = TestWriteAttributeNullableEnum16InvalidValue_316(); + ChipLogProgress(chipTool, " ***** Test Step 316 : Write attribute NULLABLE_ENUM8 Min Value\n"); + err = TestWriteAttributeNullableEnum8MinValue_316(); break; case 317: - ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); - err = TestReadAttributeNullableEnum16UnchangedValue_317(); + ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_ENUM8 Min Value\n"); + err = TestReadAttributeNullableEnum8MinValue_317(); break; case 318: - ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_ENUM16 null Value\n"); - err = TestWriteAttributeNullableEnum16NullValue_318(); + ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_ENUM8 Max Value\n"); + err = TestWriteAttributeNullableEnum8MaxValue_318(); break; case 319: - ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_ENUM16 null Value\n"); - err = TestReadAttributeNullableEnum16NullValue_319(); + ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_ENUM8 Max Value\n"); + err = TestReadAttributeNullableEnum8MaxValue_319(); break; case 320: - ChipLogProgress(chipTool, " ***** Test Step 320 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); - err = TestReadAttributeNullableOctetStringDefaultValue_320(); + ChipLogProgress(chipTool, " ***** Test Step 320 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); + err = TestWriteAttributeNullableEnum8InvalidValue_320(); break; case 321: - ChipLogProgress(chipTool, " ***** Test Step 321 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_321(); + ChipLogProgress(chipTool, " ***** Test Step 321 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); + err = TestReadAttributeNullableEnum8UnchangedValue_321(); break; case 322: - ChipLogProgress(chipTool, " ***** Test Step 322 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_322(); + ChipLogProgress(chipTool, " ***** Test Step 322 : Write attribute NULLABLE_ENUM8 null Value\n"); + err = TestWriteAttributeNullableEnum8NullValue_322(); break; case 323: - ChipLogProgress(chipTool, " ***** Test Step 323 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_323(); + ChipLogProgress(chipTool, " ***** Test Step 323 : Read attribute NULLABLE_ENUM8 null Value\n"); + err = TestReadAttributeNullableEnum8NullValue_323(); break; case 324: - ChipLogProgress(chipTool, " ***** Test Step 324 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_324(); + ChipLogProgress(chipTool, " ***** Test Step 324 : Write attribute NULLABLE_ENUM16 Min Value\n"); + err = TestWriteAttributeNullableEnum16MinValue_324(); break; case 325: - ChipLogProgress(chipTool, " ***** Test Step 325 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_325(); + ChipLogProgress(chipTool, " ***** Test Step 325 : Read attribute NULLABLE_ENUM16 Min Value\n"); + err = TestReadAttributeNullableEnum16MinValue_325(); break; case 326: - ChipLogProgress(chipTool, " ***** Test Step 326 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_326(); + ChipLogProgress(chipTool, " ***** Test Step 326 : Write attribute NULLABLE_ENUM16 Max Value\n"); + err = TestWriteAttributeNullableEnum16MaxValue_326(); break; case 327: - ChipLogProgress(chipTool, " ***** Test Step 327 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); - err = TestReadAttributeNullableCharStringDefaultValue_327(); + ChipLogProgress(chipTool, " ***** Test Step 327 : Read attribute NULLABLE_ENUM16 Max Value\n"); + err = TestReadAttributeNullableEnum16MaxValue_327(); break; case 328: - ChipLogProgress(chipTool, " ***** Test Step 328 : Write attribute NULLABLE_CHAR_STRING\n"); - err = TestWriteAttributeNullableCharString_328(); + ChipLogProgress(chipTool, " ***** Test Step 328 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); + err = TestWriteAttributeNullableEnum16InvalidValue_328(); break; case 329: - ChipLogProgress(chipTool, " ***** Test Step 329 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_329(); + ChipLogProgress(chipTool, " ***** Test Step 329 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); + err = TestReadAttributeNullableEnum16UnchangedValue_329(); break; case 330: - ChipLogProgress(chipTool, " ***** Test Step 330 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); - err = TestWriteAttributeNullableCharStringValueTooLong_330(); + ChipLogProgress(chipTool, " ***** Test Step 330 : Write attribute NULLABLE_ENUM16 null Value\n"); + err = TestWriteAttributeNullableEnum16NullValue_330(); break; case 331: - ChipLogProgress(chipTool, " ***** Test Step 331 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_331(); + ChipLogProgress(chipTool, " ***** Test Step 331 : Read attribute NULLABLE_ENUM16 null Value\n"); + err = TestReadAttributeNullableEnum16NullValue_331(); break; case 332: - ChipLogProgress(chipTool, " ***** Test Step 332 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); - err = TestWriteAttributeNullableCharStringEmpty_332(); + ChipLogProgress(chipTool, " ***** Test Step 332 : Write attribute NULLABLE_SIMPLE_ENUM Min Value\n"); + err = TestWriteAttributeNullableSimpleEnumMinValue_332(); break; case 333: - ChipLogProgress(chipTool, " ***** Test Step 333 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_333(); + ChipLogProgress(chipTool, " ***** Test Step 333 : Read attribute NULLABLE_SIMPLE_ENUM Min Value\n"); + err = TestReadAttributeNullableSimpleEnumMinValue_333(); break; case 334: - ChipLogProgress(chipTool, " ***** Test Step 334 : Read attribute from nonexistent endpoint.\n"); - err = TestReadAttributeFromNonexistentEndpoint_334(); + ChipLogProgress(chipTool, " ***** Test Step 334 : Write attribute NULLABLE_SIMPLE_ENUM Max Value\n"); + err = TestWriteAttributeNullableSimpleEnumMaxValue_334(); break; case 335: - ChipLogProgress(chipTool, " ***** Test Step 335 : Read attribute from nonexistent cluster.\n"); - err = TestReadAttributeFromNonexistentCluster_335(); + ChipLogProgress(chipTool, " ***** Test Step 335 : Read attribute NULLABLE_SIMPLE_ENUM Max Value\n"); + err = TestReadAttributeNullableSimpleEnumMaxValue_335(); break; case 336: - ChipLogProgress(chipTool, - " ***** Test Step 336 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_336(); + ChipLogProgress(chipTool, " ***** Test Step 336 : Write attribute NULLABLE_SIMPLE_ENUM Invalid Value\n"); + err = TestWriteAttributeNullableSimpleEnumInvalidValue_336(); break; case 337: - ChipLogProgress(chipTool, - " ***** Test Step 337 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_337(); + ChipLogProgress(chipTool, " ***** Test Step 337 : Read attribute NULLABLE_SIMPLE_ENUM unchanged Value\n"); + err = TestReadAttributeNullableSimpleEnumUnchangedValue_337(); break; case 338: - ChipLogProgress(chipTool, " ***** Test Step 338 : Report: Subscribe to list attribute\n"); - err = TestReportSubscribeToListAttribute_338(); + ChipLogProgress(chipTool, " ***** Test Step 338 : Write attribute NULLABLE_SIMPLE_ENUM null Value\n"); + err = TestWriteAttributeNullableSimpleEnumNullValue_338(); break; case 339: - ChipLogProgress(chipTool, " ***** Test Step 339 : Subscribe to list attribute\n"); - err = TestSubscribeToListAttribute_339(); + ChipLogProgress(chipTool, " ***** Test Step 339 : Read attribute NULLABLE_SIMPLE_ENUM null Value\n"); + err = TestReadAttributeNullableSimpleEnumNullValue_339(); break; case 340: - ChipLogProgress(chipTool, " ***** Test Step 340 : Write subscribed-to list attribute\n"); - err = TestWriteSubscribedToListAttribute_340(); + ChipLogProgress(chipTool, " ***** Test Step 340 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); + err = TestReadAttributeNullableOctetStringDefaultValue_340(); break; case 341: - ChipLogProgress(chipTool, " ***** Test Step 341 : Check for list attribute report\n"); - err = TestCheckForListAttributeReport_341(); + ChipLogProgress(chipTool, " ***** Test Step 341 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_341(); break; case 342: - ChipLogProgress(chipTool, " ***** Test Step 342 : Read range-restricted unsigned 8-bit integer\n"); - err = TestReadRangeRestrictedUnsigned8BitInteger_342(); + ChipLogProgress(chipTool, " ***** Test Step 342 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_342(); break; case 343: - ChipLogProgress(chipTool, " ***** Test Step 343 : Write min value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_343(); + ChipLogProgress(chipTool, " ***** Test Step 343 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_343(); break; case 344: - ChipLogProgress(chipTool, - " ***** Test Step 344 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_344(); + ChipLogProgress(chipTool, " ***** Test Step 344 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_344(); break; case 345: - ChipLogProgress(chipTool, - " ***** Test Step 345 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_345(); + ChipLogProgress(chipTool, " ***** Test Step 345 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_345(); break; case 346: - ChipLogProgress(chipTool, " ***** Test Step 346 : Write max value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_346(); + ChipLogProgress(chipTool, " ***** Test Step 346 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_346(); break; case 347: - ChipLogProgress(chipTool, - " ***** Test Step 347 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_347(); + ChipLogProgress(chipTool, " ***** Test Step 347 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); + err = TestReadAttributeNullableCharStringDefaultValue_347(); break; case 348: - ChipLogProgress(chipTool, - " ***** Test Step 348 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_348(); + ChipLogProgress(chipTool, " ***** Test Step 348 : Write attribute NULLABLE_CHAR_STRING\n"); + err = TestWriteAttributeNullableCharString_348(); break; case 349: - ChipLogProgress(chipTool, - " ***** Test Step 349 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_349(); + ChipLogProgress(chipTool, " ***** Test Step 349 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_349(); break; case 350: - ChipLogProgress(chipTool, - " ***** Test Step 350 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_350(); + ChipLogProgress(chipTool, " ***** Test Step 350 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); + err = TestWriteAttributeNullableCharStringValueTooLong_350(); break; case 351: - ChipLogProgress(chipTool, - " ***** Test Step 351 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_351(); + ChipLogProgress(chipTool, " ***** Test Step 351 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_351(); break; case 352: - ChipLogProgress(chipTool, - " ***** Test Step 352 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_352(); + ChipLogProgress(chipTool, " ***** Test Step 352 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); + err = TestWriteAttributeNullableCharStringEmpty_352(); break; case 353: - ChipLogProgress(chipTool, - " ***** Test Step 353 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_353(); + ChipLogProgress(chipTool, " ***** Test Step 353 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_353(); break; case 354: - ChipLogProgress(chipTool, " ***** Test Step 354 : Read range-restricted unsigned 16-bit integer\n"); - err = TestReadRangeRestrictedUnsigned16BitInteger_354(); + ChipLogProgress(chipTool, " ***** Test Step 354 : Read attribute from nonexistent endpoint.\n"); + err = TestReadAttributeFromNonexistentEndpoint_354(); break; case 355: - ChipLogProgress(chipTool, " ***** Test Step 355 : Write min value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_355(); + ChipLogProgress(chipTool, " ***** Test Step 355 : Read attribute from nonexistent cluster.\n"); + err = TestReadAttributeFromNonexistentCluster_355(); break; case 356: ChipLogProgress(chipTool, - " ***** Test Step 356 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_356(); + " ***** Test Step 356 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_356(); break; case 357: ChipLogProgress(chipTool, - " ***** Test Step 357 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_357(); + " ***** Test Step 357 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_357(); break; case 358: - ChipLogProgress(chipTool, " ***** Test Step 358 : Write max value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_358(); + ChipLogProgress(chipTool, " ***** Test Step 358 : Report: Subscribe to list attribute\n"); + err = TestReportSubscribeToListAttribute_358(); break; case 359: - ChipLogProgress(chipTool, - " ***** Test Step 359 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_359(); + ChipLogProgress(chipTool, " ***** Test Step 359 : Subscribe to list attribute\n"); + err = TestSubscribeToListAttribute_359(); break; case 360: - ChipLogProgress(chipTool, - " ***** Test Step 360 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_360(); + ChipLogProgress(chipTool, " ***** Test Step 360 : Write subscribed-to list attribute\n"); + err = TestWriteSubscribedToListAttribute_360(); break; case 361: - ChipLogProgress(chipTool, - " ***** Test Step 361 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_361(); + ChipLogProgress(chipTool, " ***** Test Step 361 : Check for list attribute report\n"); + err = TestCheckForListAttributeReport_361(); break; case 362: - ChipLogProgress(chipTool, - " ***** Test Step 362 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_362(); + ChipLogProgress(chipTool, " ***** Test Step 362 : Read range-restricted unsigned 8-bit integer\n"); + err = TestReadRangeRestrictedUnsigned8BitInteger_362(); break; case 363: - ChipLogProgress(chipTool, - " ***** Test Step 363 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_363(); + ChipLogProgress(chipTool, " ***** Test Step 363 : Write min value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_363(); break; case 364: ChipLogProgress(chipTool, - " ***** Test Step 364 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_364(); + " ***** Test Step 364 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_364(); break; case 365: ChipLogProgress(chipTool, - " ***** Test Step 365 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_365(); + " ***** Test Step 365 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_365(); break; case 366: - ChipLogProgress(chipTool, " ***** Test Step 366 : Read range-restricted signed 8-bit integer\n"); - err = TestReadRangeRestrictedSigned8BitInteger_366(); + ChipLogProgress(chipTool, " ***** Test Step 366 : Write max value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_366(); break; case 367: - ChipLogProgress(chipTool, " ***** Test Step 367 : Write min value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_367(); + ChipLogProgress(chipTool, + " ***** Test Step 367 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_367(); break; case 368: ChipLogProgress(chipTool, - " ***** Test Step 368 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_368(); + " ***** Test Step 368 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_368(); break; case 369: ChipLogProgress(chipTool, - " ***** Test Step 369 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_369(); + " ***** Test Step 369 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_369(); break; case 370: - ChipLogProgress(chipTool, " ***** Test Step 370 : Write max value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_370(); + ChipLogProgress(chipTool, + " ***** Test Step 370 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_370(); break; case 371: ChipLogProgress(chipTool, - " ***** Test Step 371 : Verify range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_371(); + " ***** Test Step 371 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_371(); break; case 372: - ChipLogProgress(chipTool, " ***** Test Step 372 : Write min valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_372(); + ChipLogProgress(chipTool, + " ***** Test Step 372 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_372(); break; case 373: ChipLogProgress(chipTool, - " ***** Test Step 373 : Verify range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_373(); + " ***** Test Step 373 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_373(); break; case 374: - ChipLogProgress(chipTool, " ***** Test Step 374 : Write max valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_374(); + ChipLogProgress(chipTool, " ***** Test Step 374 : Read range-restricted unsigned 16-bit integer\n"); + err = TestReadRangeRestrictedUnsigned16BitInteger_374(); break; case 375: - ChipLogProgress(chipTool, - " ***** Test Step 375 : Verify range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_375(); + ChipLogProgress(chipTool, " ***** Test Step 375 : Write min value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_375(); break; case 376: ChipLogProgress(chipTool, - " ***** Test Step 376 : Write middle valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_376(); + " ***** Test Step 376 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_376(); break; case 377: ChipLogProgress(chipTool, - " ***** Test Step 377 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_377(); + " ***** Test Step 377 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_377(); break; case 378: - ChipLogProgress(chipTool, " ***** Test Step 378 : Read range-restricted signed 16-bit integer\n"); - err = TestReadRangeRestrictedSigned16BitInteger_378(); + ChipLogProgress(chipTool, " ***** Test Step 378 : Write max value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_378(); break; case 379: - ChipLogProgress(chipTool, " ***** Test Step 379 : Write min value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_379(); + ChipLogProgress(chipTool, + " ***** Test Step 379 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_379(); break; case 380: ChipLogProgress(chipTool, - " ***** Test Step 380 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_380(); + " ***** Test Step 380 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_380(); break; case 381: ChipLogProgress(chipTool, - " ***** Test Step 381 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_381(); + " ***** Test Step 381 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_381(); break; case 382: - ChipLogProgress(chipTool, " ***** Test Step 382 : Write max value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_382(); + ChipLogProgress(chipTool, + " ***** Test Step 382 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_382(); break; case 383: ChipLogProgress(chipTool, - " ***** Test Step 383 : Verify range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_383(); + " ***** Test Step 383 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_383(); break; case 384: - ChipLogProgress(chipTool, " ***** Test Step 384 : Write min valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_384(); + ChipLogProgress(chipTool, + " ***** Test Step 384 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_384(); break; case 385: ChipLogProgress(chipTool, - " ***** Test Step 385 : Verify range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_385(); + " ***** Test Step 385 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_385(); break; case 386: - ChipLogProgress(chipTool, " ***** Test Step 386 : Write max valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_386(); + ChipLogProgress(chipTool, " ***** Test Step 386 : Read range-restricted signed 8-bit integer\n"); + err = TestReadRangeRestrictedSigned8BitInteger_386(); break; case 387: - ChipLogProgress(chipTool, - " ***** Test Step 387 : Verify range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_387(); + ChipLogProgress(chipTool, " ***** Test Step 387 : Write min value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_387(); break; case 388: ChipLogProgress(chipTool, - " ***** Test Step 388 : Write middle valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_388(); + " ***** Test Step 388 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_388(); break; case 389: ChipLogProgress(chipTool, - " ***** Test Step 389 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_389(); + " ***** Test Step 389 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_389(); break; case 390: - ChipLogProgress(chipTool, " ***** Test Step 390 : Read nullable range-restricted unsigned 8-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned8BitInteger_390(); + ChipLogProgress(chipTool, " ***** Test Step 390 : Write max value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_390(); break; case 391: ChipLogProgress(chipTool, - " ***** Test Step 391 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_391(); + " ***** Test Step 391 : Verify range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_391(); break; case 392: - ChipLogProgress( - chipTool, - " ***** Test Step 392 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_392(); + ChipLogProgress(chipTool, " ***** Test Step 392 : Write min valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_392(); break; case 393: - ChipLogProgress( - chipTool, - " ***** Test Step 393 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_393(); + ChipLogProgress(chipTool, + " ***** Test Step 393 : Verify range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_393(); break; case 394: - ChipLogProgress(chipTool, - " ***** Test Step 394 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_394(); + ChipLogProgress(chipTool, " ***** Test Step 394 : Write max valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_394(); break; case 395: - ChipLogProgress( - chipTool, " ***** Test Step 395 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_395(); + ChipLogProgress(chipTool, + " ***** Test Step 395 : Verify range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_395(); break; case 396: ChipLogProgress(chipTool, - " ***** Test Step 396 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_396(); + " ***** Test Step 396 : Write middle valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_396(); break; case 397: - ChipLogProgress( - chipTool, " ***** Test Step 397 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_397(); + ChipLogProgress(chipTool, + " ***** Test Step 397 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_397(); break; case 398: - ChipLogProgress(chipTool, - " ***** Test Step 398 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_398(); + ChipLogProgress(chipTool, " ***** Test Step 398 : Read range-restricted signed 16-bit integer\n"); + err = TestReadRangeRestrictedSigned16BitInteger_398(); break; case 399: - ChipLogProgress( - chipTool, " ***** Test Step 399 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_399(); + ChipLogProgress(chipTool, " ***** Test Step 399 : Write min value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_399(); break; case 400: - ChipLogProgress( - chipTool, - " ***** Test Step 400 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_400(); + ChipLogProgress(chipTool, + " ***** Test Step 400 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_400(); break; case 401: - ChipLogProgress( - chipTool, " ***** Test Step 401 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_401(); + ChipLogProgress(chipTool, + " ***** Test Step 401 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_401(); break; case 402: - ChipLogProgress(chipTool, - " ***** Test Step 402 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_402(); + ChipLogProgress(chipTool, " ***** Test Step 402 : Write max value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_402(); break; case 403: ChipLogProgress(chipTool, - " ***** Test Step 403 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_403(); + " ***** Test Step 403 : Verify range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_403(); break; case 404: - ChipLogProgress(chipTool, " ***** Test Step 404 : Read nullable range-restricted unsigned 16-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned16BitInteger_404(); + ChipLogProgress(chipTool, " ***** Test Step 404 : Write min valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_404(); break; case 405: ChipLogProgress(chipTool, - " ***** Test Step 405 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_405(); + " ***** Test Step 405 : Verify range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_405(); break; case 406: - ChipLogProgress( - chipTool, - " ***** Test Step 406 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_406(); + ChipLogProgress(chipTool, " ***** Test Step 406 : Write max valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_406(); break; case 407: - ChipLogProgress( - chipTool, - " ***** Test Step 407 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_407(); + ChipLogProgress(chipTool, + " ***** Test Step 407 : Verify range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_407(); break; case 408: ChipLogProgress(chipTool, - " ***** Test Step 408 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_408(); + " ***** Test Step 408 : Write middle valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_408(); break; case 409: - ChipLogProgress( - chipTool, - " ***** Test Step 409 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_409(); + ChipLogProgress(chipTool, + " ***** Test Step 409 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_409(); break; case 410: - ChipLogProgress( - chipTool, " ***** Test Step 410 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_410(); + ChipLogProgress(chipTool, " ***** Test Step 410 : Read nullable range-restricted unsigned 8-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned8BitInteger_410(); break; case 411: - ChipLogProgress( - chipTool, - " ***** Test Step 411 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_411(); + ChipLogProgress(chipTool, + " ***** Test Step 411 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_411(); break; case 412: ChipLogProgress( - chipTool, " ***** Test Step 412 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_412(); + chipTool, + " ***** Test Step 412 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_412(); break; case 413: ChipLogProgress( chipTool, - " ***** Test Step 413 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_413(); + " ***** Test Step 413 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_413(); break; case 414: - ChipLogProgress( - chipTool, - " ***** Test Step 414 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_414(); + ChipLogProgress(chipTool, + " ***** Test Step 414 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_414(); break; case 415: ChipLogProgress( - chipTool, - " ***** Test Step 415 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_415(); + chipTool, " ***** Test Step 415 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_415(); break; case 416: ChipLogProgress(chipTool, - " ***** Test Step 416 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_416(); + " ***** Test Step 416 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_416(); break; case 417: - ChipLogProgress(chipTool, - " ***** Test Step 417 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_417(); + ChipLogProgress( + chipTool, " ***** Test Step 417 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_417(); break; case 418: - ChipLogProgress(chipTool, " ***** Test Step 418 : Read nullable range-restricted signed 8-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned8BitInteger_418(); + ChipLogProgress(chipTool, + " ***** Test Step 418 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_418(); break; case 419: - ChipLogProgress(chipTool, - " ***** Test Step 419 : Write min value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_419(); + ChipLogProgress( + chipTool, " ***** Test Step 419 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_419(); break; case 420: ChipLogProgress( chipTool, - " ***** Test Step 420 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_420(); + " ***** Test Step 420 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_420(); break; case 421: ChipLogProgress( - chipTool, - " ***** Test Step 421 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_421(); + chipTool, " ***** Test Step 421 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_421(); break; case 422: ChipLogProgress(chipTool, - " ***** Test Step 422 : Write max value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_422(); + " ***** Test Step 422 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_422(); break; case 423: ChipLogProgress(chipTool, - " ***** Test Step 423 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_423(); + " ***** Test Step 423 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_423(); break; case 424: - ChipLogProgress(chipTool, - " ***** Test Step 424 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_424(); + ChipLogProgress(chipTool, " ***** Test Step 424 : Read nullable range-restricted unsigned 16-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned16BitInteger_424(); break; case 425: ChipLogProgress(chipTool, - " ***** Test Step 425 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_425(); + " ***** Test Step 425 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_425(); break; case 426: - ChipLogProgress(chipTool, - " ***** Test Step 426 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_426(); + ChipLogProgress( + chipTool, + " ***** Test Step 426 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_426(); break; case 427: - ChipLogProgress(chipTool, - " ***** Test Step 427 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_427(); + ChipLogProgress( + chipTool, + " ***** Test Step 427 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_427(); break; case 428: - ChipLogProgress( - chipTool, " ***** Test Step 428 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_428(); + ChipLogProgress(chipTool, + " ***** Test Step 428 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_428(); break; case 429: - ChipLogProgress(chipTool, - " ***** Test Step 429 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_429(); + ChipLogProgress( + chipTool, + " ***** Test Step 429 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_429(); break; case 430: - ChipLogProgress(chipTool, - " ***** Test Step 430 : Write null value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_430(); + ChipLogProgress( + chipTool, " ***** Test Step 430 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_430(); break; case 431: - ChipLogProgress(chipTool, - " ***** Test Step 431 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_431(); + ChipLogProgress( + chipTool, + " ***** Test Step 431 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_431(); break; case 432: - ChipLogProgress(chipTool, " ***** Test Step 432 : Read nullable range-restricted signed 16-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned16BitInteger_432(); + ChipLogProgress( + chipTool, " ***** Test Step 432 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_432(); break; case 433: - ChipLogProgress(chipTool, - " ***** Test Step 433 : Write min value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_433(); + ChipLogProgress( + chipTool, + " ***** Test Step 433 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_433(); break; case 434: ChipLogProgress( chipTool, - " ***** Test Step 434 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_434(); + " ***** Test Step 434 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_434(); break; case 435: ChipLogProgress( chipTool, - " ***** Test Step 435 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_435(); + " ***** Test Step 435 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_435(); break; case 436: ChipLogProgress(chipTool, - " ***** Test Step 436 : Write max value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_436(); + " ***** Test Step 436 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_436(); break; case 437: - ChipLogProgress( - chipTool, " ***** Test Step 437 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_437(); + ChipLogProgress(chipTool, + " ***** Test Step 437 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_437(); break; case 438: - ChipLogProgress(chipTool, - " ***** Test Step 438 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_438(); + ChipLogProgress(chipTool, " ***** Test Step 438 : Read nullable range-restricted signed 8-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned8BitInteger_438(); break; case 439: - ChipLogProgress( - chipTool, " ***** Test Step 439 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_439(); + ChipLogProgress(chipTool, + " ***** Test Step 439 : Write min value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_439(); break; case 440: - ChipLogProgress(chipTool, - " ***** Test Step 440 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_440(); + ChipLogProgress( + chipTool, + " ***** Test Step 440 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_440(); break; case 441: ChipLogProgress( - chipTool, " ***** Test Step 441 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_441(); + chipTool, + " ***** Test Step 441 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_441(); break; case 442: - ChipLogProgress( - chipTool, " ***** Test Step 442 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_442(); + ChipLogProgress(chipTool, + " ***** Test Step 442 : Write max value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_442(); break; case 443: - ChipLogProgress( - chipTool, " ***** Test Step 443 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_443(); + ChipLogProgress(chipTool, + " ***** Test Step 443 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_443(); break; case 444: ChipLogProgress(chipTool, - " ***** Test Step 444 : Write null value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_444(); + " ***** Test Step 444 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_444(); break; case 445: ChipLogProgress(chipTool, - " ***** Test Step 445 : Verify nullable range-restricted signed 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_445(); + " ***** Test Step 445 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_445(); + break; + case 446: + ChipLogProgress(chipTool, + " ***** Test Step 446 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_446(); + break; + case 447: + ChipLogProgress(chipTool, + " ***** Test Step 447 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_447(); + break; + case 448: + ChipLogProgress( + chipTool, " ***** Test Step 448 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_448(); + break; + case 449: + ChipLogProgress(chipTool, + " ***** Test Step 449 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_449(); + break; + case 450: + ChipLogProgress(chipTool, + " ***** Test Step 450 : Write null value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_450(); + break; + case 451: + ChipLogProgress(chipTool, + " ***** Test Step 451 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_451(); + break; + case 452: + ChipLogProgress(chipTool, " ***** Test Step 452 : Read nullable range-restricted signed 16-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned16BitInteger_452(); + break; + case 453: + ChipLogProgress(chipTool, + " ***** Test Step 453 : Write min value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_453(); + break; + case 454: + ChipLogProgress( + chipTool, + " ***** Test Step 454 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_454(); + break; + case 455: + ChipLogProgress( + chipTool, + " ***** Test Step 455 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_455(); + break; + case 456: + ChipLogProgress(chipTool, + " ***** Test Step 456 : Write max value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_456(); + break; + case 457: + ChipLogProgress( + chipTool, " ***** Test Step 457 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_457(); + break; + case 458: + ChipLogProgress(chipTool, + " ***** Test Step 458 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_458(); + break; + case 459: + ChipLogProgress( + chipTool, " ***** Test Step 459 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_459(); + break; + case 460: + ChipLogProgress(chipTool, + " ***** Test Step 460 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_460(); + break; + case 461: + ChipLogProgress( + chipTool, " ***** Test Step 461 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_461(); + break; + case 462: + ChipLogProgress( + chipTool, " ***** Test Step 462 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_462(); + break; + case 463: + ChipLogProgress( + chipTool, " ***** Test Step 463 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_463(); + break; + case 464: + ChipLogProgress(chipTool, + " ***** Test Step 464 : Write null value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_464(); + break; + case 465: + ChipLogProgress(chipTool, + " ***** Test Step 465 : Verify nullable range-restricted signed 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_465(); break; } @@ -36370,7 +36450,7 @@ class TestCluster : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 446; + const uint16_t mTestCount = 466; typedef void (*Test_TestCluster_list_int8u_ReportCallback)(void * context, const chip::app::DataModel::DecodableList & value); @@ -37945,10 +38025,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_206(status); } - static void OnSuccessCallback_206(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_206(nullableInt8u); - } + static void OnSuccessCallback_206(void * context) { (static_cast(context))->OnSuccessResponse_206(); } static void OnFailureCallback_207(void * context, EmberAfStatus status) { @@ -37965,7 +38042,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_208(status); } - static void OnSuccessCallback_208(void * context) { (static_cast(context))->OnSuccessResponse_208(); } + static void OnSuccessCallback_208(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_208(nullableInt8u); + } static void OnFailureCallback_209(void * context, EmberAfStatus status) { @@ -37982,26 +38062,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_210(status); } - static void OnSuccessCallback_210(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_210(nullableInt8u); - } + static void OnSuccessCallback_210(void * context) { (static_cast(context))->OnSuccessResponse_210(); } static void OnFailureCallback_211(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_211(status); } - static void OnSuccessCallback_211(void * context) { (static_cast(context))->OnSuccessResponse_211(); } + static void OnSuccessCallback_211(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_211(nullableInt8u); + } static void OnFailureCallback_212(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_212(status); } - static void OnSuccessCallback_212(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + static void OnSuccessCallback_212(void * context, const chip::app::DataModel::Nullable & nullableInt8u) { - (static_cast(context))->OnSuccessResponse_212(nullableInt16u); + (static_cast(context))->OnSuccessResponse_212(nullableInt8u); } static void OnFailureCallback_213(void * context, EmberAfStatus status) @@ -38043,10 +38123,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_217(status); } - static void OnSuccessCallback_217(void * context, const chip::app::DataModel::Nullable & nullableInt16u) - { - (static_cast(context))->OnSuccessResponse_217(nullableInt16u); - } + static void OnSuccessCallback_217(void * context) { (static_cast(context))->OnSuccessResponse_217(); } static void OnFailureCallback_218(void * context, EmberAfStatus status) { @@ -38090,33 +38167,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_222(status); } - static void OnSuccessCallback_222(void * context) { (static_cast(context))->OnSuccessResponse_222(); } + static void OnSuccessCallback_222(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_222(nullableInt16u); + } static void OnFailureCallback_223(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_223(status); } - static void OnSuccessCallback_223(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_223(nullableInt32u); - } + static void OnSuccessCallback_223(void * context) { (static_cast(context))->OnSuccessResponse_223(); } static void OnFailureCallback_224(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_224(status); } - static void OnSuccessCallback_224(void * context) { (static_cast(context))->OnSuccessResponse_224(); } + static void OnSuccessCallback_224(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_224(nullableInt16u); + } static void OnFailureCallback_225(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_225(status); } - static void OnSuccessCallback_225(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + static void OnSuccessCallback_225(void * context, const chip::app::DataModel::Nullable & nullableInt16u) { - (static_cast(context))->OnSuccessResponse_225(nullableInt32u); + (static_cast(context))->OnSuccessResponse_225(nullableInt16u); } static void OnFailureCallback_226(void * context, EmberAfStatus status) @@ -38141,10 +38221,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_228(status); } - static void OnSuccessCallback_228(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_228(nullableInt32u); - } + static void OnSuccessCallback_228(void * context) { (static_cast(context))->OnSuccessResponse_228(); } static void OnFailureCallback_229(void * context, EmberAfStatus status) { @@ -38178,26 +38255,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_232(status); } - static void OnSuccessCallback_232(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_232(nullableInt32u); - } + static void OnSuccessCallback_232(void * context) { (static_cast(context))->OnSuccessResponse_232(); } static void OnFailureCallback_233(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_233(status); } - static void OnSuccessCallback_233(void * context) { (static_cast(context))->OnSuccessResponse_233(); } + static void OnSuccessCallback_233(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_233(nullableInt32u); + } static void OnFailureCallback_234(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_234(status); } - static void OnSuccessCallback_234(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_234(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_234(nullableInt64u); + (static_cast(context))->OnSuccessResponse_234(nullableInt32u); } static void OnFailureCallback_235(void * context, EmberAfStatus status) @@ -38205,33 +38282,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_235(status); } - static void OnSuccessCallback_235(void * context) { (static_cast(context))->OnSuccessResponse_235(); } + static void OnSuccessCallback_235(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_235(nullableInt32u); + } static void OnFailureCallback_236(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_236(status); } - static void OnSuccessCallback_236(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_236(nullableInt64u); - } + static void OnSuccessCallback_236(void * context) { (static_cast(context))->OnSuccessResponse_236(); } static void OnFailureCallback_237(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_237(status); } - static void OnSuccessCallback_237(void * context) { (static_cast(context))->OnSuccessResponse_237(); } + static void OnSuccessCallback_237(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_237(nullableInt32u); + } static void OnFailureCallback_238(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_238(status); } - static void OnSuccessCallback_238(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_238(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_238(nullableInt64u); + (static_cast(context))->OnSuccessResponse_238(nullableInt32u); } static void OnFailureCallback_239(void * context, EmberAfStatus status) @@ -38239,10 +38319,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_239(status); } - static void OnSuccessCallback_239(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_239(nullableInt64u); - } + static void OnSuccessCallback_239(void * context) { (static_cast(context))->OnSuccessResponse_239(); } static void OnFailureCallback_240(void * context, EmberAfStatus status) { @@ -38276,43 +38353,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_243(status); } - static void OnSuccessCallback_243(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_243(nullableInt64u); - } + 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 & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_244(nullableInt64u); + } 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 & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_245(nullableInt8s); - } + static void OnSuccessCallback_245(void * context) { (static_cast(context))->OnSuccessResponse_245(); } static void OnFailureCallback_246(void * context, EmberAfStatus status) { (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 & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_246(nullableInt64u); + } 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 & nullableInt8s) + static void OnSuccessCallback_247(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_247(nullableInt8s); + (static_cast(context))->OnSuccessResponse_247(nullableInt64u); } static void OnFailureCallback_248(void * context, EmberAfStatus status) @@ -38320,26 +38397,26 @@ class TestCluster : public TestCommand (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 & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_248(nullableInt64u); + } 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 & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_249(nullableInt8s); - } + static void OnSuccessCallback_249(void * context) { (static_cast(context))->OnSuccessResponse_249(); } static void OnFailureCallback_250(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_250(status); } - static void OnSuccessCallback_250(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_250(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_250(nullableInt8s); + (static_cast(context))->OnSuccessResponse_250(nullableInt64u); } static void OnFailureCallback_251(void * context, EmberAfStatus status) @@ -38347,9 +38424,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_251(status); } - static void OnSuccessCallback_251(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_251(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_251(nullableInt8s); + (static_cast(context))->OnSuccessResponse_251(nullableInt64u); } static void OnFailureCallback_252(void * context, EmberAfStatus status) @@ -38374,43 +38451,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_254(status); } - static void OnSuccessCallback_254(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_254(nullableInt8s); - } + static void OnSuccessCallback_254(void * context) { (static_cast(context))->OnSuccessResponse_254(); } static void OnFailureCallback_255(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_255(status); } - static void OnSuccessCallback_255(void * context) { (static_cast(context))->OnSuccessResponse_255(); } + static void OnSuccessCallback_255(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_255(nullableInt8s); + } static void OnFailureCallback_256(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_256(status); } - static void OnSuccessCallback_256(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_256(nullableInt16s); - } + static void OnSuccessCallback_256(void * context) { (static_cast(context))->OnSuccessResponse_256(); } static void OnFailureCallback_257(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_257(status); } - static void OnSuccessCallback_257(void * context) { (static_cast(context))->OnSuccessResponse_257(); } + static void OnSuccessCallback_257(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_257(nullableInt8s); + } static void OnFailureCallback_258(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_258(status); } - static void OnSuccessCallback_258(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_258(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_258(nullableInt16s); + (static_cast(context))->OnSuccessResponse_258(nullableInt8s); } static void OnFailureCallback_259(void * context, EmberAfStatus status) @@ -38418,26 +38495,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_259(status); } - static void OnSuccessCallback_259(void * context) { (static_cast(context))->OnSuccessResponse_259(); } + static void OnSuccessCallback_259(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_259(nullableInt8s); + } static void OnFailureCallback_260(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_260(status); } - static void OnSuccessCallback_260(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_260(nullableInt16s); - } + static void OnSuccessCallback_260(void * context) { (static_cast(context))->OnSuccessResponse_260(); } 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 & nullableInt16s) + static void OnSuccessCallback_261(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_261(nullableInt16s); + (static_cast(context))->OnSuccessResponse_261(nullableInt8s); } static void OnFailureCallback_262(void * context, EmberAfStatus status) @@ -38445,9 +38522,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_262(status); } - static void OnSuccessCallback_262(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_262(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_262(nullableInt16s); + (static_cast(context))->OnSuccessResponse_262(nullableInt8s); } static void OnFailureCallback_263(void * context, EmberAfStatus status) @@ -38472,43 +38549,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_265(status); } - static void OnSuccessCallback_265(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_265(nullableInt16s); - } + 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 & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_266(nullableInt16s); + } 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 & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_267(nullableInt32s); - } + static void OnSuccessCallback_267(void * context) { (static_cast(context))->OnSuccessResponse_267(); } static void OnFailureCallback_268(void * context, EmberAfStatus status) { (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 & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_268(nullableInt16s); + } 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 & nullableInt32s) + static void OnSuccessCallback_269(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_269(nullableInt32s); + (static_cast(context))->OnSuccessResponse_269(nullableInt16s); } static void OnFailureCallback_270(void * context, EmberAfStatus status) @@ -38516,26 +38593,26 @@ class TestCluster : public TestCommand (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 & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_270(nullableInt16s); + } 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 & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_271(nullableInt32s); - } + static void OnSuccessCallback_271(void * context) { (static_cast(context))->OnSuccessResponse_271(); } static void OnFailureCallback_272(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_272(status); } - static void OnSuccessCallback_272(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_272(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_272(nullableInt32s); + (static_cast(context))->OnSuccessResponse_272(nullableInt16s); } static void OnFailureCallback_273(void * context, EmberAfStatus status) @@ -38543,9 +38620,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_273(status); } - static void OnSuccessCallback_273(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_273(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_273(nullableInt32s); + (static_cast(context))->OnSuccessResponse_273(nullableInt16s); } static void OnFailureCallback_274(void * context, EmberAfStatus status) @@ -38570,43 +38647,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_276(status); } - static void OnSuccessCallback_276(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_276(nullableInt32s); - } + static void OnSuccessCallback_276(void * context) { (static_cast(context))->OnSuccessResponse_276(); } static void OnFailureCallback_277(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_277(status); } - static void OnSuccessCallback_277(void * context) { (static_cast(context))->OnSuccessResponse_277(); } + static void OnSuccessCallback_277(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_277(nullableInt32s); + } static void OnFailureCallback_278(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_278(status); } - static void OnSuccessCallback_278(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_278(nullableInt64s); - } + static void OnSuccessCallback_278(void * context) { (static_cast(context))->OnSuccessResponse_278(); } static void OnFailureCallback_279(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_279(status); } - static void OnSuccessCallback_279(void * context) { (static_cast(context))->OnSuccessResponse_279(); } + static void OnSuccessCallback_279(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_279(nullableInt32s); + } static void OnFailureCallback_280(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_280(status); } - static void OnSuccessCallback_280(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_280(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_280(nullableInt64s); + (static_cast(context))->OnSuccessResponse_280(nullableInt32s); } static void OnFailureCallback_281(void * context, EmberAfStatus status) @@ -38614,26 +38691,26 @@ class TestCluster : public TestCommand (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 & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_281(nullableInt32s); + } 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 & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_282(nullableInt64s); - } + 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, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_283(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_283(nullableInt64s); + (static_cast(context))->OnSuccessResponse_283(nullableInt32s); } static void OnFailureCallback_284(void * context, EmberAfStatus status) @@ -38641,9 +38718,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_284(status); } - static void OnSuccessCallback_284(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_284(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_284(nullableInt64s); + (static_cast(context))->OnSuccessResponse_284(nullableInt32s); } static void OnFailureCallback_285(void * context, EmberAfStatus status) @@ -38668,43 +38745,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_287(status); } - static void OnSuccessCallback_287(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_287(nullableInt64s); - } + static void OnSuccessCallback_287(void * context) { (static_cast(context))->OnSuccessResponse_287(); } static void OnFailureCallback_288(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_288(status); } - static void OnSuccessCallback_288(void * context) { (static_cast(context))->OnSuccessResponse_288(); } + static void OnSuccessCallback_288(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_288(nullableInt64s); + } static void OnFailureCallback_289(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_289(status); } - static void OnSuccessCallback_289(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) - { - (static_cast(context))->OnSuccessResponse_289(nullableFloatSingle); - } + static void OnSuccessCallback_289(void * context) { (static_cast(context))->OnSuccessResponse_289(); } static void OnFailureCallback_290(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_290(status); } - static void OnSuccessCallback_290(void * context) { (static_cast(context))->OnSuccessResponse_290(); } + static void OnSuccessCallback_290(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_290(nullableInt64s); + } static void OnFailureCallback_291(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_291(status); } - static void OnSuccessCallback_291(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_291(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_291(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_291(nullableInt64s); } static void OnFailureCallback_292(void * context, EmberAfStatus status) @@ -38712,33 +38789,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_292(status); } - static void OnSuccessCallback_292(void * context) { (static_cast(context))->OnSuccessResponse_292(); } + static void OnSuccessCallback_292(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_292(nullableInt64s); + } static void OnFailureCallback_293(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_293(status); } - static void OnSuccessCallback_293(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) - { - (static_cast(context))->OnSuccessResponse_293(nullableFloatSingle); - } + static void OnSuccessCallback_293(void * context) { (static_cast(context))->OnSuccessResponse_293(); } static void OnFailureCallback_294(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_294(status); } - static void OnSuccessCallback_294(void * context) { (static_cast(context))->OnSuccessResponse_294(); } + static void OnSuccessCallback_294(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_294(nullableInt64s); + } static void OnFailureCallback_295(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_295(status); } - static void OnSuccessCallback_295(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_295(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_295(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_295(nullableInt64s); } static void OnFailureCallback_296(void * context, EmberAfStatus status) @@ -38770,9 +38850,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_299(status); } - static void OnSuccessCallback_299(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_299(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_299(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_299(nullableFloatSingle); } static void OnFailureCallback_300(void * context, EmberAfStatus status) @@ -38787,9 +38867,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_301(status); } - static void OnSuccessCallback_301(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_301(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_301(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_301(nullableFloatSingle); } static void OnFailureCallback_302(void * context, EmberAfStatus status) @@ -38804,9 +38884,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_303(status); } - static void OnSuccessCallback_303(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_303(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_303(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_303(nullableFloatSingle); } static void OnFailureCallback_304(void * context, EmberAfStatus status) @@ -38821,9 +38901,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_305(status); } - static void OnSuccessCallback_305(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_305(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_305(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_305(nullableFloatSingle); } static void OnFailureCallback_306(void * context, EmberAfStatus status) @@ -38855,9 +38935,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_309(status); } - static void OnSuccessCallback_309(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_309(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_309(nullableEnum8); + (static_cast(context))->OnSuccessResponse_309(nullableFloatDouble); } static void OnFailureCallback_310(void * context, EmberAfStatus status) @@ -38872,9 +38952,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_311(status); } - static void OnSuccessCallback_311(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_311(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_311(nullableEnum8); + (static_cast(context))->OnSuccessResponse_311(nullableFloatDouble); } static void OnFailureCallback_312(void * context, EmberAfStatus status) @@ -38889,9 +38969,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_313(status); } - static void OnSuccessCallback_313(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_313(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_313(nullableEnum8); + (static_cast(context))->OnSuccessResponse_313(nullableFloatDouble); } static void OnFailureCallback_314(void * context, EmberAfStatus status) @@ -38906,9 +38986,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_315(status); } - static void OnSuccessCallback_315(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_315(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_315(nullableEnum16); + (static_cast(context))->OnSuccessResponse_315(nullableFloatDouble); } static void OnFailureCallback_316(void * context, EmberAfStatus status) @@ -38923,9 +39003,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_317(status); } - static void OnSuccessCallback_317(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_317(void * context, const chip::app::DataModel::Nullable & nullableEnum8) { - (static_cast(context))->OnSuccessResponse_317(nullableEnum16); + (static_cast(context))->OnSuccessResponse_317(nullableEnum8); } static void OnFailureCallback_318(void * context, EmberAfStatus status) @@ -38940,9 +39020,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_319(status); } - static void OnSuccessCallback_319(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_319(void * context, const chip::app::DataModel::Nullable & nullableEnum8) { - (static_cast(context))->OnSuccessResponse_319(nullableEnum16); + (static_cast(context))->OnSuccessResponse_319(nullableEnum8); } static void OnFailureCallback_320(void * context, EmberAfStatus status) @@ -38950,70 +39030,67 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_320(status); } - static void OnSuccessCallback_320(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_320(nullableOctetString); - } + static void OnSuccessCallback_320(void * context) { (static_cast(context))->OnSuccessResponse_320(); } static void OnFailureCallback_321(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_321(status); } - static void OnSuccessCallback_321(void * context) { (static_cast(context))->OnSuccessResponse_321(); } + static void OnSuccessCallback_321(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_321(nullableEnum8); + } static void OnFailureCallback_322(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_322(status); } - static void OnSuccessCallback_322(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_322(nullableOctetString); - } + static void OnSuccessCallback_322(void * context) { (static_cast(context))->OnSuccessResponse_322(); } static void OnFailureCallback_323(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_323(status); } - static void OnSuccessCallback_323(void * context) { (static_cast(context))->OnSuccessResponse_323(); } + static void OnSuccessCallback_323(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_323(nullableEnum8); + } static void OnFailureCallback_324(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_324(status); } - static void OnSuccessCallback_324(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_324(nullableOctetString); - } + static void OnSuccessCallback_324(void * context) { (static_cast(context))->OnSuccessResponse_324(); } static void OnFailureCallback_325(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_325(status); } - static void OnSuccessCallback_325(void * context) { (static_cast(context))->OnSuccessResponse_325(); } + static void OnSuccessCallback_325(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_325(nullableEnum16); + } static void OnFailureCallback_326(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_326(status); } - static void OnSuccessCallback_326(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_326(nullableOctetString); - } + static void OnSuccessCallback_326(void * context) { (static_cast(context))->OnSuccessResponse_326(); } static void OnFailureCallback_327(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_327(status); } - static void OnSuccessCallback_327(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_327(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_327(nullableCharString); + (static_cast(context))->OnSuccessResponse_327(nullableEnum16); } static void OnFailureCallback_328(void * context, EmberAfStatus status) @@ -39028,9 +39105,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_329(status); } - static void OnSuccessCallback_329(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_329(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_329(nullableCharString); + (static_cast(context))->OnSuccessResponse_329(nullableEnum16); } static void OnFailureCallback_330(void * context, EmberAfStatus status) @@ -39045,9 +39122,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_331(status); } - static void OnSuccessCallback_331(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_331(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_331(nullableCharString); + (static_cast(context))->OnSuccessResponse_331(nullableEnum16); } static void OnFailureCallback_332(void * context, EmberAfStatus status) @@ -39062,9 +39139,11 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_333(status); } - static void OnSuccessCallback_333(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void + OnSuccessCallback_333(void * context, + const chip::app::DataModel::Nullable & nullableEnumAttr) { - (static_cast(context))->OnSuccessResponse_333(nullableCharString); + (static_cast(context))->OnSuccessResponse_333(nullableEnumAttr); } static void OnFailureCallback_334(void * context, EmberAfStatus status) @@ -39072,46 +39151,56 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_334(status); } - static void OnSuccessCallback_334(void * context, const chip::app::DataModel::DecodableList & listInt8u) - { - (static_cast(context))->OnSuccessResponse_334(listInt8u); - } + static void OnSuccessCallback_334(void * context) { (static_cast(context))->OnSuccessResponse_334(); } static void OnFailureCallback_335(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_335(status); } - static void OnSuccessCallback_335(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void + OnSuccessCallback_335(void * context, + const chip::app::DataModel::Nullable & nullableEnumAttr) { - (static_cast(context))->OnSuccessResponse_335(listInt8u); + (static_cast(context))->OnSuccessResponse_335(nullableEnumAttr); } - static void OnFailureCallback_338(void * context, EmberAfStatus status) + static void OnFailureCallback_336(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_338(status); + (static_cast(context))->OnFailureResponse_336(status); } - static void OnSuccessCallback_338(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_336(void * context) { (static_cast(context))->OnSuccessResponse_336(); } + + static void OnFailureCallback_337(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_338(listInt8u); + (static_cast(context))->OnFailureResponse_337(status); } - bool mReceivedReport_338 = false; - - static void OnFailureCallback_339(void * context, EmberAfStatus status) + static void + OnSuccessCallback_337(void * context, + const chip::app::DataModel::Nullable & nullableEnumAttr) { - (static_cast(context))->OnFailureResponse_339(status); + (static_cast(context))->OnSuccessResponse_337(nullableEnumAttr); + } + + static void OnFailureCallback_338(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_338(status); } - static void OnSuccessCallback_339(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_338(void * context) { (static_cast(context))->OnSuccessResponse_338(); } + + static void OnFailureCallback_339(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_339(listInt8u); + (static_cast(context))->OnFailureResponse_339(status); } - static void OnSubscriptionEstablished_339(void * context) + static void + OnSuccessCallback_339(void * context, + const chip::app::DataModel::Nullable & nullableEnumAttr) { - (static_cast(context))->OnSubscriptionEstablishedResponse_339(); + (static_cast(context))->OnSuccessResponse_339(nullableEnumAttr); } static void OnFailureCallback_340(void * context, EmberAfStatus status) @@ -39119,28 +39208,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_340(status); } - static void OnSuccessCallback_340(void * context) { (static_cast(context))->OnSuccessResponse_340(); } - - static void OnFailureCallback_341(void * context, EmberAfStatus status) + static void OnSuccessCallback_340(void * context, const chip::app::DataModel::Nullable & nullableOctetString) { - (static_cast(context))->OnFailureResponse_341(status); + (static_cast(context))->OnSuccessResponse_340(nullableOctetString); } - static void OnSuccessCallback_341(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnFailureCallback_341(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_341(listInt8u); + (static_cast(context))->OnFailureResponse_341(status); } - bool mReceivedReport_341 = false; + static void OnSuccessCallback_341(void * context) { (static_cast(context))->OnSuccessResponse_341(); } static void OnFailureCallback_342(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_342(status); } - static void OnSuccessCallback_342(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_342(void * context, const chip::app::DataModel::Nullable & nullableOctetString) { - (static_cast(context))->OnSuccessResponse_342(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_342(nullableOctetString); } static void OnFailureCallback_343(void * context, EmberAfStatus status) @@ -39155,7 +39242,10 @@ 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, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_344(nullableOctetString); + } static void OnFailureCallback_345(void * context, EmberAfStatus status) { @@ -39169,16 +39259,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_346(status); } - static void OnSuccessCallback_346(void * context) { (static_cast(context))->OnSuccessResponse_346(); } + static void OnSuccessCallback_346(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_346(nullableOctetString); + } static void OnFailureCallback_347(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_347(status); } - static void OnSuccessCallback_347(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_347(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_347(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_347(nullableCharString); } static void OnFailureCallback_348(void * context, EmberAfStatus status) @@ -39193,9 +39286,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_349(status); } - static void OnSuccessCallback_349(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_349(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_349(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_349(nullableCharString); } static void OnFailureCallback_350(void * context, EmberAfStatus status) @@ -39210,9 +39303,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_351(status); } - static void OnSuccessCallback_351(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_351(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_351(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_351(nullableCharString); } static void OnFailureCallback_352(void * context, EmberAfStatus status) @@ -39227,9 +39320,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_353(status); } - static void OnSuccessCallback_353(void * context, uint8_t rangeRestrictedInt8u) + static void OnSuccessCallback_353(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_353(rangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_353(nullableCharString); } static void OnFailureCallback_354(void * context, EmberAfStatus status) @@ -39237,9 +39330,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_354(status); } - static void OnSuccessCallback_354(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_354(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_354(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_354(listInt8u); } static void OnFailureCallback_355(void * context, EmberAfStatus status) @@ -39247,37 +39340,36 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_355(status); } - static void OnSuccessCallback_355(void * context) { (static_cast(context))->OnSuccessResponse_355(); } - - static void OnFailureCallback_356(void * context, EmberAfStatus status) + static void OnSuccessCallback_355(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnFailureResponse_356(status); + (static_cast(context))->OnSuccessResponse_355(listInt8u); } - static void OnSuccessCallback_356(void * context) { (static_cast(context))->OnSuccessResponse_356(); } - - static void OnFailureCallback_357(void * context, EmberAfStatus status) + static void OnFailureCallback_358(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_357(status); + (static_cast(context))->OnFailureResponse_358(status); } - static void OnSuccessCallback_357(void * context) { (static_cast(context))->OnSuccessResponse_357(); } - - static void OnFailureCallback_358(void * context, EmberAfStatus status) + static void OnSuccessCallback_358(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnFailureResponse_358(status); + (static_cast(context))->OnSuccessResponse_358(listInt8u); } - static void OnSuccessCallback_358(void * context) { (static_cast(context))->OnSuccessResponse_358(); } + bool mReceivedReport_358 = false; static void OnFailureCallback_359(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_359(status); } - static void OnSuccessCallback_359(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_359(void * context, const chip::app::DataModel::DecodableList & listInt8u) + { + (static_cast(context))->OnSuccessResponse_359(listInt8u); + } + + static void OnSubscriptionEstablished_359(void * context) { - (static_cast(context))->OnSuccessResponse_359(rangeRestrictedInt16u); + (static_cast(context))->OnSubscriptionEstablishedResponse_359(); } static void OnFailureCallback_360(void * context, EmberAfStatus status) @@ -39292,27 +39384,29 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_361(status); } - static void OnSuccessCallback_361(void * context, uint16_t rangeRestrictedInt16u) + static void OnSuccessCallback_361(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_361(rangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_361(listInt8u); } + bool mReceivedReport_361 = false; + static void OnFailureCallback_362(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_362(status); } - static void OnSuccessCallback_362(void * context) { (static_cast(context))->OnSuccessResponse_362(); } + static void OnSuccessCallback_362(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_362(rangeRestrictedInt8u); + } static void OnFailureCallback_363(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_363(status); } - static void OnSuccessCallback_363(void * context, uint16_t rangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_363(rangeRestrictedInt16u); - } + static void OnSuccessCallback_363(void * context) { (static_cast(context))->OnSuccessResponse_363(); } static void OnFailureCallback_364(void * context, EmberAfStatus status) { @@ -39326,27 +39420,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_365(status); } - static void OnSuccessCallback_365(void * context, uint16_t rangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_365(rangeRestrictedInt16u); - } + static void OnSuccessCallback_365(void * context) { (static_cast(context))->OnSuccessResponse_365(); } static void OnFailureCallback_366(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_366(status); } - static void OnSuccessCallback_366(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_366(rangeRestrictedInt8s); - } + static void OnSuccessCallback_366(void * context) { (static_cast(context))->OnSuccessResponse_366(); } static void OnFailureCallback_367(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_367(status); } - static void OnSuccessCallback_367(void * context) { (static_cast(context))->OnSuccessResponse_367(); } + static void OnSuccessCallback_367(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_367(rangeRestrictedInt8u); + } static void OnFailureCallback_368(void * context, EmberAfStatus status) { @@ -39360,7 +39451,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_369(status); } - static void OnSuccessCallback_369(void * context) { (static_cast(context))->OnSuccessResponse_369(); } + static void OnSuccessCallback_369(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_369(rangeRestrictedInt8u); + } static void OnFailureCallback_370(void * context, EmberAfStatus status) { @@ -39374,9 +39468,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_371(status); } - static void OnSuccessCallback_371(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_371(void * context, uint8_t rangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_371(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_371(rangeRestrictedInt8u); } static void OnFailureCallback_372(void * context, EmberAfStatus status) @@ -39391,9 +39485,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_373(status); } - static void OnSuccessCallback_373(void * context, int8_t rangeRestrictedInt8s) + static void OnSuccessCallback_373(void * context, uint8_t rangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_373(rangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_373(rangeRestrictedInt8u); } static void OnFailureCallback_374(void * context, EmberAfStatus status) @@ -39401,17 +39495,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_374(status); } - static void OnSuccessCallback_374(void * context) { (static_cast(context))->OnSuccessResponse_374(); } + static void OnSuccessCallback_374(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_374(rangeRestrictedInt16u); + } static void OnFailureCallback_375(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_375(status); } - static void OnSuccessCallback_375(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_375(rangeRestrictedInt8s); - } + static void OnSuccessCallback_375(void * context) { (static_cast(context))->OnSuccessResponse_375(); } static void OnFailureCallback_376(void * context, EmberAfStatus status) { @@ -39425,27 +39519,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_377(status); } - static void OnSuccessCallback_377(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_377(rangeRestrictedInt8s); - } + static void OnSuccessCallback_377(void * context) { (static_cast(context))->OnSuccessResponse_377(); } static void OnFailureCallback_378(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_378(status); } - static void OnSuccessCallback_378(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_378(rangeRestrictedInt16s); - } + 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, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_379(rangeRestrictedInt16u); + } static void OnFailureCallback_380(void * context, EmberAfStatus status) { @@ -39459,7 +39550,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_381(status); } - static void OnSuccessCallback_381(void * context) { (static_cast(context))->OnSuccessResponse_381(); } + static void OnSuccessCallback_381(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_381(rangeRestrictedInt16u); + } static void OnFailureCallback_382(void * context, EmberAfStatus status) { @@ -39473,9 +39567,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_383(status); } - static void OnSuccessCallback_383(void * context, int16_t rangeRestrictedInt16s) + static void OnSuccessCallback_383(void * context, uint16_t rangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_383(rangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_383(rangeRestrictedInt16u); } static void OnFailureCallback_384(void * context, EmberAfStatus status) @@ -39490,9 +39584,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_385(status); } - static void OnSuccessCallback_385(void * context, int16_t rangeRestrictedInt16s) + static void OnSuccessCallback_385(void * context, uint16_t rangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_385(rangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_385(rangeRestrictedInt16u); } static void OnFailureCallback_386(void * context, EmberAfStatus status) @@ -39500,17 +39594,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_386(status); } - static void OnSuccessCallback_386(void * context) { (static_cast(context))->OnSuccessResponse_386(); } + static void OnSuccessCallback_386(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_386(rangeRestrictedInt8s); + } static void OnFailureCallback_387(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_387(status); } - static void OnSuccessCallback_387(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_387(rangeRestrictedInt16s); - } + static void OnSuccessCallback_387(void * context) { (static_cast(context))->OnSuccessResponse_387(); } static void OnFailureCallback_388(void * context, EmberAfStatus status) { @@ -39524,27 +39618,24 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_389(status); } - static void OnSuccessCallback_389(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_389(rangeRestrictedInt16s); - } + static void OnSuccessCallback_389(void * context) { (static_cast(context))->OnSuccessResponse_389(); } static void OnFailureCallback_390(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_390(status); } - static void OnSuccessCallback_390(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_390(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_390(void * context) { (static_cast(context))->OnSuccessResponse_390(); } static void OnFailureCallback_391(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_391(status); } - static void OnSuccessCallback_391(void * context) { (static_cast(context))->OnSuccessResponse_391(); } + static void OnSuccessCallback_391(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_391(rangeRestrictedInt8s); + } static void OnFailureCallback_392(void * context, EmberAfStatus status) { @@ -39558,7 +39649,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_393(status); } - static void OnSuccessCallback_393(void * context) { (static_cast(context))->OnSuccessResponse_393(); } + static void OnSuccessCallback_393(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_393(rangeRestrictedInt8s); + } static void OnFailureCallback_394(void * context, EmberAfStatus status) { @@ -39572,9 +39666,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_395(status); } - static void OnSuccessCallback_395(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_395(void * context, int8_t rangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_395(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_395(rangeRestrictedInt8s); } static void OnFailureCallback_396(void * context, EmberAfStatus status) @@ -39589,9 +39683,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_397(status); } - static void OnSuccessCallback_397(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_397(void * context, int8_t rangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_397(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_397(rangeRestrictedInt8s); } static void OnFailureCallback_398(void * context, EmberAfStatus status) @@ -39599,17 +39693,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_398(status); } - static void OnSuccessCallback_398(void * context) { (static_cast(context))->OnSuccessResponse_398(); } + static void OnSuccessCallback_398(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_398(rangeRestrictedInt16s); + } static void OnFailureCallback_399(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_399(status); } - static void OnSuccessCallback_399(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_399(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_399(void * context) { (static_cast(context))->OnSuccessResponse_399(); } static void OnFailureCallback_400(void * context, EmberAfStatus status) { @@ -39623,10 +39717,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_401(status); } - static void OnSuccessCallback_401(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_401(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_401(void * context) { (static_cast(context))->OnSuccessResponse_401(); } static void OnFailureCallback_402(void * context, EmberAfStatus status) { @@ -39640,9 +39731,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_403(status); } - static void OnSuccessCallback_403(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + static void OnSuccessCallback_403(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_403(nullableRangeRestrictedInt8u); + (static_cast(context))->OnSuccessResponse_403(rangeRestrictedInt16s); } static void OnFailureCallback_404(void * context, EmberAfStatus status) @@ -39650,18 +39741,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_404(status); } - static void OnSuccessCallback_404(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_404(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_404(void * context) { (static_cast(context))->OnSuccessResponse_404(); } static void OnFailureCallback_405(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_405(status); } - static void OnSuccessCallback_405(void * context) { (static_cast(context))->OnSuccessResponse_405(); } + static void OnSuccessCallback_405(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_405(rangeRestrictedInt16s); + } static void OnFailureCallback_406(void * context, EmberAfStatus status) { @@ -39675,7 +39765,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_407(status); } - static void OnSuccessCallback_407(void * context) { (static_cast(context))->OnSuccessResponse_407(); } + static void OnSuccessCallback_407(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_407(rangeRestrictedInt16s); + } static void OnFailureCallback_408(void * context, EmberAfStatus status) { @@ -39689,10 +39782,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_409(status); } - static void OnSuccessCallback_409(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_409(void * context, int16_t rangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_409(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_409(rangeRestrictedInt16s); } static void OnFailureCallback_410(void * context, EmberAfStatus status) @@ -39700,18 +39792,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_410(status); } - static void OnSuccessCallback_410(void * context) { (static_cast(context))->OnSuccessResponse_410(); } + static void OnSuccessCallback_410(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_410(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_411(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_411(status); } - static void OnSuccessCallback_411(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_411(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_411(void * context) { (static_cast(context))->OnSuccessResponse_411(); } static void OnFailureCallback_412(void * context, EmberAfStatus status) { @@ -39725,11 +39816,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_413(status); } - static void OnSuccessCallback_413(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_413(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_413(void * context) { (static_cast(context))->OnSuccessResponse_413(); } static void OnFailureCallback_414(void * context, EmberAfStatus status) { @@ -39743,10 +39830,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_415(status); } - static void OnSuccessCallback_415(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_415(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_415(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_415(nullableRangeRestrictedInt8u); } static void OnFailureCallback_416(void * context, EmberAfStatus status) @@ -39761,10 +39847,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_417(status); } - static void OnSuccessCallback_417(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + static void OnSuccessCallback_417(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_417(nullableRangeRestrictedInt16u); + (static_cast(context))->OnSuccessResponse_417(nullableRangeRestrictedInt8u); } static void OnFailureCallback_418(void * context, EmberAfStatus status) @@ -39772,17 +39857,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_418(status); } - static void OnSuccessCallback_418(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_418(nullableRangeRestrictedInt8s); - } + 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) { (static_cast(context))->OnSuccessResponse_419(); } + static void OnSuccessCallback_419(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_419(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_420(void * context, EmberAfStatus status) { @@ -39796,7 +39881,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_421(status); } - static void OnSuccessCallback_421(void * context) { (static_cast(context))->OnSuccessResponse_421(); } + static void OnSuccessCallback_421(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_421(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_422(void * context, EmberAfStatus status) { @@ -39810,9 +39898,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_423(status); } - static void OnSuccessCallback_423(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_423(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { - (static_cast(context))->OnSuccessResponse_423(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_423(nullableRangeRestrictedInt8u); } static void OnFailureCallback_424(void * context, EmberAfStatus status) @@ -39820,17 +39908,18 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_424(status); } - static void OnSuccessCallback_424(void * context) { (static_cast(context))->OnSuccessResponse_424(); } + static void OnSuccessCallback_424(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_424(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_425(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_425(status); } - static void OnSuccessCallback_425(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_425(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_425(void * context) { (static_cast(context))->OnSuccessResponse_425(); } static void OnFailureCallback_426(void * context, EmberAfStatus status) { @@ -39844,10 +39933,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_427(status); } - static void OnSuccessCallback_427(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_427(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_427(void * context) { (static_cast(context))->OnSuccessResponse_427(); } static void OnFailureCallback_428(void * context, EmberAfStatus status) { @@ -39861,9 +39947,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_429(status); } - static void OnSuccessCallback_429(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_429(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_429(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_429(nullableRangeRestrictedInt16u); } static void OnFailureCallback_430(void * context, EmberAfStatus status) @@ -39878,9 +39965,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_431(status); } - static void OnSuccessCallback_431(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + static void OnSuccessCallback_431(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_431(nullableRangeRestrictedInt8s); + (static_cast(context))->OnSuccessResponse_431(nullableRangeRestrictedInt16u); } static void OnFailureCallback_432(void * context, EmberAfStatus status) @@ -39888,17 +39976,18 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_432(status); } - static void OnSuccessCallback_432(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_432(nullableRangeRestrictedInt16s); - } + 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) { (static_cast(context))->OnSuccessResponse_433(); } + static void OnSuccessCallback_433(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_433(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_434(void * context, EmberAfStatus status) { @@ -39912,7 +40001,11 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_435(status); } - static void OnSuccessCallback_435(void * context) { (static_cast(context))->OnSuccessResponse_435(); } + static void OnSuccessCallback_435(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_435(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_436(void * context, EmberAfStatus status) { @@ -39926,9 +40019,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_437(status); } - static void OnSuccessCallback_437(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_437(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { - (static_cast(context))->OnSuccessResponse_437(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_437(nullableRangeRestrictedInt16u); } static void OnFailureCallback_438(void * context, EmberAfStatus status) @@ -39936,17 +40030,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_438(status); } - static void OnSuccessCallback_438(void * context) { (static_cast(context))->OnSuccessResponse_438(); } + static void OnSuccessCallback_438(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_438(nullableRangeRestrictedInt8s); + } static void OnFailureCallback_439(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_439(status); } - static void OnSuccessCallback_439(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_439(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_439(void * context) { (static_cast(context))->OnSuccessResponse_439(); } static void OnFailureCallback_440(void * context, EmberAfStatus status) { @@ -39960,10 +40054,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_441(status); } - static void OnSuccessCallback_441(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_441(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_441(void * context) { (static_cast(context))->OnSuccessResponse_441(); } static void OnFailureCallback_442(void * context, EmberAfStatus status) { @@ -39977,9 +40068,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_443(status); } - static void OnSuccessCallback_443(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_443(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { - (static_cast(context))->OnSuccessResponse_443(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_443(nullableRangeRestrictedInt8s); } static void OnFailureCallback_444(void * context, EmberAfStatus status) @@ -39994,9 +40085,176 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_445(status); } - static void OnSuccessCallback_445(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + static void OnSuccessCallback_445(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_445(nullableRangeRestrictedInt8s); + } + + static void OnFailureCallback_446(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_446(status); + } + + static void OnSuccessCallback_446(void * context) { (static_cast(context))->OnSuccessResponse_446(); } + + static void OnFailureCallback_447(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_447(status); + } + + static void OnSuccessCallback_447(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_447(nullableRangeRestrictedInt8s); + } + + static void OnFailureCallback_448(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_448(status); + } + + static void OnSuccessCallback_448(void * context) { (static_cast(context))->OnSuccessResponse_448(); } + + static void OnFailureCallback_449(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_449(status); + } + + static void OnSuccessCallback_449(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_449(nullableRangeRestrictedInt8s); + } + + static void OnFailureCallback_450(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_450(status); + } + + static void OnSuccessCallback_450(void * context) { (static_cast(context))->OnSuccessResponse_450(); } + + static void OnFailureCallback_451(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_451(status); + } + + static void OnSuccessCallback_451(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_451(nullableRangeRestrictedInt8s); + } + + static void OnFailureCallback_452(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_452(status); + } + + static void OnSuccessCallback_452(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_452(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_453(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_453(status); + } + + static void OnSuccessCallback_453(void * context) { (static_cast(context))->OnSuccessResponse_453(); } + + static void OnFailureCallback_454(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_454(status); + } + + static void OnSuccessCallback_454(void * context) { (static_cast(context))->OnSuccessResponse_454(); } + + static void OnFailureCallback_455(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_455(status); + } + + static void OnSuccessCallback_455(void * context) { (static_cast(context))->OnSuccessResponse_455(); } + + static void OnFailureCallback_456(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_456(status); + } + + static void OnSuccessCallback_456(void * context) { (static_cast(context))->OnSuccessResponse_456(); } + + static void OnFailureCallback_457(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_457(status); + } + + static void OnSuccessCallback_457(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_457(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_458(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_458(status); + } + + static void OnSuccessCallback_458(void * context) { (static_cast(context))->OnSuccessResponse_458(); } + + static void OnFailureCallback_459(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_459(status); + } + + static void OnSuccessCallback_459(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_459(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_460(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_460(status); + } + + static void OnSuccessCallback_460(void * context) { (static_cast(context))->OnSuccessResponse_460(); } + + static void OnFailureCallback_461(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_461(status); + } + + static void OnSuccessCallback_461(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_461(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_462(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_462(status); + } + + static void OnSuccessCallback_462(void * context) { (static_cast(context))->OnSuccessResponse_462(); } + + static void OnFailureCallback_463(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_463(status); + } + + static void OnSuccessCallback_463(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { - (static_cast(context))->OnSuccessResponse_445(nullableRangeRestrictedInt16s); + (static_cast(context))->OnSuccessResponse_463(nullableRangeRestrictedInt16s); + } + + static void OnFailureCallback_464(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_464(status); + } + + static void OnSuccessCallback_464(void * context) { (static_cast(context))->OnSuccessResponse_464(); } + + static void OnFailureCallback_465(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_465(status); + } + + static void OnSuccessCallback_465(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_465(nullableRangeRestrictedInt16s); } // @@ -44604,14 +44862,14 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_200() + CHIP_ERROR TestWriteAttributeNullableInt8uMinValue_200() { 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() = 254; + nullableInt8uArgument.SetNonNull() = 0; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt8uArgument, this, OnSuccessCallback_200, OnFailureCallback_200)); @@ -44622,7 +44880,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_200() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_201() + CHIP_ERROR TestReadAttributeNullableInt8uMinValue_201() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44638,34 +44896,30 @@ class TestCluster : public TestCommand void OnSuccessResponse_201(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); - VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); + VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 0)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_202() + CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_202() { 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() = 255; + nullableInt8uArgument.SetNonNull() = 254; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt8uArgument, this, OnSuccessCallback_202, OnFailureCallback_202)); return CHIP_NO_ERROR; } - void OnFailureResponse_202(EmberAfStatus status) - { - VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - NextTest(); - } + void OnFailureResponse_202(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_202() { ThrowSuccessResponse(); } + void OnSuccessResponse_202() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_203() + CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_203() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44686,25 +44940,29 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_204() + CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_204() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableInt8uArgument; - nullableInt8uArgument.SetNull(); + nullableInt8uArgument.SetNonNull() = 255; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt8uArgument, this, OnSuccessCallback_204, OnFailureCallback_204)); return CHIP_NO_ERROR; } - void OnFailureResponse_204(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_204(EmberAfStatus status) + { + VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); + } - void OnSuccessResponse_204() { NextTest(); } + void OnSuccessResponse_204() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValue_205() + CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_205() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44719,32 +44977,31 @@ class TestCluster : public TestCommand void OnSuccessResponse_205(const chip::app::DataModel::Nullable & nullableInt8u) { - VerifyOrReturn(CheckValueNull("nullableInt8u", nullableInt8u)); + VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); + VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValueRange_206() + CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_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)); + chip::app::DataModel::Nullable nullableInt8uArgument; + nullableInt8uArgument.SetNull(); + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt8uArgument, 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(); - } + void OnSuccessResponse_206() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValueNot_207() + CHIP_ERROR TestReadAttributeNullableInt8uNullValue_207() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44759,34 +45016,36 @@ class TestCluster : public TestCommand void OnSuccessResponse_207(const chip::app::DataModel::Nullable & nullableInt8u) { - VerifyOrReturn(CheckConstraintNotValue("nullableInt8u", nullableInt8u, 254)); + VerifyOrReturn(CheckValueNull("nullableInt8u", nullableInt8u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uValue_208() + CHIP_ERROR TestReadAttributeNullableInt8uNullValueRange_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)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_208, OnFailureCallback_208)); return CHIP_NO_ERROR; } void OnFailureResponse_208(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_208() { NextTest(); } - - CHIP_ERROR TestReadAttributeNullableInt8uValueInRange_209() + void OnSuccessResponse_208(const chip::app::DataModel::Nullable & nullableInt8u) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::TestClusterClusterTest cluster; - cluster.Associate(mDevices[kIdentityAlpha], endpoint); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt8u", nullableInt8u, 254)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt8uNullValueNot_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)); @@ -44797,93 +45056,88 @@ class TestCluster : public TestCommand void OnSuccessResponse_209(const chip::app::DataModel::Nullable & nullableInt8u) { - VerifyOrReturn(CheckConstraintMaxValue("nullableInt8u", nullableInt8u, 254)); + VerifyOrReturn(CheckConstraintNotValue("nullableInt8u", nullableInt8u, 254)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNotValueOk_210() + CHIP_ERROR TestWriteAttributeNullableInt8uValue_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)); + chip::app::DataModel::Nullable nullableInt8uArgument; + nullableInt8uArgument.SetNonNull() = 128; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt8uArgument, 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(); - } + void OnSuccessResponse_210() { NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_211() + CHIP_ERROR TestReadAttributeNullableInt8uValueInRange_211() { 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() = 65534U; - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_211, OnFailureCallback_211)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_211, OnFailureCallback_211)); return CHIP_NO_ERROR; } void OnFailureResponse_211(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_211() { NextTest(); } + void OnSuccessResponse_211(const chip::app::DataModel::Nullable & nullableInt8u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt8u", nullableInt8u, 254)); + + NextTest(); + } - CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_212() + CHIP_ERROR TestReadAttributeNullableInt8uNotValueOk_212() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_212, OnFailureCallback_212)); return CHIP_NO_ERROR; } void OnFailureResponse_212(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_212(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_212(const chip::app::DataModel::Nullable & nullableInt8u) { - VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); - VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); + VerifyOrReturn(CheckConstraintNotValue("nullableInt8u", nullableInt8u, 129)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_213() + CHIP_ERROR TestWriteAttributeNullableInt16uMinValue_213() { 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() = 65535U; + nullableInt16uArgument.SetNonNull() = 0U; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt16uArgument, this, OnSuccessCallback_213, OnFailureCallback_213)); return CHIP_NO_ERROR; } - void OnFailureResponse_213(EmberAfStatus status) - { - VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - NextTest(); - } + void OnFailureResponse_213(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_213() { ThrowSuccessResponse(); } + void OnSuccessResponse_213() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_214() + CHIP_ERROR TestReadAttributeNullableInt16uMinValue_214() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44899,19 +45153,19 @@ class TestCluster : public TestCommand void OnSuccessResponse_214(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); - VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 0U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_215() + CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_215() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableInt16uArgument; - nullableInt16uArgument.SetNull(); + nullableInt16uArgument.SetNonNull() = 65534U; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt16uArgument, this, OnSuccessCallback_215, OnFailureCallback_215)); @@ -44922,7 +45176,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_215() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValue_216() + CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_216() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44937,32 +45191,35 @@ class TestCluster : public TestCommand void OnSuccessResponse_216(const chip::app::DataModel::Nullable & nullableInt16u) { - VerifyOrReturn(CheckValueNull("nullableInt16u", nullableInt16u)); + VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); + VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValueRange_217() + CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_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)); + chip::app::DataModel::Nullable nullableInt16uArgument; + nullableInt16uArgument.SetNonNull() = 65535U; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt16uArgument, this, OnSuccessCallback_217, OnFailureCallback_217)); return CHIP_NO_ERROR; } - void OnFailureResponse_217(EmberAfStatus status) { ThrowFailureResponse(); } - - void OnSuccessResponse_217(const chip::app::DataModel::Nullable & nullableInt16u) + void OnFailureResponse_217(EmberAfStatus status) { - VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); - + VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValueNot_218() + void OnSuccessResponse_217() { ThrowSuccessResponse(); } + + CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_218() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -44977,19 +45234,20 @@ class TestCluster : public TestCommand void OnSuccessResponse_218(const chip::app::DataModel::Nullable & nullableInt16u) { - VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 65534U)); + VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); + VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uValue_219() + CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_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; + nullableInt16uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt16uArgument, this, OnSuccessCallback_219, OnFailureCallback_219)); @@ -45000,7 +45258,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_219() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uValueInRange_220() + CHIP_ERROR TestReadAttributeNullableInt16uNullValue_220() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45015,12 +45273,12 @@ class TestCluster : public TestCommand void OnSuccessResponse_220(const chip::app::DataModel::Nullable & nullableInt16u) { - VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); + VerifyOrReturn(CheckValueNull("nullableInt16u", nullableInt16u)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNotValueOk_221() + CHIP_ERROR TestReadAttributeNullableInt16uNullValueRange_221() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45035,101 +45293,97 @@ class TestCluster : public TestCommand void OnSuccessResponse_221(const chip::app::DataModel::Nullable & nullableInt16u) { - VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 32001U)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_222() + CHIP_ERROR TestReadAttributeNullableInt16uNullValueNot_222() { 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() = 4294967294UL; - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_222, OnFailureCallback_222)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_222, OnFailureCallback_222)); return CHIP_NO_ERROR; } void OnFailureResponse_222(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_222() { NextTest(); } + void OnSuccessResponse_222(const chip::app::DataModel::Nullable & nullableInt16u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 65534U)); + + NextTest(); + } - CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_223() + CHIP_ERROR TestWriteAttributeNullableInt16uValue_223() { 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)); + chip::app::DataModel::Nullable nullableInt16uArgument; + nullableInt16uArgument.SetNonNull() = 32000U; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt16uArgument, this, OnSuccessCallback_223, OnFailureCallback_223)); return CHIP_NO_ERROR; } void OnFailureResponse_223(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_223(const chip::app::DataModel::Nullable & nullableInt32u) - { - VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); - VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); - - NextTest(); - } + void OnSuccessResponse_223() { NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_224() + CHIP_ERROR TestReadAttributeNullableInt16uValueInRange_224() { 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() = 4294967295UL; - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_224, OnFailureCallback_224)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_224, OnFailureCallback_224)); return CHIP_NO_ERROR; } - void OnFailureResponse_224(EmberAfStatus status) + void OnFailureResponse_224(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_224(const chip::app::DataModel::Nullable & nullableInt16u) { - VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); + NextTest(); } - void OnSuccessResponse_224() { ThrowSuccessResponse(); } - - CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_225() + CHIP_ERROR TestReadAttributeNullableInt16uNotValueOk_225() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_225, OnFailureCallback_225)); return CHIP_NO_ERROR; } void OnFailureResponse_225(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_225(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_225(const chip::app::DataModel::Nullable & nullableInt16u) { - VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); - VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); + VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 32001U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_226() + CHIP_ERROR TestWriteAttributeNullableInt32uMinValue_226() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableInt32uArgument; - nullableInt32uArgument.SetNull(); + nullableInt32uArgument.SetNonNull() = 0UL; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt32uArgument, this, OnSuccessCallback_226, OnFailureCallback_226)); @@ -45140,7 +45394,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_226() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValue_227() + CHIP_ERROR TestReadAttributeNullableInt32uMinValue_227() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45155,32 +45409,31 @@ class TestCluster : public TestCommand void OnSuccessResponse_227(const chip::app::DataModel::Nullable & nullableInt32u) { - VerifyOrReturn(CheckValueNull("nullableInt32u", nullableInt32u)); + VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); + VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 0UL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValueRange_228() + CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_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)); + chip::app::DataModel::Nullable nullableInt32uArgument; + nullableInt32uArgument.SetNonNull() = 4294967294UL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt32uArgument, 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(); - } + void OnSuccessResponse_228() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValueNot_229() + CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_229() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45195,30 +45448,35 @@ class TestCluster : public TestCommand void OnSuccessResponse_229(const chip::app::DataModel::Nullable & nullableInt32u) { - VerifyOrReturn(CheckConstraintNotValue("nullableInt32u", nullableInt32u, 4294967294UL)); + VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); + VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uValue_230() + CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_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; + nullableInt32uArgument.SetNonNull() = 4294967295UL; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt32uArgument, this, OnSuccessCallback_230, OnFailureCallback_230)); return CHIP_NO_ERROR; } - void OnFailureResponse_230(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_230(EmberAfStatus status) + { + VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); + } - void OnSuccessResponse_230() { NextTest(); } + void OnSuccessResponse_230() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32uValueInRange_231() + CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_231() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45233,172 +45491,167 @@ class TestCluster : public TestCommand void OnSuccessResponse_231(const chip::app::DataModel::Nullable & nullableInt32u) { - VerifyOrReturn(CheckConstraintMaxValue("nullableInt32u", nullableInt32u, 4294967294UL)); + VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); + VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNotValueOk_232() + CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_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)); + chip::app::DataModel::Nullable nullableInt32uArgument; + nullableInt32uArgument.SetNull(); + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt32uArgument, 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(); - } + void OnSuccessResponse_232() { NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_233() + CHIP_ERROR TestReadAttributeNullableInt32uNullValue_233() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableInt64uArgument; - nullableInt64uArgument.SetNonNull() = 18446744073709551614ULL; - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_233, OnFailureCallback_233)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_233, OnFailureCallback_233)); return CHIP_NO_ERROR; } void OnFailureResponse_233(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_233() { NextTest(); } + void OnSuccessResponse_233(const chip::app::DataModel::Nullable & nullableInt32u) + { + VerifyOrReturn(CheckValueNull("nullableInt32u", nullableInt32u)); + + NextTest(); + } - CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_234() + CHIP_ERROR TestReadAttributeNullableInt32uNullValueRange_234() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_234, OnFailureCallback_234)); return CHIP_NO_ERROR; } void OnFailureResponse_234(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_234(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_234(const chip::app::DataModel::Nullable & nullableInt32u) { - VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); - VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt32u", nullableInt32u, 4294967294UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_235() + CHIP_ERROR TestReadAttributeNullableInt32uNullValueNot_235() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableInt64uArgument; - nullableInt64uArgument.SetNonNull() = 18446744073709551615ULL; - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_235, OnFailureCallback_235)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_235, OnFailureCallback_235)); return CHIP_NO_ERROR; } - void OnFailureResponse_235(EmberAfStatus status) + void OnFailureResponse_235(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_235(const chip::app::DataModel::Nullable & nullableInt32u) { - VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckConstraintNotValue("nullableInt32u", nullableInt32u, 4294967294UL)); + NextTest(); } - void OnSuccessResponse_235() { ThrowSuccessResponse(); } - - CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_236() + CHIP_ERROR TestWriteAttributeNullableInt32uValue_236() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_236, OnFailureCallback_236)); + chip::app::DataModel::Nullable nullableInt32uArgument; + nullableInt32uArgument.SetNonNull() = 2147483647UL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt32uArgument, this, OnSuccessCallback_236, OnFailureCallback_236)); return CHIP_NO_ERROR; } void OnFailureResponse_236(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_236(const chip::app::DataModel::Nullable & nullableInt64u) - { - VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); - VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); - - NextTest(); - } + void OnSuccessResponse_236() { NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_237() + CHIP_ERROR TestReadAttributeNullableInt32uValueInRange_237() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableInt64uArgument; - nullableInt64uArgument.SetNull(); - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_237, OnFailureCallback_237)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_237, OnFailureCallback_237)); return CHIP_NO_ERROR; } void OnFailureResponse_237(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_237() { NextTest(); } + void OnSuccessResponse_237(const chip::app::DataModel::Nullable & nullableInt32u) + { + VerifyOrReturn(CheckConstraintMaxValue("nullableInt32u", nullableInt32u, 4294967294UL)); + + NextTest(); + } - CHIP_ERROR TestReadAttributeNullableInt64uNullValue_238() + CHIP_ERROR TestReadAttributeNullableInt32uNotValueOk_238() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_238, OnFailureCallback_238)); return CHIP_NO_ERROR; } void OnFailureResponse_238(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_238(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_238(const chip::app::DataModel::Nullable & nullableInt32u) { - VerifyOrReturn(CheckValueNull("nullableInt64u", nullableInt64u)); + VerifyOrReturn(CheckConstraintNotValue("nullableInt32u", nullableInt32u, 2147483648UL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValueRange_239() + CHIP_ERROR TestWriteAttributeNullableInt64uMinValue_239() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_239, OnFailureCallback_239)); + chip::app::DataModel::Nullable nullableInt64uArgument; + nullableInt64uArgument.SetNonNull() = 0ULL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt64uArgument, this, OnSuccessCallback_239, OnFailureCallback_239)); return CHIP_NO_ERROR; } void OnFailureResponse_239(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_239(const chip::app::DataModel::Nullable & nullableInt64u) - { - VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); - - NextTest(); - } + void OnSuccessResponse_239() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValueNot_240() + CHIP_ERROR TestReadAttributeNullableInt64uMinValue_240() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45413,19 +45666,20 @@ class TestCluster : public TestCommand void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableInt64u) { - VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); + VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); + VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 0ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uValue_241() + CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_241() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableInt64uArgument; - nullableInt64uArgument.SetNonNull() = 18000000000000000000ULL; + nullableInt64uArgument.SetNonNull() = 18446744073709551614ULL; ReturnErrorOnFailure(cluster.WriteAttribute( nullableInt64uArgument, this, OnSuccessCallback_241, OnFailureCallback_241)); @@ -45436,7 +45690,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_241() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uValueInRange_242() + CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_242() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45451,193 +45705,192 @@ class TestCluster : public TestCommand void OnSuccessResponse_242(const chip::app::DataModel::Nullable & nullableInt64u) { - VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); + VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); + VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNotValueOk_243() + CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_243() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_243, OnFailureCallback_243)); + chip::app::DataModel::Nullable nullableInt64uArgument; + nullableInt64uArgument.SetNonNull() = 18446744073709551615ULL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt64uArgument, this, OnSuccessCallback_243, OnFailureCallback_243)); return CHIP_NO_ERROR; } - void OnFailureResponse_243(EmberAfStatus status) { ThrowFailureResponse(); } - - void OnSuccessResponse_243(const chip::app::DataModel::Nullable & nullableInt64u) + void OnFailureResponse_243(EmberAfStatus status) { - VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18000000000000000001ULL)); - + VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_244() + void OnSuccessResponse_243() { ThrowSuccessResponse(); } + + CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_244() { 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_244, OnFailureCallback_244)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_244, OnFailureCallback_244)); return CHIP_NO_ERROR; } void OnFailureResponse_244(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_244() { NextTest(); } + void OnSuccessResponse_244(const chip::app::DataModel::Nullable & nullableInt64u) + { + VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); + VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); + + NextTest(); + } - CHIP_ERROR TestReadAttributeNullableInt8sMinValue_245() + CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_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)); + chip::app::DataModel::Nullable nullableInt64uArgument; + nullableInt64uArgument.SetNull(); + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt64uArgument, 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(CheckValueNonNull("nullableInt8s", nullableInt8s)); - VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); - - NextTest(); - } + void OnSuccessResponse_245() { NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_246() + CHIP_ERROR TestReadAttributeNullableInt64uNullValue_246() { 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() = -128; - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_246, OnFailureCallback_246)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_246, OnFailureCallback_246)); return CHIP_NO_ERROR; } - void OnFailureResponse_246(EmberAfStatus status) + void OnFailureResponse_246(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_246(const chip::app::DataModel::Nullable & nullableInt64u) { - VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValueNull("nullableInt64u", nullableInt64u)); + NextTest(); } - void OnSuccessResponse_246() { ThrowSuccessResponse(); } - - CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_247() + CHIP_ERROR TestReadAttributeNullableInt64uNullValueRange_247() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_247, OnFailureCallback_247)); return CHIP_NO_ERROR; } void OnFailureResponse_247(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_247(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_247(const chip::app::DataModel::Nullable & nullableInt64u) { - VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); - VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_248() + CHIP_ERROR TestReadAttributeNullableInt64uNullValueNot_248() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableInt8sArgument; - nullableInt8sArgument.SetNull(); - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_248, OnFailureCallback_248)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_248, OnFailureCallback_248)); return CHIP_NO_ERROR; } void OnFailureResponse_248(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_248() { NextTest(); } - - CHIP_ERROR TestReadAttributeNullableInt8sNullValue_249() + void OnSuccessResponse_248(const chip::app::DataModel::Nullable & nullableInt64u) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt64uValue_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)); + chip::app::DataModel::Nullable nullableInt64uArgument; + nullableInt64uArgument.SetNonNull() = 18000000000000000000ULL; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt64uArgument, 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(CheckValueNull("nullableInt8s", nullableInt8s)); - - NextTest(); - } + void OnSuccessResponse_249() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_250() + CHIP_ERROR TestReadAttributeNullableInt64uValueInRange_250() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_250, OnFailureCallback_250)); return CHIP_NO_ERROR; } void OnFailureResponse_250(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_250(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_250(const chip::app::DataModel::Nullable & nullableInt64u) { - VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); - VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_251() + CHIP_ERROR TestReadAttributeNullableInt64uNotValueOk_251() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_251, OnFailureCallback_251)); return CHIP_NO_ERROR; } void OnFailureResponse_251(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_251(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_251(const chip::app::DataModel::Nullable & nullableInt64u) { - VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -127)); + VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18000000000000000001ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sValue_252() + CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_252() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45655,7 +45908,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_252() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_253() + CHIP_ERROR TestReadAttributeNullableInt8sMinValue_253() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45669,6 +45922,167 @@ class TestCluster : public TestCommand void OnFailureResponse_253(EmberAfStatus status) { ThrowFailureResponse(); } void OnSuccessResponse_253(const chip::app::DataModel::Nullable & nullableInt8s) + { + VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); + VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_254() + { + 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() = -128; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt8sArgument, this, OnSuccessCallback_254, OnFailureCallback_254)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_254(EmberAfStatus status) + { + VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); + } + + void OnSuccessResponse_254() { ThrowSuccessResponse(); } + + CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_255() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_255(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_255(const chip::app::DataModel::Nullable & nullableInt8s) + { + VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); + VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_256() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableInt8sArgument; + nullableInt8sArgument.SetNull(); + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableInt8sArgument, this, OnSuccessCallback_256, OnFailureCallback_256)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_256(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_256() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt8sNullValue_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 & nullableInt8s) + { + VerifyOrReturn(CheckValueNull("nullableInt8s", nullableInt8s)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_258() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_258, OnFailureCallback_258)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_258(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_258(const chip::app::DataModel::Nullable & nullableInt8s) + { + VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); + VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_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 & nullableInt8s) + { + VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -127)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableInt8sValue_260() + { + 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_260, OnFailureCallback_260)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_260(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_260() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_261() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_261(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_261(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); @@ -45676,27 +46090,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_254() + CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_262() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_254, OnFailureCallback_254)); + this, OnSuccessCallback_262, OnFailureCallback_262)); return CHIP_NO_ERROR; } - void OnFailureResponse_254(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_262(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_254(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_262(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -126)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_255() + CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_263() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45706,28 +46120,28 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32767; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_255, OnFailureCallback_255)); + nullableInt16sArgument, this, OnSuccessCallback_263, OnFailureCallback_263)); return CHIP_NO_ERROR; } - void OnFailureResponse_255(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_263(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_255() { NextTest(); } + void OnSuccessResponse_263() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sMinValue_256() + CHIP_ERROR TestReadAttributeNullableInt16sMinValue_264() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_256, OnFailureCallback_256)); + this, OnSuccessCallback_264, OnFailureCallback_264)); return CHIP_NO_ERROR; } - void OnFailureResponse_256(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_264(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_256(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_264(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -45735,7 +46149,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_257() + CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_265() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45745,32 +46159,32 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_257, OnFailureCallback_257)); + nullableInt16sArgument, this, OnSuccessCallback_265, OnFailureCallback_265)); return CHIP_NO_ERROR; } - void OnFailureResponse_257(EmberAfStatus status) + void OnFailureResponse_265(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_257() { ThrowSuccessResponse(); } + void OnSuccessResponse_265() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_258() + CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_266() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_258, OnFailureCallback_258)); + this, OnSuccessCallback_266, OnFailureCallback_266)); return CHIP_NO_ERROR; } - void OnFailureResponse_258(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_266(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_258(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_266(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -45778,7 +46192,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_259() + CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_267() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45788,48 +46202,48 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_259, OnFailureCallback_259)); + nullableInt16sArgument, this, OnSuccessCallback_267, OnFailureCallback_267)); return CHIP_NO_ERROR; } - void OnFailureResponse_259(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_267(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_259() { NextTest(); } + void OnSuccessResponse_267() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValue_260() + CHIP_ERROR TestReadAttributeNullableInt16sNullValue_268() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_260, OnFailureCallback_260)); + this, OnSuccessCallback_268, OnFailureCallback_268)); return CHIP_NO_ERROR; } - void OnFailureResponse_260(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_268(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_260(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_268(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNull("nullableInt16s", nullableInt16s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_261() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_269() { 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_269, OnFailureCallback_269)); return CHIP_NO_ERROR; } - void OnFailureResponse_261(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_269(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_261(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_269(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); @@ -45837,27 +46251,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_262() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_270() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_262, OnFailureCallback_262)); + this, OnSuccessCallback_270, OnFailureCallback_270)); return CHIP_NO_ERROR; } - void OnFailureResponse_262(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_270(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_262(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_270(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32767)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sValue_263() + CHIP_ERROR TestWriteAttributeNullableInt16sValue_271() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45867,28 +46281,28 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32767; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_263, OnFailureCallback_263)); + nullableInt16sArgument, this, OnSuccessCallback_271, OnFailureCallback_271)); return CHIP_NO_ERROR; } - void OnFailureResponse_263(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_271(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_263() { NextTest(); } + void OnSuccessResponse_271() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_264() + CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_272() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_264, OnFailureCallback_264)); + this, OnSuccessCallback_272, OnFailureCallback_272)); return CHIP_NO_ERROR; } - void OnFailureResponse_264(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_272(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_264(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_272(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); @@ -45896,27 +46310,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_265() + CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_273() { 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_273, OnFailureCallback_273)); return CHIP_NO_ERROR; } - void OnFailureResponse_265(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_273(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_265(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_273(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32766)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_266() + CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_274() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45926,28 +46340,28 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483647L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_266, OnFailureCallback_266)); + nullableInt32sArgument, this, OnSuccessCallback_274, OnFailureCallback_274)); return CHIP_NO_ERROR; } - void OnFailureResponse_266(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_274(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_266() { NextTest(); } + void OnSuccessResponse_274() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sMinValue_267() + CHIP_ERROR TestReadAttributeNullableInt32sMinValue_275() { 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_275, OnFailureCallback_275)); return CHIP_NO_ERROR; } - void OnFailureResponse_267(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_275(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_267(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_275(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -45955,7 +46369,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_268() + CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_276() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -45965,32 +46379,32 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483648L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_268, OnFailureCallback_268)); + nullableInt32sArgument, this, OnSuccessCallback_276, OnFailureCallback_276)); return CHIP_NO_ERROR; } - void OnFailureResponse_268(EmberAfStatus status) + void OnFailureResponse_276(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_268() { ThrowSuccessResponse(); } + void OnSuccessResponse_276() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_269() + CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_277() { 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_277, OnFailureCallback_277)); return CHIP_NO_ERROR; } - void OnFailureResponse_269(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_277(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_269(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_277(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -45998,7 +46412,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_270() + CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_278() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46008,48 +46422,48 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_270, OnFailureCallback_270)); + nullableInt32sArgument, this, OnSuccessCallback_278, OnFailureCallback_278)); return CHIP_NO_ERROR; } - void OnFailureResponse_270(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_278(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_270() { NextTest(); } + void OnSuccessResponse_278() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValue_271() + CHIP_ERROR TestReadAttributeNullableInt32sNullValue_279() { 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_279, OnFailureCallback_279)); return CHIP_NO_ERROR; } - void OnFailureResponse_271(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_279(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_271(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_279(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNull("nullableInt32s", nullableInt32s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_272() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_280() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_272, OnFailureCallback_272)); + this, OnSuccessCallback_280, OnFailureCallback_280)); return CHIP_NO_ERROR; } - void OnFailureResponse_272(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_280(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_272(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_280(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); @@ -46057,27 +46471,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_273() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_281() { 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_281, OnFailureCallback_281)); return CHIP_NO_ERROR; } - void OnFailureResponse_273(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_281(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_273(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_281(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483647L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sValue_274() + CHIP_ERROR TestWriteAttributeNullableInt32sValue_282() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46087,28 +46501,28 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483647L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_274, OnFailureCallback_274)); + nullableInt32sArgument, this, OnSuccessCallback_282, OnFailureCallback_282)); return CHIP_NO_ERROR; } - void OnFailureResponse_274(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_282(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_274() { NextTest(); } + void OnSuccessResponse_282() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_275() + CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_283() { 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_283, OnFailureCallback_283)); return CHIP_NO_ERROR; } - void OnFailureResponse_275(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_283(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_275(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); @@ -46116,27 +46530,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_276() + CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_284() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_276, OnFailureCallback_276)); + this, OnSuccessCallback_284, OnFailureCallback_284)); return CHIP_NO_ERROR; } - void OnFailureResponse_276(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_284(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_276(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_284(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483646L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_277() + CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_285() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46146,28 +46560,28 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_277, OnFailureCallback_277)); + nullableInt64sArgument, this, OnSuccessCallback_285, OnFailureCallback_285)); return CHIP_NO_ERROR; } - void OnFailureResponse_277(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_285(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_277() { NextTest(); } + void OnSuccessResponse_285() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sMinValue_278() + CHIP_ERROR TestReadAttributeNullableInt64sMinValue_286() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_278, OnFailureCallback_278)); + this, OnSuccessCallback_286, OnFailureCallback_286)); return CHIP_NO_ERROR; } - void OnFailureResponse_278(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_286(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_278(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_286(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -46175,7 +46589,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_279() + CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_287() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46185,32 +46599,32 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL - 1; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_279, OnFailureCallback_279)); + nullableInt64sArgument, this, OnSuccessCallback_287, OnFailureCallback_287)); return CHIP_NO_ERROR; } - void OnFailureResponse_279(EmberAfStatus status) + void OnFailureResponse_287(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_279() { ThrowSuccessResponse(); } + void OnSuccessResponse_287() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_280() + CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_288() { 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_288, OnFailureCallback_288)); return CHIP_NO_ERROR; } - void OnFailureResponse_280(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_288(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_280(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_288(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -46218,7 +46632,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_281() + CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_289() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46228,48 +46642,48 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_281, OnFailureCallback_281)); + nullableInt64sArgument, this, OnSuccessCallback_289, OnFailureCallback_289)); return CHIP_NO_ERROR; } - void OnFailureResponse_281(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_289(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_281() { NextTest(); } + void OnSuccessResponse_289() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValue_282() + CHIP_ERROR TestReadAttributeNullableInt64sNullValue_290() { 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_290, OnFailureCallback_290)); return CHIP_NO_ERROR; } - void OnFailureResponse_282(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_290(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_282(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_290(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNull("nullableInt64s", nullableInt64s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValueRange_283() + CHIP_ERROR TestReadAttributeNullableInt64sNullValueRange_291() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_283, OnFailureCallback_283)); + this, OnSuccessCallback_291, OnFailureCallback_291)); return CHIP_NO_ERROR; } - void OnFailureResponse_283(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_291(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_291(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt64s", nullableInt64s, 9223372036854775807LL)); @@ -46277,27 +46691,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValueNot_284() + CHIP_ERROR TestReadAttributeNullableInt64sNullValueNot_292() { 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_292, OnFailureCallback_292)); return CHIP_NO_ERROR; } - void OnFailureResponse_284(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_292(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_284(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_292(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sValue_285() + CHIP_ERROR TestWriteAttributeNullableInt64sValue_293() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46307,28 +46721,28 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_285, OnFailureCallback_285)); + nullableInt64sArgument, this, OnSuccessCallback_293, OnFailureCallback_293)); return CHIP_NO_ERROR; } - void OnFailureResponse_285(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_293(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_285() { NextTest(); } + void OnSuccessResponse_293() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sValueInRange_286() + CHIP_ERROR TestReadAttributeNullableInt64sValueInRange_294() { 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_294, OnFailureCallback_294)); return CHIP_NO_ERROR; } - void OnFailureResponse_286(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_294(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_286(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_294(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt64s", nullableInt64s, 9223372036854775807LL)); @@ -46336,27 +46750,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNotValueOk_287() + CHIP_ERROR TestReadAttributeNullableInt64sNotValueOk_295() { 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_295, OnFailureCallback_295)); return CHIP_NO_ERROR; } - void OnFailureResponse_287(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_295(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_287(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_295(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt64s", nullableInt64s, -9223372036854775806LL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_288() + CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_296() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46366,28 +46780,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = 0.1f; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_288, OnFailureCallback_288)); + nullableFloatSingleArgument, this, OnSuccessCallback_296, OnFailureCallback_296)); return CHIP_NO_ERROR; } - void OnFailureResponse_288(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_296(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_288() { NextTest(); } + void OnSuccessResponse_296() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleMediumValue_289() + CHIP_ERROR TestReadAttributeNullableSingleMediumValue_297() { 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_297, OnFailureCallback_297)); return CHIP_NO_ERROR; } - void OnFailureResponse_289(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_297(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_289(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_297(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.1f)); @@ -46395,7 +46809,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_290() + CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_298() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46405,28 +46819,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_290, OnFailureCallback_290)); + nullableFloatSingleArgument, this, OnSuccessCallback_298, OnFailureCallback_298)); return CHIP_NO_ERROR; } - void OnFailureResponse_290(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_298(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_290() { NextTest(); } + void OnSuccessResponse_298() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleLargestValue_291() + CHIP_ERROR TestReadAttributeNullableSingleLargestValue_299() { 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_299, OnFailureCallback_299)); return CHIP_NO_ERROR; } - void OnFailureResponse_291(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_299(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_291(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_299(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), INFINITY)); @@ -46434,7 +46848,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_292() + CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_300() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46444,28 +46858,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_292, OnFailureCallback_292)); + nullableFloatSingleArgument, this, OnSuccessCallback_300, OnFailureCallback_300)); return CHIP_NO_ERROR; } - void OnFailureResponse_292(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_300(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_292() { NextTest(); } + void OnSuccessResponse_300() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_293() + CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_301() { 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_301, OnFailureCallback_301)); return CHIP_NO_ERROR; } - void OnFailureResponse_293(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_301(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_293(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_301(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), -INFINITY)); @@ -46473,7 +46887,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleNullValue_294() + CHIP_ERROR TestWriteAttributeNullableSingleNullValue_302() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46483,35 +46897,35 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_294, OnFailureCallback_294)); + nullableFloatSingleArgument, this, OnSuccessCallback_302, OnFailureCallback_302)); return CHIP_NO_ERROR; } - void OnFailureResponse_294(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_302(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_294() { NextTest(); } + void OnSuccessResponse_302() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleNullValue_295() + CHIP_ERROR TestReadAttributeNullableSingleNullValue_303() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_295, OnFailureCallback_295)); + this, OnSuccessCallback_303, OnFailureCallback_303)); return CHIP_NO_ERROR; } - void OnFailureResponse_295(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_303(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_295(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_303(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNull("nullableFloatSingle", nullableFloatSingle)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingle0Value_296() + CHIP_ERROR TestWriteAttributeNullableSingle0Value_304() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46521,28 +46935,28 @@ class TestCluster : public TestCommand nullableFloatSingleArgument.SetNonNull() = 0.0f; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_296, OnFailureCallback_296)); + nullableFloatSingleArgument, this, OnSuccessCallback_304, OnFailureCallback_304)); return CHIP_NO_ERROR; } - void OnFailureResponse_296(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_304(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_296() { NextTest(); } + void OnSuccessResponse_304() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingle0Value_297() + CHIP_ERROR TestReadAttributeNullableSingle0Value_305() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_297, OnFailureCallback_297)); + this, OnSuccessCallback_305, OnFailureCallback_305)); return CHIP_NO_ERROR; } - void OnFailureResponse_297(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_305(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_297(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_305(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.0f)); @@ -46550,7 +46964,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_298() + CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_306() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46560,28 +46974,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = 0.1234567890123; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_298, OnFailureCallback_298)); + nullableFloatDoubleArgument, this, OnSuccessCallback_306, OnFailureCallback_306)); return CHIP_NO_ERROR; } - void OnFailureResponse_298(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_306(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_298() { NextTest(); } + void OnSuccessResponse_306() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_299() + CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_307() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_299, OnFailureCallback_299)); + this, OnSuccessCallback_307, OnFailureCallback_307)); return CHIP_NO_ERROR; } - void OnFailureResponse_299(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_307(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_299(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_307(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0.1234567890123)); @@ -46589,7 +47003,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_300() + CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_308() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46599,28 +47013,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_300, OnFailureCallback_300)); + nullableFloatDoubleArgument, this, OnSuccessCallback_308, OnFailureCallback_308)); return CHIP_NO_ERROR; } - void OnFailureResponse_300(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_308(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_300() { NextTest(); } + void OnSuccessResponse_308() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_301() + CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_309() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_301, OnFailureCallback_301)); + this, OnSuccessCallback_309, OnFailureCallback_309)); return CHIP_NO_ERROR; } - void OnFailureResponse_301(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_309(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_301(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_309(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), INFINITY)); @@ -46628,7 +47042,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_302() + CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_310() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46638,28 +47052,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_302, OnFailureCallback_302)); + nullableFloatDoubleArgument, this, OnSuccessCallback_310, OnFailureCallback_310)); return CHIP_NO_ERROR; } - void OnFailureResponse_302(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_310(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_302() { NextTest(); } + void OnSuccessResponse_310() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_303() + CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_311() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_303, OnFailureCallback_303)); + this, OnSuccessCallback_311, OnFailureCallback_311)); return CHIP_NO_ERROR; } - void OnFailureResponse_303(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_311(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_303(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_311(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), -INFINITY)); @@ -46667,7 +47081,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_304() + CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_312() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46677,35 +47091,35 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_304, OnFailureCallback_304)); + nullableFloatDoubleArgument, this, OnSuccessCallback_312, OnFailureCallback_312)); return CHIP_NO_ERROR; } - void OnFailureResponse_304(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_312(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_304() { NextTest(); } + void OnSuccessResponse_312() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleNullValue_305() + CHIP_ERROR TestReadAttributeNullableDoubleNullValue_313() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_305, OnFailureCallback_305)); + this, OnSuccessCallback_313, OnFailureCallback_313)); return CHIP_NO_ERROR; } - void OnFailureResponse_305(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_313(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_305(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_313(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNull("nullableFloatDouble", nullableFloatDouble)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDouble0Value_306() + CHIP_ERROR TestWriteAttributeNullableDouble0Value_314() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46715,28 +47129,28 @@ class TestCluster : public TestCommand nullableFloatDoubleArgument.SetNonNull() = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_306, OnFailureCallback_306)); + nullableFloatDoubleArgument, this, OnSuccessCallback_314, OnFailureCallback_314)); return CHIP_NO_ERROR; } - void OnFailureResponse_306(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_314(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_306() { NextTest(); } + void OnSuccessResponse_314() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDouble0Value_307() + CHIP_ERROR TestReadAttributeNullableDouble0Value_315() { 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_315, OnFailureCallback_315)); return CHIP_NO_ERROR; } - void OnFailureResponse_307(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_315(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_307(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_315(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0)); @@ -46744,7 +47158,46 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_308() + CHIP_ERROR TestWriteAttributeNullableEnum8MinValue_316() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableEnum8Argument; + nullableEnum8Argument.SetNonNull() = 0; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum8Argument, this, OnSuccessCallback_316, OnFailureCallback_316)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_316(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_316() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableEnum8MinValue_317() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_317, OnFailureCallback_317)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_317(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_317(const chip::app::DataModel::Nullable & nullableEnum8) + { + VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); + VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 0)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_318() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -46754,250 +47207,452 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = 254; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_308, OnFailureCallback_308)); + nullableEnum8Argument, this, OnSuccessCallback_318, OnFailureCallback_318)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_318(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_318() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_319() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_319(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_319(const chip::app::DataModel::Nullable & nullableEnum8) + { + VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); + VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_320() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableEnum8Argument; + nullableEnum8Argument.SetNonNull() = 255; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum8Argument, this, OnSuccessCallback_320, OnFailureCallback_320)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_320(EmberAfStatus status) + { + VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); + } + + void OnSuccessResponse_320() { ThrowSuccessResponse(); } + + CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_321() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_321(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_321(const chip::app::DataModel::Nullable & nullableEnum8) + { + VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); + VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_322() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableEnum8Argument; + nullableEnum8Argument.SetNull(); + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum8Argument, this, OnSuccessCallback_322, OnFailureCallback_322)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_322(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_322() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableEnum8NullValue_323() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_323(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_323(const chip::app::DataModel::Nullable & nullableEnum8) + { + VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableEnum16MinValue_324() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableEnum16Argument; + nullableEnum16Argument.SetNonNull() = 0U; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum16Argument, this, OnSuccessCallback_324, OnFailureCallback_324)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_324(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_324() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableEnum16MinValue_325() + { + 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)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_325(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_325(const chip::app::DataModel::Nullable & nullableEnum16) + { + VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); + VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 0U)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_326() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableEnum16Argument; + nullableEnum16Argument.SetNonNull() = 65534U; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum16Argument, this, OnSuccessCallback_326, OnFailureCallback_326)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_326(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_326() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_327() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_327, OnFailureCallback_327)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_327(EmberAfStatus status) { ThrowFailureResponse(); } + + void OnSuccessResponse_327(const chip::app::DataModel::Nullable & nullableEnum16) + { + VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); + VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_328() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableEnum16Argument; + nullableEnum16Argument.SetNonNull() = 65535U; + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum16Argument, this, OnSuccessCallback_328, OnFailureCallback_328)); return CHIP_NO_ERROR; } - void OnFailureResponse_308(EmberAfStatus status) { ThrowFailureResponse(); } - - void OnSuccessResponse_308() { NextTest(); } + void OnFailureResponse_328(EmberAfStatus status) + { + VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); + } + + void OnSuccessResponse_328() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_309() + CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_329() { 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)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_329, OnFailureCallback_329)); return CHIP_NO_ERROR; } - void OnFailureResponse_309(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_329(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_309(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_329(const chip::app::DataModel::Nullable & nullableEnum16) { - VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); - VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); + VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); + VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_310() + CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_330() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnum8Argument; - nullableEnum8Argument.SetNonNull() = 255; + chip::app::DataModel::Nullable nullableEnum16Argument; + nullableEnum16Argument.SetNull(); - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_310, OnFailureCallback_310)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum16Argument, this, OnSuccessCallback_330, OnFailureCallback_330)); return CHIP_NO_ERROR; } - void OnFailureResponse_310(EmberAfStatus status) - { - VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - NextTest(); - } + void OnFailureResponse_330(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_310() { ThrowSuccessResponse(); } + void OnSuccessResponse_330() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_311() + CHIP_ERROR TestReadAttributeNullableEnum16NullValue_331() { 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)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_331, OnFailureCallback_331)); return CHIP_NO_ERROR; } - void OnFailureResponse_311(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_331(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_311(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_331(const chip::app::DataModel::Nullable & nullableEnum16) { - VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); - VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); + VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_312() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumMinValue_332() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnum8Argument; - nullableEnum8Argument.SetNull(); + chip::app::DataModel::Nullable nullableEnumAttrArgument; + nullableEnumAttrArgument.SetNonNull() = static_cast(0); - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_312, OnFailureCallback_312)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnumAttrArgument, this, OnSuccessCallback_332, OnFailureCallback_332)); return CHIP_NO_ERROR; } - void OnFailureResponse_312(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_332(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_312() { NextTest(); } + void OnSuccessResponse_332() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8NullValue_313() + CHIP_ERROR TestReadAttributeNullableSimpleEnumMinValue_333() { 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)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_333, OnFailureCallback_333)); return CHIP_NO_ERROR; } - void OnFailureResponse_313(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_333(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_313(const chip::app::DataModel::Nullable & nullableEnum8) + void + OnSuccessResponse_333(const chip::app::DataModel::Nullable & nullableEnumAttr) { - VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); + VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", nullableEnumAttr)); + VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", nullableEnumAttr.Value(), 0)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_314() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumMaxValue_334() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnum16Argument; - nullableEnum16Argument.SetNonNull() = 65534U; + chip::app::DataModel::Nullable nullableEnumAttrArgument; + nullableEnumAttrArgument.SetNonNull() = static_cast(254); - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_314, OnFailureCallback_314)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnumAttrArgument, this, OnSuccessCallback_334, OnFailureCallback_334)); return CHIP_NO_ERROR; } - void OnFailureResponse_314(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_334(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_314() { NextTest(); } + void OnSuccessResponse_334() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_315() + CHIP_ERROR TestReadAttributeNullableSimpleEnumMaxValue_335() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_315, OnFailureCallback_315)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_335, OnFailureCallback_335)); return CHIP_NO_ERROR; } - void OnFailureResponse_315(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_335(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_315(const chip::app::DataModel::Nullable & nullableEnum16) + void + OnSuccessResponse_335(const chip::app::DataModel::Nullable & nullableEnumAttr) { - VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); - VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); + VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", nullableEnumAttr)); + VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", nullableEnumAttr.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_316() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumInvalidValue_336() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnum16Argument; - nullableEnum16Argument.SetNonNull() = 65535U; + chip::app::DataModel::Nullable nullableEnumAttrArgument; + nullableEnumAttrArgument.SetNonNull() = static_cast(255); - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_316, OnFailureCallback_316)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnumAttrArgument, this, OnSuccessCallback_336, OnFailureCallback_336)); return CHIP_NO_ERROR; } - void OnFailureResponse_316(EmberAfStatus status) + void OnFailureResponse_336(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_316() { ThrowSuccessResponse(); } + void OnSuccessResponse_336() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_317() + CHIP_ERROR TestReadAttributeNullableSimpleEnumUnchangedValue_337() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_317, OnFailureCallback_317)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_337, OnFailureCallback_337)); return CHIP_NO_ERROR; } - void OnFailureResponse_317(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_337(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_317(const chip::app::DataModel::Nullable & nullableEnum16) + void + OnSuccessResponse_337(const chip::app::DataModel::Nullable & nullableEnumAttr) { - VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); - VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); + VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", nullableEnumAttr)); + VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", nullableEnumAttr.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_318() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumNullValue_338() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnum16Argument; - nullableEnum16Argument.SetNull(); + chip::app::DataModel::Nullable nullableEnumAttrArgument; + nullableEnumAttrArgument.SetNull(); - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_318, OnFailureCallback_318)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnumAttrArgument, this, OnSuccessCallback_338, OnFailureCallback_338)); return CHIP_NO_ERROR; } - void OnFailureResponse_318(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_338(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_318() { NextTest(); } + void OnSuccessResponse_338() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16NullValue_319() + CHIP_ERROR TestReadAttributeNullableSimpleEnumNullValue_339() { 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)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_339, OnFailureCallback_339)); return CHIP_NO_ERROR; } - void OnFailureResponse_319(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_339(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_319(const chip::app::DataModel::Nullable & nullableEnum16) + void + OnSuccessResponse_339(const chip::app::DataModel::Nullable & nullableEnumAttr) { - VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); + VerifyOrReturn(CheckValueNull("nullableEnumAttr", nullableEnumAttr)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_320() + CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_340() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_320, OnFailureCallback_320)); + this, OnSuccessCallback_340, OnFailureCallback_340)); return CHIP_NO_ERROR; } - void OnFailureResponse_320(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_340(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_320(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_340(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -47006,7 +47661,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_321() + CHIP_ERROR TestWriteAttributeNullableOctetString_341() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47017,28 +47672,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_321, OnFailureCallback_321)); + nullableOctetStringArgument, this, OnSuccessCallback_341, OnFailureCallback_341)); return CHIP_NO_ERROR; } - void OnFailureResponse_321(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_341(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_321() { NextTest(); } + void OnSuccessResponse_341() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_322() + CHIP_ERROR TestReadAttributeNullableOctetString_342() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_322, OnFailureCallback_322)); + this, OnSuccessCallback_342, OnFailureCallback_342)); return CHIP_NO_ERROR; } - void OnFailureResponse_322(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_342(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_322(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_342(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -47047,7 +47702,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_323() + CHIP_ERROR TestWriteAttributeNullableOctetString_343() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47057,35 +47712,35 @@ class TestCluster : public TestCommand nullableOctetStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_323, OnFailureCallback_323)); + nullableOctetStringArgument, this, OnSuccessCallback_343, OnFailureCallback_343)); return CHIP_NO_ERROR; } - void OnFailureResponse_323(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_343(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_323() { NextTest(); } + void OnSuccessResponse_343() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_324() + CHIP_ERROR TestReadAttributeNullableOctetString_344() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_324, OnFailureCallback_324)); + this, OnSuccessCallback_344, OnFailureCallback_344)); return CHIP_NO_ERROR; } - void OnFailureResponse_324(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_344(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_324(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_344(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNull("nullableOctetString", nullableOctetString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_325() + CHIP_ERROR TestWriteAttributeNullableOctetString_345() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47096,28 +47751,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_325, OnFailureCallback_325)); + nullableOctetStringArgument, this, OnSuccessCallback_345, OnFailureCallback_345)); return CHIP_NO_ERROR; } - void OnFailureResponse_325(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_345(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_325() { NextTest(); } + void OnSuccessResponse_345() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_326() + CHIP_ERROR TestReadAttributeNullableOctetString_346() { 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_346, OnFailureCallback_346)); return CHIP_NO_ERROR; } - void OnFailureResponse_326(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_346(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_326(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_346(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -47126,20 +47781,20 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_327() + CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_347() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_327, OnFailureCallback_327)); + this, OnSuccessCallback_347, OnFailureCallback_347)); return CHIP_NO_ERROR; } - void OnFailureResponse_327(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_347(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_327(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_347(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -47147,7 +47802,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharString_328() + CHIP_ERROR TestWriteAttributeNullableCharString_348() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47157,28 +47812,28 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("☉T☉garbage: not in length on purpose", 7); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_328, OnFailureCallback_328)); + nullableCharStringArgument, this, OnSuccessCallback_348, OnFailureCallback_348)); return CHIP_NO_ERROR; } - void OnFailureResponse_328(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_348(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_328() { NextTest(); } + void OnSuccessResponse_348() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_329() + CHIP_ERROR TestReadAttributeNullableCharString_349() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_329, OnFailureCallback_329)); + this, OnSuccessCallback_349, OnFailureCallback_349)); return CHIP_NO_ERROR; } - void OnFailureResponse_329(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_349(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_329(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_349(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("☉T☉", 7))); @@ -47186,7 +47841,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_330() + CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_350() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47196,35 +47851,35 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_330, OnFailureCallback_330)); + nullableCharStringArgument, this, OnSuccessCallback_350, OnFailureCallback_350)); return CHIP_NO_ERROR; } - void OnFailureResponse_330(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_350(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_330() { NextTest(); } + void OnSuccessResponse_350() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_331() + CHIP_ERROR TestReadAttributeNullableCharString_351() { 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_351, OnFailureCallback_351)); return CHIP_NO_ERROR; } - void OnFailureResponse_331(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_351(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_331(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_351(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNull("nullableCharString", nullableCharString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_332() + CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_352() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47234,28 +47889,28 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("garbage: not in length on purpose", 0); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_332, OnFailureCallback_332)); + nullableCharStringArgument, this, OnSuccessCallback_352, OnFailureCallback_352)); return CHIP_NO_ERROR; } - void OnFailureResponse_332(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_352(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_332() { NextTest(); } + void OnSuccessResponse_352() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_333() + CHIP_ERROR TestReadAttributeNullableCharString_353() { 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_353, OnFailureCallback_353)); return CHIP_NO_ERROR; } - void OnFailureResponse_333(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_353(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_333(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_353(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -47263,45 +47918,45 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_334() + CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_354() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 200; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_334, OnFailureCallback_334)); + this, OnSuccessCallback_354, OnFailureCallback_354)); return CHIP_NO_ERROR; } - void OnFailureResponse_334(EmberAfStatus status) + void OnFailureResponse_354(EmberAfStatus status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_334(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_354(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeFromNonexistentCluster_335() + CHIP_ERROR TestReadAttributeFromNonexistentCluster_355() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 0; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_335, OnFailureCallback_335)); + this, OnSuccessCallback_355, OnFailureCallback_355)); return CHIP_NO_ERROR; } - void OnFailureResponse_335(EmberAfStatus status) + void OnFailureResponse_355(EmberAfStatus status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_335(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_355(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_336() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_356() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -47309,26 +47964,26 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_336(); + (static_cast(context))->OnSuccessResponse_356(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_336(status); + (static_cast(context))->OnFailureResponse_356(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_336(EmberAfStatus status) + void OnFailureResponse_356(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_INVALID_VALUE)); NextTest(); } - void OnSuccessResponse_336() { ThrowSuccessResponse(); } + void OnSuccessResponse_356() { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_337() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_357() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -47337,36 +47992,36 @@ class TestCluster : public TestCommand request.arg1.Emplace() = 1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_337(); + (static_cast(context))->OnSuccessResponse_357(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_337(status); + (static_cast(context))->OnFailureResponse_357(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_337(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_357(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_337() { NextTest(); } + void OnSuccessResponse_357() { NextTest(); } - CHIP_ERROR TestReportSubscribeToListAttribute_338() + CHIP_ERROR TestReportSubscribeToListAttribute_358() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_338; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_358; return WaitForMs(0); } - void OnFailureResponse_338(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_358(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_338(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_358(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_338 = true; + mReceivedReport_358 = true; auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); @@ -47380,7 +48035,7 @@ class TestCluster : public TestCommand VerifyOrReturn(CheckNoMoreListItems("listInt8u", iter, 4)); } - CHIP_ERROR TestSubscribeToListAttribute_339() + CHIP_ERROR TestSubscribeToListAttribute_359() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47392,14 +48047,14 @@ class TestCluster : public TestCommand maxIntervalArgument = 10U; ReturnErrorOnFailure(cluster.SubscribeAttribute( - this, OnSuccessCallback_339, OnFailureCallback_339, minIntervalArgument, maxIntervalArgument, - OnSubscriptionEstablished_339)); + this, OnSuccessCallback_359, OnFailureCallback_359, minIntervalArgument, maxIntervalArgument, + OnSubscriptionEstablished_359)); return CHIP_NO_ERROR; } - void OnFailureResponse_339(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_359(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_339(const chip::app::DataModel::DecodableList & value) + void OnSuccessResponse_359(const chip::app::DataModel::DecodableList & value) { if (mTest_TestCluster_list_int8u_Reported) { @@ -47409,13 +48064,13 @@ class TestCluster : public TestCommand } } - void OnSubscriptionEstablishedResponse_339() + void OnSubscriptionEstablishedResponse_359() { - VerifyOrReturn(mReceivedReport_338, Exit("Initial report not received!")); + VerifyOrReturn(mReceivedReport_358, Exit("Initial report not received!")); NextTest(); } - CHIP_ERROR TestWriteSubscribedToListAttribute_340() + CHIP_ERROR TestWriteSubscribedToListAttribute_360() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47431,29 +48086,29 @@ class TestCluster : public TestCommand listInt8uArgument = listInt8uList; ReturnErrorOnFailure(cluster.WriteAttribute( - listInt8uArgument, this, OnSuccessCallback_340, OnFailureCallback_340)); + listInt8uArgument, this, OnSuccessCallback_360, OnFailureCallback_360)); return CHIP_NO_ERROR; } - void OnFailureResponse_340(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_360(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_340() { NextTest(); } + void OnSuccessResponse_360() { NextTest(); } - CHIP_ERROR TestCheckForListAttributeReport_341() + CHIP_ERROR TestCheckForListAttributeReport_361() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_341; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_361; return CHIP_NO_ERROR; } - void OnFailureResponse_341(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_361(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_341(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_361(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_341 = true; + mReceivedReport_361 = true; auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); @@ -47469,27 +48124,27 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_342() + CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_362() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_342, OnFailureCallback_342)); + this, OnSuccessCallback_362, OnFailureCallback_362)); return CHIP_NO_ERROR; } - void OnFailureResponse_342(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_362(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_342(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_362(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_343() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_363() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47499,19 +48154,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_343, OnFailureCallback_343)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_363, OnFailureCallback_363)); return CHIP_NO_ERROR; } - void OnFailureResponse_343(EmberAfStatus status) + void OnFailureResponse_363(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_343() { ThrowSuccessResponse(); } + void OnSuccessResponse_363() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_344() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_364() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47521,19 +48176,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 19; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_344, OnFailureCallback_344)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_364, OnFailureCallback_364)); return CHIP_NO_ERROR; } - void OnFailureResponse_344(EmberAfStatus status) + void OnFailureResponse_364(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_344() { ThrowSuccessResponse(); } + void OnSuccessResponse_364() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_345() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_365() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47543,19 +48198,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 101; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_345, OnFailureCallback_345)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_365, OnFailureCallback_365)); return CHIP_NO_ERROR; } - void OnFailureResponse_345(EmberAfStatus status) + void OnFailureResponse_365(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_345() { ThrowSuccessResponse(); } + void OnSuccessResponse_365() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_346() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_366() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47565,39 +48220,39 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_346, OnFailureCallback_346)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_366, OnFailureCallback_366)); return CHIP_NO_ERROR; } - void OnFailureResponse_346(EmberAfStatus status) + void OnFailureResponse_366(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_346() { ThrowSuccessResponse(); } + void OnSuccessResponse_366() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_347() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_367() { 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_367, OnFailureCallback_367)); return CHIP_NO_ERROR; } - void OnFailureResponse_347(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_367(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_347(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_367(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_348() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_368() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47607,35 +48262,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 20; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_348, OnFailureCallback_348)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_368, OnFailureCallback_368)); return CHIP_NO_ERROR; } - void OnFailureResponse_348(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_368(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_348() { NextTest(); } + void OnSuccessResponse_368() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_349() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_369() { 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_369, OnFailureCallback_369)); return CHIP_NO_ERROR; } - void OnFailureResponse_349(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_369(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_349(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_369(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 20)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_350() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_370() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47645,35 +48300,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 100; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_350, OnFailureCallback_350)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_370, OnFailureCallback_370)); return CHIP_NO_ERROR; } - void OnFailureResponse_350(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_370(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_350() { NextTest(); } + void OnSuccessResponse_370() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_351() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_371() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_351, OnFailureCallback_351)); + this, OnSuccessCallback_371, OnFailureCallback_371)); return CHIP_NO_ERROR; } - void OnFailureResponse_351(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_371(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_351(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_371(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 100)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_352() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_372() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47683,55 +48338,55 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_352, OnFailureCallback_352)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); return CHIP_NO_ERROR; } - void OnFailureResponse_352(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_372(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_352() { NextTest(); } + void OnSuccessResponse_372() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_353() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_373() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_353, OnFailureCallback_353)); + this, OnSuccessCallback_373, OnFailureCallback_373)); return CHIP_NO_ERROR; } - void OnFailureResponse_353(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_373(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_353(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_373(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 50)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_354() + CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_374() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_354, OnFailureCallback_354)); + this, OnSuccessCallback_374, OnFailureCallback_374)); return CHIP_NO_ERROR; } - void OnFailureResponse_354(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_374(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_354(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_374(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_355() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_375() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47741,19 +48396,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 0U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_355, OnFailureCallback_355)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_375, OnFailureCallback_375)); return CHIP_NO_ERROR; } - void OnFailureResponse_355(EmberAfStatus status) + void OnFailureResponse_375(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_355() { ThrowSuccessResponse(); } + void OnSuccessResponse_375() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_356() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_376() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47763,19 +48418,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 99U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_356, OnFailureCallback_356)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); return CHIP_NO_ERROR; } - void OnFailureResponse_356(EmberAfStatus status) + void OnFailureResponse_376(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_356() { ThrowSuccessResponse(); } + void OnSuccessResponse_376() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_357() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_377() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47785,19 +48440,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1001U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_357, OnFailureCallback_357)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_377, OnFailureCallback_377)); return CHIP_NO_ERROR; } - void OnFailureResponse_357(EmberAfStatus status) + void OnFailureResponse_377(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_357() { ThrowSuccessResponse(); } + void OnSuccessResponse_377() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_358() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_378() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47807,39 +48462,39 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_358, OnFailureCallback_358)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_378, OnFailureCallback_378)); return CHIP_NO_ERROR; } - void OnFailureResponse_358(EmberAfStatus status) + void OnFailureResponse_378(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_358() { ThrowSuccessResponse(); } + void OnSuccessResponse_378() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_359() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_379() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_359, OnFailureCallback_359)); + this, OnSuccessCallback_379, OnFailureCallback_379)); return CHIP_NO_ERROR; } - void OnFailureResponse_359(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_379(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_359(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_379(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_360() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_380() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47849,35 +48504,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 100U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_360, OnFailureCallback_360)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_380, OnFailureCallback_380)); return CHIP_NO_ERROR; } - void OnFailureResponse_360(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_380(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_360() { NextTest(); } + void OnSuccessResponse_380() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_361() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_381() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_361, OnFailureCallback_361)); + this, OnSuccessCallback_381, OnFailureCallback_381)); return CHIP_NO_ERROR; } - void OnFailureResponse_361(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_381(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_361(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_381(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 100U)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_362() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_382() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47887,35 +48542,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1000U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_362, OnFailureCallback_362)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_382, OnFailureCallback_382)); return CHIP_NO_ERROR; } - void OnFailureResponse_362(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_382(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_362() { NextTest(); } + void OnSuccessResponse_382() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_363() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_383() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_363, OnFailureCallback_363)); + this, OnSuccessCallback_383, OnFailureCallback_383)); return CHIP_NO_ERROR; } - void OnFailureResponse_363(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_383(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_363(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_383(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 1000U)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_364() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_384() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47925,55 +48580,55 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 500U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_364, OnFailureCallback_364)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); return CHIP_NO_ERROR; } - void OnFailureResponse_364(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_384(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_364() { NextTest(); } + void OnSuccessResponse_384() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_365() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_385() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_365, OnFailureCallback_365)); + this, OnSuccessCallback_385, OnFailureCallback_385)); return CHIP_NO_ERROR; } - void OnFailureResponse_365(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_385(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_365(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_385(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 500U)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_366() + CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_386() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_366, OnFailureCallback_366)); + this, OnSuccessCallback_386, OnFailureCallback_386)); return CHIP_NO_ERROR; } - void OnFailureResponse_366(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_386(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_366(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_386(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_367() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_387() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -47983,19 +48638,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -128; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_367, OnFailureCallback_367)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_387, OnFailureCallback_387)); return CHIP_NO_ERROR; } - void OnFailureResponse_367(EmberAfStatus status) + void OnFailureResponse_387(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_367() { ThrowSuccessResponse(); } + void OnSuccessResponse_387() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_368() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_388() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48005,19 +48660,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -41; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_368, OnFailureCallback_368)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); return CHIP_NO_ERROR; } - void OnFailureResponse_368(EmberAfStatus status) + void OnFailureResponse_388(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_368() { ThrowSuccessResponse(); } + void OnSuccessResponse_388() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_369() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_389() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48027,19 +48682,19 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 51; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_369, OnFailureCallback_369)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_389, OnFailureCallback_389)); return CHIP_NO_ERROR; } - void OnFailureResponse_369(EmberAfStatus status) + void OnFailureResponse_389(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_369() { ThrowSuccessResponse(); } + void OnSuccessResponse_389() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_370() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_390() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48049,39 +48704,39 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 127; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_370, OnFailureCallback_370)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_390, OnFailureCallback_390)); return CHIP_NO_ERROR; } - void OnFailureResponse_370(EmberAfStatus status) + void OnFailureResponse_390(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_370() { ThrowSuccessResponse(); } + void OnSuccessResponse_390() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_371() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_391() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_371, OnFailureCallback_371)); + this, OnSuccessCallback_391, OnFailureCallback_391)); return CHIP_NO_ERROR; } - void OnFailureResponse_371(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_391(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_371(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_391(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_372() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_392() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48091,35 +48746,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -40; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_392, OnFailureCallback_392)); return CHIP_NO_ERROR; } - void OnFailureResponse_372(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_392(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_372() { NextTest(); } + void OnSuccessResponse_392() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_373() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_393() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_373, OnFailureCallback_373)); + this, OnSuccessCallback_393, OnFailureCallback_393)); return CHIP_NO_ERROR; } - void OnFailureResponse_373(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_393(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_373(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_393(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, -40)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_374() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_394() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48129,35 +48784,35 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_374, OnFailureCallback_374)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_394, OnFailureCallback_394)); return CHIP_NO_ERROR; } - void OnFailureResponse_374(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_394(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_374() { NextTest(); } + void OnSuccessResponse_394() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_375() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_395() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_375, OnFailureCallback_375)); + this, OnSuccessCallback_395, OnFailureCallback_395)); return CHIP_NO_ERROR; } - void OnFailureResponse_375(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_395(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_375(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_395(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 50)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_376() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_396() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48167,55 +48822,55 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 6; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); return CHIP_NO_ERROR; } - void OnFailureResponse_376(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_396(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_376() { NextTest(); } + void OnSuccessResponse_396() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_377() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_397() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_377, OnFailureCallback_377)); + this, OnSuccessCallback_397, OnFailureCallback_397)); return CHIP_NO_ERROR; } - void OnFailureResponse_377(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_397(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_377(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_397(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 6)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_378() + CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_398() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_378, OnFailureCallback_378)); + this, OnSuccessCallback_398, OnFailureCallback_398)); return CHIP_NO_ERROR; } - void OnFailureResponse_378(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_398(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_378(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_398(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_379() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_399() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48225,19 +48880,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_379, OnFailureCallback_379)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_399, OnFailureCallback_399)); return CHIP_NO_ERROR; } - void OnFailureResponse_379(EmberAfStatus status) + void OnFailureResponse_399(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_379() { ThrowSuccessResponse(); } + void OnSuccessResponse_399() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_380() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_400() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48247,19 +48902,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -151; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_380, OnFailureCallback_380)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); return CHIP_NO_ERROR; } - void OnFailureResponse_380(EmberAfStatus status) + void OnFailureResponse_400(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_380() { ThrowSuccessResponse(); } + void OnSuccessResponse_400() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_381() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_401() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48269,19 +48924,19 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 201; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_381, OnFailureCallback_381)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_401, OnFailureCallback_401)); return CHIP_NO_ERROR; } - void OnFailureResponse_381(EmberAfStatus status) + void OnFailureResponse_401(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_381() { ThrowSuccessResponse(); } + void OnSuccessResponse_401() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_382() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_402() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48291,39 +48946,39 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 32767; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_382, OnFailureCallback_382)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); return CHIP_NO_ERROR; } - void OnFailureResponse_382(EmberAfStatus status) + void OnFailureResponse_402(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_382() { ThrowSuccessResponse(); } + void OnSuccessResponse_402() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_383() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_403() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_383, OnFailureCallback_383)); + this, OnSuccessCallback_403, OnFailureCallback_403)); return CHIP_NO_ERROR; } - void OnFailureResponse_383(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_403(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_383(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_403(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 0)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_384() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_404() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48333,35 +48988,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -150; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_404, OnFailureCallback_404)); return CHIP_NO_ERROR; } - void OnFailureResponse_384(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_404(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_384() { NextTest(); } + void OnSuccessResponse_404() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_385() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_405() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_385, OnFailureCallback_385)); + this, OnSuccessCallback_405, OnFailureCallback_405)); return CHIP_NO_ERROR; } - void OnFailureResponse_385(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_405(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_385(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_405(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, -150)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_386() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_406() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48371,35 +49026,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 200; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_386, OnFailureCallback_386)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_406, OnFailureCallback_406)); return CHIP_NO_ERROR; } - void OnFailureResponse_386(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_406(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_386() { NextTest(); } + void OnSuccessResponse_406() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_387() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_407() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_387, OnFailureCallback_387)); + this, OnSuccessCallback_407, OnFailureCallback_407)); return CHIP_NO_ERROR; } - void OnFailureResponse_387(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_407(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_387(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_407(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 200)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_388() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_408() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48409,35 +49064,35 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 7; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_408, OnFailureCallback_408)); return CHIP_NO_ERROR; } - void OnFailureResponse_388(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_408(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_388() { NextTest(); } + void OnSuccessResponse_408() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_389() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_409() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_389, OnFailureCallback_389)); + this, OnSuccessCallback_409, OnFailureCallback_409)); return CHIP_NO_ERROR; } - void OnFailureResponse_389(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_409(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_389(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_409(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 7)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_390() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_410() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48445,13 +49100,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_390, OnFailureCallback_390)); + this, OnSuccessCallback_410, OnFailureCallback_410)); return CHIP_NO_ERROR; } - void OnFailureResponse_390(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_410(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_390(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_410(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -48459,7 +49114,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_391() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_411() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48470,19 +49125,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_391, OnFailureCallback_391)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_411, OnFailureCallback_411)); return CHIP_NO_ERROR; } - void OnFailureResponse_391(EmberAfStatus status) + void OnFailureResponse_411(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_391() { ThrowSuccessResponse(); } + void OnSuccessResponse_411() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_392() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_412() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48493,19 +49148,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_392, OnFailureCallback_392)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_412, OnFailureCallback_412)); return CHIP_NO_ERROR; } - void OnFailureResponse_392(EmberAfStatus status) + void OnFailureResponse_412(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_392() { ThrowSuccessResponse(); } + void OnSuccessResponse_412() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_393() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_413() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48516,19 +49171,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_393, OnFailureCallback_393)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_413, OnFailureCallback_413)); return CHIP_NO_ERROR; } - void OnFailureResponse_393(EmberAfStatus status) + void OnFailureResponse_413(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_393() { ThrowSuccessResponse(); } + void OnSuccessResponse_413() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_394() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_414() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48539,19 +49194,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_394, OnFailureCallback_394)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_414, OnFailureCallback_414)); return CHIP_NO_ERROR; } - void OnFailureResponse_394(EmberAfStatus status) + void OnFailureResponse_414(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_394() { ThrowSuccessResponse(); } + void OnSuccessResponse_414() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_395() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_415() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48559,13 +49214,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_395, OnFailureCallback_395)); + this, OnSuccessCallback_415, OnFailureCallback_415)); return CHIP_NO_ERROR; } - void OnFailureResponse_395(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_415(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_395(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_415(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -48573,7 +49228,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_396() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_416() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48584,15 +49239,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_416, OnFailureCallback_416)); return CHIP_NO_ERROR; } - void OnFailureResponse_396(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_416(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_396() { NextTest(); } + void OnSuccessResponse_416() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_397() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_417() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48600,13 +49255,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_397, OnFailureCallback_397)); + this, OnSuccessCallback_417, OnFailureCallback_417)); return CHIP_NO_ERROR; } - void OnFailureResponse_397(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_417(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_397(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_417(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 20)); @@ -48614,7 +49269,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_398() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_418() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48625,15 +49280,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_398, OnFailureCallback_398)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_418, OnFailureCallback_418)); return CHIP_NO_ERROR; } - void OnFailureResponse_398(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_418(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_398() { NextTest(); } + void OnSuccessResponse_418() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_399() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_419() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48641,13 +49296,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_399, OnFailureCallback_399)); + this, OnSuccessCallback_419, OnFailureCallback_419)); return CHIP_NO_ERROR; } - void OnFailureResponse_399(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_419(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_399(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_419(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 100)); @@ -48655,7 +49310,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_400() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_420() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48666,15 +49321,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_420, OnFailureCallback_420)); return CHIP_NO_ERROR; } - void OnFailureResponse_400(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_420(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_400() { NextTest(); } + void OnSuccessResponse_420() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_401() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_421() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48682,13 +49337,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_401, OnFailureCallback_401)); + this, OnSuccessCallback_421, OnFailureCallback_421)); return CHIP_NO_ERROR; } - void OnFailureResponse_401(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_421(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_401(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_421(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 50)); @@ -48696,7 +49351,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_402() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_422() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48707,15 +49362,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_422, OnFailureCallback_422)); return CHIP_NO_ERROR; } - void OnFailureResponse_402(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_422(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_402() { NextTest(); } + void OnSuccessResponse_422() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_403() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_423() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48723,20 +49378,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_403, OnFailureCallback_403)); + this, OnSuccessCallback_423, OnFailureCallback_423)); return CHIP_NO_ERROR; } - void OnFailureResponse_403(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_423(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_403(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_423(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_404() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_424() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48744,13 +49399,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_404, OnFailureCallback_404)); + this, OnSuccessCallback_424, OnFailureCallback_424)); return CHIP_NO_ERROR; } - void OnFailureResponse_404(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_424(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_404(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_424(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -48758,7 +49413,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_405() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_425() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48769,19 +49424,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_405, OnFailureCallback_405)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_425, OnFailureCallback_425)); return CHIP_NO_ERROR; } - void OnFailureResponse_405(EmberAfStatus status) + void OnFailureResponse_425(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_405() { ThrowSuccessResponse(); } + void OnSuccessResponse_425() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_406() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_426() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48792,19 +49447,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_406, OnFailureCallback_406)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_426, OnFailureCallback_426)); return CHIP_NO_ERROR; } - void OnFailureResponse_406(EmberAfStatus status) + void OnFailureResponse_426(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_406() { ThrowSuccessResponse(); } + void OnSuccessResponse_426() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_407() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_427() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48815,19 +49470,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_407, OnFailureCallback_407)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_427, OnFailureCallback_427)); return CHIP_NO_ERROR; } - void OnFailureResponse_407(EmberAfStatus status) + void OnFailureResponse_427(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_407() { ThrowSuccessResponse(); } + void OnSuccessResponse_427() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_408() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_428() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48838,19 +49493,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_408, OnFailureCallback_408)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_428, OnFailureCallback_428)); return CHIP_NO_ERROR; } - void OnFailureResponse_408(EmberAfStatus status) + void OnFailureResponse_428(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_408() { ThrowSuccessResponse(); } + void OnSuccessResponse_428() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_409() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_429() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48858,13 +49513,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_409, OnFailureCallback_409)); + this, OnSuccessCallback_429, OnFailureCallback_429)); return CHIP_NO_ERROR; } - void OnFailureResponse_409(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_429(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_409(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_429(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -48872,7 +49527,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_410() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_430() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48883,15 +49538,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_410, OnFailureCallback_410)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_430, OnFailureCallback_430)); return CHIP_NO_ERROR; } - void OnFailureResponse_410(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_430(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_410() { NextTest(); } + void OnSuccessResponse_430() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_411() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_431() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48899,13 +49554,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_411, OnFailureCallback_411)); + this, OnSuccessCallback_431, OnFailureCallback_431)); return CHIP_NO_ERROR; } - void OnFailureResponse_411(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_431(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_411(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_431(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 100U)); @@ -48913,7 +49568,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_412() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_432() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48924,15 +49579,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_412, OnFailureCallback_412)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_432, OnFailureCallback_432)); return CHIP_NO_ERROR; } - void OnFailureResponse_412(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_432(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_412() { NextTest(); } + void OnSuccessResponse_432() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_413() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_433() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48940,13 +49595,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_413, OnFailureCallback_413)); + this, OnSuccessCallback_433, OnFailureCallback_433)); return CHIP_NO_ERROR; } - void OnFailureResponse_413(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_433(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_413(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_433(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 1000U)); @@ -48954,7 +49609,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_414() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_434() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48965,15 +49620,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_414, OnFailureCallback_414)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_434, OnFailureCallback_434)); return CHIP_NO_ERROR; } - void OnFailureResponse_414(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_434(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_414() { NextTest(); } + void OnSuccessResponse_434() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_415() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_435() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -48981,13 +49636,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_415, OnFailureCallback_415)); + this, OnSuccessCallback_435, OnFailureCallback_435)); return CHIP_NO_ERROR; } - void OnFailureResponse_415(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_435(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_415(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_435(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 500U)); @@ -48995,7 +49650,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_416() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_436() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49006,15 +49661,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_416, OnFailureCallback_416)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_436, OnFailureCallback_436)); return CHIP_NO_ERROR; } - void OnFailureResponse_416(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_436(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_416() { NextTest(); } + void OnSuccessResponse_436() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_417() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_437() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49022,20 +49677,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_417, OnFailureCallback_417)); + this, OnSuccessCallback_437, OnFailureCallback_437)); return CHIP_NO_ERROR; } - void OnFailureResponse_417(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_437(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_417(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_437(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_418() + CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_438() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49043,13 +49698,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_418, OnFailureCallback_418)); + this, OnSuccessCallback_438, OnFailureCallback_438)); return CHIP_NO_ERROR; } - void OnFailureResponse_418(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_438(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_418(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_438(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 0)); @@ -49057,7 +49712,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_419() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_439() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49068,19 +49723,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_419, OnFailureCallback_419)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_439, OnFailureCallback_439)); return CHIP_NO_ERROR; } - void OnFailureResponse_419(EmberAfStatus status) + void OnFailureResponse_439(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_419() { ThrowSuccessResponse(); } + void OnSuccessResponse_439() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_420() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_440() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49091,19 +49746,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_420, OnFailureCallback_420)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_440, OnFailureCallback_440)); return CHIP_NO_ERROR; } - void OnFailureResponse_420(EmberAfStatus status) + void OnFailureResponse_440(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_420() { ThrowSuccessResponse(); } + void OnSuccessResponse_440() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_421() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_441() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49114,19 +49769,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_421, OnFailureCallback_421)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_441, OnFailureCallback_441)); return CHIP_NO_ERROR; } - void OnFailureResponse_421(EmberAfStatus status) + void OnFailureResponse_441(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_421() { ThrowSuccessResponse(); } + void OnSuccessResponse_441() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_422() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_442() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49137,19 +49792,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_422, OnFailureCallback_422)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_442, OnFailureCallback_442)); return CHIP_NO_ERROR; } - void OnFailureResponse_422(EmberAfStatus status) + void OnFailureResponse_442(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_422() { ThrowSuccessResponse(); } + void OnSuccessResponse_442() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_423() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_443() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49157,13 +49812,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_423, OnFailureCallback_423)); + this, OnSuccessCallback_443, OnFailureCallback_443)); return CHIP_NO_ERROR; } - void OnFailureResponse_423(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_443(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_423(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_443(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 0)); @@ -49171,7 +49826,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_424() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_444() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49182,15 +49837,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_424, OnFailureCallback_424)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_444, OnFailureCallback_444)); return CHIP_NO_ERROR; } - void OnFailureResponse_424(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_444(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_424() { NextTest(); } + void OnSuccessResponse_444() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_425() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_445() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49198,13 +49853,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_425, OnFailureCallback_425)); + this, OnSuccessCallback_445, OnFailureCallback_445)); return CHIP_NO_ERROR; } - void OnFailureResponse_425(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_445(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_425(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_445(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), -40)); @@ -49212,7 +49867,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_426() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_446() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49223,15 +49878,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_426, OnFailureCallback_426)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_446, OnFailureCallback_446)); return CHIP_NO_ERROR; } - void OnFailureResponse_426(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_446(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_426() { NextTest(); } + void OnSuccessResponse_446() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_427() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_447() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49239,13 +49894,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_427, OnFailureCallback_427)); + this, OnSuccessCallback_447, OnFailureCallback_447)); return CHIP_NO_ERROR; } - void OnFailureResponse_427(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_447(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_427(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_447(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 50)); @@ -49253,7 +49908,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_428() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_448() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49264,15 +49919,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_428, OnFailureCallback_428)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_448, OnFailureCallback_448)); return CHIP_NO_ERROR; } - void OnFailureResponse_428(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_448(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_428() { NextTest(); } + void OnSuccessResponse_448() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_429() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_449() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49280,13 +49935,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_429, OnFailureCallback_429)); + this, OnSuccessCallback_449, OnFailureCallback_449)); return CHIP_NO_ERROR; } - void OnFailureResponse_429(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_449(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_429(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_449(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 6)); @@ -49294,7 +49949,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_430() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_450() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49305,15 +49960,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_430, OnFailureCallback_430)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_450, OnFailureCallback_450)); return CHIP_NO_ERROR; } - void OnFailureResponse_430(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_450(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_430() { NextTest(); } + void OnSuccessResponse_450() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_431() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_451() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49321,20 +49976,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_431, OnFailureCallback_431)); + this, OnSuccessCallback_451, OnFailureCallback_451)); return CHIP_NO_ERROR; } - void OnFailureResponse_431(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_451(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_431(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_451(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_432() + CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_452() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49342,13 +49997,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_432, OnFailureCallback_432)); + this, OnSuccessCallback_452, OnFailureCallback_452)); return CHIP_NO_ERROR; } - void OnFailureResponse_432(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_452(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_432(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_452(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 0)); @@ -49356,7 +50011,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_433() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_453() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49367,19 +50022,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_433, OnFailureCallback_433)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_453, OnFailureCallback_453)); return CHIP_NO_ERROR; } - void OnFailureResponse_433(EmberAfStatus status) + void OnFailureResponse_453(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_433() { ThrowSuccessResponse(); } + void OnSuccessResponse_453() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_434() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_454() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49390,19 +50045,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_434, OnFailureCallback_434)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_454, OnFailureCallback_454)); return CHIP_NO_ERROR; } - void OnFailureResponse_434(EmberAfStatus status) + void OnFailureResponse_454(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_434() { ThrowSuccessResponse(); } + void OnSuccessResponse_454() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_435() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_455() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49413,19 +50068,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_435, OnFailureCallback_435)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_455, OnFailureCallback_455)); return CHIP_NO_ERROR; } - void OnFailureResponse_435(EmberAfStatus status) + void OnFailureResponse_455(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_435() { ThrowSuccessResponse(); } + void OnSuccessResponse_455() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_436() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_456() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49436,19 +50091,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_436, OnFailureCallback_436)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_456, OnFailureCallback_456)); return CHIP_NO_ERROR; } - void OnFailureResponse_436(EmberAfStatus status) + void OnFailureResponse_456(EmberAfStatus status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_436() { ThrowSuccessResponse(); } + void OnSuccessResponse_456() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_437() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_457() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49456,13 +50111,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_437, OnFailureCallback_437)); + this, OnSuccessCallback_457, OnFailureCallback_457)); return CHIP_NO_ERROR; } - void OnFailureResponse_437(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_457(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_437(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_457(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 0)); @@ -49470,7 +50125,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_438() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_458() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49481,15 +50136,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_438, OnFailureCallback_438)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_458, OnFailureCallback_458)); return CHIP_NO_ERROR; } - void OnFailureResponse_438(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_458(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_438() { NextTest(); } + void OnSuccessResponse_458() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_439() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_459() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49497,13 +50152,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_439, OnFailureCallback_439)); + this, OnSuccessCallback_459, OnFailureCallback_459)); return CHIP_NO_ERROR; } - void OnFailureResponse_439(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_459(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_439(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_459(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), -150)); @@ -49511,7 +50166,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_440() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_460() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49522,15 +50177,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_440, OnFailureCallback_440)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_460, OnFailureCallback_460)); return CHIP_NO_ERROR; } - void OnFailureResponse_440(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_460(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_440() { NextTest(); } + void OnSuccessResponse_460() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_441() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_461() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49538,13 +50193,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_441, OnFailureCallback_441)); + this, OnSuccessCallback_461, OnFailureCallback_461)); return CHIP_NO_ERROR; } - void OnFailureResponse_441(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_461(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_441(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_461(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 200)); @@ -49552,7 +50207,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_442() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_462() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49563,15 +50218,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_442, OnFailureCallback_442)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_462, OnFailureCallback_462)); return CHIP_NO_ERROR; } - void OnFailureResponse_442(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_462(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_442() { NextTest(); } + void OnSuccessResponse_462() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_443() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_463() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49579,13 +50234,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_443, OnFailureCallback_443)); + this, OnSuccessCallback_463, OnFailureCallback_463)); return CHIP_NO_ERROR; } - void OnFailureResponse_443(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_463(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_443(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_463(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 7)); @@ -49593,7 +50248,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_444() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_464() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49604,15 +50259,15 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_444, OnFailureCallback_444)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_464, OnFailureCallback_464)); return CHIP_NO_ERROR; } - void OnFailureResponse_444(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_464(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_444() { NextTest(); } + void OnSuccessResponse_464() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_445() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_465() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -49620,13 +50275,13 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_445, OnFailureCallback_445)); + this, OnSuccessCallback_465, OnFailureCallback_465)); return CHIP_NO_ERROR; } - void OnFailureResponse_445(EmberAfStatus status) { ThrowFailureResponse(); } + void OnFailureResponse_465(EmberAfStatus status) { ThrowFailureResponse(); } - void OnSuccessResponse_445(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_465(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s));