[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 <commits@restyled.io>
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 aa7de84..a85c92d 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 2782edb..62b5351 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 @@
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 a326d64..b2a5d01 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 @@
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 2645767..e5f2881 100644
--- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
+++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
@@ -16502,7 +16502,7 @@
- (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 @@
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_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 @@
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_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 @@
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_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 @@
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:@"reads back global attribute: FeatureMap"];
+ 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:@"3b: reads back global attribute: FeatureMap"];
CHIPDevice * device = GetConnectedDevice();
dispatch_queue_t queue = dispatch_get_main_queue();
@@ -16605,14 +16620,11 @@
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_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,62 +16642,53 @@
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:@"reads back the RO mandatory attribute: Type"];
+ 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);
- [cluster readAttributeTypeWithResponseHandler:^(NSError * err, NSDictionary * values) {
- NSLog(@"reads back the RO mandatory attribute: Type Error: %@", err);
+ 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, 0);
-
- {
- id actualValue = values[@"value"];
- XCTAssertEqual([actualValue unsignedCharValue], 0);
- }
-
- [expectation fulfill];
- }];
+ XCTAssertEqual(err.code, 1);
+ [expectation fulfill];
+ }];
[self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
}
- (void)testSendClusterTest_TC_WNCV_2_1_000002_ReadAttribute
{
- XCTestExpectation * expectation = [self expectationWithDescription:@"read the RO mandatory attribute default: ConfigStatus"];
+ XCTestExpectation * expectation = [self expectationWithDescription:@"3b: reads back 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);
- [cluster readAttributeConfigStatusWithResponseHandler:^(NSError * err, NSDictionary * values) {
- NSLog(@"read the RO mandatory attribute default: ConfigStatus Error: %@", err);
+ [cluster readAttributeTypeWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"3b: reads back the RO mandatory attribute: Type Error: %@", err);
XCTAssertEqual(err.code, 0);
- {
- id actualValue = values[@"value"];
- XCTAssertEqual([actualValue unsignedCharValue], 3);
- }
+ XCTAssertNotEqual([values[@"value"] unsignedCharValue], 250);
[expectation fulfill];
}];
@@ -16694,7 +16697,7 @@
}
- (void)testSendClusterTest_TC_WNCV_2_1_000003_ReadAttribute
{
- XCTestExpectation * expectation = [self expectationWithDescription:@"reads back the RO mandatory attribute: ConfigStatus"];
+ XCTestExpectation * expectation = [self expectationWithDescription:@"2: read the RO mandatory attribute default: ConfigStatus"];
CHIPDevice * device = GetConnectedDevice();
dispatch_queue_t queue = dispatch_get_main_queue();
@@ -16702,63 +16705,54 @@
XCTAssertNotNil(cluster);
[cluster readAttributeConfigStatusWithResponseHandler:^(NSError * err, NSDictionary * values) {
- NSLog(@"reads back the RO mandatory attribute: 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_000004_ReadAttribute
+- (void)testSendClusterTest_TC_WNCV_2_1_000004_WriteAttribute
{
XCTestExpectation * expectation =
- [self expectationWithDescription:@"read the RO mandatory attribute default: OperationalStatus"];
+ [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);
- [cluster readAttributeOperationalStatusWithResponseHandler:^(NSError * err, NSDictionary * values) {
- NSLog(@"read the RO mandatory attribute default: OperationalStatus Error: %@", err);
+ 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, 0);
-
- {
- id actualValue = values[@"value"];
- XCTAssertEqual([actualValue unsignedCharValue], 0);
- }
-
- [expectation fulfill];
- }];
+ 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: OperationalStatus"];
+ XCTestExpectation * expectation = [self expectationWithDescription:@"3b: reads back 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);
- [cluster readAttributeOperationalStatusWithResponseHandler:^(NSError * err, NSDictionary * values) {
- NSLog(@"reads back the RO mandatory attribute: OperationalStatus Error: %@", err);
+ [cluster readAttributeConfigStatusWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"3b: reads back the RO mandatory attribute: ConfigStatus Error: %@", err);
XCTAssertEqual(err.code, 0);
- {
- id actualValue = values[@"value"];
- XCTAssertEqual([actualValue unsignedCharValue], 0);
- }
+ XCTAssertNotEqual([values[@"value"] unsignedCharValue], 128);
[expectation fulfill];
}];
@@ -16767,55 +16761,140 @@
}
- (void)testSendClusterTest_TC_WNCV_2_1_000006_ReadAttribute
{
- XCTestExpectation * expectation = [self expectationWithDescription:@"read the RO mandatory attribute default: EndProductType"];
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"2: read the RO mandatory attribute default: OperationalStatus"];
CHIPDevice * device = GetConnectedDevice();
dispatch_queue_t queue = dispatch_get_main_queue();
CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue];
XCTAssertNotNil(cluster);
- [cluster readAttributeEndProductTypeWithResponseHandler:^(NSError * err, NSDictionary * values) {
- NSLog(@"read the RO mandatory attribute default: EndProductType Error: %@", err);
+ [cluster readAttributeOperationalStatusWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ 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_000007_ReadAttribute
+- (void)testSendClusterTest_TC_WNCV_2_1_000007_WriteAttribute
{
- XCTestExpectation * expectation = [self expectationWithDescription:@"reads back the RO mandatory attribute: EndProductType"];
+ 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);
- [cluster readAttributeEndProductTypeWithResponseHandler:^(NSError * err, NSDictionary * values) {
- NSLog(@"reads back the RO mandatory attribute: EndProductType Error: %@", err);
+ 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, 0);
-
- {
- id actualValue = values[@"value"];
- XCTAssertEqual([actualValue unsignedCharValue], 0);
- }
-
- [expectation fulfill];
- }];
+ XCTAssertEqual(err.code, 1);
+ [expectation fulfill];
+ }];
[self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
}
- (void)testSendClusterTest_TC_WNCV_2_1_000008_ReadAttribute
{
- XCTestExpectation * expectation = [self expectationWithDescription:@"read the RW mandatory attribute default: Mode"];
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"3b: reads back 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);
+
+ [cluster readAttributeOperationalStatusWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"3b: reads back the RO mandatory attribute: OperationalStatus Error: %@", err);
+
+ XCTAssertEqual(err.code, 0);
+
+ XCTAssertNotEqual([values[@"value"] unsignedCharValue], 128);
+
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+- (void)testSendClusterTest_TC_WNCV_2_1_000009_ReadAttribute
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"2: read the RO mandatory attribute default: EndProductType"];
+
+ CHIPDevice * device = GetConnectedDevice();
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPTestWindowCovering * cluster = [[CHIPTestWindowCovering alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeEndProductTypeWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"2: read the RO mandatory attribute default: EndProductType Error: %@", err);
+
+ XCTAssertEqual(err.code, 0);
+
+ XCTAssertLessThanOrEqual([values[@"value"] unsignedCharValue], 23);
+
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+- (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:@"3b: reads back 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);
+
+ [cluster readAttributeEndProductTypeWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"3b: reads back the RO mandatory attribute: EndProductType Error: %@", err);
+
+ XCTAssertEqual(err.code, 0);
+
+ XCTAssertNotEqual([values[@"value"] unsignedCharValue], 250);
+
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+- (void)testSendClusterTest_TC_WNCV_2_1_000012_ReadAttribute
+{
+ 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 @@
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 @@
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 @@
[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 @@
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 @@
[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 c37cbee..99984eb 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 4a56713..3d39708 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 @@
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 @@
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 @@
(static_cast<Test_TC_WNCV_1_1 *>(context))->OnFailureResponse_4(chip::to_underlying(status));
}
- static void OnSuccessCallback_4(void * context, uint32_t featureMap)
+ static void OnSuccessCallback_4(void * context) { (static_cast<Test_TC_WNCV_1_1 *>(context))->OnSuccessResponse_4(); }
+
+ static void OnFailureCallback_5(void * context, EmberAfStatus status)
{
- (static_cast<Test_TC_WNCV_1_1 *>(context))->OnSuccessResponse_4(featureMap);
+ (static_cast<Test_TC_WNCV_1_1 *>(context))->OnFailureResponse_5(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_5(void * context, uint32_t featureMap)
+ {
+ (static_cast<Test_TC_WNCV_1_1 *>(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 @@
void OnSuccessResponse_0(uint16_t clusterRevision)
{
- VerifyOrReturn(CheckValue<uint16_t>("clusterRevision", clusterRevision, 5U));
+ VerifyOrReturn(CheckConstraintType("clusterRevision", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMinValue<uint16_t>("clusterRevision", clusterRevision, 5));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::ClusterRevision::TypeInfo>(
clusterRevisionArgument, this, OnSuccessCallback_1, OnFailureCallback_1);
@@ -25887,7 +25901,7 @@
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 @@
void OnSuccessResponse_2(uint16_t clusterRevision)
{
- VerifyOrReturn(CheckValue<uint16_t>("clusterRevision", clusterRevision, 5U));
+ VerifyOrReturn(CheckConstraintType("clusterRevision", "", "uint16"));
+ VerifyOrReturn(CheckConstraintNotValue<uint16_t>("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 @@
void OnSuccessResponse_3(uint32_t featureMap)
{
- VerifyOrReturn(CheckValue<uint32_t>("featureMap", featureMap, 0UL));
+ VerifyOrReturn(CheckConstraintType("featureMap", "", "uint32"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint32_t>("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<chip::app::Clusters::WindowCovering::Attributes::FeatureMap::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::FeatureMap::TypeInfo>(
- 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<uint32_t>("featureMap", featureMap, 0UL));
+ VerifyOrReturn(CheckConstraintType("featureMap", "", "uint32"));
+ VerifyOrReturn(CheckConstraintNotValue<uint32_t>("featureMap", featureMap, 32769));
NextTest();
}
};
@@ -25973,48 +26007,253 @@
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 @@
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 @@
(static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_1(chip::to_underlying(status));
}
- static void OnSuccessCallback_1(void * context, uint8_t type)
- {
- (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_1(type);
- }
+ static void OnSuccessCallback_1(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_1(); }
static void OnFailureCallback_2(void * context, EmberAfStatus status)
{
(static_cast<Test_TC_WNCV_2_1 *>(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<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_2(configStatus);
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_2(type);
}
static void OnFailureCallback_3(void * context, EmberAfStatus status)
@@ -26074,19 +26310,16 @@
(static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_4(chip::to_underlying(status));
}
- static void OnSuccessCallback_4(void * context, uint8_t operationalStatus)
- {
- (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_4(operationalStatus);
- }
+ static void OnSuccessCallback_4(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_4(); }
static void OnFailureCallback_5(void * context, EmberAfStatus status)
{
(static_cast<Test_TC_WNCV_2_1 *>(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<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_5(operationalStatus);
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_5(configStatus);
}
static void OnFailureCallback_6(void * context, EmberAfStatus status)
@@ -26094,9 +26327,9 @@
(static_cast<Test_TC_WNCV_2_1 *>(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<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_6(endProductType);
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_6(operationalStatus);
}
static void OnFailureCallback_7(void * context, EmberAfStatus status)
@@ -26104,19 +26337,16 @@
(static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_7(chip::to_underlying(status));
}
- static void OnSuccessCallback_7(void * context, uint8_t endProductType)
- {
- (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_7(endProductType);
- }
+ static void OnSuccessCallback_7(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_7(); }
static void OnFailureCallback_8(void * context, EmberAfStatus status)
{
(static_cast<Test_TC_WNCV_2_1 *>(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<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_8(mode);
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_8(operationalStatus);
}
static void OnFailureCallback_9(void * context, EmberAfStatus status)
@@ -26124,23 +26354,411 @@
(static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_9(chip::to_underlying(status));
}
- static void OnSuccessCallback_9(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_9(); }
+ static void OnSuccessCallback_9(void * context, uint8_t endProductType)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_9(endProductType);
+ }
static void OnFailureCallback_10(void * context, EmberAfStatus status)
{
(static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_10(chip::to_underlying(status));
}
- static void OnSuccessCallback_10(void * context, uint8_t mode)
+ static void OnSuccessCallback_10(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_10(); }
+
+ static void OnFailureCallback_11(void * context, EmberAfStatus status)
{
- (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_10(mode);
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_11(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_11(void * context, uint8_t endProductType)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_11(endProductType);
+ }
+
+ static void OnFailureCallback_12(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_12(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_12(void * context, uint8_t mode)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_12(mode);
+ }
+
+ static void OnFailureCallback_13(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_13(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_13(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_13(); }
+
+ static void OnFailureCallback_14(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_14(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_14(void * context, uint8_t mode)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_14(mode);
+ }
+
+ static void OnFailureCallback_15(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_15(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_15(void * context, uint16_t targetPositionLiftPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_15(targetPositionLiftPercent100ths);
+ }
+
+ static void OnFailureCallback_16(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_16(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_16(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_16(); }
+
+ static void OnFailureCallback_17(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_17(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_17(void * context, uint16_t targetPositionLiftPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_17(targetPositionLiftPercent100ths);
+ }
+
+ static void OnFailureCallback_18(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_18(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_18(void * context, uint16_t targetPositionTiltPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_18(targetPositionTiltPercent100ths);
+ }
+
+ static void OnFailureCallback_19(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_19(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_19(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_19(); }
+
+ static void OnFailureCallback_20(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_20(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_20(void * context, uint16_t targetPositionTiltPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_20(targetPositionTiltPercent100ths);
+ }
+
+ static void OnFailureCallback_21(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_21(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_21(void * context, uint16_t currentPositionLiftPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_21(currentPositionLiftPercent100ths);
+ }
+
+ static void OnFailureCallback_22(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_22(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_22(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_22(); }
+
+ static void OnFailureCallback_23(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_23(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_23(void * context, uint16_t currentPositionLiftPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_23(currentPositionLiftPercent100ths);
+ }
+
+ static void OnFailureCallback_24(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_24(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_24(void * context, uint16_t currentPositionTiltPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_24(currentPositionTiltPercent100ths);
+ }
+
+ static void OnFailureCallback_25(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_25(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_25(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_25(); }
+
+ static void OnFailureCallback_26(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_26(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_26(void * context, uint16_t currentPositionTiltPercent100ths)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_26(currentPositionTiltPercent100ths);
+ }
+
+ static void OnFailureCallback_27(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_27(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_27(void * context, uint16_t installedOpenLimitLift)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_27(installedOpenLimitLift);
+ }
+
+ static void OnFailureCallback_28(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_28(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_28(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_28(); }
+
+ static void OnFailureCallback_29(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_29(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_29(void * context, uint16_t installedOpenLimitLift)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_29(installedOpenLimitLift);
+ }
+
+ static void OnFailureCallback_30(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_30(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_30(void * context, uint16_t installedClosedLimitLift)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_30(installedClosedLimitLift);
+ }
+
+ static void OnFailureCallback_31(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_31(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_31(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_31(); }
+
+ static void OnFailureCallback_32(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_32(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_32(void * context, uint16_t installedClosedLimitLift)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_32(installedClosedLimitLift);
+ }
+
+ static void OnFailureCallback_33(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_33(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_33(void * context, uint16_t installedOpenLimitTilt)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_33(installedOpenLimitTilt);
+ }
+
+ static void OnFailureCallback_34(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_34(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_34(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_34(); }
+
+ static void OnFailureCallback_35(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_35(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_35(void * context, uint16_t installedOpenLimitTilt)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_35(installedOpenLimitTilt);
+ }
+
+ static void OnFailureCallback_36(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_36(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_36(void * context, uint16_t installedClosedLimitTilt)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_36(installedClosedLimitTilt);
+ }
+
+ static void OnFailureCallback_37(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_37(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_37(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_37(); }
+
+ static void OnFailureCallback_38(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_38(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_38(void * context, uint16_t installedClosedLimitTilt)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_38(installedClosedLimitTilt);
+ }
+
+ static void OnFailureCallback_39(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_39(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_39(void * context, uint16_t safetyStatus)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_39(safetyStatus);
+ }
+
+ static void OnFailureCallback_40(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_40(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_40(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_40(); }
+
+ static void OnFailureCallback_41(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_41(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_41(void * context, uint16_t safetyStatus)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_41(safetyStatus);
+ }
+
+ static void OnFailureCallback_42(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_42(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_42(void * context, uint16_t currentPositionLift)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_42(currentPositionLift);
+ }
+
+ static void OnFailureCallback_43(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_43(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_43(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_43(); }
+
+ static void OnFailureCallback_44(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_44(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_44(void * context, uint16_t currentPositionLift)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_44(currentPositionLift);
+ }
+
+ static void OnFailureCallback_45(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_45(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_45(void * context, uint16_t currentPositionTilt)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_45(currentPositionTilt);
+ }
+
+ static void OnFailureCallback_46(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_46(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_46(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_46(); }
+
+ static void OnFailureCallback_47(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_47(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_47(void * context, uint16_t currentPositionTilt)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_47(currentPositionTilt);
+ }
+
+ static void OnFailureCallback_48(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_48(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_48(void * context, uint8_t currentPositionLiftPercentage)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_48(currentPositionLiftPercentage);
+ }
+
+ static void OnFailureCallback_49(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_49(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_49(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_49(); }
+
+ static void OnFailureCallback_50(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_50(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_50(void * context, uint8_t currentPositionLiftPercentage)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_50(currentPositionLiftPercentage);
+ }
+
+ static void OnFailureCallback_51(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_51(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_51(void * context, uint8_t currentPositionTiltPercentage)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_51(currentPositionTiltPercentage);
+ }
+
+ static void OnFailureCallback_52(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_52(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_52(void * context) { (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_52(); }
+
+ static void OnFailureCallback_53(void * context, EmberAfStatus status)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnFailureResponse_53(chip::to_underlying(status));
+ }
+
+ static void OnSuccessCallback_53(void * context, uint8_t currentPositionTiltPercentage)
+ {
+ (static_cast<Test_TC_WNCV_2_1 *>(context))->OnSuccessResponse_53(currentPositionTiltPercentage);
}
//
// Tests methods
//
- CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultType_0()
+ CHIP_ERROR Test2ReadTheRoMandatoryAttributeDefaultType_0()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
@@ -26154,47 +26772,48 @@
void OnSuccessResponse_0(uint8_t type)
{
- VerifyOrReturn(CheckValue<uint8_t>("type", type, 0));
+ VerifyOrReturn(CheckConstraintType("type", "", "enum8"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint8_t>("type", type, 9));
NextTest();
}
- CHIP_ERROR TestReadsBackTheRoMandatoryAttributeType_1()
+ CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryAttributeType_1()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
cluster.Associate(mDevice, endpoint);
- return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::Type::TypeInfo>(this, OnSuccessCallback_1,
- OnFailureCallback_1);
+ uint8_t typeArgument;
+ typeArgument = static_cast<uint8_t>(250);
+
+ return cluster.WriteAttribute<chip::app::Clusters::WindowCovering::Attributes::Type::TypeInfo>(
+ typeArgument, this, OnSuccessCallback_1, OnFailureCallback_1);
}
- void OnFailureResponse_1(uint8_t status) { ThrowFailureResponse(); }
+ void OnFailureResponse_1(uint8_t status) { NextTest(); }
- void OnSuccessResponse_1(uint8_t type)
- {
- VerifyOrReturn(CheckValue<uint8_t>("type", type, 0));
- NextTest();
- }
+ void OnSuccessResponse_1() { ThrowSuccessResponse(); }
- CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultConfigStatus_2()
+ CHIP_ERROR Test3bReadsBackTheRoMandatoryAttributeType_2()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
cluster.Associate(mDevice, endpoint);
- return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::ConfigStatus::TypeInfo>(
- this, OnSuccessCallback_2, OnFailureCallback_2);
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::Type::TypeInfo>(this, OnSuccessCallback_2,
+ OnFailureCallback_2);
}
void OnFailureResponse_2(uint8_t status) { ThrowFailureResponse(); }
- void OnSuccessResponse_2(uint8_t configStatus)
+ void OnSuccessResponse_2(uint8_t type)
{
- VerifyOrReturn(CheckValue<uint8_t>("configStatus", configStatus, 3));
+ VerifyOrReturn(CheckConstraintType("type", "", "enum8"));
+ VerifyOrReturn(CheckConstraintNotValue<uint8_t>("type", type, 250));
NextTest();
}
- CHIP_ERROR TestReadsBackTheRoMandatoryAttributeConfigStatus_3()
+ CHIP_ERROR Test2ReadTheRoMandatoryAttributeDefaultConfigStatus_3()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
@@ -26208,132 +26827,931 @@
void OnSuccessResponse_3(uint8_t configStatus)
{
- VerifyOrReturn(CheckValue<uint8_t>("configStatus", configStatus, 3));
+ VerifyOrReturn(CheckConstraintType("configStatus", "", "map8"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint8_t>("configStatus", configStatus, 63));
NextTest();
}
- CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultOperationalStatus_4()
+ CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryAttributeConfigStatus_4()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
cluster.Associate(mDevice, endpoint);
- return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::OperationalStatus::TypeInfo>(
- this, OnSuccessCallback_4, OnFailureCallback_4);
+ uint8_t configStatusArgument;
+ configStatusArgument = 128;
+
+ return cluster.WriteAttribute<chip::app::Clusters::WindowCovering::Attributes::ConfigStatus::TypeInfo>(
+ configStatusArgument, this, OnSuccessCallback_4, OnFailureCallback_4);
}
- void OnFailureResponse_4(uint8_t status) { ThrowFailureResponse(); }
+ void OnFailureResponse_4(uint8_t status) { NextTest(); }
- void OnSuccessResponse_4(uint8_t operationalStatus)
- {
- VerifyOrReturn(CheckValue<uint8_t>("operationalStatus", operationalStatus, 0));
- NextTest();
- }
+ void OnSuccessResponse_4() { ThrowSuccessResponse(); }
- CHIP_ERROR TestReadsBackTheRoMandatoryAttributeOperationalStatus_5()
+ CHIP_ERROR Test3bReadsBackTheRoMandatoryAttributeConfigStatus_5()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
cluster.Associate(mDevice, endpoint);
- return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::OperationalStatus::TypeInfo>(
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::ConfigStatus::TypeInfo>(
this, OnSuccessCallback_5, OnFailureCallback_5);
}
void OnFailureResponse_5(uint8_t status) { ThrowFailureResponse(); }
- void OnSuccessResponse_5(uint8_t operationalStatus)
+ void OnSuccessResponse_5(uint8_t configStatus)
{
- VerifyOrReturn(CheckValue<uint8_t>("operationalStatus", operationalStatus, 0));
+ VerifyOrReturn(CheckConstraintType("configStatus", "", "map8"));
+ VerifyOrReturn(CheckConstraintNotValue<uint8_t>("configStatus", configStatus, 128));
NextTest();
}
- CHIP_ERROR TestReadTheRoMandatoryAttributeDefaultEndProductType_6()
+ CHIP_ERROR Test2ReadTheRoMandatoryAttributeDefaultOperationalStatus_6()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
cluster.Associate(mDevice, endpoint);
- return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::EndProductType::TypeInfo>(
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::OperationalStatus::TypeInfo>(
this, OnSuccessCallback_6, OnFailureCallback_6);
}
void OnFailureResponse_6(uint8_t status) { ThrowFailureResponse(); }
- void OnSuccessResponse_6(uint8_t endProductType)
+ void OnSuccessResponse_6(uint8_t operationalStatus)
{
- VerifyOrReturn(CheckValue<uint8_t>("endProductType", endProductType, 0));
+ VerifyOrReturn(CheckConstraintType("operationalStatus", "", "map8"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint8_t>("operationalStatus", operationalStatus, 63));
NextTest();
}
- CHIP_ERROR TestReadsBackTheRoMandatoryAttributeEndProductType_7()
+ 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<chip::app::Clusters::WindowCovering::Attributes::OperationalStatus::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::OperationalStatus::TypeInfo>(
+ this, OnSuccessCallback_8, OnFailureCallback_8);
+ }
+
+ void OnFailureResponse_8(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_8(uint8_t operationalStatus)
+ {
+ VerifyOrReturn(CheckConstraintType("operationalStatus", "", "map8"));
+ VerifyOrReturn(CheckConstraintNotValue<uint8_t>("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<chip::app::Clusters::WindowCovering::Attributes::EndProductType::TypeInfo>(
- this, OnSuccessCallback_7, OnFailureCallback_7);
+ this, OnSuccessCallback_9, OnFailureCallback_9);
}
- void OnFailureResponse_7(uint8_t status) { ThrowFailureResponse(); }
+ void OnFailureResponse_9(uint8_t status) { ThrowFailureResponse(); }
- void OnSuccessResponse_7(uint8_t endProductType)
+ void OnSuccessResponse_9(uint8_t endProductType)
{
- VerifyOrReturn(CheckValue<uint8_t>("endProductType", endProductType, 0));
+ VerifyOrReturn(CheckConstraintType("endProductType", "", "enum8"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint8_t>("endProductType", endProductType, 23));
NextTest();
}
- CHIP_ERROR TestReadTheRwMandatoryAttributeDefaultMode_8()
+ CHIP_ERROR Test3aWriteAValueIntoTheRoMandatoryAttributeEndProductType_10()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
cluster.Associate(mDevice, endpoint);
- return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::Mode::TypeInfo>(this, OnSuccessCallback_8,
- OnFailureCallback_8);
+ uint8_t endProductTypeArgument;
+ endProductTypeArgument = static_cast<uint8_t>(250);
+
+ return cluster.WriteAttribute<chip::app::Clusters::WindowCovering::Attributes::EndProductType::TypeInfo>(
+ endProductTypeArgument, this, OnSuccessCallback_10, OnFailureCallback_10);
}
- void OnFailureResponse_8(uint8_t status) { ThrowFailureResponse(); }
+ void OnFailureResponse_10(uint8_t status) { NextTest(); }
- void OnSuccessResponse_8(uint8_t mode)
+ void OnSuccessResponse_10() { ThrowSuccessResponse(); }
+
+ CHIP_ERROR Test3bReadsBackTheRoMandatoryAttributeEndProductType_11()
{
- VerifyOrReturn(CheckValue<uint8_t>("mode", mode, 0));
+ const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
+ chip::Controller::WindowCoveringClusterTest cluster;
+ cluster.Associate(mDevice, endpoint);
+
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::EndProductType::TypeInfo>(
+ this, OnSuccessCallback_11, OnFailureCallback_11);
+ }
+
+ void OnFailureResponse_11(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_11(uint8_t endProductType)
+ {
+ VerifyOrReturn(CheckConstraintType("endProductType", "", "enum8"));
+ VerifyOrReturn(CheckConstraintNotValue<uint8_t>("endProductType", endProductType, 250));
NextTest();
}
- CHIP_ERROR TestWriteAValueIntoTheRwMandatoryAttributeMode_9()
+ CHIP_ERROR Test2ReadTheRwMandatoryAttributeDefaultMode_12()
+ {
+ const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
+ chip::Controller::WindowCoveringClusterTest cluster;
+ cluster.Associate(mDevice, endpoint);
+
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::Mode::TypeInfo>(this, OnSuccessCallback_12,
+ OnFailureCallback_12);
+ }
+
+ void OnFailureResponse_12(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_12(uint8_t mode)
+ {
+ VerifyOrReturn(CheckConstraintType("mode", "", "map8"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint8_t>("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 = 7;
+ modeArgument = 8;
return cluster.WriteAttribute<chip::app::Clusters::WindowCovering::Attributes::Mode::TypeInfo>(
- modeArgument, this, OnSuccessCallback_9, OnFailureCallback_9);
+ modeArgument, this, OnSuccessCallback_13, OnFailureCallback_13);
}
- void OnFailureResponse_9(uint8_t status) { ThrowFailureResponse(); }
+ void OnFailureResponse_13(uint8_t status) { ThrowFailureResponse(); }
- void OnSuccessResponse_9() { NextTest(); }
+ void OnSuccessResponse_13() { NextTest(); }
- CHIP_ERROR TestReadsBackTheRwMandatoryAttributeMode_10()
+ CHIP_ERROR Test3bReadsBackTheRwMandatoryAttributeMode_14()
{
const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
chip::Controller::WindowCoveringClusterTest cluster;
cluster.Associate(mDevice, endpoint);
- return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::Mode::TypeInfo>(this, OnSuccessCallback_10,
- OnFailureCallback_10);
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::Mode::TypeInfo>(this, OnSuccessCallback_14,
+ OnFailureCallback_14);
}
- void OnFailureResponse_10(uint8_t status) { ThrowFailureResponse(); }
+ void OnFailureResponse_14(uint8_t status) { ThrowFailureResponse(); }
- void OnSuccessResponse_10(uint8_t mode)
+ void OnSuccessResponse_14(uint8_t mode)
{
- VerifyOrReturn(CheckValue<uint8_t>("mode", mode, 7));
+ VerifyOrReturn(CheckValue<uint8_t>("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<chip::app::Clusters::WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_15, OnFailureCallback_15);
+ }
+
+ void OnFailureResponse_15(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_15(uint16_t targetPositionLiftPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("targetPositionLiftPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_17, OnFailureCallback_17);
+ }
+
+ void OnFailureResponse_17(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_17(uint16_t targetPositionLiftPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("targetPositionLiftPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintNotValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_18, OnFailureCallback_18);
+ }
+
+ void OnFailureResponse_18(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_18(uint16_t targetPositionTiltPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("targetPositionTiltPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_20, OnFailureCallback_20);
+ }
+
+ void OnFailureResponse_20(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_20(uint16_t targetPositionTiltPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("targetPositionTiltPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintNotValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_21, OnFailureCallback_21);
+ }
+
+ void OnFailureResponse_21(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_21(uint16_t currentPositionLiftPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionLiftPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_23, OnFailureCallback_23);
+ }
+
+ void OnFailureResponse_23(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_23(uint16_t currentPositionLiftPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionLiftPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintNotValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_24, OnFailureCallback_24);
+ }
+
+ void OnFailureResponse_24(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_24(uint16_t currentPositionTiltPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionTiltPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo>(
+ this, OnSuccessCallback_26, OnFailureCallback_26);
+ }
+
+ void OnFailureResponse_26(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_26(uint16_t currentPositionTiltPercent100ths)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionTiltPercent100ths", "", "uint16"));
+ VerifyOrReturn(
+ CheckConstraintNotValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo>(
+ this, OnSuccessCallback_27, OnFailureCallback_27);
+ }
+
+ void OnFailureResponse_27(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_27(uint16_t installedOpenLimitLift)
+ {
+ VerifyOrReturn(CheckConstraintType("installedOpenLimitLift", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo>(
+ this, OnSuccessCallback_29, OnFailureCallback_29);
+ }
+
+ void OnFailureResponse_29(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_29(uint16_t installedOpenLimitLift)
+ {
+ VerifyOrReturn(CheckConstraintType("installedOpenLimitLift", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo>(
+ this, OnSuccessCallback_30, OnFailureCallback_30);
+ }
+
+ void OnFailureResponse_30(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_30(uint16_t installedClosedLimitLift)
+ {
+ VerifyOrReturn(CheckConstraintType("installedClosedLimitLift", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo>(
+ this, OnSuccessCallback_32, OnFailureCallback_32);
+ }
+
+ void OnFailureResponse_32(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_32(uint16_t installedClosedLimitLift)
+ {
+ VerifyOrReturn(CheckConstraintType("installedClosedLimitLift", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("installedClosedLimitLift", installedClosedLimitLift, 65535));
+ NextTest();
+ }
+
+ CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultInstalledOpenLimitTilt_33()
+ {
+ const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
+ chip::Controller::WindowCoveringClusterTest cluster;
+ cluster.Associate(mDevice, endpoint);
+
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo>(
+ this, OnSuccessCallback_33, OnFailureCallback_33);
+ }
+
+ void OnFailureResponse_33(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_33(uint16_t installedOpenLimitTilt)
+ {
+ VerifyOrReturn(CheckConstraintType("installedOpenLimitTilt", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("installedOpenLimitTilt", installedOpenLimitTilt, 65535));
+ NextTest();
+ }
+
+ CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeInstalledOpenLimitTilt_34()
+ {
+ const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
+ chip::Controller::WindowCoveringClusterTest cluster;
+ cluster.Associate(mDevice, endpoint);
+
+ uint16_t installedOpenLimitTiltArgument;
+ installedOpenLimitTiltArgument = 255U;
+
+ return cluster.WriteAttribute<chip::app::Clusters::WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo>(
+ installedOpenLimitTiltArgument, this, OnSuccessCallback_34, OnFailureCallback_34);
+ }
+
+ 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<chip::app::Clusters::WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo>(
+ this, OnSuccessCallback_35, OnFailureCallback_35);
+ }
+
+ void OnFailureResponse_35(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_35(uint16_t installedOpenLimitTilt)
+ {
+ VerifyOrReturn(CheckConstraintType("installedOpenLimitTilt", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("installedOpenLimitTilt", installedOpenLimitTilt, 65535));
+ NextTest();
+ }
+
+ CHIP_ERROR Test2ReadTheRoOptionalAttributeDefaultInstalledClosedLimitTilt_36()
+ {
+ const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
+ chip::Controller::WindowCoveringClusterTest cluster;
+ cluster.Associate(mDevice, endpoint);
+
+ return cluster.ReadAttribute<chip::app::Clusters::WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo>(
+ this, OnSuccessCallback_36, OnFailureCallback_36);
+ }
+
+ void OnFailureResponse_36(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_36(uint16_t installedClosedLimitTilt)
+ {
+ VerifyOrReturn(CheckConstraintType("installedClosedLimitTilt", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("installedClosedLimitTilt", installedClosedLimitTilt, 65535));
+ NextTest();
+ }
+
+ CHIP_ERROR Test3aWriteAValueIntoTheRoOptionalAttributeInstalledClosedLimitTilt_37()
+ {
+ const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1;
+ chip::Controller::WindowCoveringClusterTest cluster;
+ cluster.Associate(mDevice, endpoint);
+
+ uint16_t installedClosedLimitTiltArgument;
+ installedClosedLimitTiltArgument = 255U;
+
+ return cluster.WriteAttribute<chip::app::Clusters::WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo>(
+ installedClosedLimitTiltArgument, this, OnSuccessCallback_37, OnFailureCallback_37);
+ }
+
+ 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<chip::app::Clusters::WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo>(
+ this, OnSuccessCallback_38, OnFailureCallback_38);
+ }
+
+ void OnFailureResponse_38(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_38(uint16_t installedClosedLimitTilt)
+ {
+ VerifyOrReturn(CheckConstraintType("installedClosedLimitTilt", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::SafetyStatus::TypeInfo>(
+ this, OnSuccessCallback_39, OnFailureCallback_39);
+ }
+
+ void OnFailureResponse_39(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_39(uint16_t safetyStatus)
+ {
+ VerifyOrReturn(CheckConstraintType("safetyStatus", "", "map16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::SafetyStatus::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::SafetyStatus::TypeInfo>(
+ this, OnSuccessCallback_41, OnFailureCallback_41);
+ }
+
+ void OnFailureResponse_41(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_41(uint16_t safetyStatus)
+ {
+ VerifyOrReturn(CheckConstraintType("safetyStatus", "", "map16"));
+ VerifyOrReturn(CheckConstraintNotValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLift::TypeInfo>(
+ this, OnSuccessCallback_42, OnFailureCallback_42);
+ }
+
+ void OnFailureResponse_42(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_42(uint16_t currentPositionLift)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionLift", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLift::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLift::TypeInfo>(
+ this, OnSuccessCallback_44, OnFailureCallback_44);
+ }
+
+ void OnFailureResponse_44(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_44(uint16_t currentPositionLift)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionLift", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTilt::TypeInfo>(
+ this, OnSuccessCallback_45, OnFailureCallback_45);
+ }
+
+ void OnFailureResponse_45(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_45(uint16_t currentPositionTilt)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionTilt", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTilt::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTilt::TypeInfo>(
+ this, OnSuccessCallback_47, OnFailureCallback_47);
+ }
+
+ void OnFailureResponse_47(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_47(uint16_t currentPositionTilt)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionTilt", "", "uint16"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint16_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo>(
+ this, OnSuccessCallback_48, OnFailureCallback_48);
+ }
+
+ void OnFailureResponse_48(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_48(uint8_t currentPositionLiftPercentage)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionLiftPercentage", "", "uint8"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint8_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo>(
+ this, OnSuccessCallback_50, OnFailureCallback_50);
+ }
+
+ void OnFailureResponse_50(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_50(uint8_t currentPositionLiftPercentage)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionLiftPercentage", "", "uint8"));
+ VerifyOrReturn(CheckConstraintNotValue<uint8_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo>(
+ this, OnSuccessCallback_51, OnFailureCallback_51);
+ }
+
+ void OnFailureResponse_51(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_51(uint8_t currentPositionTiltPercentage)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionTiltPercentage", "", "uint8"));
+ VerifyOrReturn(CheckConstraintMaxValue<uint8_t>("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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo>(
+ 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<chip::app::Clusters::WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo>(
+ this, OnSuccessCallback_53, OnFailureCallback_53);
+ }
+
+ void OnFailureResponse_53(uint8_t status) { ThrowFailureResponse(); }
+
+ void OnSuccessResponse_53(uint8_t currentPositionTiltPercentage)
+ {
+ VerifyOrReturn(CheckConstraintType("currentPositionTiltPercentage", "", "uint8"));
+ VerifyOrReturn(CheckConstraintNotValue<uint8_t>("currentPositionTiltPercentage", currentPositionTiltPercentage, 200));
NextTest();
}
};
