From 2537321cbe3e0001807621108815e1a3b0db5924 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Tue, 14 Jun 2022 16:26:23 -0400 Subject: [PATCH] Fix handling of deadband in themostat constraint enforcement. (#19564) The deadband support was incorrectly conditioned on the OCC bit (feature bit 2), and we were never setting OccupancySupported to true. Our test apps don't set the OCC bit, so this last was not getting caught. Fixes https://github.com/project-chip/connectedhomeip/issues/19551 --- .../thermostat-server/thermostat-server.cpp | 13 +- .../certification/Test_TC_TSTAT_2_2.yaml | 24 +- .../chip-tool/zap-generated/test/Commands.h | 354 ++++------- .../zap-generated/test/Commands.h | 565 ++++++------------ 4 files changed, 329 insertions(+), 627 deletions(-) diff --git a/src/app/clusters/thermostat-server/thermostat-server.cpp b/src/app/clusters/thermostat-server/thermostat-server.cpp index d98ec597a6c352..c133e1514ca7de 100644 --- a/src/app/clusters/thermostat-server/thermostat-server.cpp +++ b/src/app/clusters/thermostat-server/thermostat-server.cpp @@ -127,15 +127,16 @@ MatterThermostatClusterServerPreAttributeChangedCallback(const app::ConcreteAttr CoolSupported = true; if (OurFeatureMap & 1 << 2) + OccupancySupported = true; - if (AutoSupported) + if (AutoSupported) + { + if (MinSetpointDeadBand::Get(endpoint, &DeadBand) != EMBER_ZCL_STATUS_SUCCESS) { - if (MinSetpointDeadBand::Get(endpoint, &DeadBand) != EMBER_ZCL_STATUS_SUCCESS) - { - DeadBand = kDefaultDeadBand; - } - DeadBandTemp = static_cast(DeadBand * 10); + DeadBand = kDefaultDeadBand; } + DeadBandTemp = static_cast(DeadBand * 10); + } if (AbsMinCoolSetpointLimit::Get(endpoint, &AbsMinCoolSetpointLimit) != EMBER_ZCL_STATUS_SUCCESS) AbsMinCoolSetpointLimit = kDefaultAbsMinCoolSetpointLimit; diff --git a/src/app/tests/suites/certification/Test_TC_TSTAT_2_2.yaml b/src/app/tests/suites/certification/Test_TC_TSTAT_2_2.yaml index 29ac6104014ee4..752468f829e576 100644 --- a/src/app/tests/suites/certification/Test_TC_TSTAT_2_2.yaml +++ b/src/app/tests/suites/certification/Test_TC_TSTAT_2_2.yaml @@ -50,7 +50,7 @@ tests: attribute: "OccupiedCoolingSetpoint" PICS: A_OCCUPIEDCOOLINGSETPOINT arguments: - value: 2000 + value: 2250 - label: "Reads it back again to confirm the successful write of @@ -60,7 +60,7 @@ tests: attribute: "OccupiedCoolingSetpoint" PICS: A_OCCUPIEDCOOLINGSETPOINT response: - value: 2000 + value: 2250 - label: "Writes OccupiedCoolingSetpoint to value below the @@ -508,9 +508,13 @@ tests: arguments: value: 700 + # Disabled: This test makes no sense: It's setting MaxHeatSetpointLimit to + # a value too close to MaxCoolSetpointLimit, ignoring deadband. + # See https://github.com/CHIP-Specifications/chip-test-plans/issues/1379 - label: "Writes the limit of AbsMaxHeatSetpointLimit to MaxHeatSetpointLimit attribute" + disabled: true optional: true command: "writeAttribute" attribute: "MaxHeatSetpointLimit" @@ -691,7 +695,11 @@ tests: arguments: value: 700 + # Disabled: This test makes no sense: It's setting MaxHeatSetpointLimit to + # a value too close to MaxCoolSetpointLimit, ignoring deadband. + # See https://github.com/CHIP-Specifications/chip-test-plans/issues/1379 - label: "Writes (sets back)default value of MaxHeatSetpointLimit" + disabled: true optional: true command: "writeAttribute" attribute: "MaxHeatSetpointLimit" @@ -814,8 +822,11 @@ tests: response: value: 2 + # Disabled: This test can't work because our setpoint limits are all messed up. + # See https://github.com/CHIP-Specifications/chip-test-plans/issues/1379 - label: "Sets OccupiedHeatingSetpoint to default value" optional: true + disabled: true command: "writeAttribute" attribute: "OccupiedHeatingSetpoint" PICS: A_OCCUPIEDHEATINGSETPOINT @@ -843,8 +854,11 @@ tests: response: value: -30 + # Disabled: This test can't work because our setpoint limits are all messed up. + # See https://github.com/CHIP-Specifications/chip-test-plans/issues/1379 - label: "Sets OccupiedHeatingSetpoint to default value" optional: true + disabled: true command: "writeAttribute" attribute: "OccupiedHeatingSetpoint" PICS: A_OCCUPIEDHEATINGSETPOINT @@ -938,7 +952,10 @@ tests: arguments: value: 2600 + # Disabled: This test can't work because our setpoint limits are all messed up. + # See https://github.com/CHIP-Specifications/chip-test-plans/issues/1379 - label: "Sets OccupiedHeatingSetpoint to default value" + disabled: true optional: true command: "writeAttribute" attribute: "OccupiedHeatingSetpoint" @@ -985,8 +1002,11 @@ tests: arguments: value: 2600 + # Disabled: This test can't work because our setpoint limits are all messed up. + # See https://github.com/CHIP-Specifications/chip-test-plans/issues/1379 - label: "Sets OccupiedHeatingSetpoint to default value" optional: true + disabled: true command: "writeAttribute" attribute: "OccupiedHeatingSetpoint" PICS: A_OCCUPIEDHEATINGSETPOINT diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 3a63f8d86d752e..d641bfcb2ed17c 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -31358,7 +31358,7 @@ class Test_TC_TSTAT_2_1Suite : public TestCommand class Test_TC_TSTAT_2_2Suite : public TestCommand { public: - Test_TC_TSTAT_2_2Suite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("Test_TC_TSTAT_2_2", 84, credsIssuerConfig) + Test_TC_TSTAT_2_2Suite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("Test_TC_TSTAT_2_2", 78, credsIssuerConfig) { AddArgument("nodeId", 0, UINT64_MAX, &mNodeId); AddArgument("cluster", &mCluster); @@ -31426,7 +31426,7 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand { int16_t value; VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); - VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", value, 2000)); + VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", value, 2250)); } break; case 4: @@ -31658,13 +31658,6 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 36: - if (IsUnsupported(status.mStatus)) - { - return; - } - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 37: if (IsUnsupported(status.mStatus)) { return; @@ -31679,14 +31672,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 3200)); } break; - case 38: + case 37: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 39: + case 38: if (IsUnsupported(status.mStatus)) { return; @@ -31698,27 +31691,27 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("minCoolSetpointLimit", value, 2000)); } break; - case 40: + case 39: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 41: + case 40: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 42: + case 41: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 43: + case 42: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 44: + case 43: if (IsUnsupported(status.mStatus)) { return; @@ -31733,48 +31726,41 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 3200)); } break; - case 45: + case 44: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 46: + case 45: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 47: - if (IsUnsupported(status.mStatus)) - { - return; - } - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 48: + case 46: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 49: + case 47: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 50: + case 48: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 51: + case 49: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 52: + case 50: if (IsUnsupported(status.mStatus)) { return; @@ -31789,14 +31775,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 25)); } break; - case 53: + case 51: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 54: + case 52: if (IsUnsupported(status.mStatus)) { return; @@ -31808,27 +31794,27 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("minSetpointDeadBand", value, 5)); } break; - case 55: + case 53: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 56: + case 54: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 57: + case 55: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 58: + case 56: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 59: + case 57: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::Thermostat::ThermostatControlSequence value; @@ -31839,10 +31825,10 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 5)); } break; - case 60: + case 58: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 61: + case 59: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::Thermostat::ThermostatControlSequence value; @@ -31850,17 +31836,10 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("controlSequenceOfOperation", value, 2)); } break; - case 62: - if (IsUnsupported(status.mStatus)) - { - return; - } - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 63: + case 60: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 64: + case 61: if (IsUnsupported(status.mStatus)) { return; @@ -31872,17 +31851,10 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", value, -30)); } break; - case 65: - if (IsUnsupported(status.mStatus)) - { - return; - } - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 66: + case 62: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 67: + case 63: if (IsUnsupported(status.mStatus)) { return; @@ -31894,17 +31866,17 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", value, 30)); } break; - case 68: + case 64: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 69: + case 65: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 70: + case 66: if (IsUnsupported(status.mStatus)) { return; @@ -31916,17 +31888,17 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", value, -30)); } break; - case 71: + case 67: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 72: + case 68: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 73: + case 69: if (IsUnsupported(status.mStatus)) { return; @@ -31938,24 +31910,17 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", value, 30)); } break; - case 74: - if (IsUnsupported(status.mStatus)) - { - return; - } - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 75: + case 70: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 76: + case 71: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 77: + case 72: if (IsUnsupported(status.mStatus)) { return; @@ -31967,7 +31932,7 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", value, -30)); } break; - case 78: + case 73: if (IsUnsupported(status.mStatus)) { return; @@ -31979,24 +31944,17 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", value, -30)); } break; - case 79: - if (IsUnsupported(status.mStatus)) - { - return; - } - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 80: + case 74: if (IsUnsupported(status.mStatus)) { return; } VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 81: + case 75: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 82: + case 76: if (IsUnsupported(status.mStatus)) { return; @@ -32008,7 +31966,7 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", value, 30)); } break; - case 83: + case 77: if (IsUnsupported(status.mStatus)) { return; @@ -32053,7 +32011,7 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand VerifyOrDo(!ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; - value = 2000; + value = 2250; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedCoolingSetpoint::Id, value, chip::NullOptional, chip::NullOptional); @@ -32346,22 +32304,13 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand value, chip::NullOptional, chip::NullOptional); } case 36: { - LogStep(36, "Writes the limit of AbsMaxHeatSetpointLimit to MaxHeatSetpointLimit attribute"); - VerifyOrDo(!ShouldSkip("A_MAXHEATSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); - ListFreer listFreer; - int16_t value; - value = 3000; - return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MaxHeatSetpointLimit::Id, - value, chip::NullOptional, chip::NullOptional); - } - case 37: { - LogStep(37, "Reads MinCoolSetpointLimit attribute from Server DUT and verifies that the value is within range"); + LogStep(36, "Reads MinCoolSetpointLimit attribute from Server DUT and verifies that the value is within range"); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, true, chip::NullOptional); } - case 38: { - LogStep(38, "Writes a value back that is different but valid for MinCoolSetpointLimit attribute"); + case 37: { + LogStep(37, "Writes a value back that is different but valid for MinCoolSetpointLimit attribute"); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32369,14 +32318,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 39: { - LogStep(39, "Reads it back again to confirm the successful write of MinCoolSetpointLimit attribute"); + case 38: { + LogStep(38, "Reads it back again to confirm the successful write of MinCoolSetpointLimit attribute"); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, true, chip::NullOptional); } - case 40: { - LogStep(40, "Writes MinCoolSetpointLimit to value below the AbsMinCoolSetpointLimit "); + case 39: { + LogStep(39, "Writes MinCoolSetpointLimit to value below the AbsMinCoolSetpointLimit "); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32384,8 +32333,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 41: { - LogStep(41, "Writes MinCoolSetpointLimit to value above the MaxCoolSetpointLimit "); + case 40: { + LogStep(40, "Writes MinCoolSetpointLimit to value above the MaxCoolSetpointLimit "); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32393,8 +32342,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 42: { - LogStep(42, "Writes the limit of AbsMinCoolSetpointLimit to MinCoolSetpointLimit attribute"); + case 41: { + LogStep(41, "Writes the limit of AbsMinCoolSetpointLimit to MinCoolSetpointLimit attribute"); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32402,8 +32351,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 43: { - LogStep(43, "Writes the limit of MaxCoolSetpointLimit to MinCoolSetpointLimit attribute"); + case 42: { + LogStep(42, "Writes the limit of MaxCoolSetpointLimit to MinCoolSetpointLimit attribute"); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32411,14 +32360,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 44: { - LogStep(44, "Reads MaxCoolSetpointLimit attribute from Server DUT and verifies that the value is within range"); + case 43: { + LogStep(43, "Reads MaxCoolSetpointLimit attribute from Server DUT and verifies that the value is within range"); VerifyOrDo(!ShouldSkip("A_MAXCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MaxCoolSetpointLimit::Id, true, chip::NullOptional); } - case 45: { - LogStep(45, "Writes MaxCoolSetpointLimit to value below the AbsMinCoolSetpointLimit "); + case 44: { + LogStep(44, "Writes MaxCoolSetpointLimit to value below the AbsMinCoolSetpointLimit "); VerifyOrDo(!ShouldSkip("A_MAXCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32426,8 +32375,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MaxCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 46: { - LogStep(46, "Writes MaxCoolSetpointLimit to value above the MaxCoolSetpointLimit "); + case 45: { + LogStep(45, "Writes MaxCoolSetpointLimit to value above the MaxCoolSetpointLimit "); VerifyOrDo(!ShouldSkip("A_MAXCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32435,8 +32384,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MaxCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 47: { - LogStep(47, "Writes the limit of MaxCoolSetpointLimit to MaxCoolSetpointLimit attribute"); + case 46: { + LogStep(46, "Writes the limit of MaxCoolSetpointLimit to MaxCoolSetpointLimit attribute"); VerifyOrDo(!ShouldSkip("A_MAXCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32444,8 +32393,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MaxCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 48: { - LogStep(48, "Writes (sets back) default value of MinHeatSetpointLimit"); + case 47: { + LogStep(47, "Writes (sets back) default value of MinHeatSetpointLimit"); VerifyOrDo(!ShouldSkip("A_MINHEATSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32453,17 +32402,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinHeatSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 49: { - LogStep(49, "Writes (sets back)default value of MaxHeatSetpointLimit"); - VerifyOrDo(!ShouldSkip("A_MINHEATSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); - ListFreer listFreer; - int16_t value; - value = 3000; - return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MaxHeatSetpointLimit::Id, - value, chip::NullOptional, chip::NullOptional); - } - case 50: { - LogStep(50, "Writes (sets back) default value of MinCoolSetpointLimit"); + case 48: { + LogStep(48, "Writes (sets back) default value of MinCoolSetpointLimit"); VerifyOrDo(!ShouldSkip("A_MINCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32471,8 +32411,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 51: { - LogStep(51, "Writes (sets back) default value of MaxCoolSetpointLimit"); + case 49: { + LogStep(49, "Writes (sets back) default value of MaxCoolSetpointLimit"); VerifyOrDo(!ShouldSkip("A_MAXCOOLSETPOINTLIMIT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32480,14 +32420,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MaxCoolSetpointLimit::Id, value, chip::NullOptional, chip::NullOptional); } - case 52: { - LogStep(52, "Reads MinSetpointDeadBand attribute from Server DUT and verifies that the value is within range"); + case 50: { + LogStep(50, "Reads MinSetpointDeadBand attribute from Server DUT and verifies that the value is within range"); VerifyOrDo(!ShouldSkip("A_MINSETPOINTDEADBAND"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinSetpointDeadBand::Id, true, chip::NullOptional); } - case 53: { - LogStep(53, "Writes a value back that is different but valid for MinSetpointDeadBand attribute"); + case 51: { + LogStep(51, "Writes a value back that is different but valid for MinSetpointDeadBand attribute"); VerifyOrDo(!ShouldSkip("A_MINSETPOINTDEADBAND"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int8_t value; @@ -32495,14 +32435,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinSetpointDeadBand::Id, value, chip::NullOptional, chip::NullOptional); } - case 54: { - LogStep(54, "Reads it back again to confirm the successful write of MinSetpointDeadBand attribute"); + case 52: { + LogStep(52, "Reads it back again to confirm the successful write of MinSetpointDeadBand attribute"); VerifyOrDo(!ShouldSkip("A_MINSETPOINTDEADBAND"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinSetpointDeadBand::Id, true, chip::NullOptional); } - case 55: { - LogStep(55, "Writes the value below MinSetpointDeadBand"); + case 53: { + LogStep(53, "Writes the value below MinSetpointDeadBand"); VerifyOrDo(!ShouldSkip("A_MINSETPOINTDEADBAND"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int8_t value; @@ -32510,8 +32450,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinSetpointDeadBand::Id, value, chip::NullOptional, chip::NullOptional); } - case 56: { - LogStep(56, "Writes the value above MinSetpointDeadBand "); + case 54: { + LogStep(54, "Writes the value above MinSetpointDeadBand "); VerifyOrDo(!ShouldSkip("A_MINSETPOINTDEADBAND"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int8_t value; @@ -32519,8 +32459,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinSetpointDeadBand::Id, value, chip::NullOptional, chip::NullOptional); } - case 57: { - LogStep(57, "Writes the min limit of MinSetpointDeadBand"); + case 55: { + LogStep(55, "Writes the min limit of MinSetpointDeadBand"); VerifyOrDo(!ShouldSkip("A_MINSETPOINTDEADBAND"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int8_t value; @@ -32528,8 +32468,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinSetpointDeadBand::Id, value, chip::NullOptional, chip::NullOptional); } - case 58: { - LogStep(58, "Writes the max limit of MinSetpointDeadBand"); + case 56: { + LogStep(56, "Writes the max limit of MinSetpointDeadBand"); VerifyOrDo(!ShouldSkip("A_MINSETPOINTDEADBAND"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int8_t value; @@ -32537,14 +32477,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::MinSetpointDeadBand::Id, value, chip::NullOptional, chip::NullOptional); } - case 59: { - LogStep(59, "Reads ControlSequenceOfOperation from Server DUT and verifies that the value is valid"); + case 57: { + LogStep(57, "Reads ControlSequenceOfOperation from Server DUT and verifies that the value is valid"); VerifyOrDo(!ShouldSkip("A_CONTROLSEQUENCEOFOPERATION"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::ControlSequenceOfOperation::Id, true, chip::NullOptional); } - case 60: { - LogStep(60, "Write Attribute command for ControlSequenceOfOperation with a new valid value"); + case 58: { + LogStep(58, "Write Attribute command for ControlSequenceOfOperation with a new valid value"); VerifyOrDo(!ShouldSkip("A_CONTROLSEQUENCEOFOPERATION"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; chip::app::Clusters::Thermostat::ThermostatControlSequence value; @@ -32553,24 +32493,14 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand Thermostat::Attributes::ControlSequenceOfOperation::Id, value, chip::NullOptional, chip::NullOptional); } - case 61: { - LogStep(61, "Read it back again to confirm the successful write"); + case 59: { + LogStep(59, "Read it back again to confirm the successful write"); VerifyOrDo(!ShouldSkip("A_CONTROLSEQUENCEOFOPERATION"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::ControlSequenceOfOperation::Id, true, chip::NullOptional); } - case 62: { - LogStep(62, "Sets OccupiedHeatingSetpoint to default value"); - VerifyOrDo(!ShouldSkip("A_OCCUPIEDHEATINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); - ListFreer listFreer; - int16_t value; - value = 2000; - return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, - Thermostat::Attributes::OccupiedHeatingSetpoint::Id, value, chip::NullOptional, - chip::NullOptional); - } - case 63: { - LogStep(63, "Sends SetpointRaise Command"); + case 60: { + LogStep(60, "Sends SetpointRaise Command"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; @@ -32582,25 +32512,15 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand ); } - case 64: { - LogStep(64, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); + case 61: { + LogStep(61, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDHEATINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedHeatingSetpoint::Id, true, chip::NullOptional); } - case 65: { - LogStep(65, "Sets OccupiedHeatingSetpoint to default value"); - VerifyOrDo(!ShouldSkip("A_OCCUPIEDHEATINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); - ListFreer listFreer; - int16_t value; - value = 2000; - return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, - Thermostat::Attributes::OccupiedHeatingSetpoint::Id, value, chip::NullOptional, - chip::NullOptional); - } - case 66: { - LogStep(66, "Sends SetpointRaise Command"); + case 62: { + LogStep(62, "Sends SetpointRaise Command"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; @@ -32612,15 +32532,15 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand ); } - case 67: { - LogStep(67, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); + case 63: { + LogStep(63, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedHeatingSetpoint::Id, true, chip::NullOptional); } - case 68: { - LogStep(68, "Sets OccupiedCoolingSetpoint to default value"); + case 64: { + LogStep(64, "Sets OccupiedCoolingSetpoint to default value"); VerifyOrDo(!ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32629,8 +32549,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand Thermostat::Attributes::OccupiedCoolingSetpoint::Id, value, chip::NullOptional, chip::NullOptional); } - case 69: { - LogStep(69, "Sends SetpointRaise Command"); + case 65: { + LogStep(65, "Sends SetpointRaise Command"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; @@ -32642,15 +32562,15 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand ); } - case 70: { - LogStep(70, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); + case 66: { + LogStep(66, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedCoolingSetpoint::Id, true, chip::NullOptional); } - case 71: { - LogStep(71, "Sets OccupiedCoolingSetpoint to default value"); + case 67: { + LogStep(67, "Sets OccupiedCoolingSetpoint to default value"); VerifyOrDo(!ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32659,8 +32579,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand Thermostat::Attributes::OccupiedCoolingSetpoint::Id, value, chip::NullOptional, chip::NullOptional); } - case 72: { - LogStep(72, "Sends SetpointRaise Command"); + case 68: { + LogStep(68, "Sends SetpointRaise Command"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; @@ -32672,15 +32592,15 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand ); } - case 73: { - LogStep(73, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); + case 69: { + LogStep(69, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedCoolingSetpoint::Id, true, chip::NullOptional); } - case 74: { - LogStep(74, "Sets OccupiedCoolingSetpoint to default value"); + case 70: { + LogStep(70, "Sets OccupiedCoolingSetpoint to default value"); VerifyOrDo(!ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32689,18 +32609,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand Thermostat::Attributes::OccupiedCoolingSetpoint::Id, value, chip::NullOptional, chip::NullOptional); } - case 75: { - LogStep(75, "Sets OccupiedHeatingSetpoint to default value"); - VerifyOrDo(!ShouldSkip("A_OCCUPIEDHEATINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); - ListFreer listFreer; - int16_t value; - value = 2000; - return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, - Thermostat::Attributes::OccupiedHeatingSetpoint::Id, value, chip::NullOptional, - chip::NullOptional); - } - case 76: { - LogStep(76, "Sends SetpointRaise Command"); + case 71: { + LogStep(71, "Sends SetpointRaise Command"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; @@ -32712,21 +32622,21 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand ); } - case 77: { - LogStep(77, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); + case 72: { + LogStep(72, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedCoolingSetpoint::Id, true, chip::NullOptional); } - case 78: { - LogStep(78, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); + case 73: { + LogStep(73, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDHEATINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedHeatingSetpoint::Id, true, chip::NullOptional); } - case 79: { - LogStep(79, "Sets OccupiedCoolingSetpoint to default value"); + case 74: { + LogStep(74, "Sets OccupiedCoolingSetpoint to default value"); VerifyOrDo(!ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; int16_t value; @@ -32735,18 +32645,8 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand Thermostat::Attributes::OccupiedCoolingSetpoint::Id, value, chip::NullOptional, chip::NullOptional); } - case 80: { - LogStep(80, "Sets OccupiedHeatingSetpoint to default value"); - VerifyOrDo(!ShouldSkip("A_OCCUPIEDHEATINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); - ListFreer listFreer; - int16_t value; - value = 2000; - return WriteAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, - Thermostat::Attributes::OccupiedHeatingSetpoint::Id, value, chip::NullOptional, - chip::NullOptional); - } - case 81: { - LogStep(81, "Sends SetpointRaise Command"); + case 75: { + LogStep(75, "Sends SetpointRaise Command"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); ListFreer listFreer; @@ -32758,15 +32658,15 @@ class Test_TC_TSTAT_2_2Suite : public TestCommand ); } - case 82: { - LogStep(82, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); + case 76: { + LogStep(76, "Reads back OccupiedCoolingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, Thermostat::Attributes::OccupiedCoolingSetpoint::Id, true, chip::NullOptional); } - case 83: { - LogStep(83, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); + case 77: { + LogStep(77, "Reads back OccupiedHeatingSetpoint to confirm the success of the write"); VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDHEATINGSETPOINT"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), Thermostat::Id, diff --git a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h index c2dc5476781413..40014b616daf36 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h @@ -51272,416 +51272,367 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { err = TestWritesTheLimitOfAbsMinHeatSetpointLimitToMaxHeatSetpointLimitAttribute_35(); break; case 36: - ChipLogProgress( - chipTool, " ***** Test Step 36 : Writes the limit of AbsMaxHeatSetpointLimit to MaxHeatSetpointLimit attribute\n"); - if (ShouldSkip("A_MAXHEATSETPOINTLIMIT")) { + ChipLogProgress(chipTool, + " ***** Test Step 36 : Reads MinCoolSetpointLimit attribute from Server DUT and verifies that the value is within " + "range\n"); + if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesTheLimitOfAbsMaxHeatSetpointLimitToMaxHeatSetpointLimitAttribute_36(); + err = TestReadsMinCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_36(); break; case 37: ChipLogProgress(chipTool, - " ***** Test Step 37 : Reads MinCoolSetpointLimit attribute from Server DUT and verifies that the value is within " - "range\n"); + " ***** Test Step 37 : Writes a value back that is different but valid for MinCoolSetpointLimit attribute\n"); if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestReadsMinCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_37(); + err = TestWritesAValueBackThatIsDifferentButValidForMinCoolSetpointLimitAttribute_37(); break; case 38: ChipLogProgress(chipTool, - " ***** Test Step 38 : Writes a value back that is different but valid for MinCoolSetpointLimit attribute\n"); + " ***** Test Step 38 : Reads it back again to confirm the successful write of MinCoolSetpointLimit attribute\n"); if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesAValueBackThatIsDifferentButValidForMinCoolSetpointLimitAttribute_38(); + err = TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinCoolSetpointLimitAttribute_38(); break; case 39: - ChipLogProgress(chipTool, - " ***** Test Step 39 : Reads it back again to confirm the successful write of MinCoolSetpointLimit attribute\n"); + ChipLogProgress( + chipTool, " ***** Test Step 39 : Writes MinCoolSetpointLimit to value below the AbsMinCoolSetpointLimit \n"); if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinCoolSetpointLimitAttribute_39(); + err = TestWritesMinCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_39(); break; case 40: ChipLogProgress( - chipTool, " ***** Test Step 40 : Writes MinCoolSetpointLimit to value below the AbsMinCoolSetpointLimit \n"); + chipTool, " ***** Test Step 40 : Writes MinCoolSetpointLimit to value above the MaxCoolSetpointLimit \n"); if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesMinCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_40(); + err = TestWritesMinCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_40(); break; case 41: ChipLogProgress( - chipTool, " ***** Test Step 41 : Writes MinCoolSetpointLimit to value above the MaxCoolSetpointLimit \n"); + chipTool, " ***** Test Step 41 : Writes the limit of AbsMinCoolSetpointLimit to MinCoolSetpointLimit attribute\n"); if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesMinCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_41(); + err = TestWritesTheLimitOfAbsMinCoolSetpointLimitToMinCoolSetpointLimitAttribute_41(); break; case 42: ChipLogProgress( - chipTool, " ***** Test Step 42 : Writes the limit of AbsMinCoolSetpointLimit to MinCoolSetpointLimit attribute\n"); + chipTool, " ***** Test Step 42 : Writes the limit of MaxCoolSetpointLimit to MinCoolSetpointLimit attribute\n"); if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesTheLimitOfAbsMinCoolSetpointLimitToMinCoolSetpointLimitAttribute_42(); + err = TestWritesTheLimitOfMaxCoolSetpointLimitToMinCoolSetpointLimitAttribute_42(); break; case 43: - ChipLogProgress( - chipTool, " ***** Test Step 43 : Writes the limit of MaxCoolSetpointLimit to MinCoolSetpointLimit attribute\n"); - if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { + ChipLogProgress(chipTool, + " ***** Test Step 43 : Reads MaxCoolSetpointLimit attribute from Server DUT and verifies that the value is within " + "range\n"); + if (ShouldSkip("A_MAXCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesTheLimitOfMaxCoolSetpointLimitToMinCoolSetpointLimitAttribute_43(); + err = TestReadsMaxCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_43(); break; case 44: - ChipLogProgress(chipTool, - " ***** Test Step 44 : Reads MaxCoolSetpointLimit attribute from Server DUT and verifies that the value is within " - "range\n"); + ChipLogProgress( + chipTool, " ***** Test Step 44 : Writes MaxCoolSetpointLimit to value below the AbsMinCoolSetpointLimit \n"); if (ShouldSkip("A_MAXCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestReadsMaxCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_44(); + err = TestWritesMaxCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_44(); break; case 45: ChipLogProgress( - chipTool, " ***** Test Step 45 : Writes MaxCoolSetpointLimit to value below the AbsMinCoolSetpointLimit \n"); + chipTool, " ***** Test Step 45 : Writes MaxCoolSetpointLimit to value above the MaxCoolSetpointLimit \n"); if (ShouldSkip("A_MAXCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesMaxCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_45(); + err = TestWritesMaxCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_45(); break; case 46: ChipLogProgress( - chipTool, " ***** Test Step 46 : Writes MaxCoolSetpointLimit to value above the MaxCoolSetpointLimit \n"); + chipTool, " ***** Test Step 46 : Writes the limit of MaxCoolSetpointLimit to MaxCoolSetpointLimit attribute\n"); if (ShouldSkip("A_MAXCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesMaxCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_46(); + err = TestWritesTheLimitOfMaxCoolSetpointLimitToMaxCoolSetpointLimitAttribute_46(); break; case 47: - ChipLogProgress( - chipTool, " ***** Test Step 47 : Writes the limit of MaxCoolSetpointLimit to MaxCoolSetpointLimit attribute\n"); - if (ShouldSkip("A_MAXCOOLSETPOINTLIMIT")) { + ChipLogProgress(chipTool, " ***** Test Step 47 : Writes (sets back) default value of MinHeatSetpointLimit\n"); + if (ShouldSkip("A_MINHEATSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesTheLimitOfMaxCoolSetpointLimitToMaxCoolSetpointLimitAttribute_47(); + err = TestWritesSetsBackDefaultValueOfMinHeatSetpointLimit_47(); break; case 48: - ChipLogProgress(chipTool, " ***** Test Step 48 : Writes (sets back) default value of MinHeatSetpointLimit\n"); - if (ShouldSkip("A_MINHEATSETPOINTLIMIT")) { + ChipLogProgress(chipTool, " ***** Test Step 48 : Writes (sets back) default value of MinCoolSetpointLimit\n"); + if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesSetsBackDefaultValueOfMinHeatSetpointLimit_48(); + err = TestWritesSetsBackDefaultValueOfMinCoolSetpointLimit_48(); break; case 49: - ChipLogProgress(chipTool, " ***** Test Step 49 : Writes (sets back)default value of MaxHeatSetpointLimit\n"); - if (ShouldSkip("A_MINHEATSETPOINTLIMIT")) { + ChipLogProgress(chipTool, " ***** Test Step 49 : Writes (sets back) default value of MaxCoolSetpointLimit\n"); + if (ShouldSkip("A_MAXCOOLSETPOINTLIMIT")) { NextTest(); return; } - err = TestWritesSetsBackdefaultValueOfMaxHeatSetpointLimit_49(); + err = TestWritesSetsBackDefaultValueOfMaxCoolSetpointLimit_49(); break; case 50: - ChipLogProgress(chipTool, " ***** Test Step 50 : Writes (sets back) default value of MinCoolSetpointLimit\n"); - if (ShouldSkip("A_MINCOOLSETPOINTLIMIT")) { + ChipLogProgress(chipTool, + " ***** Test Step 50 : Reads MinSetpointDeadBand attribute from Server DUT and verifies that the value is within " + "range\n"); + if (ShouldSkip("A_MINSETPOINTDEADBAND")) { NextTest(); return; } - err = TestWritesSetsBackDefaultValueOfMinCoolSetpointLimit_50(); + err = TestReadsMinSetpointDeadBandAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_50(); break; case 51: - ChipLogProgress(chipTool, " ***** Test Step 51 : Writes (sets back) default value of MaxCoolSetpointLimit\n"); - if (ShouldSkip("A_MAXCOOLSETPOINTLIMIT")) { + ChipLogProgress(chipTool, + " ***** Test Step 51 : Writes a value back that is different but valid for MinSetpointDeadBand attribute\n"); + if (ShouldSkip("A_MINSETPOINTDEADBAND")) { NextTest(); return; } - err = TestWritesSetsBackDefaultValueOfMaxCoolSetpointLimit_51(); + err = TestWritesAValueBackThatIsDifferentButValidForMinSetpointDeadBandAttribute_51(); break; case 52: ChipLogProgress(chipTool, - " ***** Test Step 52 : Reads MinSetpointDeadBand attribute from Server DUT and verifies that the value is within " - "range\n"); + " ***** Test Step 52 : Reads it back again to confirm the successful write of MinSetpointDeadBand attribute\n"); if (ShouldSkip("A_MINSETPOINTDEADBAND")) { NextTest(); return; } - err = TestReadsMinSetpointDeadBandAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_52(); + err = TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinSetpointDeadBandAttribute_52(); break; case 53: - ChipLogProgress(chipTool, - " ***** Test Step 53 : Writes a value back that is different but valid for MinSetpointDeadBand attribute\n"); + ChipLogProgress(chipTool, " ***** Test Step 53 : Writes the value below MinSetpointDeadBand\n"); if (ShouldSkip("A_MINSETPOINTDEADBAND")) { NextTest(); return; } - err = TestWritesAValueBackThatIsDifferentButValidForMinSetpointDeadBandAttribute_53(); + err = TestWritesTheValueBelowMinSetpointDeadBand_53(); break; case 54: - ChipLogProgress(chipTool, - " ***** Test Step 54 : Reads it back again to confirm the successful write of MinSetpointDeadBand attribute\n"); + ChipLogProgress(chipTool, " ***** Test Step 54 : Writes the value above MinSetpointDeadBand \n"); if (ShouldSkip("A_MINSETPOINTDEADBAND")) { NextTest(); return; } - err = TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinSetpointDeadBandAttribute_54(); + err = TestWritesTheValueAboveMinSetpointDeadBand_54(); break; case 55: - ChipLogProgress(chipTool, " ***** Test Step 55 : Writes the value below MinSetpointDeadBand\n"); + ChipLogProgress(chipTool, " ***** Test Step 55 : Writes the min limit of MinSetpointDeadBand\n"); if (ShouldSkip("A_MINSETPOINTDEADBAND")) { NextTest(); return; } - err = TestWritesTheValueBelowMinSetpointDeadBand_55(); + err = TestWritesTheMinLimitOfMinSetpointDeadBand_55(); break; case 56: - ChipLogProgress(chipTool, " ***** Test Step 56 : Writes the value above MinSetpointDeadBand \n"); + ChipLogProgress(chipTool, " ***** Test Step 56 : Writes the max limit of MinSetpointDeadBand\n"); if (ShouldSkip("A_MINSETPOINTDEADBAND")) { NextTest(); return; } - err = TestWritesTheValueAboveMinSetpointDeadBand_56(); + err = TestWritesTheMaxLimitOfMinSetpointDeadBand_56(); break; case 57: - ChipLogProgress(chipTool, " ***** Test Step 57 : Writes the min limit of MinSetpointDeadBand\n"); - if (ShouldSkip("A_MINSETPOINTDEADBAND")) { - NextTest(); - return; - } - err = TestWritesTheMinLimitOfMinSetpointDeadBand_57(); - break; - case 58: - ChipLogProgress(chipTool, " ***** Test Step 58 : Writes the max limit of MinSetpointDeadBand\n"); - if (ShouldSkip("A_MINSETPOINTDEADBAND")) { - NextTest(); - return; - } - err = TestWritesTheMaxLimitOfMinSetpointDeadBand_58(); - break; - case 59: ChipLogProgress(chipTool, - " ***** Test Step 59 : Reads ControlSequenceOfOperation from Server DUT and verifies that the value is valid\n"); + " ***** Test Step 57 : Reads ControlSequenceOfOperation from Server DUT and verifies that the value is valid\n"); if (ShouldSkip("A_CONTROLSEQUENCEOFOPERATION")) { NextTest(); return; } - err = TestReadsControlSequenceOfOperationFromServerDutAndVerifiesThatTheValueIsValid_59(); + err = TestReadsControlSequenceOfOperationFromServerDutAndVerifiesThatTheValueIsValid_57(); break; - case 60: + case 58: ChipLogProgress( - chipTool, " ***** Test Step 60 : Write Attribute command for ControlSequenceOfOperation with a new valid value\n"); + chipTool, " ***** Test Step 58 : Write Attribute command for ControlSequenceOfOperation with a new valid value\n"); if (ShouldSkip("A_CONTROLSEQUENCEOFOPERATION")) { NextTest(); return; } - err = TestWriteAttributeCommandForControlSequenceOfOperationWithANewValidValue_60(); + err = TestWriteAttributeCommandForControlSequenceOfOperationWithANewValidValue_58(); break; - case 61: - ChipLogProgress(chipTool, " ***** Test Step 61 : Read it back again to confirm the successful write\n"); + case 59: + ChipLogProgress(chipTool, " ***** Test Step 59 : Read it back again to confirm the successful write\n"); if (ShouldSkip("A_CONTROLSEQUENCEOFOPERATION")) { NextTest(); return; } - err = TestReadItBackAgainToConfirmTheSuccessfulWrite_61(); + err = TestReadItBackAgainToConfirmTheSuccessfulWrite_59(); break; - case 62: - ChipLogProgress(chipTool, " ***** Test Step 62 : Sets OccupiedHeatingSetpoint to default value\n"); - if (ShouldSkip("A_OCCUPIEDHEATINGSETPOINT")) { - NextTest(); - return; - } - err = TestSetsOccupiedHeatingSetpointToDefaultValue_62(); - break; - case 63: - ChipLogProgress(chipTool, " ***** Test Step 63 : Sends SetpointRaise Command\n"); + case 60: + ChipLogProgress(chipTool, " ***** Test Step 60 : Sends SetpointRaise Command\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower")) { NextTest(); return; } - err = TestSendsSetpointRaiseCommand_63(); + err = TestSendsSetpointRaiseCommand_60(); break; - case 64: + case 61: ChipLogProgress( - chipTool, " ***** Test Step 64 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 61 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDHEATINGSETPOINT")) { NextTest(); return; } - err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_64(); + err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_61(); break; - case 65: - ChipLogProgress(chipTool, " ***** Test Step 65 : Sets OccupiedHeatingSetpoint to default value\n"); - if (ShouldSkip("A_OCCUPIEDHEATINGSETPOINT")) { - NextTest(); - return; - } - err = TestSetsOccupiedHeatingSetpointToDefaultValue_65(); - break; - case 66: - ChipLogProgress(chipTool, " ***** Test Step 66 : Sends SetpointRaise Command\n"); + case 62: + ChipLogProgress(chipTool, " ***** Test Step 62 : Sends SetpointRaise Command\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower")) { NextTest(); return; } - err = TestSendsSetpointRaiseCommand_66(); + err = TestSendsSetpointRaiseCommand_62(); break; - case 67: + case 63: ChipLogProgress( - chipTool, " ***** Test Step 67 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 63 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_67(); + err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_63(); break; - case 68: - ChipLogProgress(chipTool, " ***** Test Step 68 : Sets OccupiedCoolingSetpoint to default value\n"); + case 64: + ChipLogProgress(chipTool, " ***** Test Step 64 : Sets OccupiedCoolingSetpoint to default value\n"); if (ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestSetsOccupiedCoolingSetpointToDefaultValue_68(); + err = TestSetsOccupiedCoolingSetpointToDefaultValue_64(); break; - case 69: - ChipLogProgress(chipTool, " ***** Test Step 69 : Sends SetpointRaise Command\n"); + case 65: + ChipLogProgress(chipTool, " ***** Test Step 65 : Sends SetpointRaise Command\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower")) { NextTest(); return; } - err = TestSendsSetpointRaiseCommand_69(); + err = TestSendsSetpointRaiseCommand_65(); break; - case 70: + case 66: ChipLogProgress( - chipTool, " ***** Test Step 70 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 66 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_70(); + err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_66(); break; - case 71: - ChipLogProgress(chipTool, " ***** Test Step 71 : Sets OccupiedCoolingSetpoint to default value\n"); + case 67: + ChipLogProgress(chipTool, " ***** Test Step 67 : Sets OccupiedCoolingSetpoint to default value\n"); if (ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestSetsOccupiedCoolingSetpointToDefaultValue_71(); + err = TestSetsOccupiedCoolingSetpointToDefaultValue_67(); break; - case 72: - ChipLogProgress(chipTool, " ***** Test Step 72 : Sends SetpointRaise Command\n"); + case 68: + ChipLogProgress(chipTool, " ***** Test Step 68 : Sends SetpointRaise Command\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower")) { NextTest(); return; } - err = TestSendsSetpointRaiseCommand_72(); + err = TestSendsSetpointRaiseCommand_68(); break; - case 73: + case 69: ChipLogProgress( - chipTool, " ***** Test Step 73 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 69 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_73(); + err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_69(); break; - case 74: - ChipLogProgress(chipTool, " ***** Test Step 74 : Sets OccupiedCoolingSetpoint to default value\n"); + case 70: + ChipLogProgress(chipTool, " ***** Test Step 70 : Sets OccupiedCoolingSetpoint to default value\n"); if (ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestSetsOccupiedCoolingSetpointToDefaultValue_74(); - break; - case 75: - ChipLogProgress(chipTool, " ***** Test Step 75 : Sets OccupiedHeatingSetpoint to default value\n"); - if (ShouldSkip("A_OCCUPIEDHEATINGSETPOINT")) { - NextTest(); - return; - } - err = TestSetsOccupiedHeatingSetpointToDefaultValue_75(); + err = TestSetsOccupiedCoolingSetpointToDefaultValue_70(); break; - case 76: - ChipLogProgress(chipTool, " ***** Test Step 76 : Sends SetpointRaise Command\n"); + case 71: + ChipLogProgress(chipTool, " ***** Test Step 71 : Sends SetpointRaise Command\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower")) { NextTest(); return; } - err = TestSendsSetpointRaiseCommand_76(); + err = TestSendsSetpointRaiseCommand_71(); break; - case 77: + case 72: ChipLogProgress( - chipTool, " ***** Test Step 77 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 72 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP")) { NextTest(); return; } - err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_77(); + err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_72(); break; - case 78: + case 73: ChipLogProgress( - chipTool, " ***** Test Step 78 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 73 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDHEATINGSETPOINT")) { NextTest(); return; } - err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_78(); + err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_73(); break; - case 79: - ChipLogProgress(chipTool, " ***** Test Step 79 : Sets OccupiedCoolingSetpoint to default value\n"); + case 74: + ChipLogProgress(chipTool, " ***** Test Step 74 : Sets OccupiedCoolingSetpoint to default value\n"); if (ShouldSkip("A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestSetsOccupiedCoolingSetpointToDefaultValue_79(); - break; - case 80: - ChipLogProgress(chipTool, " ***** Test Step 80 : Sets OccupiedHeatingSetpoint to default value\n"); - if (ShouldSkip("A_OCCUPIEDHEATINGSETPOINT")) { - NextTest(); - return; - } - err = TestSetsOccupiedHeatingSetpointToDefaultValue_80(); + err = TestSetsOccupiedCoolingSetpointToDefaultValue_74(); break; - case 81: - ChipLogProgress(chipTool, " ***** Test Step 81 : Sends SetpointRaise Command\n"); + case 75: + ChipLogProgress(chipTool, " ***** Test Step 75 : Sends SetpointRaise Command\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && CR_SetpointRaiseLower")) { NextTest(); return; } - err = TestSendsSetpointRaiseCommand_81(); + err = TestSendsSetpointRaiseCommand_75(); break; - case 82: + case 76: ChipLogProgress( - chipTool, " ***** Test Step 82 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 76 : Reads back OccupiedCoolingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDCOOLINGSETPOINT")) { NextTest(); return; } - err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_82(); + err = TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_76(); break; - case 83: + case 77: ChipLogProgress( - chipTool, " ***** Test Step 83 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); + chipTool, " ***** Test Step 77 : Reads back OccupiedHeatingSetpoint to confirm the success of the write\n"); if (ShouldSkip("PICS_SKIP_SAMPLE_APP && A_OCCUPIEDHEATINGSETPOINT")) { NextTest(); return; } - err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_83(); + err = TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_77(); break; } @@ -51812,13 +51763,13 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 39: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 40: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 41: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 42: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -51827,13 +51778,13 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 44: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 45: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 46: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 47: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -51854,16 +51805,16 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 53: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 54: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 55: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 56: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 57: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -51928,24 +51879,6 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { case 77: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 78: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 79: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 80: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 81: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 82: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; - case 83: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); - break; } // Go on to the next test. @@ -51959,7 +51892,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 84; + const uint16_t mTestCount = 78; chip::Optional mNodeId; chip::Optional mCluster; @@ -52012,7 +51945,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); id occupiedCoolingSetpointArgument; - occupiedCoolingSetpointArgument = [NSNumber numberWithShort:2000]; + occupiedCoolingSetpointArgument = [NSNumber numberWithShort:2250]; [cluster writeAttributeOccupiedCoolingSetpointWithValue:occupiedCoolingSetpointArgument completionHandler:^(NSError * _Nullable err) { NSLog(@"Writes a value back that is different but valid for " @@ -52050,7 +51983,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { { id actualValue = value; - VerifyOrReturn(CheckValue("OccupiedCoolingSetpoint", actualValue, 2000)); + VerifyOrReturn(CheckValue("OccupiedCoolingSetpoint", actualValue, 2250)); } NextTest(); @@ -52953,34 +52886,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheLimitOfAbsMaxHeatSetpointLimitToMaxHeatSetpointLimitAttribute_36() - { - CHIPDevice * device = GetDevice("alpha"); - CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; - VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); - - id maxHeatSetpointLimitArgument; - maxHeatSetpointLimitArgument = [NSNumber numberWithShort:3000]; - [cluster writeAttributeMaxHeatSetpointLimitWithValue:maxHeatSetpointLimitArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Writes the limit of AbsMaxHeatSetpointLimit to MaxHeatSetpointLimit " - @"attribute Error: %@", - err); - - if (err.code == MatterInteractionErrorCodeUnsupportedAttribute) { - NextTest(); - return; - } - - VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); - - NextTest(); - }]; - - return CHIP_NO_ERROR; - } - - CHIP_ERROR TestReadsMinCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_37() + CHIP_ERROR TestReadsMinCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_36() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53012,7 +52918,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesAValueBackThatIsDifferentButValidForMinCoolSetpointLimitAttribute_38() + CHIP_ERROR TestWritesAValueBackThatIsDifferentButValidForMinCoolSetpointLimitAttribute_37() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53039,7 +52945,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinCoolSetpointLimitAttribute_39() + CHIP_ERROR TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinCoolSetpointLimitAttribute_38() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53066,7 +52972,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesMinCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_40() + CHIP_ERROR TestWritesMinCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_39() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53094,7 +53000,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesMinCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_41() + CHIP_ERROR TestWritesMinCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_40() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53121,7 +53027,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheLimitOfAbsMinCoolSetpointLimitToMinCoolSetpointLimitAttribute_42() + CHIP_ERROR TestWritesTheLimitOfAbsMinCoolSetpointLimitToMinCoolSetpointLimitAttribute_41() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53148,7 +53054,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheLimitOfMaxCoolSetpointLimitToMinCoolSetpointLimitAttribute_43() + CHIP_ERROR TestWritesTheLimitOfMaxCoolSetpointLimitToMinCoolSetpointLimitAttribute_42() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53175,7 +53081,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsMaxCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_44() + CHIP_ERROR TestReadsMaxCoolSetpointLimitAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_43() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53207,7 +53113,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesMaxCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_45() + CHIP_ERROR TestWritesMaxCoolSetpointLimitToValueBelowTheAbsMinCoolSetpointLimit_44() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53235,7 +53141,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesMaxCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_46() + CHIP_ERROR TestWritesMaxCoolSetpointLimitToValueAboveTheMaxCoolSetpointLimit_45() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53262,7 +53168,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheLimitOfMaxCoolSetpointLimitToMaxCoolSetpointLimitAttribute_47() + CHIP_ERROR TestWritesTheLimitOfMaxCoolSetpointLimitToMaxCoolSetpointLimitAttribute_46() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53289,7 +53195,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesSetsBackDefaultValueOfMinHeatSetpointLimit_48() + CHIP_ERROR TestWritesSetsBackDefaultValueOfMinHeatSetpointLimit_47() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53314,32 +53220,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesSetsBackdefaultValueOfMaxHeatSetpointLimit_49() - { - CHIPDevice * device = GetDevice("alpha"); - CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; - VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); - - id maxHeatSetpointLimitArgument; - maxHeatSetpointLimitArgument = [NSNumber numberWithShort:3000]; - [cluster writeAttributeMaxHeatSetpointLimitWithValue:maxHeatSetpointLimitArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Writes (sets back)default value of MaxHeatSetpointLimit Error: %@", err); - - if (err.code == MatterInteractionErrorCodeUnsupportedAttribute) { - NextTest(); - return; - } - - VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); - - NextTest(); - }]; - - return CHIP_NO_ERROR; - } - - CHIP_ERROR TestWritesSetsBackDefaultValueOfMinCoolSetpointLimit_50() + CHIP_ERROR TestWritesSetsBackDefaultValueOfMinCoolSetpointLimit_48() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53364,7 +53245,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesSetsBackDefaultValueOfMaxCoolSetpointLimit_51() + CHIP_ERROR TestWritesSetsBackDefaultValueOfMaxCoolSetpointLimit_49() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53389,7 +53270,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsMinSetpointDeadBandAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_52() + CHIP_ERROR TestReadsMinSetpointDeadBandAttributeFromServerDutAndVerifiesThatTheValueIsWithinRange_50() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53421,7 +53302,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesAValueBackThatIsDifferentButValidForMinSetpointDeadBandAttribute_53() + CHIP_ERROR TestWritesAValueBackThatIsDifferentButValidForMinSetpointDeadBandAttribute_51() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53448,7 +53329,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinSetpointDeadBandAttribute_54() + CHIP_ERROR TestReadsItBackAgainToConfirmTheSuccessfulWriteOfMinSetpointDeadBandAttribute_52() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53475,7 +53356,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheValueBelowMinSetpointDeadBand_55() + CHIP_ERROR TestWritesTheValueBelowMinSetpointDeadBand_53() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53500,7 +53381,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheValueAboveMinSetpointDeadBand_56() + CHIP_ERROR TestWritesTheValueAboveMinSetpointDeadBand_54() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53525,7 +53406,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheMinLimitOfMinSetpointDeadBand_57() + CHIP_ERROR TestWritesTheMinLimitOfMinSetpointDeadBand_55() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53550,7 +53431,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWritesTheMaxLimitOfMinSetpointDeadBand_58() + CHIP_ERROR TestWritesTheMaxLimitOfMinSetpointDeadBand_56() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53575,7 +53456,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsControlSequenceOfOperationFromServerDutAndVerifiesThatTheValueIsValid_59() + CHIP_ERROR TestReadsControlSequenceOfOperationFromServerDutAndVerifiesThatTheValueIsValid_57() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53602,7 +53483,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeCommandForControlSequenceOfOperationWithANewValidValue_60() + CHIP_ERROR TestWriteAttributeCommandForControlSequenceOfOperationWithANewValidValue_58() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53624,7 +53505,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadItBackAgainToConfirmTheSuccessfulWrite_61() + CHIP_ERROR TestReadItBackAgainToConfirmTheSuccessfulWrite_59() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53647,32 +53528,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedHeatingSetpointToDefaultValue_62() - { - CHIPDevice * device = GetDevice("alpha"); - CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; - VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); - - id occupiedHeatingSetpointArgument; - occupiedHeatingSetpointArgument = [NSNumber numberWithShort:2000]; - [cluster writeAttributeOccupiedHeatingSetpointWithValue:occupiedHeatingSetpointArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Sets OccupiedHeatingSetpoint to default value Error: %@", err); - - if (err.code == MatterInteractionErrorCodeUnsupportedAttribute) { - NextTest(); - return; - } - - VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); - - NextTest(); - }]; - - return CHIP_NO_ERROR; - } - - CHIP_ERROR TestSendsSetpointRaiseCommand_63() + CHIP_ERROR TestSendsSetpointRaiseCommand_60() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53693,7 +53549,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_64() + CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_61() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53720,32 +53576,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedHeatingSetpointToDefaultValue_65() - { - CHIPDevice * device = GetDevice("alpha"); - CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; - VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); - - id occupiedHeatingSetpointArgument; - occupiedHeatingSetpointArgument = [NSNumber numberWithShort:2000]; - [cluster writeAttributeOccupiedHeatingSetpointWithValue:occupiedHeatingSetpointArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Sets OccupiedHeatingSetpoint to default value Error: %@", err); - - if (err.code == MatterInteractionErrorCodeUnsupportedAttribute) { - NextTest(); - return; - } - - VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); - - NextTest(); - }]; - - return CHIP_NO_ERROR; - } - - CHIP_ERROR TestSendsSetpointRaiseCommand_66() + CHIP_ERROR TestSendsSetpointRaiseCommand_62() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53766,7 +53597,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_67() + CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_63() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53793,7 +53624,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_68() + CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_64() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53818,7 +53649,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendsSetpointRaiseCommand_69() + CHIP_ERROR TestSendsSetpointRaiseCommand_65() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53839,7 +53670,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_70() + CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_66() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53866,7 +53697,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_71() + CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_67() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53891,7 +53722,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendsSetpointRaiseCommand_72() + CHIP_ERROR TestSendsSetpointRaiseCommand_68() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53912,7 +53743,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_73() + CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_69() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53939,7 +53770,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_74() + CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_70() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -53964,32 +53795,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedHeatingSetpointToDefaultValue_75() - { - CHIPDevice * device = GetDevice("alpha"); - CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; - VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); - - id occupiedHeatingSetpointArgument; - occupiedHeatingSetpointArgument = [NSNumber numberWithShort:2000]; - [cluster writeAttributeOccupiedHeatingSetpointWithValue:occupiedHeatingSetpointArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Sets OccupiedHeatingSetpoint to default value Error: %@", err); - - if (err.code == MatterInteractionErrorCodeUnsupportedAttribute) { - NextTest(); - return; - } - - VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); - - NextTest(); - }]; - - return CHIP_NO_ERROR; - } - - CHIP_ERROR TestSendsSetpointRaiseCommand_76() + CHIP_ERROR TestSendsSetpointRaiseCommand_71() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -54010,7 +53816,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_77() + CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_72() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -54037,7 +53843,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_78() + CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_73() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -54064,7 +53870,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_79() + CHIP_ERROR TestSetsOccupiedCoolingSetpointToDefaultValue_74() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -54089,32 +53895,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSetsOccupiedHeatingSetpointToDefaultValue_80() - { - CHIPDevice * device = GetDevice("alpha"); - CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; - VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); - - id occupiedHeatingSetpointArgument; - occupiedHeatingSetpointArgument = [NSNumber numberWithShort:2000]; - [cluster writeAttributeOccupiedHeatingSetpointWithValue:occupiedHeatingSetpointArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Sets OccupiedHeatingSetpoint to default value Error: %@", err); - - if (err.code == MatterInteractionErrorCodeUnsupportedAttribute) { - NextTest(); - return; - } - - VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); - - NextTest(); - }]; - - return CHIP_NO_ERROR; - } - - CHIP_ERROR TestSendsSetpointRaiseCommand_81() + CHIP_ERROR TestSendsSetpointRaiseCommand_75() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -54135,7 +53916,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_82() + CHIP_ERROR TestReadsBackOccupiedCoolingSetpointToConfirmTheSuccessOfTheWrite_76() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -54162,7 +53943,7 @@ class Test_TC_TSTAT_2_2 : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_83() + CHIP_ERROR TestReadsBackOccupiedHeatingSetpointToConfirmTheSuccessOfTheWrite_77() { CHIPDevice * device = GetDevice("alpha"); CHIPTestThermostat * cluster = [[CHIPTestThermostat alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];