From 0adc4f3b366899555000b2d7a3fecf23a0fa0245 Mon Sep 17 00:00:00 2001 From: Evgeniy Morozov Date: Fri, 10 Jun 2022 00:00:25 +0300 Subject: [PATCH] Bugfix: Dont read non-existing attributes for lock/unlock commands (#19373) * [#19316] Don't require PIN for locking/unlocking the door when not required * Update auto-generated files --- .../door-lock-server/door-lock-server.cpp | 18 +- .../door-lock-server/door-lock-server.h | 5 + src/app/tests/suites/DL_LockUnlock.yaml | 20 ++ .../chip-tool/zap-generated/test/Commands.h | 110 ++++++++--- .../zap-generated/test/Commands.h | 172 +++++++++++++++--- 5 files changed, 260 insertions(+), 65 deletions(-) diff --git a/src/app/clusters/door-lock-server/door-lock-server.cpp b/src/app/clusters/door-lock-server/door-lock-server.cpp index 2f69c839e6c1c8..93f83a529953b5 100644 --- a/src/app/clusters/door-lock-server/door-lock-server.cpp +++ b/src/app/clusters/door-lock-server/door-lock-server.cpp @@ -3143,13 +3143,19 @@ bool DoorLockServer::HandleRemoteLockOperation(chip::app::CommandHandler * comma } else { - // appclusters.pdf 5.3.4.1: - // If the RequirePINforRemoteOperation attribute is True then PINCode field SHALL be provided and the door lock SHALL NOT - // grant access if it is not provided. bool requirePin = false; - VerifyOrExit(GetAttribute(endpoint, Attributes::RequirePINforRemoteOperation::Id, - Attributes::RequirePINforRemoteOperation::Get, requirePin), - /* credentialsOk is false here */); + + // appclusters.pdf 5.3.4.1: + // If the RequirePINForRemoteOperation attribute is True then PINCode field SHALL be provided and the door lock SHALL NOT + // grant access if it is not provided. This attribute exists when COTA and PIN features are both enabled. Otherwise we + // assume PIN to be OK. + if (SupportsCredentialsOTA(endpoint) && SupportsPIN(endpoint)) + { + auto status = Attributes::RequirePINforRemoteOperation::Get(endpoint, &requirePin); + VerifyOrExit( + EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE == status || EMBER_ZCL_STATUS_SUCCESS == status, + ChipLogError(Zcl, "Failed to read Require PIN For Remote Operation attribute, status=0x%x", to_underlying(status))); + } credentialsOk = !requirePin; } diff --git a/src/app/clusters/door-lock-server/door-lock-server.h b/src/app/clusters/door-lock-server/door-lock-server.h index 25ccf346a953b2..efe8a0ace57ae3 100644 --- a/src/app/clusters/door-lock-server/door-lock-server.h +++ b/src/app/clusters/door-lock-server/door-lock-server.h @@ -168,6 +168,11 @@ class DoorLockServer inline bool SupportsSchedules(chip::EndpointId endpointId) { return HasFeature(endpointId, DoorLockFeature::kAccessSchedules); } + inline bool SupportsCredentialsOTA(chip::EndpointId endpointId) + { + return HasFeature(endpointId, DoorLockFeature::kCredentialsOTA); + } + inline bool SupportsUSR(chip::EndpointId endpointId) { // appclusters, 5.2.2: USR feature has conformance [PIN | RID | FGP | FACE] diff --git a/src/app/tests/suites/DL_LockUnlock.yaml b/src/app/tests/suites/DL_LockUnlock.yaml index 0cf5e6f9f94c0b..4ddaee939b4254 100644 --- a/src/app/tests/suites/DL_LockUnlock.yaml +++ b/src/app/tests/suites/DL_LockUnlock.yaml @@ -28,6 +28,26 @@ tests: - name: "nodeId" value: nodeId + - label: "Try to unlock the door without PIN" + command: "UnlockDoor" + timedInteractionTimeoutMs: 10000 + + - label: "Verify that lock state attribute value is set to Unlocked" + command: "readAttribute" + attribute: "LockState" + response: + value: 2 + + - label: "Try to unlock the door without a PIN" + command: "LockDoor" + timedInteractionTimeoutMs: 10000 + + - label: "Verify that lock state attribute value is set to Locked" + command: "readAttribute" + attribute: "LockState" + response: + value: 1 + - label: "Create new PIN credential and lock/unlock user" command: "SetCredential" timedInteractionTimeoutMs: 10000 diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index deda87ea5e0eef..3286d6d5baed98 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -59225,7 +59225,7 @@ class DL_UsersAndCredentialsSuite : public TestCommand class DL_LockUnlockSuite : public TestCommand { public: - DL_LockUnlockSuite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("DL_LockUnlock", 11, credsIssuerConfig) + DL_LockUnlockSuite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("DL_LockUnlock", 15, credsIssuerConfig) { AddArgument("nodeId", 0, UINT64_MAX, &mNodeId); AddArgument("cluster", &mCluster); @@ -59263,6 +59263,30 @@ class DL_LockUnlockSuite : public TestCommand shouldContinue = true; break; case 1: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + break; + case 2: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::Nullable value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckValueNonNull("lockState", value)); + VerifyOrReturn(CheckValue("lockState.Value()", value.Value(), 2)); + } + break; + case 3: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + break; + case 4: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::Nullable value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckValueNonNull("lockState", value)); + VerifyOrReturn(CheckValue("lockState.Value()", value.Value(), 1)); + } + break; + case 5: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::DoorLock::Commands::SetCredentialResponse::DecodableType value; @@ -59276,10 +59300,10 @@ class DL_LockUnlockSuite : public TestCommand VerifyOrReturn(CheckValue("nextCredentialIndex.Value()", value.nextCredentialIndex.Value(), 2U)); } break; - case 2: + case 6: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); break; - case 3: + case 7: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -59288,10 +59312,10 @@ class DL_LockUnlockSuite : public TestCommand VerifyOrReturn(CheckValue("lockState.Value()", value.Value(), 1)); } break; - case 4: + case 8: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 5: + case 9: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -59300,10 +59324,10 @@ class DL_LockUnlockSuite : public TestCommand VerifyOrReturn(CheckValue("lockState.Value()", value.Value(), 2)); } break; - case 6: + case 10: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); break; - case 7: + case 11: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -59312,10 +59336,10 @@ class DL_LockUnlockSuite : public TestCommand VerifyOrReturn(CheckValue("lockState.Value()", value.Value(), 2)); } break; - case 8: + case 12: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 9: + case 13: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -59324,7 +59348,7 @@ class DL_LockUnlockSuite : public TestCommand VerifyOrReturn(CheckValue("lockState.Value()", value.Value(), 1)); } break; - case 10: + case 14: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; default: @@ -59350,7 +59374,35 @@ class DL_LockUnlockSuite : public TestCommand return WaitForCommissionee(kIdentityAlpha, value); } case 1: { - LogStep(1, "Create new PIN credential and lock/unlock user"); + LogStep(1, "Try to unlock the door without PIN"); + ListFreer listFreer; + chip::app::Clusters::DoorLock::Commands::UnlockDoor::Type value; + return SendCommand(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Commands::UnlockDoor::Id, value, + chip::Optional(10000), chip::NullOptional + + ); + } + case 2: { + LogStep(2, "Verify that lock state attribute value is set to Unlocked"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Attributes::LockState::Id, true, + chip::NullOptional); + } + case 3: { + LogStep(3, "Try to unlock the door without a PIN"); + ListFreer listFreer; + chip::app::Clusters::DoorLock::Commands::LockDoor::Type value; + return SendCommand(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Commands::LockDoor::Id, value, + chip::Optional(10000), chip::NullOptional + + ); + } + case 4: { + LogStep(4, "Verify that lock state attribute value is set to Locked"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Attributes::LockState::Id, true, + chip::NullOptional); + } + case 5: { + LogStep(5, "Create new PIN credential and lock/unlock user"); ListFreer listFreer; chip::app::Clusters::DoorLock::Commands::SetCredential::Type value; value.operationType = static_cast(0); @@ -59367,8 +59419,8 @@ class DL_LockUnlockSuite : public TestCommand ); } - case 2: { - LogStep(2, "Try to unlock the door with invalid PIN"); + case 6: { + LogStep(6, "Try to unlock the door with invalid PIN"); ListFreer listFreer; chip::app::Clusters::DoorLock::Commands::UnlockDoor::Type value; value.pinCode.Emplace(); @@ -59378,13 +59430,13 @@ class DL_LockUnlockSuite : public TestCommand ); } - case 3: { - LogStep(3, "Verify that lock state attribute value is set to Locked"); + case 7: { + LogStep(7, "Verify that lock state attribute value is set to Locked"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Attributes::LockState::Id, true, chip::NullOptional); } - case 4: { - LogStep(4, "Try to unlock the door with valid PIN"); + case 8: { + LogStep(8, "Try to unlock the door with valid PIN"); ListFreer listFreer; chip::app::Clusters::DoorLock::Commands::UnlockDoor::Type value; value.pinCode.Emplace(); @@ -59394,13 +59446,13 @@ class DL_LockUnlockSuite : public TestCommand ); } - case 5: { - LogStep(5, "Verify that lock state attribute value is set to Unlocked"); + case 9: { + LogStep(9, "Verify that lock state attribute value is set to Unlocked"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Attributes::LockState::Id, true, chip::NullOptional); } - case 6: { - LogStep(6, "Try to lock the door with invalid PIN"); + case 10: { + LogStep(10, "Try to lock the door with invalid PIN"); ListFreer listFreer; chip::app::Clusters::DoorLock::Commands::LockDoor::Type value; value.pinCode.Emplace(); @@ -59410,13 +59462,13 @@ class DL_LockUnlockSuite : public TestCommand ); } - case 7: { - LogStep(7, "Verify that lock state attribute value is set to Unlocked"); + case 11: { + LogStep(11, "Verify that lock state attribute value is set to Unlocked"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Attributes::LockState::Id, true, chip::NullOptional); } - case 8: { - LogStep(8, "Try to unlock the door with valid PIN"); + case 12: { + LogStep(12, "Try to unlock the door with valid PIN"); ListFreer listFreer; chip::app::Clusters::DoorLock::Commands::LockDoor::Type value; value.pinCode.Emplace(); @@ -59426,13 +59478,13 @@ class DL_LockUnlockSuite : public TestCommand ); } - case 9: { - LogStep(9, "Verify that lock state attribute value is set to Locked"); + case 13: { + LogStep(13, "Verify that lock state attribute value is set to Locked"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), DoorLock::Id, DoorLock::Attributes::LockState::Id, true, chip::NullOptional); } - case 10: { - LogStep(10, "Clean the created credential"); + case 14: { + LogStep(14, "Clean the created credential"); ListFreer listFreer; chip::app::Clusters::DoorLock::Commands::ClearCredential::Type value; value.credential.SetNonNull(); 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 0d0b2cd01a0080..e768de29782417 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h @@ -99570,44 +99570,60 @@ class DL_LockUnlock : public TestCommandBridge { err = TestWaitForTheCommissionedDeviceToBeRetrieved_0(); break; case 1: - ChipLogProgress(chipTool, " ***** Test Step 1 : Create new PIN credential and lock/unlock user\n"); - err = TestCreateNewPinCredentialAndLockUnlockUser_1(); + ChipLogProgress(chipTool, " ***** Test Step 1 : Try to unlock the door without PIN\n"); + err = TestTryToUnlockTheDoorWithoutPin_1(); break; case 2: - ChipLogProgress(chipTool, " ***** Test Step 2 : Try to unlock the door with invalid PIN\n"); - err = TestTryToUnlockTheDoorWithInvalidPin_2(); + ChipLogProgress(chipTool, " ***** Test Step 2 : Verify that lock state attribute value is set to Unlocked\n"); + err = TestVerifyThatLockStateAttributeValueIsSetToUnlocked_2(); break; case 3: - ChipLogProgress(chipTool, " ***** Test Step 3 : Verify that lock state attribute value is set to Locked\n"); - err = TestVerifyThatLockStateAttributeValueIsSetToLocked_3(); + ChipLogProgress(chipTool, " ***** Test Step 3 : Try to unlock the door without a PIN\n"); + err = TestTryToUnlockTheDoorWithoutAPin_3(); break; case 4: - ChipLogProgress(chipTool, " ***** Test Step 4 : Try to unlock the door with valid PIN\n"); - err = TestTryToUnlockTheDoorWithValidPin_4(); + ChipLogProgress(chipTool, " ***** Test Step 4 : Verify that lock state attribute value is set to Locked\n"); + err = TestVerifyThatLockStateAttributeValueIsSetToLocked_4(); break; case 5: - ChipLogProgress(chipTool, " ***** Test Step 5 : Verify that lock state attribute value is set to Unlocked\n"); - err = TestVerifyThatLockStateAttributeValueIsSetToUnlocked_5(); + ChipLogProgress(chipTool, " ***** Test Step 5 : Create new PIN credential and lock/unlock user\n"); + err = TestCreateNewPinCredentialAndLockUnlockUser_5(); break; case 6: - ChipLogProgress(chipTool, " ***** Test Step 6 : Try to lock the door with invalid PIN\n"); - err = TestTryToLockTheDoorWithInvalidPin_6(); + ChipLogProgress(chipTool, " ***** Test Step 6 : Try to unlock the door with invalid PIN\n"); + err = TestTryToUnlockTheDoorWithInvalidPin_6(); break; case 7: - ChipLogProgress(chipTool, " ***** Test Step 7 : Verify that lock state attribute value is set to Unlocked\n"); - err = TestVerifyThatLockStateAttributeValueIsSetToUnlocked_7(); + ChipLogProgress(chipTool, " ***** Test Step 7 : Verify that lock state attribute value is set to Locked\n"); + err = TestVerifyThatLockStateAttributeValueIsSetToLocked_7(); break; case 8: ChipLogProgress(chipTool, " ***** Test Step 8 : Try to unlock the door with valid PIN\n"); err = TestTryToUnlockTheDoorWithValidPin_8(); break; case 9: - ChipLogProgress(chipTool, " ***** Test Step 9 : Verify that lock state attribute value is set to Locked\n"); - err = TestVerifyThatLockStateAttributeValueIsSetToLocked_9(); + ChipLogProgress(chipTool, " ***** Test Step 9 : Verify that lock state attribute value is set to Unlocked\n"); + err = TestVerifyThatLockStateAttributeValueIsSetToUnlocked_9(); break; case 10: - ChipLogProgress(chipTool, " ***** Test Step 10 : Clean the created credential\n"); - err = TestCleanTheCreatedCredential_10(); + ChipLogProgress(chipTool, " ***** Test Step 10 : Try to lock the door with invalid PIN\n"); + err = TestTryToLockTheDoorWithInvalidPin_10(); + break; + case 11: + ChipLogProgress(chipTool, " ***** Test Step 11 : Verify that lock state attribute value is set to Unlocked\n"); + err = TestVerifyThatLockStateAttributeValueIsSetToUnlocked_11(); + break; + case 12: + ChipLogProgress(chipTool, " ***** Test Step 12 : Try to unlock the door with valid PIN\n"); + err = TestTryToUnlockTheDoorWithValidPin_12(); + break; + case 13: + ChipLogProgress(chipTool, " ***** Test Step 13 : Verify that lock state attribute value is set to Locked\n"); + err = TestVerifyThatLockStateAttributeValueIsSetToLocked_13(); + break; + case 14: + ChipLogProgress(chipTool, " ***** Test Step 14 : Clean the created credential\n"); + err = TestCleanTheCreatedCredential_14(); break; } @@ -99627,7 +99643,7 @@ class DL_LockUnlock : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 2: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 3: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -99651,6 +99667,18 @@ class DL_LockUnlock : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 10: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); + break; + case 11: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + break; + case 12: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + break; + case 13: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + break; + case 14: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; } @@ -99666,7 +99694,7 @@ class DL_LockUnlock : public TestCommandBridge { private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 11; + const uint16_t mTestCount = 15; chip::Optional mNodeId; chip::Optional mCluster; @@ -99680,7 +99708,91 @@ class DL_LockUnlock : public TestCommandBridge { return WaitForCommissionee("alpha", value); } - CHIP_ERROR TestCreateNewPinCredentialAndLockUnlockUser_1() + CHIP_ERROR TestTryToUnlockTheDoorWithoutPin_1() + { + CHIPDevice * device = GetDevice("alpha"); + CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; + VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); + + __auto_type * params = [[CHIPDoorLockClusterUnlockDoorParams alloc] init]; + [cluster unlockDoorWithParams:params + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Try to unlock the door without PIN Error: %@", err); + + VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); + + NextTest(); + }]; + + return CHIP_NO_ERROR; + } + + CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToUnlocked_2() + { + CHIPDevice * device = GetDevice("alpha"); + CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; + VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); + + [cluster readAttributeLockStateWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Verify that lock state attribute value is set to Unlocked Error: %@", err); + + VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); + + { + id actualValue = value; + VerifyOrReturn(CheckValueNonNull("LockState", actualValue)); + VerifyOrReturn(CheckValue("LockState", actualValue, 2)); + } + + NextTest(); + }]; + + return CHIP_NO_ERROR; + } + + CHIP_ERROR TestTryToUnlockTheDoorWithoutAPin_3() + { + CHIPDevice * device = GetDevice("alpha"); + CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; + VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); + + __auto_type * params = [[CHIPDoorLockClusterLockDoorParams alloc] init]; + [cluster lockDoorWithParams:params + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Try to unlock the door without a PIN Error: %@", err); + + VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); + + NextTest(); + }]; + + return CHIP_NO_ERROR; + } + + CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToLocked_4() + { + CHIPDevice * device = GetDevice("alpha"); + CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; + VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); + + [cluster readAttributeLockStateWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Verify that lock state attribute value is set to Locked Error: %@", err); + + VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); + + { + id actualValue = value; + VerifyOrReturn(CheckValueNonNull("LockState", actualValue)); + VerifyOrReturn(CheckValue("LockState", actualValue, 1)); + } + + NextTest(); + }]; + + return CHIP_NO_ERROR; + } + + CHIP_ERROR TestCreateNewPinCredentialAndLockUnlockUser_5() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99726,7 +99838,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestTryToUnlockTheDoorWithInvalidPin_2() + CHIP_ERROR TestTryToUnlockTheDoorWithInvalidPin_6() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99745,7 +99857,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToLocked_3() + CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToLocked_7() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99768,7 +99880,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestTryToUnlockTheDoorWithValidPin_4() + CHIP_ERROR TestTryToUnlockTheDoorWithValidPin_8() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99788,7 +99900,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToUnlocked_5() + CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToUnlocked_9() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99811,7 +99923,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestTryToLockTheDoorWithInvalidPin_6() + CHIP_ERROR TestTryToLockTheDoorWithInvalidPin_10() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99830,7 +99942,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToUnlocked_7() + CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToUnlocked_11() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99853,7 +99965,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestTryToUnlockTheDoorWithValidPin_8() + CHIP_ERROR TestTryToUnlockTheDoorWithValidPin_12() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99873,7 +99985,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToLocked_9() + CHIP_ERROR TestVerifyThatLockStateAttributeValueIsSetToLocked_13() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue]; @@ -99896,7 +100008,7 @@ class DL_LockUnlock : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestCleanTheCreatedCredential_10() + CHIP_ERROR TestCleanTheCreatedCredential_14() { CHIPDevice * device = GetDevice("alpha"); CHIPTestDoorLock * cluster = [[CHIPTestDoorLock alloc] initWithDevice:device endpoint:1 queue:mCallbackQueue];