From 729af595982b8cfdbd1e082d8edf5c5398e8eda6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonathan=20M=C3=A9gevand?= <77852424+jmeg-sfy@users.noreply.github.com> Date: Tue, 23 Nov 2021 14:39:19 +0100 Subject: [PATCH] [Yaml] WindowCovering: Fix and Update WNCV_1_1 and WNCV_2_1 (#12096) * WC: Fixes and add some testing * WC : Yaml test refinements * WC Yaml fix * Update Yaml testing to zap/zzz/generated * Restyled by whitespace * Restyled by prettier-yaml * WC: Fix: preset all cluster position attribute to half their ranges * Zap : regen update Co-authored-by: Restyled.io --- .../all-clusters-common/all-clusters-app.zap | 18 +- .../certification/Test_TC_WNCV_1_1.yaml | 41 +- .../certification/Test_TC_WNCV_2_1.yaml | 635 +++++- .../Framework/CHIPTests/CHIPClustersTests.m | 1154 ++++++++++- .../zap-generated/endpoint_config.h | 16 +- .../chip-tool/zap-generated/test/Commands.h | 1772 +++++++++++++++-- 6 files changed, 3291 insertions(+), 345 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap index aa7de84bf23ce3..a85c92de527f9d 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap @@ -10515,7 +10515,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": "0x7FFF", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -10530,7 +10530,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": "0x7FFF", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -10560,7 +10560,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFF", + "defaultValue": "50", "reportable": 1, "minInterval": 0, "maxInterval": 100, @@ -10575,7 +10575,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFF", + "defaultValue": "50", "reportable": 1, "minInterval": 0, "maxInterval": 100, @@ -10605,7 +10605,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFF", + "defaultValue": "500", "reportable": 1, "minInterval": 0, "maxInterval": 10000, @@ -10620,7 +10620,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFFFF", + "defaultValue": "500", "reportable": 1, "minInterval": 0, "maxInterval": 10000, @@ -10650,7 +10650,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFF", + "defaultValue": "500", "reportable": 1, "minInterval": 0, "maxInterval": 10000, @@ -10665,7 +10665,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFF", + "defaultValue": "500", "reportable": 1, "minInterval": 0, "maxInterval": 10000, @@ -19630,4 +19630,4 @@ } ], "log": [] -} \ No newline at end of file +} diff --git a/src/app/tests/suites/certification/Test_TC_WNCV_1_1.yaml b/src/app/tests/suites/certification/Test_TC_WNCV_1_1.yaml index 2782edb38b5891..62b53512042997 100644 --- a/src/app/tests/suites/certification/Test_TC_WNCV_1_1.yaml +++ b/src/app/tests/suites/certification/Test_TC_WNCV_1_1.yaml @@ -19,45 +19,60 @@ config: endpoint: 1 tests: - - label: "read the global attribute: ClusterRevision" + ### MANDATORY GLOBAL Attributes + ### Attribute[0xFFFD]: ClusterRevision ======================================= + - label: "2: read the global attribute: ClusterRevision" command: "readAttribute" attribute: "ClusterRevision" response: - value: 5 + constraints: + type: uint16 + minValue: 5 + maxValue: 200 - label: - "write the default value to mandatory global attribute: + "3a: write a value into the RO mandatory global attribute: ClusterRevision" command: "writeAttribute" attribute: "ClusterRevision" arguments: - value: 5 + value: 201 response: error: 1 - - label: "reads back global attribute: ClusterRevision" + - label: "3b: reads back global attribute: ClusterRevision" command: "readAttribute" attribute: "ClusterRevision" response: - value: 5 + constraints: + type: uint16 + notValue: 201 - - label: "read the global attribute: FeatureMap" + ### Attribute[0xFFFC]: FeatureMap ======================================= + - label: "2: read the global attribute: FeatureMap" command: "readAttribute" attribute: "FeatureMap" response: - value: 0 + constraints: + type: uint32 + minValue: 0 + maxValue: 32768 - - label: "write the default value to optional global attribute: FeatureMap" - disabled: true + - label: + "3a: write the default value to optional global attribute: FeatureMap" command: "writeAttribute" attribute: "FeatureMap" arguments: - value: 5 + value: 32769 response: error: 1 - - label: "reads back global attribute: FeatureMap" + - label: "3b: reads back global attribute: FeatureMap" command: "readAttribute" attribute: "FeatureMap" response: - value: 0 + constraints: + type: uint32 + notValue: 32769 + ### OPTIONAL GLOBAL Attributes + ### None ======================================= diff --git a/src/app/tests/suites/certification/Test_TC_WNCV_2_1.yaml b/src/app/tests/suites/certification/Test_TC_WNCV_2_1.yaml index a326d641d49400..b2a5d01ab915f9 100644 --- a/src/app/tests/suites/certification/Test_TC_WNCV_2_1.yaml +++ b/src/app/tests/suites/certification/Test_TC_WNCV_2_1.yaml @@ -12,6 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +# TODO : WindowCovering Test WNCV_2_1 add/complete some Conditional test using the FeatureMap (dynamics Mandatory and Optional attributes) + name: Window Covering [TC-WNCV-2.1] Attributes with server as DUT config: @@ -20,112 +22,665 @@ config: tests: ### MANDATORY Attributes - ### Attribute[ 0]: Type - - label: "read the RO mandatory attribute default: Type" + ### Attribute[ 0]: Type ======================================= + - label: "2: read the RO mandatory attribute default: Type" command: "readAttribute" attribute: "Type" response: - value: 0 + constraints: + type: enum8 + minValue: 0 + maxValue: 9 - - label: "write a value into the RO mandatory attribute: Type" - disabled: true # TODO : follow chip-tool error messaging capabilities to write or not into read only attribute + - label: "3a: write a value into the RO mandatory attribute: Type" command: "writeAttribute" attribute: "Type" arguments: - value: 7 + value: 250 response: error: 1 - - label: "reads back the RO mandatory attribute: Type" + - label: "3b: reads back the RO mandatory attribute: Type" command: "readAttribute" attribute: "Type" response: - value: 0 + constraints: + type: enum8 + notValue: 250 - ### Attribute[ 7]: ConfigStatus - - label: "read the RO mandatory attribute default: ConfigStatus" + ### Attribute[ 7]: ConfigStatus =============================== + - label: "2: read the RO mandatory attribute default: ConfigStatus" command: "readAttribute" attribute: "ConfigStatus" response: - value: 3 + constraints: + type: map8 + minValue: 0 + maxValue: 63 - - label: "write a value into the RO mandatory attribute: ConfigStatus" - disabled: true # TODO : follow chip-tool error messaging capabilities to write or not into read only attribute + - label: "3a: write a value into the RO mandatory attribute: ConfigStatus" command: "writeAttribute" attribute: "ConfigStatus" arguments: - value: 7 + value: 128 response: error: 1 - - label: "reads back the RO mandatory attribute: ConfigStatus" + - label: "3b: reads back the RO mandatory attribute: ConfigStatus" command: "readAttribute" attribute: "ConfigStatus" response: - value: 3 + constraints: + type: map8 + notValue: 128 - ### Attribute[ 10]: OperationalStatus - - label: "read the RO mandatory attribute default: OperationalStatus" + ### Attribute[ 10]: OperationalStatus ========================== + - label: "2: read the RO mandatory attribute default: OperationalStatus" command: "readAttribute" attribute: "OperationalStatus" response: - value: 0 + constraints: + type: map8 + minValue: 0 + maxValue: 63 - - label: "write a value into the RO mandatory attribute: OperationalStatus" - disabled: true # TODO : follow chip-tool error messaging capabilities to write or not into read only attribute + - label: + "3a: write a value into the RO mandatory attribute: OperationalStatus" command: "writeAttribute" attribute: "OperationalStatus" arguments: - value: 7 + value: 128 response: error: 1 - - label: "reads back the RO mandatory attribute: OperationalStatus" + - label: "3b: reads back the RO mandatory attribute: OperationalStatus" command: "readAttribute" attribute: "OperationalStatus" response: - value: 0 + constraints: + type: map8 + notValue: 128 - ### Attribute[ 13]: EndProductType - - label: "read the RO mandatory attribute default: EndProductType" + ### Attribute[ 13]: EndProductType ============================== + - label: "2: read the RO mandatory attribute default: EndProductType" command: "readAttribute" attribute: "EndProductType" response: - value: 0 + constraints: + type: enum8 + minValue: 0 + maxValue: 23 - - label: "write a value into the RO mandatory attribute: EndProductType" - disabled: true # TODO : follow chip-tool error messaging capabilities to write or not into read only attribute + - label: "3a: write a value into the RO mandatory attribute: EndProductType" command: "writeAttribute" attribute: "EndProductType" arguments: - value: 7 + value: 250 response: error: 1 - - label: "reads back the RO mandatory attribute: EndProductType" + - label: "3b: reads back the RO mandatory attribute: EndProductType" command: "readAttribute" attribute: "EndProductType" response: - value: 0 + constraints: + type: enum8 + notValue: 250 - ### Attribute[ 23]: Mode - - label: "read the RW mandatory attribute default: Mode" + ### Attribute[ 23]: Mode ======================================== + - label: "2: read the RW mandatory attribute default: Mode" command: "readAttribute" attribute: "Mode" response: - value: 0 + constraints: + type: map8 + minValue: 0 + maxValue: 15 - - label: "write a value into the RW mandatory attribute:: Mode" - disabled: false + - label: "3a: write a value into the RW mandatory attribute:: Mode" command: "writeAttribute" attribute: "Mode" arguments: - value: 7 + value: 8 response: error: 0 - - label: "reads back the RW mandatory attribute: Mode" + - label: "3b: reads back the RW mandatory attribute: Mode" command: "readAttribute" attribute: "Mode" response: - value: 7 + value: 8 + + ### CONDITIONALLY MANDATORY Attributes + ### Attribute[ 11]: TargetPositionLiftPercent100ths ==================== + - label: + "2: read the RO optional attribute default: + TargetPositionLiftPercent100ths" + command: "readAttribute" + attribute: "TargetPositionLiftPercent100ths" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 10000 + + - label: + "3a: write a value into the RO optional attribute: + TargetPositionLiftPercent100ths" + command: "writeAttribute" + attribute: "TargetPositionLiftPercent100ths" + arguments: + value: 20000 + response: + error: 1 + + - label: + "3b: reads back the RO optional attribute: + TargetPositionLiftPercent100ths" + command: "readAttribute" + attribute: "TargetPositionLiftPercent100ths" + response: + constraints: + type: uint16 + notValue: 20000 + + ### Attribute[ 12]: TargetPositionTiltPercent100ths ==================== + - label: + "2: read the RO optional attribute default: + TargetPositionTiltPercent100ths" + command: "readAttribute" + attribute: "TargetPositionTiltPercent100ths" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 10000 + + - label: + "3a: write a value into the RO optional attribute: + TargetPositionTiltPercent100ths" + command: "writeAttribute" + attribute: "TargetPositionTiltPercent100ths" + arguments: + value: 20000 + response: + error: 1 + + - label: + "3b: reads back the RO optional attribute: + TargetPositionTiltPercent100ths" + command: "readAttribute" + attribute: "TargetPositionTiltPercent100ths" + response: + constraints: + type: uint16 + notValue: 20000 + + ### Attribute[ 14]: CurrentPositionLiftPercent100ths ==================== + - label: + "2: read the RO optional attribute default: + CurrentPositionLiftPercent100ths" + command: "readAttribute" + attribute: "CurrentPositionLiftPercent100ths" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 10000 + + - label: + "3a: write a value into the RO optional attribute: + CurrentPositionLiftPercent100ths" + command: "writeAttribute" + attribute: "CurrentPositionLiftPercent100ths" + arguments: + value: 20000 + response: + error: 1 + + - label: + "3b: reads back the RO optional attribute: + CurrentPositionLiftPercent100ths" + command: "readAttribute" + attribute: "CurrentPositionLiftPercent100ths" + response: + constraints: + type: uint16 + notValue: 20000 + + ### Attribute[ 15]: CurrentPositionTiltPercent100ths ==================== + - label: + "2: read the RO optional attribute default: + CurrentPositionTiltPercent100ths" + command: "readAttribute" + attribute: "CurrentPositionTiltPercent100ths" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 10000 + + - label: + "3a: write a value into the RO optional attribute: + CurrentPositionTiltPercent100ths" + command: "writeAttribute" + attribute: "CurrentPositionTiltPercent100ths" + arguments: + value: 20000 + response: + error: 1 + + - label: + "3b: reads back the RO optional attribute: + CurrentPositionTiltPercent100ths" + command: "readAttribute" + attribute: "CurrentPositionTiltPercent100ths" + response: + constraints: + type: uint16 + notValue: 20000 + + ### Attribute[ 16]: InstalledOpenLimitLift ==================== + - label: "2: read the RO optional attribute default: InstalledOpenLimitLift" + command: "readAttribute" + attribute: "InstalledOpenLimitLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "3a: write a value into the RO optional attribute: + InstalledOpenLimitLift" + command: "writeAttribute" + attribute: "InstalledOpenLimitLift" + arguments: + value: 255 + response: + error: 1 + + - label: "3b: reads back the RO optional attribute: InstalledOpenLimitLift" + command: "readAttribute" + attribute: "InstalledOpenLimitLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 17]: InstalledClosedLimitLift ==================== + - label: + "2: read the RO optional attribute default: InstalledClosedLimitLift" + command: "readAttribute" + attribute: "InstalledClosedLimitLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "3a: write a value into the RO optional attribute: + InstalledClosedLimitLift" + command: "writeAttribute" + attribute: "InstalledClosedLimitLift" + arguments: + value: 255 + response: + error: 1 + + - label: + "3b: reads back the RO optional attribute: InstalledClosedLimitLift" + command: "readAttribute" + attribute: "InstalledClosedLimitLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 18]: InstalledOpenLimitTilt ==================== + - label: "2: read the RO optional attribute default: InstalledOpenLimitTilt" + command: "readAttribute" + attribute: "InstalledOpenLimitTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "3a: write a value into the RO optional attribute: + InstalledOpenLimitTilt" + command: "writeAttribute" + attribute: "InstalledOpenLimitTilt" + arguments: + value: 255 + response: + error: 1 + + - label: "3b: reads back the RO optional attribute: InstalledOpenLimitTilt" + command: "readAttribute" + attribute: "InstalledOpenLimitTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 19]: InstalledClosedLimitTilt ==================== + - label: + "2: read the RO optional attribute default: InstalledClosedLimitTilt" + command: "readAttribute" + attribute: "InstalledClosedLimitTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "3a: write a value into the RO optional attribute: + InstalledClosedLimitTilt" + command: "writeAttribute" + attribute: "InstalledClosedLimitTilt" + arguments: + value: 255 + response: + error: 1 + + - label: + "3b: reads back the RO optional attribute: InstalledClosedLimitTilt" + command: "readAttribute" + attribute: "InstalledClosedLimitTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### CONDITIONALLY and PURELY OPTIONAL Attributes + ### Attribute[ 26]: SafetyStatus ========================== + - label: "4: read the RO mandatory attribute default: SafetyStatus" + command: "readAttribute" + attribute: "SafetyStatus" + response: + constraints: + type: map16 + minValue: 0 + maxValue: 2047 + + - label: "5a: write a value into the RO mandatory attribute: SafetyStatus" + command: "writeAttribute" + attribute: "SafetyStatus" + arguments: + value: 4096 + response: + error: 1 + + - label: "5b: reads back the RO mandatory attribute: SafetyStatus" + command: "readAttribute" + attribute: "SafetyStatus" + response: + constraints: + type: map16 + notValue: 4096 + + ### Attribute[ 1]: PhysicalClosedLimitLift ==================== + - label: + "4: read the RO optional attribute default: PhysicalClosedLimitLift" + disabled: true + command: "readAttribute" + attribute: "PhysicalClosedLimitLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "5a: write a value into the RO optional attribute: + PhysicalClosedLimitLift" + disabled: true + command: "writeAttribute" + attribute: "PhysicalClosedLimitLift" + arguments: + value: 255 + response: + error: 1 + + - label: "5b: reads back the RO optional attribute: PhysicalClosedLimitLift" + disabled: true + command: "readAttribute" + attribute: "PhysicalClosedLimitLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 2]: PhysicalClosedLimitTilt ==================== + - label: + "4: read the RO optional attribute default: PhysicalClosedLimitTilt" + disabled: true + command: "readAttribute" + attribute: "PhysicalClosedLimitTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "5a: write a value into the RO optional attribute: + PhysicalClosedLimitTilt" + disabled: true + command: "writeAttribute" + attribute: "PhysicalClosedLimitTilt" + arguments: + value: 255 + response: + error: 1 + + - label: "5b: reads back the RO optional attribute: PhysicalClosedLimitTilt" + disabled: true + command: "readAttribute" + attribute: "PhysicalClosedLimitTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 3]: CurrentPositionLift ==================== + - label: "4: read the RO optional attribute default: CurrentPositionLift" + command: "readAttribute" + attribute: "CurrentPositionLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "5a: write a value into the RO optional attribute: CurrentPositionLift" + command: "writeAttribute" + attribute: "CurrentPositionLift" + arguments: + value: 255 + response: + error: 1 + + - label: "5b: reads back the RO optional attribute: CurrentPositionLift" + command: "readAttribute" + attribute: "CurrentPositionLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 4]: CurrentPositionTilt ==================== + - label: "4: read the RO optional attribute default: CurrentPositionTilt" + command: "readAttribute" + attribute: "CurrentPositionTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "5a: write a value into the RO optional attribute: CurrentPositionTilt" + command: "writeAttribute" + attribute: "CurrentPositionTilt" + arguments: + value: 255 + response: + error: 1 + + - label: "5b: reads back the RO optional attribute: CurrentPositionTilt" + command: "readAttribute" + attribute: "CurrentPositionTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 5]: NumberOfActuationsLift ==================== + - label: "4: read the RO optional attribute default: NumberOfActuationsLift" + disabled: true + command: "readAttribute" + attribute: "NumberOfActuationsLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "5a: write a value into the RO optional attribute: + NumberOfActuationsLift" + disabled: true + command: "writeAttribute" + attribute: "NumberOfActuationsLift" + arguments: + value: 255 + response: + error: 1 + + - label: "5b: reads back the RO optional attribute: NumberOfActuationsLift" + disabled: true + command: "readAttribute" + attribute: "NumberOfActuationsLift" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 6]: NumberOfActuationsTilt ==================== + - label: "4: read the RO optional attribute default: NumberOfActuationsTilt" + disabled: true + command: "readAttribute" + attribute: "NumberOfActuationsTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + - label: + "5a: write a value into the RO optional attribute: + NumberOfActuationsTilt" + disabled: true + command: "writeAttribute" + attribute: "NumberOfActuationsTilt" + arguments: + value: 255 + response: + error: 1 + + - label: "5b: reads back the RO optional attribute: NumberOfActuationsTilt" + disabled: true + command: "readAttribute" + attribute: "NumberOfActuationsTilt" + response: + constraints: + type: uint16 + minValue: 0 + maxValue: 65535 + + ### Attribute[ 8]: CurrentPositionLiftPercentage ==================== + - label: + "4: read the RO optional attribute default: + CurrentPositionLiftPercentage" + command: "readAttribute" + attribute: "CurrentPositionLiftPercentage" + response: + constraints: + type: uint8 + minValue: 0 + maxValue: 100 + + - label: + "5a: write a value into the RO optional attribute: + CurrentPositionLiftPercentage" + command: "writeAttribute" + attribute: "CurrentPositionLiftPercentage" + arguments: + value: 200 + response: + error: 1 + + - label: + "5b: reads back the RO optional attribute: + CurrentPositionLiftPercentage" + command: "readAttribute" + attribute: "CurrentPositionLiftPercentage" + response: + constraints: + type: uint8 + notValue: 200 + + ### Attribute[ 9]: CurrentPositionTiltPercentage ==================== + - label: + "4: read the RO optional attribute default: + CurrentPositionTiltPercentage" + command: "readAttribute" + attribute: "CurrentPositionTiltPercentage" + response: + constraints: + type: uint8 + minValue: 0 + maxValue: 100 + + - label: + "5a: write a value into the RO optional attribute: + CurrentPositionTiltPercentage" + command: "writeAttribute" + attribute: "CurrentPositionTiltPercentage" + arguments: + value: 200 + response: + error: 1 + + - label: + "5b: reads back the RO optional attribute: + CurrentPositionTiltPercentage" + command: "readAttribute" + attribute: "CurrentPositionTiltPercentage" + response: + constraints: + type: uint8 + notValue: 200 + ################################################### + # FYI Non Tested deprecated attributes + # 20 VelocityLift + # 21 AccelerationTimeLift + # 22 DecelerationTimeLift + # 24 IntermediateSetpointsLift + # 25 IntermediateSetpointsTilt + ################################################### diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 2645767f8ce5b5..e5f2881664fe34 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -16502,7 +16502,7 @@ - (void)testSendClusterTest_TC_DIAGTH_1_1_000002_ReadAttribute - (void)testSendClusterTest_TC_WNCV_1_1_000000_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"read the global attribute: ClusterRevision"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"2: read the global attribute: ClusterRevision"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16510,14 +16510,12 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000000_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeClusterRevisionWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"read the global attribute: ClusterRevision Error: %@", err); + NSLog(@"2: read the global attribute: ClusterRevision Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedShortValue], 5U); - } + XCTAssertGreaterThanOrEqual([values[@"value"] unsignedShortValue], 5); + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 200); [expectation fulfill]; }]; @@ -16527,7 +16525,7 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000000_ReadAttribute - (void)testSendClusterTest_TC_WNCV_1_1_000001_WriteAttribute { XCTestExpectation * expectation = - [self expectationWithDescription:@"write the default value to mandatory global attribute: ClusterRevision"]; + [self expectationWithDescription:@"3a: write a value into the RO mandatory global attribute: ClusterRevision"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16535,11 +16533,12 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000001_WriteAttribute XCTAssertNotNil(cluster); id clusterRevisionArgument; - clusterRevisionArgument = [NSNumber numberWithUnsignedShort:5U]; + clusterRevisionArgument = [NSNumber numberWithUnsignedShort:201U]; [cluster writeAttributeClusterRevisionWithValue:clusterRevisionArgument responseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"write the default value to mandatory global attribute: ClusterRevision Error: %@", err); + NSLog( + @"3a: write a value into the RO mandatory global attribute: ClusterRevision Error: %@", err); XCTAssertEqual(err.code, 1); [expectation fulfill]; @@ -16549,7 +16548,7 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000001_WriteAttribute } - (void)testSendClusterTest_TC_WNCV_1_1_000002_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"reads back global attribute: ClusterRevision"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"3b: reads back global attribute: ClusterRevision"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16557,14 +16556,11 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000002_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeClusterRevisionWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"reads back global attribute: ClusterRevision Error: %@", err); + NSLog(@"3b: reads back global attribute: ClusterRevision Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedShortValue], 5U); - } + XCTAssertNotEqual([values[@"value"] unsignedShortValue], 201); [expectation fulfill]; }]; @@ -16573,7 +16569,7 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000002_ReadAttribute } - (void)testSendClusterTest_TC_WNCV_1_1_000003_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"read the global attribute: FeatureMap"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"2: read the global attribute: FeatureMap"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16581,23 +16577,42 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000003_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeFeatureMapWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"read the global attribute: FeatureMap Error: %@", err); + NSLog(@"2: read the global attribute: FeatureMap Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedIntValue], 0UL); - } + XCTAssertLessThanOrEqual([values[@"value"] unsignedIntValue], 32768); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_1_1_000004_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_1_1_000004_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write the default value to optional global attribute: FeatureMap"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id featureMapArgument; + featureMapArgument = [NSNumber numberWithUnsignedInt:32769UL]; + [cluster writeAttributeFeatureMapWithValue:featureMapArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write the default value to optional global attribute: FeatureMap Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_1_1_000005_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"reads back global attribute: FeatureMap"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"3b: reads back global attribute: FeatureMap"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16605,14 +16620,11 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000004_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeFeatureMapWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"reads back global attribute: FeatureMap Error: %@", err); + NSLog(@"3b: reads back global attribute: FeatureMap Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedIntValue], 0UL); - } + XCTAssertNotEqual([values[@"value"] unsignedIntValue], 32769); [expectation fulfill]; }]; @@ -16622,7 +16634,7 @@ - (void)testSendClusterTest_TC_WNCV_1_1_000004_ReadAttribute - (void)testSendClusterTest_TC_WNCV_2_1_000000_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"read the RO mandatory attribute default: Type"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"2: read the RO mandatory attribute default: Type"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16630,23 +16642,41 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000000_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeTypeWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"read the RO mandatory attribute default: Type Error: %@", err); + NSLog(@"2: read the RO mandatory attribute default: Type Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } + XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 9); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000001_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000001_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"3a: write a value into the RO mandatory attribute: Type"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id typeArgument; + typeArgument = [NSNumber numberWithUnsignedChar:250]; + [cluster writeAttributeTypeWithValue:typeArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO mandatory attribute: Type Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000002_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"reads back the RO mandatory attribute: Type"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"3b: reads back the RO mandatory attribute: Type"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16654,23 +16684,20 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000001_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeTypeWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"reads back the RO mandatory attribute: Type Error: %@", err); + NSLog(@"3b: reads back the RO mandatory attribute: Type Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } + XCTAssertNotEqual([values[@"value"] unsignedCharValue], 250); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000002_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000003_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"read the RO mandatory attribute default: ConfigStatus"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"2: read the RO mandatory attribute default: ConfigStatus"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16678,23 +16705,42 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000002_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeConfigStatusWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"read the RO mandatory attribute default: ConfigStatus Error: %@", err); + NSLog(@"2: read the RO mandatory attribute default: ConfigStatus Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 3); - } + XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 63); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000003_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000004_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO mandatory attribute: ConfigStatus"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id configStatusArgument; + configStatusArgument = [NSNumber numberWithUnsignedChar:128]; + [cluster writeAttributeConfigStatusWithValue:configStatusArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO mandatory attribute: ConfigStatus Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000005_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"reads back the RO mandatory attribute: ConfigStatus"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"3b: reads back the RO mandatory attribute: ConfigStatus"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16702,24 +16748,21 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000003_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeConfigStatusWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"reads back the RO mandatory attribute: ConfigStatus Error: %@", err); + NSLog(@"3b: reads back the RO mandatory attribute: ConfigStatus Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 3); - } + XCTAssertNotEqual([values[@"value"] unsignedCharValue], 128); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000004_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000006_ReadAttribute { XCTestExpectation * expectation = - [self expectationWithDescription:@"read the RO mandatory attribute default: OperationalStatus"]; + [self expectationWithDescription:@"2: read the RO mandatory attribute default: OperationalStatus"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16727,23 +16770,44 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000004_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeOperationalStatusWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"read the RO mandatory attribute default: OperationalStatus Error: %@", err); + NSLog(@"2: read the RO mandatory attribute default: OperationalStatus Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } + XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 63); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000005_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000007_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO mandatory attribute: OperationalStatus"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id operationalStatusArgument; + operationalStatusArgument = [NSNumber numberWithUnsignedChar:128]; + [cluster + writeAttributeOperationalStatusWithValue:operationalStatusArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO mandatory attribute: OperationalStatus Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000008_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"reads back the RO mandatory attribute: OperationalStatus"]; + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO mandatory attribute: OperationalStatus"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16751,23 +16815,21 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000005_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeOperationalStatusWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"reads back the RO mandatory attribute: OperationalStatus Error: %@", err); + NSLog(@"3b: reads back the RO mandatory attribute: OperationalStatus Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } + XCTAssertNotEqual([values[@"value"] unsignedCharValue], 128); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000006_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000009_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"read the RO mandatory attribute default: EndProductType"]; + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO mandatory attribute default: EndProductType"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16775,23 +16837,43 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000006_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeEndProductTypeWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"read the RO mandatory attribute default: EndProductType Error: %@", err); + NSLog(@"2: read the RO mandatory attribute default: EndProductType Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } + XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 23); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000007_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000010_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO mandatory attribute: EndProductType"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id endProductTypeArgument; + endProductTypeArgument = [NSNumber numberWithUnsignedChar:250]; + [cluster writeAttributeEndProductTypeWithValue:endProductTypeArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO mandatory attribute: EndProductType Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000011_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"reads back the RO mandatory attribute: EndProductType"]; + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO mandatory attribute: EndProductType"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16799,23 +16881,20 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000007_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeEndProductTypeWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"reads back the RO mandatory attribute: EndProductType Error: %@", err); + NSLog(@"3b: reads back the RO mandatory attribute: EndProductType Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } + XCTAssertNotEqual([values[@"value"] unsignedCharValue], 250); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000008_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000012_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"read the RW mandatory attribute default: Mode"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"2: read the RW mandatory attribute default: Mode"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16823,23 +16902,20 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000008_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeModeWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"read the RW mandatory attribute default: Mode Error: %@", err); + NSLog(@"2: read the RW mandatory attribute default: Mode Error: %@", err); XCTAssertEqual(err.code, 0); - { - id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } + XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 15); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000009_WriteAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000013_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"write a value into the RW mandatory attribute:: Mode"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"3a: write a value into the RW mandatory attribute:: Mode"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16847,10 +16923,10 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000009_WriteAttribute XCTAssertNotNil(cluster); id modeArgument; - modeArgument = [NSNumber numberWithUnsignedChar:7]; + modeArgument = [NSNumber numberWithUnsignedChar:8]; [cluster writeAttributeModeWithValue:modeArgument responseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"write a value into the RW mandatory attribute:: Mode Error: %@", err); + NSLog(@"3a: write a value into the RW mandatory attribute:: Mode Error: %@", err); XCTAssertEqual(err.code, 0); @@ -16859,9 +16935,9 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000009_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTest_TC_WNCV_2_1_000010_ReadAttribute +- (void)testSendClusterTest_TC_WNCV_2_1_000014_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"reads back the RW mandatory attribute: Mode"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"3b: reads back the RW mandatory attribute: Mode"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -16869,13 +16945,13 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000010_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeModeWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"reads back the RW mandatory attribute: Mode Error: %@", err); + NSLog(@"3b: reads back the RW mandatory attribute: Mode Error: %@", err); XCTAssertEqual(err.code, 0); { id actualValue = values[@"value"]; - XCTAssertEqual([actualValue unsignedCharValue], 7); + XCTAssertEqual([actualValue unsignedCharValue], 8); } [expectation fulfill]; @@ -16883,6 +16959,888 @@ - (void)testSendClusterTest_TC_WNCV_2_1_000010_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } +- (void)testSendClusterTest_TC_WNCV_2_1_000015_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: TargetPositionLiftPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeTargetPositionLiftPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: TargetPositionLiftPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 10000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000016_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: TargetPositionLiftPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id targetPositionLiftPercent100thsArgument; + targetPositionLiftPercent100thsArgument = [NSNumber numberWithUnsignedShort:20000U]; + [cluster writeAttributeTargetPositionLiftPercent100thsWithValue:targetPositionLiftPercent100thsArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO optional attribute: " + @"TargetPositionLiftPercent100ths Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000017_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: TargetPositionLiftPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeTargetPositionLiftPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: TargetPositionLiftPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertNotEqual([values[@"value"] unsignedShortValue], 20000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000018_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: TargetPositionTiltPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeTargetPositionTiltPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: TargetPositionTiltPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 10000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000019_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: TargetPositionTiltPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id targetPositionTiltPercent100thsArgument; + targetPositionTiltPercent100thsArgument = [NSNumber numberWithUnsignedShort:20000U]; + [cluster writeAttributeTargetPositionTiltPercent100thsWithValue:targetPositionTiltPercent100thsArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO optional attribute: " + @"TargetPositionTiltPercent100ths Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000020_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: TargetPositionTiltPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeTargetPositionTiltPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: TargetPositionTiltPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertNotEqual([values[@"value"] unsignedShortValue], 20000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000021_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: CurrentPositionLiftPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionLiftPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: CurrentPositionLiftPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 10000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000022_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: CurrentPositionLiftPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id currentPositionLiftPercent100thsArgument; + currentPositionLiftPercent100thsArgument = [NSNumber numberWithUnsignedShort:20000U]; + [cluster writeAttributeCurrentPositionLiftPercent100thsWithValue:currentPositionLiftPercent100thsArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO optional attribute: " + @"CurrentPositionLiftPercent100ths Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000023_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: CurrentPositionLiftPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionLiftPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: CurrentPositionLiftPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertNotEqual([values[@"value"] unsignedShortValue], 20000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000024_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: CurrentPositionTiltPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionTiltPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: CurrentPositionTiltPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 10000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000025_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: CurrentPositionTiltPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id currentPositionTiltPercent100thsArgument; + currentPositionTiltPercent100thsArgument = [NSNumber numberWithUnsignedShort:20000U]; + [cluster writeAttributeCurrentPositionTiltPercent100thsWithValue:currentPositionTiltPercent100thsArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO optional attribute: " + @"CurrentPositionTiltPercent100ths Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000026_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: CurrentPositionTiltPercent100ths"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionTiltPercent100thsWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: CurrentPositionTiltPercent100ths Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertNotEqual([values[@"value"] unsignedShortValue], 20000); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000027_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: InstalledOpenLimitLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledOpenLimitLiftWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: InstalledOpenLimitLift Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000028_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: InstalledOpenLimitLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id installedOpenLimitLiftArgument; + installedOpenLimitLiftArgument = [NSNumber numberWithUnsignedShort:255U]; + [cluster + writeAttributeInstalledOpenLimitLiftWithValue:installedOpenLimitLiftArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog( + @"3a: write a value into the RO optional attribute: InstalledOpenLimitLift Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000029_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: InstalledOpenLimitLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledOpenLimitLiftWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: InstalledOpenLimitLift Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000030_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: InstalledClosedLimitLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledClosedLimitLiftWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: InstalledClosedLimitLift Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000031_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: InstalledClosedLimitLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id installedClosedLimitLiftArgument; + installedClosedLimitLiftArgument = [NSNumber numberWithUnsignedShort:255U]; + [cluster writeAttributeInstalledClosedLimitLiftWithValue:installedClosedLimitLiftArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO optional attribute: " + @"InstalledClosedLimitLift Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000032_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: InstalledClosedLimitLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledClosedLimitLiftWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: InstalledClosedLimitLift Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000033_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: InstalledOpenLimitTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledOpenLimitTiltWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: InstalledOpenLimitTilt Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000034_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: InstalledOpenLimitTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id installedOpenLimitTiltArgument; + installedOpenLimitTiltArgument = [NSNumber numberWithUnsignedShort:255U]; + [cluster + writeAttributeInstalledOpenLimitTiltWithValue:installedOpenLimitTiltArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog( + @"3a: write a value into the RO optional attribute: InstalledOpenLimitTilt Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000035_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: InstalledOpenLimitTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledOpenLimitTiltWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: InstalledOpenLimitTilt Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000036_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"2: read the RO optional attribute default: InstalledClosedLimitTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledClosedLimitTiltWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"2: read the RO optional attribute default: InstalledClosedLimitTilt Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000037_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3a: write a value into the RO optional attribute: InstalledClosedLimitTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id installedClosedLimitTiltArgument; + installedClosedLimitTiltArgument = [NSNumber numberWithUnsignedShort:255U]; + [cluster writeAttributeInstalledClosedLimitTiltWithValue:installedClosedLimitTiltArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3a: write a value into the RO optional attribute: " + @"InstalledClosedLimitTilt Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000038_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"3b: reads back the RO optional attribute: InstalledClosedLimitTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeInstalledClosedLimitTiltWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"3b: reads back the RO optional attribute: InstalledClosedLimitTilt Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000039_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"4: read the RO mandatory attribute default: SafetyStatus"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeSafetyStatusWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"4: read the RO mandatory attribute default: SafetyStatus Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 2047); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000040_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5a: write a value into the RO mandatory attribute: SafetyStatus"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id safetyStatusArgument; + safetyStatusArgument = [NSNumber numberWithUnsignedShort:4096U]; + [cluster writeAttributeSafetyStatusWithValue:safetyStatusArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5a: write a value into the RO mandatory attribute: SafetyStatus Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000041_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"5b: reads back the RO mandatory attribute: SafetyStatus"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeSafetyStatusWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5b: reads back the RO mandatory attribute: SafetyStatus Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertNotEqual([values[@"value"] unsignedShortValue], 4096); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000042_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"4: read the RO optional attribute default: CurrentPositionLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionLiftWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"4: read the RO optional attribute default: CurrentPositionLift Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000043_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5a: write a value into the RO optional attribute: CurrentPositionLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id currentPositionLiftArgument; + currentPositionLiftArgument = [NSNumber numberWithUnsignedShort:255U]; + [cluster + writeAttributeCurrentPositionLiftWithValue:currentPositionLiftArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog( + @"5a: write a value into the RO optional attribute: CurrentPositionLift Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000044_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5b: reads back the RO optional attribute: CurrentPositionLift"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionLiftWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5b: reads back the RO optional attribute: CurrentPositionLift Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000045_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"4: read the RO optional attribute default: CurrentPositionTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionTiltWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"4: read the RO optional attribute default: CurrentPositionTilt Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000046_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5a: write a value into the RO optional attribute: CurrentPositionTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id currentPositionTiltArgument; + currentPositionTiltArgument = [NSNumber numberWithUnsignedShort:255U]; + [cluster + writeAttributeCurrentPositionTiltWithValue:currentPositionTiltArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog( + @"5a: write a value into the RO optional attribute: CurrentPositionTilt Error: %@", err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000047_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5b: reads back the RO optional attribute: CurrentPositionTilt"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionTiltWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5b: reads back the RO optional attribute: CurrentPositionTilt Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedShortValue], 65535); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000048_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"4: read the RO optional attribute default: CurrentPositionLiftPercentage"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionLiftPercentageWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"4: read the RO optional attribute default: CurrentPositionLiftPercentage Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 100); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000049_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5a: write a value into the RO optional attribute: CurrentPositionLiftPercentage"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id currentPositionLiftPercentageArgument; + currentPositionLiftPercentageArgument = [NSNumber numberWithUnsignedChar:200]; + [cluster writeAttributeCurrentPositionLiftPercentageWithValue:currentPositionLiftPercentageArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5a: write a value into the RO optional attribute: " + @"CurrentPositionLiftPercentage Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000050_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5b: reads back the RO optional attribute: CurrentPositionLiftPercentage"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionLiftPercentageWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5b: reads back the RO optional attribute: CurrentPositionLiftPercentage Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertNotEqual([values[@"value"] unsignedCharValue], 200); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000051_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"4: read the RO optional attribute default: CurrentPositionTiltPercentage"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionTiltPercentageWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"4: read the RO optional attribute default: CurrentPositionTiltPercentage Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 100); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000052_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5a: write a value into the RO optional attribute: CurrentPositionTiltPercentage"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id currentPositionTiltPercentageArgument; + currentPositionTiltPercentageArgument = [NSNumber numberWithUnsignedChar:200]; + [cluster writeAttributeCurrentPositionTiltPercentageWithValue:currentPositionTiltPercentageArgument + responseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5a: write a value into the RO optional attribute: " + @"CurrentPositionTiltPercentage Error: %@", + err); + + XCTAssertEqual(err.code, 1); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTest_TC_WNCV_2_1_000053_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"5b: reads back the RO optional attribute: CurrentPositionTiltPercentage"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCurrentPositionTiltPercentageWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"5b: reads back the RO optional attribute: CurrentPositionTiltPercentage Error: %@", err); + + XCTAssertEqual(err.code, 0); + + XCTAssertNotEqual([values[@"value"] unsignedCharValue], 200); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} - (void)testSendClusterTest_TC_WNCV_2_4_000000_ReadAttribute { diff --git a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h index c37cbeebabab23..99984eb30038f4 100644 --- a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h +++ b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h @@ -1527,17 +1527,17 @@ \ /* Endpoint: 1, Cluster: Window Covering (server) */ \ { 0x0000, ZAP_TYPE(ENUM8), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* Type */ \ - { 0x0003, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0000) }, /* CurrentPositionLift */ \ - { 0x0004, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0000) }, /* CurrentPositionTilt */ \ + { 0x0003, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x7FFF) }, /* CurrentPositionLift */ \ + { 0x0004, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x7FFF) }, /* CurrentPositionTilt */ \ { 0x0007, ZAP_TYPE(BITMAP8), 1, 0, ZAP_SIMPLE_DEFAULT(0x03) }, /* ConfigStatus */ \ - { 0x0008, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(0xFF) }, /* CurrentPositionLiftPercentage */ \ - { 0x0009, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(0xFF) }, /* CurrentPositionTiltPercentage */ \ + { 0x0008, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(50) }, /* CurrentPositionLiftPercentage */ \ + { 0x0009, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(50) }, /* CurrentPositionTiltPercentage */ \ { 0x000A, ZAP_TYPE(BITMAP8), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* OperationalStatus */ \ - { 0x000B, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xFF) }, /* TargetPositionLiftPercent100ths */ \ - { 0x000C, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xFFFF) }, /* TargetPositionTiltPercent100ths */ \ + { 0x000B, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(500) }, /* TargetPositionLiftPercent100ths */ \ + { 0x000C, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(500) }, /* TargetPositionTiltPercent100ths */ \ { 0x000D, ZAP_TYPE(ENUM8), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* EndProductType */ \ - { 0x000E, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xFF) }, /* CurrentPositionLiftPercent100ths */ \ - { 0x000F, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xFF) }, /* CurrentPositionTiltPercent100ths */ \ + { 0x000E, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(500) }, /* CurrentPositionLiftPercent100ths */ \ + { 0x000F, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(500) }, /* CurrentPositionTiltPercent100ths */ \ { 0x0010, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0000) }, /* InstalledOpenLimitLift */ \ { 0x0011, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xFFFF) }, /* InstalledClosedLimitLift */ \ { 0x0012, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0000) }, /* InstalledOpenLimitTilt */ \ diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 4a56713a0b739b..3d397085b1eb3d 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -25768,25 +25768,30 @@ class Test_TC_WNCV_1_1 : public TestCommand switch (mTestIndex++) { case 0: - ChipLogProgress(chipTool, " ***** Test Step 0 : read the global attribute: ClusterRevision\n"); - err = TestReadTheGlobalAttributeClusterRevision_0(); + ChipLogProgress(chipTool, " ***** Test Step 0 : 2: read the global attribute: ClusterRevision\n"); + err = Test2ReadTheGlobalAttributeClusterRevision_0(); break; case 1: ChipLogProgress(chipTool, - " ***** Test Step 1 : write the default value to mandatory global attribute: ClusterRevision\n"); - err = TestWriteTheDefaultValueToMandatoryGlobalAttributeClusterRevision_1(); + " ***** Test Step 1 : 3a: write a value into the RO mandatory global attribute: ClusterRevision\n"); + err = Test3aWriteAValueIntoTheRoMandatoryGlobalAttributeClusterRevision_1(); break; case 2: - ChipLogProgress(chipTool, " ***** Test Step 2 : reads back global attribute: ClusterRevision\n"); - err = TestReadsBackGlobalAttributeClusterRevision_2(); + ChipLogProgress(chipTool, " ***** Test Step 2 : 3b: reads back global attribute: ClusterRevision\n"); + err = Test3bReadsBackGlobalAttributeClusterRevision_2(); break; case 3: - ChipLogProgress(chipTool, " ***** Test Step 3 : read the global attribute: FeatureMap\n"); - err = TestReadTheGlobalAttributeFeatureMap_3(); + ChipLogProgress(chipTool, " ***** Test Step 3 : 2: read the global attribute: FeatureMap\n"); + err = Test2ReadTheGlobalAttributeFeatureMap_3(); break; case 4: - ChipLogProgress(chipTool, " ***** Test Step 4 : reads back global attribute: FeatureMap\n"); - err = TestReadsBackGlobalAttributeFeatureMap_4(); + ChipLogProgress(chipTool, + " ***** Test Step 4 : 3a: write the default value to optional global attribute: FeatureMap\n"); + err = Test3aWriteTheDefaultValueToOptionalGlobalAttributeFeatureMap_4(); + break; + case 5: + ChipLogProgress(chipTool, " ***** Test Step 5 : 3b: reads back global attribute: FeatureMap\n"); + err = Test3bReadsBackGlobalAttributeFeatureMap_5(); break; } @@ -25799,7 +25804,7 @@ class Test_TC_WNCV_1_1 : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 5; + const uint16_t mTestCount = 6; static void OnFailureCallback_0(void * context, EmberAfStatus status) { @@ -25843,16 +25848,23 @@ class Test_TC_WNCV_1_1 : public TestCommand (static_cast(context))->OnFailureResponse_4(chip::to_underlying(status)); } - static void OnSuccessCallback_4(void * context, uint32_t featureMap) + static void OnSuccessCallback_4(void * context) { (static_cast(context))->OnSuccessResponse_4(); } + + static void OnFailureCallback_5(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_5(chip::to_underlying(status)); + } + + static void OnSuccessCallback_5(void * context, uint32_t featureMap) { - (static_cast(context))->OnSuccessResponse_4(featureMap); + (static_cast(context))->OnSuccessResponse_5(featureMap); } // // Tests methods // - CHIP_ERROR TestReadTheGlobalAttributeClusterRevision_0() + CHIP_ERROR Test2ReadTheGlobalAttributeClusterRevision_0() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; @@ -25866,18 +25878,20 @@ class Test_TC_WNCV_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 5U)); + VerifyOrReturn(CheckConstraintType("clusterRevision", "", "uint16")); + VerifyOrReturn(CheckConstraintMinValue("clusterRevision", clusterRevision, 5)); + VerifyOrReturn(CheckConstraintMaxValue("clusterRevision", clusterRevision, 200)); NextTest(); } - CHIP_ERROR TestWriteTheDefaultValueToMandatoryGlobalAttributeClusterRevision_1() + CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryGlobalAttributeClusterRevision_1() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; cluster.Associate(mDevice, endpoint); uint16_t clusterRevisionArgument; - clusterRevisionArgument = 5U; + clusterRevisionArgument = 201U; return cluster.WriteAttribute( clusterRevisionArgument, this, OnSuccessCallback_1, OnFailureCallback_1); @@ -25887,7 +25901,7 @@ class Test_TC_WNCV_1_1 : public TestCommand void OnSuccessResponse_1() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadsBackGlobalAttributeClusterRevision_2() + CHIP_ERROR Test3bReadsBackGlobalAttributeClusterRevision_2() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; @@ -25901,11 +25915,12 @@ class Test_TC_WNCV_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 5U)); + VerifyOrReturn(CheckConstraintType("clusterRevision", "", "uint16")); + VerifyOrReturn(CheckConstraintNotValue("clusterRevision", clusterRevision, 201)); NextTest(); } - CHIP_ERROR TestReadTheGlobalAttributeFeatureMap_3() + CHIP_ERROR Test2ReadTheGlobalAttributeFeatureMap_3() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; @@ -25919,25 +25934,44 @@ class Test_TC_WNCV_1_1 : public TestCommand void OnSuccessResponse_3(uint32_t featureMap) { - VerifyOrReturn(CheckValue("featureMap", featureMap, 0UL)); + VerifyOrReturn(CheckConstraintType("featureMap", "", "uint32")); + VerifyOrReturn(CheckConstraintMaxValue("featureMap", featureMap, 32768)); NextTest(); } - CHIP_ERROR TestReadsBackGlobalAttributeFeatureMap_4() + CHIP_ERROR Test3aWriteTheDefaultValueToOptionalGlobalAttributeFeatureMap_4() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint32_t featureMapArgument; + featureMapArgument = 32769UL; + + return cluster.WriteAttribute( + featureMapArgument, this, OnSuccessCallback_4, OnFailureCallback_4); + } + + void OnFailureResponse_4(uint8_t status) { NextTest(); } + + void OnSuccessResponse_4() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackGlobalAttributeFeatureMap_5() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_4, OnFailureCallback_4); + this, OnSuccessCallback_5, OnFailureCallback_5); } - void OnFailureResponse_4(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_5(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_4(uint32_t featureMap) + void OnSuccessResponse_5(uint32_t featureMap) { - VerifyOrReturn(CheckValue("featureMap", featureMap, 0UL)); + VerifyOrReturn(CheckConstraintType("featureMap", "", "uint32")); + VerifyOrReturn(CheckConstraintNotValue("featureMap", featureMap, 32769)); NextTest(); } }; @@ -25973,48 +26007,253 @@ class Test_TC_WNCV_2_1 : public TestCommand switch (mTestIndex++) { case 0: - ChipLogProgress(chipTool, " ***** Test Step 0 : read the RO mandatory attribute default: Type\n"); - err = TestReadTheRoMandatoryAttributeDefaultType_0(); + ChipLogProgress(chipTool, " ***** Test Step 0 : 2: read the RO mandatory attribute default: Type\n"); + err = Test2ReadTheRoMandatoryAttributeDefaultType_0(); break; case 1: - ChipLogProgress(chipTool, " ***** Test Step 1 : reads back the RO mandatory attribute: Type\n"); - err = TestReadsBackTheRoMandatoryAttributeType_1(); + ChipLogProgress(chipTool, " ***** Test Step 1 : 3a: write a value into the RO mandatory attribute: Type\n"); + err = Test3aWriteAValueIntoTheRoMandatoryAttributeType_1(); break; case 2: - ChipLogProgress(chipTool, " ***** Test Step 2 : read the RO mandatory attribute default: ConfigStatus\n"); - err = TestReadTheRoMandatoryAttributeDefaultConfigStatus_2(); + ChipLogProgress(chipTool, " ***** Test Step 2 : 3b: reads back the RO mandatory attribute: Type\n"); + err = Test3bReadsBackTheRoMandatoryAttributeType_2(); break; case 3: - ChipLogProgress(chipTool, " ***** Test Step 3 : reads back the RO mandatory attribute: ConfigStatus\n"); - err = TestReadsBackTheRoMandatoryAttributeConfigStatus_3(); + ChipLogProgress(chipTool, " ***** Test Step 3 : 2: read the RO mandatory attribute default: ConfigStatus\n"); + err = Test2ReadTheRoMandatoryAttributeDefaultConfigStatus_3(); break; case 4: - ChipLogProgress(chipTool, " ***** Test Step 4 : read the RO mandatory attribute default: OperationalStatus\n"); - err = TestReadTheRoMandatoryAttributeDefaultOperationalStatus_4(); + ChipLogProgress(chipTool, " ***** Test Step 4 : 3a: write a value into the RO mandatory attribute: ConfigStatus\n"); + err = Test3aWriteAValueIntoTheRoMandatoryAttributeConfigStatus_4(); break; case 5: - ChipLogProgress(chipTool, " ***** Test Step 5 : reads back the RO mandatory attribute: OperationalStatus\n"); - err = TestReadsBackTheRoMandatoryAttributeOperationalStatus_5(); + ChipLogProgress(chipTool, " ***** Test Step 5 : 3b: reads back the RO mandatory attribute: ConfigStatus\n"); + err = Test3bReadsBackTheRoMandatoryAttributeConfigStatus_5(); break; case 6: - ChipLogProgress(chipTool, " ***** Test Step 6 : read the RO mandatory attribute default: EndProductType\n"); - err = TestReadTheRoMandatoryAttributeDefaultEndProductType_6(); + ChipLogProgress(chipTool, " ***** Test Step 6 : 2: read the RO mandatory attribute default: OperationalStatus\n"); + err = Test2ReadTheRoMandatoryAttributeDefaultOperationalStatus_6(); break; case 7: - ChipLogProgress(chipTool, " ***** Test Step 7 : reads back the RO mandatory attribute: EndProductType\n"); - err = TestReadsBackTheRoMandatoryAttributeEndProductType_7(); + ChipLogProgress(chipTool, + " ***** Test Step 7 : 3a: write a value into the RO mandatory attribute: OperationalStatus\n"); + err = Test3aWriteAValueIntoTheRoMandatoryAttributeOperationalStatus_7(); break; case 8: - ChipLogProgress(chipTool, " ***** Test Step 8 : read the RW mandatory attribute default: Mode\n"); - err = TestReadTheRwMandatoryAttributeDefaultMode_8(); + ChipLogProgress(chipTool, " ***** Test Step 8 : 3b: reads back the RO mandatory attribute: OperationalStatus\n"); + err = Test3bReadsBackTheRoMandatoryAttributeOperationalStatus_8(); break; case 9: - ChipLogProgress(chipTool, " ***** Test Step 9 : write a value into the RW mandatory attribute:: Mode\n"); - err = TestWriteAValueIntoTheRwMandatoryAttributeMode_9(); + ChipLogProgress(chipTool, " ***** Test Step 9 : 2: read the RO mandatory attribute default: EndProductType\n"); + err = Test2ReadTheRoMandatoryAttributeDefaultEndProductType_9(); break; case 10: - ChipLogProgress(chipTool, " ***** Test Step 10 : reads back the RW mandatory attribute: Mode\n"); - err = TestReadsBackTheRwMandatoryAttributeMode_10(); + ChipLogProgress(chipTool, " ***** Test Step 10 : 3a: write a value into the RO mandatory attribute: EndProductType\n"); + err = Test3aWriteAValueIntoTheRoMandatoryAttributeEndProductType_10(); + break; + case 11: + ChipLogProgress(chipTool, " ***** Test Step 11 : 3b: reads back the RO mandatory attribute: EndProductType\n"); + err = Test3bReadsBackTheRoMandatoryAttributeEndProductType_11(); + break; + case 12: + ChipLogProgress(chipTool, " ***** Test Step 12 : 2: read the RW mandatory attribute default: Mode\n"); + err = Test2ReadTheRwMandatoryAttributeDefaultMode_12(); + break; + case 13: + ChipLogProgress(chipTool, " ***** Test Step 13 : 3a: write a value into the RW mandatory attribute:: Mode\n"); + err = Test3aWriteAValueIntoTheRwMandatoryAttributeMode_13(); + break; + case 14: + ChipLogProgress(chipTool, " ***** Test Step 14 : 3b: reads back the RW mandatory attribute: Mode\n"); + err = Test3bReadsBackTheRwMandatoryAttributeMode_14(); + break; + case 15: + ChipLogProgress(chipTool, + " ***** Test Step 15 : 2: read the RO optional attribute default: TargetPositionLiftPercent100ths\n"); + err = Test2ReadTheRoOptionalAttributeDefaultTargetPositionLiftPercent100ths_15(); + break; + case 16: + ChipLogProgress( + chipTool, + " ***** Test Step 16 : 3a: write a value into the RO optional attribute: TargetPositionLiftPercent100ths\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeTargetPositionLiftPercent100ths_16(); + break; + case 17: + ChipLogProgress(chipTool, + " ***** Test Step 17 : 3b: reads back the RO optional attribute: TargetPositionLiftPercent100ths\n"); + err = Test3bReadsBackTheRoOptionalAttributeTargetPositionLiftPercent100ths_17(); + break; + case 18: + ChipLogProgress(chipTool, + " ***** Test Step 18 : 2: read the RO optional attribute default: TargetPositionTiltPercent100ths\n"); + err = Test2ReadTheRoOptionalAttributeDefaultTargetPositionTiltPercent100ths_18(); + break; + case 19: + ChipLogProgress( + chipTool, + " ***** Test Step 19 : 3a: write a value into the RO optional attribute: TargetPositionTiltPercent100ths\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeTargetPositionTiltPercent100ths_19(); + break; + case 20: + ChipLogProgress(chipTool, + " ***** Test Step 20 : 3b: reads back the RO optional attribute: TargetPositionTiltPercent100ths\n"); + err = Test3bReadsBackTheRoOptionalAttributeTargetPositionTiltPercent100ths_20(); + break; + case 21: + ChipLogProgress(chipTool, + " ***** Test Step 21 : 2: read the RO optional attribute default: CurrentPositionLiftPercent100ths\n"); + err = Test2ReadTheRoOptionalAttributeDefaultCurrentPositionLiftPercent100ths_21(); + break; + case 22: + ChipLogProgress( + chipTool, + " ***** Test Step 22 : 3a: write a value into the RO optional attribute: CurrentPositionLiftPercent100ths\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeCurrentPositionLiftPercent100ths_22(); + break; + case 23: + ChipLogProgress(chipTool, + " ***** Test Step 23 : 3b: reads back the RO optional attribute: CurrentPositionLiftPercent100ths\n"); + err = Test3bReadsBackTheRoOptionalAttributeCurrentPositionLiftPercent100ths_23(); + break; + case 24: + ChipLogProgress(chipTool, + " ***** Test Step 24 : 2: read the RO optional attribute default: CurrentPositionTiltPercent100ths\n"); + err = Test2ReadTheRoOptionalAttributeDefaultCurrentPositionTiltPercent100ths_24(); + break; + case 25: + ChipLogProgress( + chipTool, + " ***** Test Step 25 : 3a: write a value into the RO optional attribute: CurrentPositionTiltPercent100ths\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeCurrentPositionTiltPercent100ths_25(); + break; + case 26: + ChipLogProgress(chipTool, + " ***** Test Step 26 : 3b: reads back the RO optional attribute: CurrentPositionTiltPercent100ths\n"); + err = Test3bReadsBackTheRoOptionalAttributeCurrentPositionTiltPercent100ths_26(); + break; + case 27: + ChipLogProgress(chipTool, " ***** Test Step 27 : 2: read the RO optional attribute default: InstalledOpenLimitLift\n"); + err = Test2ReadTheRoOptionalAttributeDefaultInstalledOpenLimitLift_27(); + break; + case 28: + ChipLogProgress(chipTool, + " ***** Test Step 28 : 3a: write a value into the RO optional attribute: InstalledOpenLimitLift\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeInstalledOpenLimitLift_28(); + break; + case 29: + ChipLogProgress(chipTool, " ***** Test Step 29 : 3b: reads back the RO optional attribute: InstalledOpenLimitLift\n"); + err = Test3bReadsBackTheRoOptionalAttributeInstalledOpenLimitLift_29(); + break; + case 30: + ChipLogProgress(chipTool, + " ***** Test Step 30 : 2: read the RO optional attribute default: InstalledClosedLimitLift\n"); + err = Test2ReadTheRoOptionalAttributeDefaultInstalledClosedLimitLift_30(); + break; + case 31: + ChipLogProgress(chipTool, + " ***** Test Step 31 : 3a: write a value into the RO optional attribute: InstalledClosedLimitLift\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeInstalledClosedLimitLift_31(); + break; + case 32: + ChipLogProgress(chipTool, " ***** Test Step 32 : 3b: reads back the RO optional attribute: InstalledClosedLimitLift\n"); + err = Test3bReadsBackTheRoOptionalAttributeInstalledClosedLimitLift_32(); + break; + case 33: + ChipLogProgress(chipTool, " ***** Test Step 33 : 2: read the RO optional attribute default: InstalledOpenLimitTilt\n"); + err = Test2ReadTheRoOptionalAttributeDefaultInstalledOpenLimitTilt_33(); + break; + case 34: + ChipLogProgress(chipTool, + " ***** Test Step 34 : 3a: write a value into the RO optional attribute: InstalledOpenLimitTilt\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeInstalledOpenLimitTilt_34(); + break; + case 35: + ChipLogProgress(chipTool, " ***** Test Step 35 : 3b: reads back the RO optional attribute: InstalledOpenLimitTilt\n"); + err = Test3bReadsBackTheRoOptionalAttributeInstalledOpenLimitTilt_35(); + break; + case 36: + ChipLogProgress(chipTool, + " ***** Test Step 36 : 2: read the RO optional attribute default: InstalledClosedLimitTilt\n"); + err = Test2ReadTheRoOptionalAttributeDefaultInstalledClosedLimitTilt_36(); + break; + case 37: + ChipLogProgress(chipTool, + " ***** Test Step 37 : 3a: write a value into the RO optional attribute: InstalledClosedLimitTilt\n"); + err = Test3aWriteAValueIntoTheRoOptionalAttributeInstalledClosedLimitTilt_37(); + break; + case 38: + ChipLogProgress(chipTool, " ***** Test Step 38 : 3b: reads back the RO optional attribute: InstalledClosedLimitTilt\n"); + err = Test3bReadsBackTheRoOptionalAttributeInstalledClosedLimitTilt_38(); + break; + case 39: + ChipLogProgress(chipTool, " ***** Test Step 39 : 4: read the RO mandatory attribute default: SafetyStatus\n"); + err = Test4ReadTheRoMandatoryAttributeDefaultSafetyStatus_39(); + break; + case 40: + ChipLogProgress(chipTool, " ***** Test Step 40 : 5a: write a value into the RO mandatory attribute: SafetyStatus\n"); + err = Test5aWriteAValueIntoTheRoMandatoryAttributeSafetyStatus_40(); + break; + case 41: + ChipLogProgress(chipTool, " ***** Test Step 41 : 5b: reads back the RO mandatory attribute: SafetyStatus\n"); + err = Test5bReadsBackTheRoMandatoryAttributeSafetyStatus_41(); + break; + case 42: + ChipLogProgress(chipTool, " ***** Test Step 42 : 4: read the RO optional attribute default: CurrentPositionLift\n"); + err = Test4ReadTheRoOptionalAttributeDefaultCurrentPositionLift_42(); + break; + case 43: + ChipLogProgress(chipTool, + " ***** Test Step 43 : 5a: write a value into the RO optional attribute: CurrentPositionLift\n"); + err = Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionLift_43(); + break; + case 44: + ChipLogProgress(chipTool, " ***** Test Step 44 : 5b: reads back the RO optional attribute: CurrentPositionLift\n"); + err = Test5bReadsBackTheRoOptionalAttributeCurrentPositionLift_44(); + break; + case 45: + ChipLogProgress(chipTool, " ***** Test Step 45 : 4: read the RO optional attribute default: CurrentPositionTilt\n"); + err = Test4ReadTheRoOptionalAttributeDefaultCurrentPositionTilt_45(); + break; + case 46: + ChipLogProgress(chipTool, + " ***** Test Step 46 : 5a: write a value into the RO optional attribute: CurrentPositionTilt\n"); + err = Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionTilt_46(); + break; + case 47: + ChipLogProgress(chipTool, " ***** Test Step 47 : 5b: reads back the RO optional attribute: CurrentPositionTilt\n"); + err = Test5bReadsBackTheRoOptionalAttributeCurrentPositionTilt_47(); + break; + case 48: + ChipLogProgress(chipTool, + " ***** Test Step 48 : 4: read the RO optional attribute default: CurrentPositionLiftPercentage\n"); + err = Test4ReadTheRoOptionalAttributeDefaultCurrentPositionLiftPercentage_48(); + break; + case 49: + ChipLogProgress( + chipTool, + " ***** Test Step 49 : 5a: write a value into the RO optional attribute: CurrentPositionLiftPercentage\n"); + err = Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionLiftPercentage_49(); + break; + case 50: + ChipLogProgress(chipTool, + " ***** Test Step 50 : 5b: reads back the RO optional attribute: CurrentPositionLiftPercentage\n"); + err = Test5bReadsBackTheRoOptionalAttributeCurrentPositionLiftPercentage_50(); + break; + case 51: + ChipLogProgress(chipTool, + " ***** Test Step 51 : 4: read the RO optional attribute default: CurrentPositionTiltPercentage\n"); + err = Test4ReadTheRoOptionalAttributeDefaultCurrentPositionTiltPercentage_51(); + break; + case 52: + ChipLogProgress( + chipTool, + " ***** Test Step 52 : 5a: write a value into the RO optional attribute: CurrentPositionTiltPercentage\n"); + err = Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionTiltPercentage_52(); + break; + case 53: + ChipLogProgress(chipTool, + " ***** Test Step 53 : 5b: reads back the RO optional attribute: CurrentPositionTiltPercentage\n"); + err = Test5bReadsBackTheRoOptionalAttributeCurrentPositionTiltPercentage_53(); break; } @@ -26027,7 +26266,7 @@ class Test_TC_WNCV_2_1 : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 11; + const uint16_t mTestCount = 54; static void OnFailureCallback_0(void * context, EmberAfStatus status) { @@ -26044,19 +26283,16 @@ class Test_TC_WNCV_2_1 : public TestCommand (static_cast(context))->OnFailureResponse_1(chip::to_underlying(status)); } - static void OnSuccessCallback_1(void * context, uint8_t type) - { - (static_cast(context))->OnSuccessResponse_1(type); - } + static void OnSuccessCallback_1(void * context) { (static_cast(context))->OnSuccessResponse_1(); } static void OnFailureCallback_2(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_2(chip::to_underlying(status)); } - static void OnSuccessCallback_2(void * context, uint8_t configStatus) + static void OnSuccessCallback_2(void * context, uint8_t type) { - (static_cast(context))->OnSuccessResponse_2(configStatus); + (static_cast(context))->OnSuccessResponse_2(type); } static void OnFailureCallback_3(void * context, EmberAfStatus status) @@ -26074,19 +26310,16 @@ class Test_TC_WNCV_2_1 : public TestCommand (static_cast(context))->OnFailureResponse_4(chip::to_underlying(status)); } - static void OnSuccessCallback_4(void * context, uint8_t operationalStatus) - { - (static_cast(context))->OnSuccessResponse_4(operationalStatus); - } + static void OnSuccessCallback_4(void * context) { (static_cast(context))->OnSuccessResponse_4(); } static void OnFailureCallback_5(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_5(chip::to_underlying(status)); } - static void OnSuccessCallback_5(void * context, uint8_t operationalStatus) + static void OnSuccessCallback_5(void * context, uint8_t configStatus) { - (static_cast(context))->OnSuccessResponse_5(operationalStatus); + (static_cast(context))->OnSuccessResponse_5(configStatus); } static void OnFailureCallback_6(void * context, EmberAfStatus status) @@ -26094,9 +26327,9 @@ class Test_TC_WNCV_2_1 : public TestCommand (static_cast(context))->OnFailureResponse_6(chip::to_underlying(status)); } - static void OnSuccessCallback_6(void * context, uint8_t endProductType) + static void OnSuccessCallback_6(void * context, uint8_t operationalStatus) { - (static_cast(context))->OnSuccessResponse_6(endProductType); + (static_cast(context))->OnSuccessResponse_6(operationalStatus); } static void OnFailureCallback_7(void * context, EmberAfStatus status) @@ -26104,19 +26337,16 @@ class Test_TC_WNCV_2_1 : public TestCommand (static_cast(context))->OnFailureResponse_7(chip::to_underlying(status)); } - static void OnSuccessCallback_7(void * context, uint8_t endProductType) - { - (static_cast(context))->OnSuccessResponse_7(endProductType); - } + static void OnSuccessCallback_7(void * context) { (static_cast(context))->OnSuccessResponse_7(); } static void OnFailureCallback_8(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_8(chip::to_underlying(status)); } - static void OnSuccessCallback_8(void * context, uint8_t mode) + static void OnSuccessCallback_8(void * context, uint8_t operationalStatus) { - (static_cast(context))->OnSuccessResponse_8(mode); + (static_cast(context))->OnSuccessResponse_8(operationalStatus); } static void OnFailureCallback_9(void * context, EmberAfStatus status) @@ -26124,216 +26354,1404 @@ class Test_TC_WNCV_2_1 : public TestCommand (static_cast(context))->OnFailureResponse_9(chip::to_underlying(status)); } - static void OnSuccessCallback_9(void * context) { (static_cast(context))->OnSuccessResponse_9(); } + static void OnSuccessCallback_9(void * context, uint8_t endProductType) + { + (static_cast(context))->OnSuccessResponse_9(endProductType); + } static void OnFailureCallback_10(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_10(chip::to_underlying(status)); } - static void OnSuccessCallback_10(void * context, uint8_t mode) + static void OnSuccessCallback_10(void * context) { (static_cast(context))->OnSuccessResponse_10(); } + + static void OnFailureCallback_11(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_10(mode); + (static_cast(context))->OnFailureResponse_11(chip::to_underlying(status)); } - // - // Tests methods - // - - CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultType_0() + static void OnSuccessCallback_11(void * context, uint8_t endProductType) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::WindowCoveringClusterTest cluster; - cluster.Associate(mDevice, endpoint); - - return cluster.ReadAttribute(this, OnSuccessCallback_0, - OnFailureCallback_0); + (static_cast(context))->OnSuccessResponse_11(endProductType); } - void OnFailureResponse_0(uint8_t status) { ThrowFailureResponse(); } - - void OnSuccessResponse_0(uint8_t type) + static void OnFailureCallback_12(void * context, EmberAfStatus status) { - VerifyOrReturn(CheckValue("type", type, 0)); - NextTest(); + (static_cast(context))->OnFailureResponse_12(chip::to_underlying(status)); } - CHIP_ERROR TestReadsBackTheRoMandatoryAttributeType_1() + static void OnSuccessCallback_12(void * context, uint8_t mode) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::WindowCoveringClusterTest cluster; - cluster.Associate(mDevice, endpoint); + (static_cast(context))->OnSuccessResponse_12(mode); + } - return cluster.ReadAttribute(this, OnSuccessCallback_1, - OnFailureCallback_1); + static void OnFailureCallback_13(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_13(chip::to_underlying(status)); } - void OnFailureResponse_1(uint8_t status) { ThrowFailureResponse(); } + static void OnSuccessCallback_13(void * context) { (static_cast(context))->OnSuccessResponse_13(); } - void OnSuccessResponse_1(uint8_t type) + static void OnFailureCallback_14(void * context, EmberAfStatus status) { - VerifyOrReturn(CheckValue("type", type, 0)); - NextTest(); + (static_cast(context))->OnFailureResponse_14(chip::to_underlying(status)); } - CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultConfigStatus_2() + static void OnSuccessCallback_14(void * context, uint8_t mode) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::WindowCoveringClusterTest cluster; - cluster.Associate(mDevice, endpoint); - - return cluster.ReadAttribute( - this, OnSuccessCallback_2, OnFailureCallback_2); + (static_cast(context))->OnSuccessResponse_14(mode); } - void OnFailureResponse_2(uint8_t status) { ThrowFailureResponse(); } - - void OnSuccessResponse_2(uint8_t configStatus) + static void OnFailureCallback_15(void * context, EmberAfStatus status) { - VerifyOrReturn(CheckValue("configStatus", configStatus, 3)); - NextTest(); + (static_cast(context))->OnFailureResponse_15(chip::to_underlying(status)); } - CHIP_ERROR TestReadsBackTheRoMandatoryAttributeConfigStatus_3() + static void OnSuccessCallback_15(void * context, uint16_t targetPositionLiftPercent100ths) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::WindowCoveringClusterTest cluster; - cluster.Associate(mDevice, endpoint); + (static_cast(context))->OnSuccessResponse_15(targetPositionLiftPercent100ths); + } - return cluster.ReadAttribute( - this, OnSuccessCallback_3, OnFailureCallback_3); + static void OnFailureCallback_16(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_16(chip::to_underlying(status)); } - void OnFailureResponse_3(uint8_t status) { ThrowFailureResponse(); } + static void OnSuccessCallback_16(void * context) { (static_cast(context))->OnSuccessResponse_16(); } - void OnSuccessResponse_3(uint8_t configStatus) + static void OnFailureCallback_17(void * context, EmberAfStatus status) { - VerifyOrReturn(CheckValue("configStatus", configStatus, 3)); - NextTest(); + (static_cast(context))->OnFailureResponse_17(chip::to_underlying(status)); } - CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultOperationalStatus_4() + static void OnSuccessCallback_17(void * context, uint16_t targetPositionLiftPercent100ths) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::WindowCoveringClusterTest cluster; - cluster.Associate(mDevice, endpoint); - - return cluster.ReadAttribute( - this, OnSuccessCallback_4, OnFailureCallback_4); + (static_cast(context))->OnSuccessResponse_17(targetPositionLiftPercent100ths); } - void OnFailureResponse_4(uint8_t status) { ThrowFailureResponse(); } - - void OnSuccessResponse_4(uint8_t operationalStatus) + static void OnFailureCallback_18(void * context, EmberAfStatus status) { - VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); - NextTest(); + (static_cast(context))->OnFailureResponse_18(chip::to_underlying(status)); } - CHIP_ERROR TestReadsBackTheRoMandatoryAttributeOperationalStatus_5() + static void OnSuccessCallback_18(void * context, uint16_t targetPositionTiltPercent100ths) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::WindowCoveringClusterTest cluster; - cluster.Associate(mDevice, endpoint); + (static_cast(context))->OnSuccessResponse_18(targetPositionTiltPercent100ths); + } - return cluster.ReadAttribute( - this, OnSuccessCallback_5, OnFailureCallback_5); + static void OnFailureCallback_19(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_19(chip::to_underlying(status)); } - void OnFailureResponse_5(uint8_t status) { ThrowFailureResponse(); } + static void OnSuccessCallback_19(void * context) { (static_cast(context))->OnSuccessResponse_19(); } - void OnSuccessResponse_5(uint8_t operationalStatus) + static void OnFailureCallback_20(void * context, EmberAfStatus status) { - VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); - NextTest(); + (static_cast(context))->OnFailureResponse_20(chip::to_underlying(status)); } - CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultEndProductType_6() + static void OnSuccessCallback_20(void * context, uint16_t targetPositionTiltPercent100ths) { - const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; - chip::Controller::WindowCoveringClusterTest cluster; - cluster.Associate(mDevice, endpoint); - - return cluster.ReadAttribute( - this, OnSuccessCallback_6, OnFailureCallback_6); + (static_cast(context))->OnSuccessResponse_20(targetPositionTiltPercent100ths); } - void OnFailureResponse_6(uint8_t status) { ThrowFailureResponse(); } + static void OnFailureCallback_21(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_21(chip::to_underlying(status)); + } - void OnSuccessResponse_6(uint8_t endProductType) + static void OnSuccessCallback_21(void * context, uint16_t currentPositionLiftPercent100ths) { - VerifyOrReturn(CheckValue("endProductType", endProductType, 0)); + (static_cast(context))->OnSuccessResponse_21(currentPositionLiftPercent100ths); + } + + static void OnFailureCallback_22(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_22(chip::to_underlying(status)); + } + + static void OnSuccessCallback_22(void * context) { (static_cast(context))->OnSuccessResponse_22(); } + + static void OnFailureCallback_23(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_23(chip::to_underlying(status)); + } + + static void OnSuccessCallback_23(void * context, uint16_t currentPositionLiftPercent100ths) + { + (static_cast(context))->OnSuccessResponse_23(currentPositionLiftPercent100ths); + } + + static void OnFailureCallback_24(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_24(chip::to_underlying(status)); + } + + static void OnSuccessCallback_24(void * context, uint16_t currentPositionTiltPercent100ths) + { + (static_cast(context))->OnSuccessResponse_24(currentPositionTiltPercent100ths); + } + + static void OnFailureCallback_25(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_25(chip::to_underlying(status)); + } + + static void OnSuccessCallback_25(void * context) { (static_cast(context))->OnSuccessResponse_25(); } + + static void OnFailureCallback_26(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_26(chip::to_underlying(status)); + } + + static void OnSuccessCallback_26(void * context, uint16_t currentPositionTiltPercent100ths) + { + (static_cast(context))->OnSuccessResponse_26(currentPositionTiltPercent100ths); + } + + static void OnFailureCallback_27(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_27(chip::to_underlying(status)); + } + + static void OnSuccessCallback_27(void * context, uint16_t installedOpenLimitLift) + { + (static_cast(context))->OnSuccessResponse_27(installedOpenLimitLift); + } + + static void OnFailureCallback_28(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_28(chip::to_underlying(status)); + } + + static void OnSuccessCallback_28(void * context) { (static_cast(context))->OnSuccessResponse_28(); } + + static void OnFailureCallback_29(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_29(chip::to_underlying(status)); + } + + static void OnSuccessCallback_29(void * context, uint16_t installedOpenLimitLift) + { + (static_cast(context))->OnSuccessResponse_29(installedOpenLimitLift); + } + + static void OnFailureCallback_30(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_30(chip::to_underlying(status)); + } + + static void OnSuccessCallback_30(void * context, uint16_t installedClosedLimitLift) + { + (static_cast(context))->OnSuccessResponse_30(installedClosedLimitLift); + } + + static void OnFailureCallback_31(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_31(chip::to_underlying(status)); + } + + static void OnSuccessCallback_31(void * context) { (static_cast(context))->OnSuccessResponse_31(); } + + static void OnFailureCallback_32(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_32(chip::to_underlying(status)); + } + + static void OnSuccessCallback_32(void * context, uint16_t installedClosedLimitLift) + { + (static_cast(context))->OnSuccessResponse_32(installedClosedLimitLift); + } + + static void OnFailureCallback_33(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_33(chip::to_underlying(status)); + } + + static void OnSuccessCallback_33(void * context, uint16_t installedOpenLimitTilt) + { + (static_cast(context))->OnSuccessResponse_33(installedOpenLimitTilt); + } + + static void OnFailureCallback_34(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_34(chip::to_underlying(status)); + } + + static void OnSuccessCallback_34(void * context) { (static_cast(context))->OnSuccessResponse_34(); } + + static void OnFailureCallback_35(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_35(chip::to_underlying(status)); + } + + static void OnSuccessCallback_35(void * context, uint16_t installedOpenLimitTilt) + { + (static_cast(context))->OnSuccessResponse_35(installedOpenLimitTilt); + } + + static void OnFailureCallback_36(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_36(chip::to_underlying(status)); + } + + static void OnSuccessCallback_36(void * context, uint16_t installedClosedLimitTilt) + { + (static_cast(context))->OnSuccessResponse_36(installedClosedLimitTilt); + } + + static void OnFailureCallback_37(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_37(chip::to_underlying(status)); + } + + static void OnSuccessCallback_37(void * context) { (static_cast(context))->OnSuccessResponse_37(); } + + static void OnFailureCallback_38(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_38(chip::to_underlying(status)); + } + + static void OnSuccessCallback_38(void * context, uint16_t installedClosedLimitTilt) + { + (static_cast(context))->OnSuccessResponse_38(installedClosedLimitTilt); + } + + static void OnFailureCallback_39(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_39(chip::to_underlying(status)); + } + + static void OnSuccessCallback_39(void * context, uint16_t safetyStatus) + { + (static_cast(context))->OnSuccessResponse_39(safetyStatus); + } + + static void OnFailureCallback_40(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_40(chip::to_underlying(status)); + } + + static void OnSuccessCallback_40(void * context) { (static_cast(context))->OnSuccessResponse_40(); } + + static void OnFailureCallback_41(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_41(chip::to_underlying(status)); + } + + static void OnSuccessCallback_41(void * context, uint16_t safetyStatus) + { + (static_cast(context))->OnSuccessResponse_41(safetyStatus); + } + + static void OnFailureCallback_42(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_42(chip::to_underlying(status)); + } + + static void OnSuccessCallback_42(void * context, uint16_t currentPositionLift) + { + (static_cast(context))->OnSuccessResponse_42(currentPositionLift); + } + + static void OnFailureCallback_43(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_43(chip::to_underlying(status)); + } + + static void OnSuccessCallback_43(void * context) { (static_cast(context))->OnSuccessResponse_43(); } + + static void OnFailureCallback_44(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_44(chip::to_underlying(status)); + } + + static void OnSuccessCallback_44(void * context, uint16_t currentPositionLift) + { + (static_cast(context))->OnSuccessResponse_44(currentPositionLift); + } + + static void OnFailureCallback_45(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_45(chip::to_underlying(status)); + } + + static void OnSuccessCallback_45(void * context, uint16_t currentPositionTilt) + { + (static_cast(context))->OnSuccessResponse_45(currentPositionTilt); + } + + static void OnFailureCallback_46(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_46(chip::to_underlying(status)); + } + + static void OnSuccessCallback_46(void * context) { (static_cast(context))->OnSuccessResponse_46(); } + + static void OnFailureCallback_47(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_47(chip::to_underlying(status)); + } + + static void OnSuccessCallback_47(void * context, uint16_t currentPositionTilt) + { + (static_cast(context))->OnSuccessResponse_47(currentPositionTilt); + } + + static void OnFailureCallback_48(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_48(chip::to_underlying(status)); + } + + static void OnSuccessCallback_48(void * context, uint8_t currentPositionLiftPercentage) + { + (static_cast(context))->OnSuccessResponse_48(currentPositionLiftPercentage); + } + + static void OnFailureCallback_49(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_49(chip::to_underlying(status)); + } + + static void OnSuccessCallback_49(void * context) { (static_cast(context))->OnSuccessResponse_49(); } + + static void OnFailureCallback_50(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_50(chip::to_underlying(status)); + } + + static void OnSuccessCallback_50(void * context, uint8_t currentPositionLiftPercentage) + { + (static_cast(context))->OnSuccessResponse_50(currentPositionLiftPercentage); + } + + static void OnFailureCallback_51(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_51(chip::to_underlying(status)); + } + + static void OnSuccessCallback_51(void * context, uint8_t currentPositionTiltPercentage) + { + (static_cast(context))->OnSuccessResponse_51(currentPositionTiltPercentage); + } + + static void OnFailureCallback_52(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_52(chip::to_underlying(status)); + } + + static void OnSuccessCallback_52(void * context) { (static_cast(context))->OnSuccessResponse_52(); } + + static void OnFailureCallback_53(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_53(chip::to_underlying(status)); + } + + static void OnSuccessCallback_53(void * context, uint8_t currentPositionTiltPercentage) + { + (static_cast(context))->OnSuccessResponse_53(currentPositionTiltPercentage); + } + + // + // Tests methods + // + + CHIP_ERROR Test2ReadTheRoMandatoryAttributeDefaultType_0() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute(this, OnSuccessCallback_0, + OnFailureCallback_0); + } + + void OnFailureResponse_0(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_0(uint8_t type) + { + VerifyOrReturn(CheckConstraintType("type", "", "enum8")); + VerifyOrReturn(CheckConstraintMaxValue("type", type, 9)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryAttributeType_1() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint8_t typeArgument; + typeArgument = static_cast(250); + + return cluster.WriteAttribute( + typeArgument, this, OnSuccessCallback_1, OnFailureCallback_1); + } + + void OnFailureResponse_1(uint8_t status) { NextTest(); } + + void OnSuccessResponse_1() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoMandatoryAttributeType_2() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute(this, OnSuccessCallback_2, + OnFailureCallback_2); + } + + void OnFailureResponse_2(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_2(uint8_t type) + { + VerifyOrReturn(CheckConstraintType("type", "", "enum8")); + VerifyOrReturn(CheckConstraintNotValue("type", type, 250)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoMandatoryAttributeDefaultConfigStatus_3() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_3, OnFailureCallback_3); + } + + void OnFailureResponse_3(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_3(uint8_t configStatus) + { + VerifyOrReturn(CheckConstraintType("configStatus", "", "map8")); + VerifyOrReturn(CheckConstraintMaxValue("configStatus", configStatus, 63)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryAttributeConfigStatus_4() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint8_t configStatusArgument; + configStatusArgument = 128; + + return cluster.WriteAttribute( + configStatusArgument, this, OnSuccessCallback_4, OnFailureCallback_4); + } + + void OnFailureResponse_4(uint8_t status) { NextTest(); } + + void OnSuccessResponse_4() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoMandatoryAttributeConfigStatus_5() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_5, OnFailureCallback_5); + } + + void OnFailureResponse_5(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_5(uint8_t configStatus) + { + VerifyOrReturn(CheckConstraintType("configStatus", "", "map8")); + VerifyOrReturn(CheckConstraintNotValue("configStatus", configStatus, 128)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoMandatoryAttributeDefaultOperationalStatus_6() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_6, OnFailureCallback_6); + } + + void OnFailureResponse_6(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_6(uint8_t operationalStatus) + { + VerifyOrReturn(CheckConstraintType("operationalStatus", "", "map8")); + VerifyOrReturn(CheckConstraintMaxValue("operationalStatus", operationalStatus, 63)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryAttributeOperationalStatus_7() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint8_t operationalStatusArgument; + operationalStatusArgument = 128; + + return cluster.WriteAttribute( + operationalStatusArgument, this, OnSuccessCallback_7, OnFailureCallback_7); + } + + void OnFailureResponse_7(uint8_t status) { NextTest(); } + + void OnSuccessResponse_7() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoMandatoryAttributeOperationalStatus_8() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_8, OnFailureCallback_8); + } + + void OnFailureResponse_8(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_8(uint8_t operationalStatus) + { + VerifyOrReturn(CheckConstraintType("operationalStatus", "", "map8")); + VerifyOrReturn(CheckConstraintNotValue("operationalStatus", operationalStatus, 128)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoMandatoryAttributeDefaultEndProductType_9() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_9, OnFailureCallback_9); + } + + void OnFailureResponse_9(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_9(uint8_t endProductType) + { + VerifyOrReturn(CheckConstraintType("endProductType", "", "enum8")); + VerifyOrReturn(CheckConstraintMaxValue("endProductType", endProductType, 23)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryAttributeEndProductType_10() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint8_t endProductTypeArgument; + endProductTypeArgument = static_cast(250); + + return cluster.WriteAttribute( + endProductTypeArgument, this, OnSuccessCallback_10, OnFailureCallback_10); + } + + void OnFailureResponse_10(uint8_t status) { NextTest(); } + + void OnSuccessResponse_10() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoMandatoryAttributeEndProductType_11() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_11, OnFailureCallback_11); + } + + void OnFailureResponse_11(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_11(uint8_t endProductType) + { + VerifyOrReturn(CheckConstraintType("endProductType", "", "enum8")); + VerifyOrReturn(CheckConstraintNotValue("endProductType", endProductType, 250)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRwMandatoryAttributeDefaultMode_12() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute(this, OnSuccessCallback_12, + OnFailureCallback_12); + } + + void OnFailureResponse_12(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_12(uint8_t mode) + { + VerifyOrReturn(CheckConstraintType("mode", "", "map8")); + VerifyOrReturn(CheckConstraintMaxValue("mode", mode, 15)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRwMandatoryAttributeMode_13() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint8_t modeArgument; + modeArgument = 8; + + return cluster.WriteAttribute( + modeArgument, this, OnSuccessCallback_13, OnFailureCallback_13); + } + + void OnFailureResponse_13(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_13() { NextTest(); } + + CHIP_ERROR Test3bReadsBackTheRwMandatoryAttributeMode_14() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute(this, OnSuccessCallback_14, + OnFailureCallback_14); + } + + void OnFailureResponse_14(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_14(uint8_t mode) + { + VerifyOrReturn(CheckValue("mode", mode, 8)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultTargetPositionLiftPercent100ths_15() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_15, OnFailureCallback_15); + } + + void OnFailureResponse_15(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_15(uint16_t targetPositionLiftPercent100ths) + { + VerifyOrReturn(CheckConstraintType("targetPositionLiftPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintMaxValue("targetPositionLiftPercent100ths", targetPositionLiftPercent100ths, 10000)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeTargetPositionLiftPercent100ths_16() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t targetPositionLiftPercent100thsArgument; + targetPositionLiftPercent100thsArgument = 20000U; + + return cluster.WriteAttribute( + targetPositionLiftPercent100thsArgument, this, OnSuccessCallback_16, OnFailureCallback_16); + } + + void OnFailureResponse_16(uint8_t status) { NextTest(); } + + void OnSuccessResponse_16() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeTargetPositionLiftPercent100ths_17() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_17, OnFailureCallback_17); + } + + void OnFailureResponse_17(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_17(uint16_t targetPositionLiftPercent100ths) + { + VerifyOrReturn(CheckConstraintType("targetPositionLiftPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintNotValue("targetPositionLiftPercent100ths", targetPositionLiftPercent100ths, 20000)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultTargetPositionTiltPercent100ths_18() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_18, OnFailureCallback_18); + } + + void OnFailureResponse_18(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_18(uint16_t targetPositionTiltPercent100ths) + { + VerifyOrReturn(CheckConstraintType("targetPositionTiltPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintMaxValue("targetPositionTiltPercent100ths", targetPositionTiltPercent100ths, 10000)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeTargetPositionTiltPercent100ths_19() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t targetPositionTiltPercent100thsArgument; + targetPositionTiltPercent100thsArgument = 20000U; + + return cluster.WriteAttribute( + targetPositionTiltPercent100thsArgument, this, OnSuccessCallback_19, OnFailureCallback_19); + } + + void OnFailureResponse_19(uint8_t status) { NextTest(); } + + void OnSuccessResponse_19() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeTargetPositionTiltPercent100ths_20() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_20, OnFailureCallback_20); + } + + void OnFailureResponse_20(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_20(uint16_t targetPositionTiltPercent100ths) + { + VerifyOrReturn(CheckConstraintType("targetPositionTiltPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintNotValue("targetPositionTiltPercent100ths", targetPositionTiltPercent100ths, 20000)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultCurrentPositionLiftPercent100ths_21() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_21, OnFailureCallback_21); + } + + void OnFailureResponse_21(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_21(uint16_t currentPositionLiftPercent100ths) + { + VerifyOrReturn(CheckConstraintType("currentPositionLiftPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintMaxValue("currentPositionLiftPercent100ths", currentPositionLiftPercent100ths, 10000)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeCurrentPositionLiftPercent100ths_22() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t currentPositionLiftPercent100thsArgument; + currentPositionLiftPercent100thsArgument = 20000U; + + return cluster.WriteAttribute( + currentPositionLiftPercent100thsArgument, this, OnSuccessCallback_22, OnFailureCallback_22); + } + + void OnFailureResponse_22(uint8_t status) { NextTest(); } + + void OnSuccessResponse_22() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeCurrentPositionLiftPercent100ths_23() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_23, OnFailureCallback_23); + } + + void OnFailureResponse_23(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_23(uint16_t currentPositionLiftPercent100ths) + { + VerifyOrReturn(CheckConstraintType("currentPositionLiftPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintNotValue("currentPositionLiftPercent100ths", currentPositionLiftPercent100ths, 20000)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultCurrentPositionTiltPercent100ths_24() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_24, OnFailureCallback_24); + } + + void OnFailureResponse_24(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_24(uint16_t currentPositionTiltPercent100ths) + { + VerifyOrReturn(CheckConstraintType("currentPositionTiltPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintMaxValue("currentPositionTiltPercent100ths", currentPositionTiltPercent100ths, 10000)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeCurrentPositionTiltPercent100ths_25() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t currentPositionTiltPercent100thsArgument; + currentPositionTiltPercent100thsArgument = 20000U; + + return cluster.WriteAttribute( + currentPositionTiltPercent100thsArgument, this, OnSuccessCallback_25, OnFailureCallback_25); + } + + void OnFailureResponse_25(uint8_t status) { NextTest(); } + + void OnSuccessResponse_25() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeCurrentPositionTiltPercent100ths_26() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_26, OnFailureCallback_26); + } + + void OnFailureResponse_26(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_26(uint16_t currentPositionTiltPercent100ths) + { + VerifyOrReturn(CheckConstraintType("currentPositionTiltPercent100ths", "", "uint16")); + VerifyOrReturn( + CheckConstraintNotValue("currentPositionTiltPercent100ths", currentPositionTiltPercent100ths, 20000)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultInstalledOpenLimitLift_27() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_27, OnFailureCallback_27); + } + + void OnFailureResponse_27(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_27(uint16_t installedOpenLimitLift) + { + VerifyOrReturn(CheckConstraintType("installedOpenLimitLift", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitLift", installedOpenLimitLift, 65535)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeInstalledOpenLimitLift_28() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t installedOpenLimitLiftArgument; + installedOpenLimitLiftArgument = 255U; + + return cluster.WriteAttribute( + installedOpenLimitLiftArgument, this, OnSuccessCallback_28, OnFailureCallback_28); + } + + void OnFailureResponse_28(uint8_t status) { NextTest(); } + + void OnSuccessResponse_28() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeInstalledOpenLimitLift_29() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_29, OnFailureCallback_29); + } + + void OnFailureResponse_29(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_29(uint16_t installedOpenLimitLift) + { + VerifyOrReturn(CheckConstraintType("installedOpenLimitLift", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitLift", installedOpenLimitLift, 65535)); + NextTest(); + } + + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultInstalledClosedLimitLift_30() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_30, OnFailureCallback_30); + } + + void OnFailureResponse_30(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_30(uint16_t installedClosedLimitLift) + { + VerifyOrReturn(CheckConstraintType("installedClosedLimitLift", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitLift", installedClosedLimitLift, 65535)); + NextTest(); + } + + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeInstalledClosedLimitLift_31() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t installedClosedLimitLiftArgument; + installedClosedLimitLiftArgument = 255U; + + return cluster.WriteAttribute( + installedClosedLimitLiftArgument, this, OnSuccessCallback_31, OnFailureCallback_31); + } + + void OnFailureResponse_31(uint8_t status) { NextTest(); } + + void OnSuccessResponse_31() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeInstalledClosedLimitLift_32() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_32, OnFailureCallback_32); + } + + void OnFailureResponse_32(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_32(uint16_t installedClosedLimitLift) + { + VerifyOrReturn(CheckConstraintType("installedClosedLimitLift", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitLift", installedClosedLimitLift, 65535)); NextTest(); } - CHIP_ERROR TestReadsBackTheRoMandatoryAttributeEndProductType_7() + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultInstalledOpenLimitTilt_33() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; cluster.Associate(mDevice, endpoint); - return cluster.ReadAttribute( - this, OnSuccessCallback_7, OnFailureCallback_7); + return cluster.ReadAttribute( + this, OnSuccessCallback_33, OnFailureCallback_33); } - void OnFailureResponse_7(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_33(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_7(uint8_t endProductType) + void OnSuccessResponse_33(uint16_t installedOpenLimitTilt) { - VerifyOrReturn(CheckValue("endProductType", endProductType, 0)); + VerifyOrReturn(CheckConstraintType("installedOpenLimitTilt", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitTilt", installedOpenLimitTilt, 65535)); NextTest(); } - CHIP_ERROR TestReadTheRwMandatoryAttributeDefaultMode_8() + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeInstalledOpenLimitTilt_34() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; cluster.Associate(mDevice, endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_8, - OnFailureCallback_8); + uint16_t installedOpenLimitTiltArgument; + installedOpenLimitTiltArgument = 255U; + + return cluster.WriteAttribute( + installedOpenLimitTiltArgument, this, OnSuccessCallback_34, OnFailureCallback_34); } - void OnFailureResponse_8(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_34(uint8_t status) { NextTest(); } + + void OnSuccessResponse_34() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeInstalledOpenLimitTilt_35() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_35, OnFailureCallback_35); + } + + void OnFailureResponse_35(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_8(uint8_t mode) + void OnSuccessResponse_35(uint16_t installedOpenLimitTilt) { - VerifyOrReturn(CheckValue("mode", mode, 0)); + VerifyOrReturn(CheckConstraintType("installedOpenLimitTilt", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedOpenLimitTilt", installedOpenLimitTilt, 65535)); NextTest(); } - CHIP_ERROR TestWriteAValueIntoTheRwMandatoryAttributeMode_9() + CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultInstalledClosedLimitTilt_36() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; cluster.Associate(mDevice, endpoint); - uint8_t modeArgument; - modeArgument = 7; + return cluster.ReadAttribute( + this, OnSuccessCallback_36, OnFailureCallback_36); + } - return cluster.WriteAttribute( - modeArgument, this, OnSuccessCallback_9, OnFailureCallback_9); + void OnFailureResponse_36(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_36(uint16_t installedClosedLimitTilt) + { + VerifyOrReturn(CheckConstraintType("installedClosedLimitTilt", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitTilt", installedClosedLimitTilt, 65535)); + NextTest(); } - void OnFailureResponse_9(uint8_t status) { ThrowFailureResponse(); } + CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeInstalledClosedLimitTilt_37() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); - void OnSuccessResponse_9() { NextTest(); } + uint16_t installedClosedLimitTiltArgument; + installedClosedLimitTiltArgument = 255U; + + return cluster.WriteAttribute( + installedClosedLimitTiltArgument, this, OnSuccessCallback_37, OnFailureCallback_37); + } - CHIP_ERROR TestReadsBackTheRwMandatoryAttributeMode_10() + void OnFailureResponse_37(uint8_t status) { NextTest(); } + + void OnSuccessResponse_37() { ThrowSuccessResponse(); } + + CHIP_ERROR Test3bReadsBackTheRoOptionalAttributeInstalledClosedLimitTilt_38() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::WindowCoveringClusterTest cluster; cluster.Associate(mDevice, endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_10, - OnFailureCallback_10); + return cluster.ReadAttribute( + this, OnSuccessCallback_38, OnFailureCallback_38); } - void OnFailureResponse_10(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_38(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_38(uint16_t installedClosedLimitTilt) + { + VerifyOrReturn(CheckConstraintType("installedClosedLimitTilt", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("installedClosedLimitTilt", installedClosedLimitTilt, 65535)); + NextTest(); + } + + CHIP_ERROR Test4ReadTheRoMandatoryAttributeDefaultSafetyStatus_39() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_39, OnFailureCallback_39); + } + + void OnFailureResponse_39(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_39(uint16_t safetyStatus) + { + VerifyOrReturn(CheckConstraintType("safetyStatus", "", "map16")); + VerifyOrReturn(CheckConstraintMaxValue("safetyStatus", safetyStatus, 2047)); + NextTest(); + } + + CHIP_ERROR Test5aWriteAValueIntoTheRoMandatoryAttributeSafetyStatus_40() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t safetyStatusArgument; + safetyStatusArgument = 4096U; + + return cluster.WriteAttribute( + safetyStatusArgument, this, OnSuccessCallback_40, OnFailureCallback_40); + } + + void OnFailureResponse_40(uint8_t status) { NextTest(); } + + void OnSuccessResponse_40() { ThrowSuccessResponse(); } + + CHIP_ERROR Test5bReadsBackTheRoMandatoryAttributeSafetyStatus_41() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_41, OnFailureCallback_41); + } + + void OnFailureResponse_41(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_41(uint16_t safetyStatus) + { + VerifyOrReturn(CheckConstraintType("safetyStatus", "", "map16")); + VerifyOrReturn(CheckConstraintNotValue("safetyStatus", safetyStatus, 4096)); + NextTest(); + } + + CHIP_ERROR Test4ReadTheRoOptionalAttributeDefaultCurrentPositionLift_42() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_42, OnFailureCallback_42); + } + + void OnFailureResponse_42(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_42(uint16_t currentPositionLift) + { + VerifyOrReturn(CheckConstraintType("currentPositionLift", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionLift", currentPositionLift, 65535)); + NextTest(); + } + + CHIP_ERROR Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionLift_43() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t currentPositionLiftArgument; + currentPositionLiftArgument = 255U; + + return cluster.WriteAttribute( + currentPositionLiftArgument, this, OnSuccessCallback_43, OnFailureCallback_43); + } + + void OnFailureResponse_43(uint8_t status) { NextTest(); } + + void OnSuccessResponse_43() { ThrowSuccessResponse(); } + + CHIP_ERROR Test5bReadsBackTheRoOptionalAttributeCurrentPositionLift_44() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_44, OnFailureCallback_44); + } + + void OnFailureResponse_44(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_44(uint16_t currentPositionLift) + { + VerifyOrReturn(CheckConstraintType("currentPositionLift", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionLift", currentPositionLift, 65535)); + NextTest(); + } + + CHIP_ERROR Test4ReadTheRoOptionalAttributeDefaultCurrentPositionTilt_45() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_45, OnFailureCallback_45); + } + + void OnFailureResponse_45(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_45(uint16_t currentPositionTilt) + { + VerifyOrReturn(CheckConstraintType("currentPositionTilt", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionTilt", currentPositionTilt, 65535)); + NextTest(); + } + + CHIP_ERROR Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionTilt_46() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint16_t currentPositionTiltArgument; + currentPositionTiltArgument = 255U; + + return cluster.WriteAttribute( + currentPositionTiltArgument, this, OnSuccessCallback_46, OnFailureCallback_46); + } + + void OnFailureResponse_46(uint8_t status) { NextTest(); } + + void OnSuccessResponse_46() { ThrowSuccessResponse(); } + + CHIP_ERROR Test5bReadsBackTheRoOptionalAttributeCurrentPositionTilt_47() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_47, OnFailureCallback_47); + } + + void OnFailureResponse_47(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_47(uint16_t currentPositionTilt) + { + VerifyOrReturn(CheckConstraintType("currentPositionTilt", "", "uint16")); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionTilt", currentPositionTilt, 65535)); + NextTest(); + } + + CHIP_ERROR Test4ReadTheRoOptionalAttributeDefaultCurrentPositionLiftPercentage_48() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_48, OnFailureCallback_48); + } + + void OnFailureResponse_48(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_48(uint8_t currentPositionLiftPercentage) + { + VerifyOrReturn(CheckConstraintType("currentPositionLiftPercentage", "", "uint8")); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionLiftPercentage", currentPositionLiftPercentage, 100)); + NextTest(); + } + + CHIP_ERROR Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionLiftPercentage_49() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint8_t currentPositionLiftPercentageArgument; + currentPositionLiftPercentageArgument = 200; + + return cluster.WriteAttribute( + currentPositionLiftPercentageArgument, this, OnSuccessCallback_49, OnFailureCallback_49); + } + + void OnFailureResponse_49(uint8_t status) { NextTest(); } + + void OnSuccessResponse_49() { ThrowSuccessResponse(); } + + CHIP_ERROR Test5bReadsBackTheRoOptionalAttributeCurrentPositionLiftPercentage_50() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_50, OnFailureCallback_50); + } + + void OnFailureResponse_50(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_50(uint8_t currentPositionLiftPercentage) + { + VerifyOrReturn(CheckConstraintType("currentPositionLiftPercentage", "", "uint8")); + VerifyOrReturn(CheckConstraintNotValue("currentPositionLiftPercentage", currentPositionLiftPercentage, 200)); + NextTest(); + } + + CHIP_ERROR Test4ReadTheRoOptionalAttributeDefaultCurrentPositionTiltPercentage_51() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_51, OnFailureCallback_51); + } + + void OnFailureResponse_51(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_51(uint8_t currentPositionTiltPercentage) + { + VerifyOrReturn(CheckConstraintType("currentPositionTiltPercentage", "", "uint8")); + VerifyOrReturn(CheckConstraintMaxValue("currentPositionTiltPercentage", currentPositionTiltPercentage, 100)); + NextTest(); + } + + CHIP_ERROR Test5aWriteAValueIntoTheRoOptionalAttributeCurrentPositionTiltPercentage_52() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + uint8_t currentPositionTiltPercentageArgument; + currentPositionTiltPercentageArgument = 200; + + return cluster.WriteAttribute( + currentPositionTiltPercentageArgument, this, OnSuccessCallback_52, OnFailureCallback_52); + } + + void OnFailureResponse_52(uint8_t status) { NextTest(); } + + void OnSuccessResponse_52() { ThrowSuccessResponse(); } + + CHIP_ERROR Test5bReadsBackTheRoOptionalAttributeCurrentPositionTiltPercentage_53() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::WindowCoveringClusterTest cluster; + cluster.Associate(mDevice, endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_53, OnFailureCallback_53); + } + + void OnFailureResponse_53(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_10(uint8_t mode) + void OnSuccessResponse_53(uint8_t currentPositionTiltPercentage) { - VerifyOrReturn(CheckValue("mode", mode, 7)); + VerifyOrReturn(CheckConstraintType("currentPositionTiltPercentage", "", "uint8")); + VerifyOrReturn(CheckConstraintNotValue("currentPositionTiltPercentage", currentPositionTiltPercentage, 200)); NextTest(); } };