From e42ea9a1e76a8dcc717ba3ddd062f9649af78cf1 Mon Sep 17 00:00:00 2001 From: Lazar Kovacic Date: Wed, 30 Jun 2021 14:10:49 +0200 Subject: [PATCH] Running zap generator Problem - Tests does not have zap regenerated files Summary of Changes - Run zap_regen_all.py script --- examples/all-clusters-app/linux/BUILD.gn | 6 +- .../linux/include/media/tv-stubs.cpp | 2 +- .../chip-tool/commands/clusters/Commands.h | 24 +- examples/chip-tool/commands/tests/Commands.h | 3175 ++++++++++++++++- .../ApplicationLauncherManager.cpp | 2 +- .../keypad-input/KeypadInputManager.cpp | 2 +- .../include/media-input/MediaInputManager.cpp | 2 +- .../media-playback/MediaPlaybackManager.cpp | 2 +- .../TargetNavigatorManager.cpp | 2 +- .../account-login-server.cpp | 2 +- .../media-playback-server.cpp | 2 +- .../target-navigator-server.cpp | 2 +- src/app/tests/suites/AccountLoginCluster.yaml | 4 +- .../tests/suites/ApplicationBasicCluster.yaml | 8 +- .../suites/ApplicationLauncherCluster.yaml | 2 +- src/app/tests/suites/AudioOutputCluster.yaml | 4 +- src/app/tests/suites/KeypadInputCluster.yaml | 2 +- src/app/tests/suites/LowPowerCluster.yaml | 3 +- src/app/tests/suites/MediaInputCluster.yaml | 4 +- .../tests/suites/MediaPlaybackCluster.yaml | 15 +- .../tests/suites/TargetNavigatorCluster.yaml | 8 +- src/app/tests/suites/TvChannelCluster.yaml | 20 +- .../data_model/gen/CHIPClusters.cpp | 4 +- src/controller/data_model/gen/CHIPClusters.h | 2 +- .../data_model/gen/chip-zcl-zpro-codec-api.h | 8 +- src/controller/data_model/gen/encoder.cpp | 8 +- .../python/chip/clusters/CHIPClusters.cpp | 6 +- .../python/chip/clusters/CHIPClusters.py | 12 +- .../Framework/CHIP/gen/CHIPClustersObjc.h | 2 +- .../Framework/CHIP/gen/CHIPClustersObjc.mm | 4 +- .../Framework/CHIPTests/CHIPClustersTests.m | 8 +- 31 files changed, 3262 insertions(+), 85 deletions(-) diff --git a/examples/all-clusters-app/linux/BUILD.gn b/examples/all-clusters-app/linux/BUILD.gn index 68c4359c50319a..281ada9e29eb71 100644 --- a/examples/all-clusters-app/linux/BUILD.gn +++ b/examples/all-clusters-app/linux/BUILD.gn @@ -16,10 +16,10 @@ import("//build_overrides/build.gni") import("//build_overrides/chip.gni") executable("chip-all-clusters-app") { - sources = [ + sources = [ "include/media/tv-stubs.cpp", - "main.cpp" - ] + "main.cpp", + ] deps = [ "${chip_root}/examples/all-clusters-app/all-clusters-common", diff --git a/examples/all-clusters-app/linux/include/media/tv-stubs.cpp b/examples/all-clusters-app/linux/include/media/tv-stubs.cpp index da5e67ce350500..b479ac6779bd2e 100644 --- a/examples/all-clusters-app/linux/include/media/tv-stubs.cpp +++ b/examples/all-clusters-app/linux/include/media/tv-stubs.cpp @@ -41,4 +41,4 @@ bool lowPowerClusterSleep() { return true; -} \ No newline at end of file +} diff --git a/examples/chip-tool/commands/clusters/Commands.h b/examples/chip-tool/commands/clusters/Commands.h index cb358e34b01bbf..a5ccbbaa56c821 100644 --- a/examples/chip-tool/commands/clusters/Commands.h +++ b/examples/chip-tool/commands/clusters/Commands.h @@ -1346,7 +1346,7 @@ class ReadAccountLoginClusterRevision : public ModelCommand | * ProductId | 0x0003 | | * ApplicationId | 0x0005 | | * CatalogVendorId | 0x0006 | -| * ApplicationSatus | 0x0007 | +| * ApplicationStatus | 0x0007 | | * ClusterRevision | 0xFFFD | \*----------------------------------------------------------------------------*/ @@ -1619,18 +1619,18 @@ class ReadApplicationBasicCatalogVendorId : public ModelCommand }; /* - * Attribute ApplicationSatus + * Attribute ApplicationStatus */ -class ReadApplicationBasicApplicationSatus : public ModelCommand +class ReadApplicationBasicApplicationStatus : public ModelCommand { public: - ReadApplicationBasicApplicationSatus() : ModelCommand("read") + ReadApplicationBasicApplicationStatus() : ModelCommand("read") { - AddArgument("attr-name", "application-satus"); + AddArgument("attr-name", "application-status"); ModelCommand::AddArguments(); } - ~ReadApplicationBasicApplicationSatus() + ~ReadApplicationBasicApplicationStatus() { delete onSuccessCallback; delete onFailureCallback; @@ -1642,7 +1642,7 @@ class ReadApplicationBasicApplicationSatus : public ModelCommand chip::Controller::ApplicationBasicCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeApplicationSatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeApplicationStatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: @@ -21920,11 +21920,11 @@ void registerClusterApplicationBasic(Commands & commands) const char * clusterName = "ApplicationBasic"; commands_list clusterCommands = { - make_unique(), make_unique(), - make_unique(), make_unique(), - make_unique(), make_unique(), - make_unique(), make_unique(), - make_unique(), make_unique(), + make_unique(), make_unique(), + make_unique(), make_unique(), + make_unique(), make_unique(), + make_unique(), make_unique(), + make_unique(), make_unique(), }; commands.Register(clusterName, clusterCommands); diff --git a/examples/chip-tool/commands/tests/Commands.h b/examples/chip-tool/commands/tests/Commands.h index dc586d8e4b5a28..13bbe55e38d5c6 100644 --- a/examples/chip-tool/commands/tests/Commands.h +++ b/examples/chip-tool/commands/tests/Commands.h @@ -21,6 +21,3164 @@ #include "TestCommand.h" +class TargetNavigatorCluster : public TestCommand +{ +public: + TargetNavigatorCluster() : TestCommand("TargetNavigatorCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "TargetNavigatorCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterTargetNavigatorCommandReadAttribute_0(); + break; + case 1: + err = TestSendClusterTargetNavigatorCommandNavigateTarget_1(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "TargetNavigatorCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 2; + + // + // Tests methods + // + + // Test Read attribute Target Navigator list + typedef void (*SuccessCallback_0)(void * context, uint16_t count, _NavigateTargetTargetInfo * targetNavigatorList); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterTargetNavigatorCommandReadAttribute_0() + { + ChipLogProgress(chipTool, "Target Navigator - Read attribute Target Navigator list: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterTargetNavigatorCommandReadAttribute_0_FailureResponse, this); + mOnSuccessCallback_0 = new chip::Callback::Callback( + OnTestSendClusterTargetNavigatorCommandReadAttribute_0_SuccessResponse, this); + + chip::Controller::TargetNavigatorCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeTargetNavigatorList(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterTargetNavigatorCommandReadAttribute_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Target Navigator - Read attribute Target Navigator list: Failure Response"); + + TargetNavigatorCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void + OnTestSendClusterTargetNavigatorCommandReadAttribute_0_SuccessResponse(void * context, uint16_t count, + _NavigateTargetTargetInfo * targetNavigatorList) + { + ChipLogProgress(chipTool, "Target Navigator - Read attribute Target Navigator list: Success Response"); + + TargetNavigatorCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (count != 2) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "[object Object],[object Object]"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Navigate Target Command + typedef void (*SuccessCallback_1)(void * context, uint8_t status, chip::ByteSpan data); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterTargetNavigatorCommandNavigateTarget_1() + { + ChipLogProgress(chipTool, "Target Navigator - Navigate Target Command: Sending command..."); + + mOnFailureCallback_1 = new chip::Callback::Callback( + OnTestSendClusterTargetNavigatorCommandNavigateTarget_1_FailureResponse, this); + mOnSuccessCallback_1 = new chip::Callback::Callback( + OnTestSendClusterTargetNavigatorCommandNavigateTarget_1_SuccessResponse, this); + + chip::Controller::TargetNavigatorCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint8_t targetArgument = 1; + chip::ByteSpan dataArgument = chip::ByteSpan(chip::Uint8::from_const_char("1"), strlen("1")); + err = cluster.NavigateTarget(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel(), targetArgument, dataArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterTargetNavigatorCommandNavigateTarget_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Target Navigator - Navigate Target Command: Failure Response"); + + TargetNavigatorCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterTargetNavigatorCommandNavigateTarget_1_SuccessResponse(void * context, uint8_t status, + chip::ByteSpan data) + { + ChipLogProgress(chipTool, "Target Navigator - Navigate Target Command: Success Response"); + + TargetNavigatorCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class AudioOutputCluster : public TestCommand +{ +public: + AudioOutputCluster() : TestCommand("AudioOutputCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "AudioOutputCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterAudioOutputCommandReadAttribute_0(); + break; + case 1: + err = TestSendClusterAudioOutputCommandSelectOutput_1(); + break; + case 2: + err = TestSendClusterAudioOutputCommandRenameOutput_2(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "AudioOutputCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 3; + + // + // Tests methods + // + + // Test Read attribute Audio Output list + typedef void (*SuccessCallback_0)(void * context, uint16_t count, _AudioOutputInfo * audioOutputList); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterAudioOutputCommandReadAttribute_0() + { + ChipLogProgress(chipTool, "Audio Output - Read attribute Audio Output list: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterAudioOutputCommandReadAttribute_0_FailureResponse, this); + mOnSuccessCallback_0 = new chip::Callback::Callback( + OnTestSendClusterAudioOutputCommandReadAttribute_0_SuccessResponse, this); + + chip::Controller::AudioOutputCluster cluster; + cluster.Associate(mDevice, 2); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeAudioOutputList(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterAudioOutputCommandReadAttribute_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Audio Output - Read attribute Audio Output list: Failure Response"); + + AudioOutputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterAudioOutputCommandReadAttribute_0_SuccessResponse(void * context, uint16_t count, + _AudioOutputInfo * audioOutputList) + { + ChipLogProgress(chipTool, "Audio Output - Read attribute Audio Output list: Success Response"); + + AudioOutputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (count != 3) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "[object Object],[object Object],[object Object]"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Select Output Command + typedef void (*SuccessCallback_1)(void * context); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterAudioOutputCommandSelectOutput_1() + { + ChipLogProgress(chipTool, "Audio Output - Select Output Command: Sending command..."); + + mOnFailureCallback_1 = new chip::Callback::Callback( + OnTestSendClusterAudioOutputCommandSelectOutput_1_FailureResponse, this); + mOnSuccessCallback_1 = new chip::Callback::Callback( + OnTestSendClusterAudioOutputCommandSelectOutput_1_SuccessResponse, this); + + chip::Controller::AudioOutputCluster cluster; + cluster.Associate(mDevice, 2); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint8_t indexArgument = 1; + err = cluster.SelectOutput(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel(), indexArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterAudioOutputCommandSelectOutput_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Audio Output - Select Output Command: Failure Response"); + + AudioOutputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterAudioOutputCommandSelectOutput_1_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Audio Output - Select Output Command: Success Response"); + + AudioOutputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Rename Output Command + typedef void (*SuccessCallback_2)(void * context); + chip::Callback::Callback * mOnSuccessCallback_2 = nullptr; + chip::Callback::Callback * mOnFailureCallback_2 = nullptr; + bool mIsFailureExpected_2 = 0; + + CHIP_ERROR TestSendClusterAudioOutputCommandRenameOutput_2() + { + ChipLogProgress(chipTool, "Audio Output - Rename Output Command: Sending command..."); + + mOnFailureCallback_2 = new chip::Callback::Callback( + OnTestSendClusterAudioOutputCommandRenameOutput_2_FailureResponse, this); + mOnSuccessCallback_2 = new chip::Callback::Callback( + OnTestSendClusterAudioOutputCommandRenameOutput_2_SuccessResponse, this); + + chip::Controller::AudioOutputCluster cluster; + cluster.Associate(mDevice, 2); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint8_t indexArgument = 1; + chip::ByteSpan nameArgument = chip::ByteSpan(chip::Uint8::from_const_char("exampleName"), strlen("exampleName")); + err = cluster.RenameOutput(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel(), indexArgument, nameArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_2; + delete mOnSuccessCallback_2; + } + + return err; + } + + static void OnTestSendClusterAudioOutputCommandRenameOutput_2_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Audio Output - Rename Output Command: Failure Response"); + + AudioOutputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterAudioOutputCommandRenameOutput_2_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Audio Output - Rename Output Command: Success Response"); + + AudioOutputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class ApplicationLauncherCluster : public TestCommand +{ +public: + ApplicationLauncherCluster() : TestCommand("ApplicationLauncherCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "ApplicationLauncherCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterApplicationLauncherCommandReadAttribute_0(); + break; + case 1: + err = TestSendClusterApplicationLauncherCommandLaunchApp_1(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "ApplicationLauncherCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 2; + + // + // Tests methods + // + + // Test Read attribute Application Launcher list + typedef void (*SuccessCallback_0)(void * context, uint16_t count, uint16_t * applicationLauncherList); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterApplicationLauncherCommandReadAttribute_0() + { + ChipLogProgress(chipTool, "Application Launcher - Read attribute Application Launcher list: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterApplicationLauncherCommandReadAttribute_0_FailureResponse, this); + mOnSuccessCallback_0 = new chip::Callback::Callback( + OnTestSendClusterApplicationLauncherCommandReadAttribute_0_SuccessResponse, this); + + chip::Controller::ApplicationLauncherCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeApplicationLauncherList(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterApplicationLauncherCommandReadAttribute_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Launcher - Read attribute Application Launcher list: Failure Response"); + + ApplicationLauncherCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationLauncherCommandReadAttribute_0_SuccessResponse(void * context, uint16_t count, + uint16_t * applicationLauncherList) + { + ChipLogProgress(chipTool, "Application Launcher - Read attribute Application Launcher list: Success Response"); + + ApplicationLauncherCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (count != 2) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "123,456"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Launch App Command + typedef void (*SuccessCallback_1)(void * context, uint8_t status, chip::ByteSpan data); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterApplicationLauncherCommandLaunchApp_1() + { + ChipLogProgress(chipTool, "Application Launcher - Launch App Command: Sending command..."); + + mOnFailureCallback_1 = new chip::Callback::Callback( + OnTestSendClusterApplicationLauncherCommandLaunchApp_1_FailureResponse, this); + mOnSuccessCallback_1 = new chip::Callback::Callback( + OnTestSendClusterApplicationLauncherCommandLaunchApp_1_SuccessResponse, this); + + chip::Controller::ApplicationLauncherCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + chip::ByteSpan dataArgument = chip::ByteSpan(chip::Uint8::from_const_char("exampleData"), strlen("exampleData")); + uint16_t catalogVendorIdArgument = 1U; + chip::ByteSpan applicationIdArgument = chip::ByteSpan(chip::Uint8::from_const_char("appId"), strlen("appId")); + err = cluster.LaunchApp(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel(), dataArgument, + catalogVendorIdArgument, applicationIdArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterApplicationLauncherCommandLaunchApp_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Launcher - Launch App Command: Failure Response"); + + ApplicationLauncherCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationLauncherCommandLaunchApp_1_SuccessResponse(void * context, uint8_t status, + chip::ByteSpan data) + { + ChipLogProgress(chipTool, "Application Launcher - Launch App Command: Success Response"); + + ApplicationLauncherCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class KeypadInputCluster : public TestCommand +{ +public: + KeypadInputCluster() : TestCommand("KeypadInputCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "KeypadInputCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterKeypadInputCommandSendKey_0(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "KeypadInputCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 1; + + // + // Tests methods + // + + // Test Send Key Command + typedef void (*SuccessCallback_0)(void * context, uint8_t status); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterKeypadInputCommandSendKey_0() + { + ChipLogProgress(chipTool, "Keypad Input - Send Key Command: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterKeypadInputCommandSendKey_0_FailureResponse, this); + mOnSuccessCallback_0 = + new chip::Callback::Callback(OnTestSendClusterKeypadInputCommandSendKey_0_SuccessResponse, this); + + chip::Controller::KeypadInputCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint8_t keyCodeArgument = 3; + err = cluster.SendKey(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel(), keyCodeArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterKeypadInputCommandSendKey_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Keypad Input - Send Key Command: Failure Response"); + + KeypadInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterKeypadInputCommandSendKey_0_SuccessResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Keypad Input - Send Key Command: Success Response"); + + KeypadInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class AccountLoginCluster : public TestCommand +{ +public: + AccountLoginCluster() : TestCommand("AccountLoginCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "AccountLoginCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterAccountLoginCommandGetSetupPIN_0(); + break; + case 1: + err = TestSendClusterAccountLoginCommandLogin_1(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "AccountLoginCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 2; + + // + // Tests methods + // + + // Test Get Setup PIN Command + typedef void (*SuccessCallback_0)(void * context, chip::ByteSpan setupPIN); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterAccountLoginCommandGetSetupPIN_0() + { + ChipLogProgress(chipTool, "Account Login - Get Setup PIN Command: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterAccountLoginCommandGetSetupPIN_0_FailureResponse, this); + mOnSuccessCallback_0 = new chip::Callback::Callback( + OnTestSendClusterAccountLoginCommandGetSetupPIN_0_SuccessResponse, this); + + chip::Controller::AccountLoginCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + chip::ByteSpan tempAccountIdentifierArgument = chip::ByteSpan(chip::Uint8::from_const_char("asdf"), strlen("asdf")); + err = cluster.GetSetupPIN(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel(), tempAccountIdentifierArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterAccountLoginCommandGetSetupPIN_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Account Login - Get Setup PIN Command: Failure Response"); + + AccountLoginCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterAccountLoginCommandGetSetupPIN_0_SuccessResponse(void * context, chip::ByteSpan setupPIN) + { + ChipLogProgress(chipTool, "Account Login - Get Setup PIN Command: Success Response"); + + AccountLoginCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Login Command + typedef void (*SuccessCallback_1)(void * context); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterAccountLoginCommandLogin_1() + { + ChipLogProgress(chipTool, "Account Login - Login Command: Sending command..."); + + mOnFailureCallback_1 = + new chip::Callback::Callback(OnTestSendClusterAccountLoginCommandLogin_1_FailureResponse, this); + mOnSuccessCallback_1 = + new chip::Callback::Callback(OnTestSendClusterAccountLoginCommandLogin_1_SuccessResponse, this); + + chip::Controller::AccountLoginCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + chip::ByteSpan tempAccountIdentifierArgument = chip::ByteSpan(chip::Uint8::from_const_char("asdf"), strlen("asdf")); + chip::ByteSpan setupPINArgument = chip::ByteSpan(chip::Uint8::from_const_char("tempPin123"), strlen("tempPin123")); + err = cluster.Login(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel(), tempAccountIdentifierArgument, + setupPINArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterAccountLoginCommandLogin_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Account Login - Login Command: Failure Response"); + + AccountLoginCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterAccountLoginCommandLogin_1_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Account Login - Login Command: Success Response"); + + AccountLoginCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class ApplicationBasicCluster : public TestCommand +{ +public: + ApplicationBasicCluster() : TestCommand("ApplicationBasicCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "ApplicationBasicCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterApplicationBasicCommandChangeStatus_0(); + break; + case 1: + err = TestSendClusterApplicationBasicCommandReadAttribute_1(); + break; + case 2: + err = TestSendClusterApplicationBasicCommandReadAttribute_2(); + break; + case 3: + err = TestSendClusterApplicationBasicCommandReadAttribute_3(); + break; + case 4: + err = TestSendClusterApplicationBasicCommandReadAttribute_4(); + break; + case 5: + err = TestSendClusterApplicationBasicCommandReadAttribute_5(); + break; + case 6: + err = TestSendClusterApplicationBasicCommandReadAttribute_6(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "ApplicationBasicCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 7; + + // + // Tests methods + // + + // Test Change Status Command + typedef void (*SuccessCallback_0)(void * context); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterApplicationBasicCommandChangeStatus_0() + { + ChipLogProgress(chipTool, "Application Basic - Change Status Command: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandChangeStatus_0_FailureResponse, this); + mOnSuccessCallback_0 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandChangeStatus_0_SuccessResponse, this); + + chip::Controller::ApplicationBasicCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint8_t statusArgument = 1; + err = cluster.ChangeStatus(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel(), statusArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterApplicationBasicCommandChangeStatus_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Basic - Change Status Command: Failure Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationBasicCommandChangeStatus_0_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Application Basic - Change Status Command: Success Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Read attribute vendor name + typedef void (*SuccessCallback_1)(void * context, chip::ByteSpan vendorName); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterApplicationBasicCommandReadAttribute_1() + { + ChipLogProgress(chipTool, "Application Basic - Read attribute vendor name: Sending command..."); + + mOnFailureCallback_1 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_1_FailureResponse, this); + mOnSuccessCallback_1 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_1_SuccessResponse, this); + + chip::Controller::ApplicationBasicCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeVendorName(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute vendor name: Failure Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_1_SuccessResponse(void * context, chip::ByteSpan vendorName) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute vendor name: Success Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Read attribute vendor id + typedef void (*SuccessCallback_2)(void * context, uint16_t vendorId); + chip::Callback::Callback * mOnSuccessCallback_2 = nullptr; + chip::Callback::Callback * mOnFailureCallback_2 = nullptr; + bool mIsFailureExpected_2 = 0; + + CHIP_ERROR TestSendClusterApplicationBasicCommandReadAttribute_2() + { + ChipLogProgress(chipTool, "Application Basic - Read attribute vendor id: Sending command..."); + + mOnFailureCallback_2 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_2_FailureResponse, this); + mOnSuccessCallback_2 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_2_SuccessResponse, this); + + chip::Controller::ApplicationBasicCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeVendorId(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_2; + delete mOnSuccessCallback_2; + } + + return err; + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_2_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute vendor id: Failure Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_2_SuccessResponse(void * context, uint16_t vendorId) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute vendor id: Success Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (vendorId != 1U) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Read attribute name + typedef void (*SuccessCallback_3)(void * context, chip::ByteSpan applicationName); + chip::Callback::Callback * mOnSuccessCallback_3 = nullptr; + chip::Callback::Callback * mOnFailureCallback_3 = nullptr; + bool mIsFailureExpected_3 = 0; + + CHIP_ERROR TestSendClusterApplicationBasicCommandReadAttribute_3() + { + ChipLogProgress(chipTool, "Application Basic - Read attribute name: Sending command..."); + + mOnFailureCallback_3 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_3_FailureResponse, this); + mOnSuccessCallback_3 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_3_SuccessResponse, this); + + chip::Controller::ApplicationBasicCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeApplicationName(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_3; + delete mOnSuccessCallback_3; + } + + return err; + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_3_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute name: Failure Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_3; + delete runner->mOnSuccessCallback_3; + + if (runner->mIsFailureExpected_3 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_3_SuccessResponse(void * context, + chip::ByteSpan applicationName) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute name: Success Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_3; + delete runner->mOnSuccessCallback_3; + + if (runner->mIsFailureExpected_3 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Read attribute product id + typedef void (*SuccessCallback_4)(void * context, uint16_t productId); + chip::Callback::Callback * mOnSuccessCallback_4 = nullptr; + chip::Callback::Callback * mOnFailureCallback_4 = nullptr; + bool mIsFailureExpected_4 = 0; + + CHIP_ERROR TestSendClusterApplicationBasicCommandReadAttribute_4() + { + ChipLogProgress(chipTool, "Application Basic - Read attribute product id: Sending command..."); + + mOnFailureCallback_4 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_4_FailureResponse, this); + mOnSuccessCallback_4 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_4_SuccessResponse, this); + + chip::Controller::ApplicationBasicCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeProductId(mOnSuccessCallback_4->Cancel(), mOnFailureCallback_4->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_4; + delete mOnSuccessCallback_4; + } + + return err; + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_4_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute product id: Failure Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_4; + delete runner->mOnSuccessCallback_4; + + if (runner->mIsFailureExpected_4 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_4_SuccessResponse(void * context, uint16_t productId) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute product id: Success Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_4; + delete runner->mOnSuccessCallback_4; + + if (runner->mIsFailureExpected_4 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (productId != 1U) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Read attribute id + typedef void (*SuccessCallback_5)(void * context, chip::ByteSpan applicationId); + chip::Callback::Callback * mOnSuccessCallback_5 = nullptr; + chip::Callback::Callback * mOnFailureCallback_5 = nullptr; + bool mIsFailureExpected_5 = 0; + + CHIP_ERROR TestSendClusterApplicationBasicCommandReadAttribute_5() + { + ChipLogProgress(chipTool, "Application Basic - Read attribute id: Sending command..."); + + mOnFailureCallback_5 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_5_FailureResponse, this); + mOnSuccessCallback_5 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_5_SuccessResponse, this); + + chip::Controller::ApplicationBasicCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeApplicationId(mOnSuccessCallback_5->Cancel(), mOnFailureCallback_5->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_5; + delete mOnSuccessCallback_5; + } + + return err; + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_5_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute id: Failure Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_5; + delete runner->mOnSuccessCallback_5; + + if (runner->mIsFailureExpected_5 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_5_SuccessResponse(void * context, + chip::ByteSpan applicationId) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute id: Success Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_5; + delete runner->mOnSuccessCallback_5; + + if (runner->mIsFailureExpected_5 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Read attribute catalog vendor id + typedef void (*SuccessCallback_6)(void * context, uint16_t catalogVendorId); + chip::Callback::Callback * mOnSuccessCallback_6 = nullptr; + chip::Callback::Callback * mOnFailureCallback_6 = nullptr; + bool mIsFailureExpected_6 = 0; + + CHIP_ERROR TestSendClusterApplicationBasicCommandReadAttribute_6() + { + ChipLogProgress(chipTool, "Application Basic - Read attribute catalog vendor id: Sending command..."); + + mOnFailureCallback_6 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_6_FailureResponse, this); + mOnSuccessCallback_6 = new chip::Callback::Callback( + OnTestSendClusterApplicationBasicCommandReadAttribute_6_SuccessResponse, this); + + chip::Controller::ApplicationBasicCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeCatalogVendorId(mOnSuccessCallback_6->Cancel(), mOnFailureCallback_6->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_6; + delete mOnSuccessCallback_6; + } + + return err; + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_6_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute catalog vendor id: Failure Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_6; + delete runner->mOnSuccessCallback_6; + + if (runner->mIsFailureExpected_6 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterApplicationBasicCommandReadAttribute_6_SuccessResponse(void * context, uint16_t catalogVendorId) + { + ChipLogProgress(chipTool, "Application Basic - Read attribute catalog vendor id: Success Response"); + + ApplicationBasicCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_6; + delete runner->mOnSuccessCallback_6; + + if (runner->mIsFailureExpected_6 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (catalogVendorId != 1U) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class MediaPlaybackCluster : public TestCommand +{ +public: + MediaPlaybackCluster() : TestCommand("MediaPlaybackCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "MediaPlaybackCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterMediaPlaybackCommandMediaPlay_0(); + break; + case 1: + err = TestSendClusterMediaPlaybackCommandMediaPause_1(); + break; + case 2: + err = TestSendClusterMediaPlaybackCommandMediaStop_2(); + break; + case 3: + err = TestSendClusterMediaPlaybackCommandMediaStartOver_3(); + break; + case 4: + err = TestSendClusterMediaPlaybackCommandMediaPrevious_4(); + break; + case 5: + err = TestSendClusterMediaPlaybackCommandMediaNext_5(); + break; + case 6: + err = TestSendClusterMediaPlaybackCommandMediaRewind_6(); + break; + case 7: + err = TestSendClusterMediaPlaybackCommandMediaFastForward_7(); + break; + case 8: + err = TestSendClusterMediaPlaybackCommandMediaSkipForward_8(); + break; + case 9: + err = TestSendClusterMediaPlaybackCommandMediaSkipBackward_9(); + break; + case 10: + err = TestSendClusterMediaPlaybackCommandMediaSkipSeek_10(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "MediaPlaybackCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 11; + + // + // Tests methods + // + + // Test Media Playback Play Command + typedef void (*SuccessCallback_0)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaPlay_0() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Play Command: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaPlay_0_FailureResponse, this); + mOnSuccessCallback_0 = + new chip::Callback::Callback(OnTestSendClusterMediaPlaybackCommandMediaPlay_0_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaPlay(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaPlay_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Play Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaPlay_0_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Play Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Pause Command + typedef void (*SuccessCallback_1)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaPause_1() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Pause Command: Sending command..."); + + mOnFailureCallback_1 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaPause_1_FailureResponse, this); + mOnSuccessCallback_1 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaPause_1_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaPause(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaPause_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Pause Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaPause_1_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Pause Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Stop Command + typedef void (*SuccessCallback_2)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_2 = nullptr; + chip::Callback::Callback * mOnFailureCallback_2 = nullptr; + bool mIsFailureExpected_2 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaStop_2() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Stop Command: Sending command..."); + + mOnFailureCallback_2 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaStop_2_FailureResponse, this); + mOnSuccessCallback_2 = + new chip::Callback::Callback(OnTestSendClusterMediaPlaybackCommandMediaStop_2_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaStop(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_2; + delete mOnSuccessCallback_2; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaStop_2_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Stop Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaStop_2_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Stop Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Start Over Command + typedef void (*SuccessCallback_3)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_3 = nullptr; + chip::Callback::Callback * mOnFailureCallback_3 = nullptr; + bool mIsFailureExpected_3 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaStartOver_3() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Start Over Command: Sending command..."); + + mOnFailureCallback_3 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaStartOver_3_FailureResponse, this); + mOnSuccessCallback_3 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaStartOver_3_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaStartOver(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_3; + delete mOnSuccessCallback_3; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaStartOver_3_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Start Over Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_3; + delete runner->mOnSuccessCallback_3; + + if (runner->mIsFailureExpected_3 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaStartOver_3_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Start Over Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_3; + delete runner->mOnSuccessCallback_3; + + if (runner->mIsFailureExpected_3 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Previous Command + typedef void (*SuccessCallback_4)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_4 = nullptr; + chip::Callback::Callback * mOnFailureCallback_4 = nullptr; + bool mIsFailureExpected_4 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaPrevious_4() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Previous Command: Sending command..."); + + mOnFailureCallback_4 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaPrevious_4_FailureResponse, this); + mOnSuccessCallback_4 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaPrevious_4_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaPrevious(mOnSuccessCallback_4->Cancel(), mOnFailureCallback_4->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_4; + delete mOnSuccessCallback_4; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaPrevious_4_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Previous Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_4; + delete runner->mOnSuccessCallback_4; + + if (runner->mIsFailureExpected_4 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaPrevious_4_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Previous Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_4; + delete runner->mOnSuccessCallback_4; + + if (runner->mIsFailureExpected_4 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Next Command + typedef void (*SuccessCallback_5)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_5 = nullptr; + chip::Callback::Callback * mOnFailureCallback_5 = nullptr; + bool mIsFailureExpected_5 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaNext_5() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Next Command: Sending command..."); + + mOnFailureCallback_5 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaNext_5_FailureResponse, this); + mOnSuccessCallback_5 = + new chip::Callback::Callback(OnTestSendClusterMediaPlaybackCommandMediaNext_5_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaNext(mOnSuccessCallback_5->Cancel(), mOnFailureCallback_5->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_5; + delete mOnSuccessCallback_5; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaNext_5_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Next Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_5; + delete runner->mOnSuccessCallback_5; + + if (runner->mIsFailureExpected_5 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaNext_5_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Next Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_5; + delete runner->mOnSuccessCallback_5; + + if (runner->mIsFailureExpected_5 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Rewind Command + typedef void (*SuccessCallback_6)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_6 = nullptr; + chip::Callback::Callback * mOnFailureCallback_6 = nullptr; + bool mIsFailureExpected_6 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaRewind_6() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Rewind Command: Sending command..."); + + mOnFailureCallback_6 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaRewind_6_FailureResponse, this); + mOnSuccessCallback_6 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaRewind_6_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaRewind(mOnSuccessCallback_6->Cancel(), mOnFailureCallback_6->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_6; + delete mOnSuccessCallback_6; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaRewind_6_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Rewind Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_6; + delete runner->mOnSuccessCallback_6; + + if (runner->mIsFailureExpected_6 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaRewind_6_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Rewind Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_6; + delete runner->mOnSuccessCallback_6; + + if (runner->mIsFailureExpected_6 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Fast Forward Command + typedef void (*SuccessCallback_7)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_7 = nullptr; + chip::Callback::Callback * mOnFailureCallback_7 = nullptr; + bool mIsFailureExpected_7 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaFastForward_7() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Fast Forward Command: Sending command..."); + + mOnFailureCallback_7 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaFastForward_7_FailureResponse, this); + mOnSuccessCallback_7 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaFastForward_7_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.MediaFastForward(mOnSuccessCallback_7->Cancel(), mOnFailureCallback_7->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_7; + delete mOnSuccessCallback_7; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaFastForward_7_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Fast Forward Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_7; + delete runner->mOnSuccessCallback_7; + + if (runner->mIsFailureExpected_7 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaFastForward_7_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Fast Forward Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_7; + delete runner->mOnSuccessCallback_7; + + if (runner->mIsFailureExpected_7 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Skip Forward Command + typedef void (*SuccessCallback_8)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_8 = nullptr; + chip::Callback::Callback * mOnFailureCallback_8 = nullptr; + bool mIsFailureExpected_8 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaSkipForward_8() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Forward Command: Sending command..."); + + mOnFailureCallback_8 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaSkipForward_8_FailureResponse, this); + mOnSuccessCallback_8 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaSkipForward_8_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint64_t deltaPositionMillisecondsArgument = 100ULL; + err = cluster.MediaSkipForward(mOnSuccessCallback_8->Cancel(), mOnFailureCallback_8->Cancel(), + deltaPositionMillisecondsArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_8; + delete mOnSuccessCallback_8; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaSkipForward_8_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Forward Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_8; + delete runner->mOnSuccessCallback_8; + + if (runner->mIsFailureExpected_8 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaSkipForward_8_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Forward Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_8; + delete runner->mOnSuccessCallback_8; + + if (runner->mIsFailureExpected_8 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Skip Backward Command + typedef void (*SuccessCallback_9)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_9 = nullptr; + chip::Callback::Callback * mOnFailureCallback_9 = nullptr; + bool mIsFailureExpected_9 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaSkipBackward_9() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Backward Command: Sending command..."); + + mOnFailureCallback_9 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaSkipBackward_9_FailureResponse, this); + mOnSuccessCallback_9 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaSkipBackward_9_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint64_t deltaPositionMillisecondsArgument = 100ULL; + err = cluster.MediaSkipBackward(mOnSuccessCallback_9->Cancel(), mOnFailureCallback_9->Cancel(), + deltaPositionMillisecondsArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_9; + delete mOnSuccessCallback_9; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaSkipBackward_9_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Backward Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_9; + delete runner->mOnSuccessCallback_9; + + if (runner->mIsFailureExpected_9 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaSkipBackward_9_SuccessResponse(void * context, + uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Backward Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_9; + delete runner->mOnSuccessCallback_9; + + if (runner->mIsFailureExpected_9 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Media Playback Skip Seek Command + typedef void (*SuccessCallback_10)(void * context, uint8_t mediaPlaybackStatus); + chip::Callback::Callback * mOnSuccessCallback_10 = nullptr; + chip::Callback::Callback * mOnFailureCallback_10 = nullptr; + bool mIsFailureExpected_10 = 0; + + CHIP_ERROR TestSendClusterMediaPlaybackCommandMediaSkipSeek_10() + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Seek Command: Sending command..."); + + mOnFailureCallback_10 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaSkipSeek_10_FailureResponse, this); + mOnSuccessCallback_10 = new chip::Callback::Callback( + OnTestSendClusterMediaPlaybackCommandMediaSkipSeek_10_SuccessResponse, this); + + chip::Controller::MediaPlaybackCluster cluster; + cluster.Associate(mDevice, 3); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint64_t positionArgument = 100ULL; + err = cluster.MediaSkipSeek(mOnSuccessCallback_10->Cancel(), mOnFailureCallback_10->Cancel(), positionArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_10; + delete mOnSuccessCallback_10; + } + + return err; + } + + static void OnTestSendClusterMediaPlaybackCommandMediaSkipSeek_10_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Seek Command: Failure Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_10; + delete runner->mOnSuccessCallback_10; + + if (runner->mIsFailureExpected_10 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaPlaybackCommandMediaSkipSeek_10_SuccessResponse(void * context, uint8_t mediaPlaybackStatus) + { + ChipLogProgress(chipTool, "Media Playback - Media Playback Skip Seek Command: Success Response"); + + MediaPlaybackCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_10; + delete runner->mOnSuccessCallback_10; + + if (runner->mIsFailureExpected_10 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class TvChannelCluster : public TestCommand +{ +public: + TvChannelCluster() : TestCommand("TvChannelCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "TvChannelCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterTvChannelCommandReadAttribute_0(); + break; + case 1: + err = TestSendClusterTvChannelCommandChangeChannelByNumber_1(); + break; + case 2: + err = TestSendClusterTvChannelCommandSkipChannel_2(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "TvChannelCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 3; + + // + // Tests methods + // + + // Test Read attribute TV Channel list + typedef void (*SuccessCallback_0)(void * context, uint16_t count, _TvChannelInfo * tvChannelList); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterTvChannelCommandReadAttribute_0() + { + ChipLogProgress(chipTool, "TV Channel - Read attribute TV Channel list: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterTvChannelCommandReadAttribute_0_FailureResponse, this); + mOnSuccessCallback_0 = + new chip::Callback::Callback(OnTestSendClusterTvChannelCommandReadAttribute_0_SuccessResponse, this); + + chip::Controller::TvChannelCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeTvChannelList(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterTvChannelCommandReadAttribute_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "TV Channel - Read attribute TV Channel list: Failure Response"); + + TvChannelCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterTvChannelCommandReadAttribute_0_SuccessResponse(void * context, uint16_t count, + _TvChannelInfo * tvChannelList) + { + ChipLogProgress(chipTool, "TV Channel - Read attribute TV Channel list: Success Response"); + + TvChannelCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (count != 2) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "[object Object],[object Object]"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Change Channel By Number Command + typedef void (*SuccessCallback_1)(void * context); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterTvChannelCommandChangeChannelByNumber_1() + { + ChipLogProgress(chipTool, "TV Channel - Change Channel By Number Command: Sending command..."); + + mOnFailureCallback_1 = new chip::Callback::Callback( + OnTestSendClusterTvChannelCommandChangeChannelByNumber_1_FailureResponse, this); + mOnSuccessCallback_1 = new chip::Callback::Callback( + OnTestSendClusterTvChannelCommandChangeChannelByNumber_1_SuccessResponse, this); + + chip::Controller::TvChannelCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint16_t majorNumberArgument = 1U; + uint16_t minorNumberArgument = 2U; + err = cluster.ChangeChannelByNumber(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel(), majorNumberArgument, + minorNumberArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterTvChannelCommandChangeChannelByNumber_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "TV Channel - Change Channel By Number Command: Failure Response"); + + TvChannelCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterTvChannelCommandChangeChannelByNumber_1_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "TV Channel - Change Channel By Number Command: Success Response"); + + TvChannelCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Skip Channel Command + typedef void (*SuccessCallback_2)(void * context); + chip::Callback::Callback * mOnSuccessCallback_2 = nullptr; + chip::Callback::Callback * mOnFailureCallback_2 = nullptr; + bool mIsFailureExpected_2 = 0; + + CHIP_ERROR TestSendClusterTvChannelCommandSkipChannel_2() + { + ChipLogProgress(chipTool, "TV Channel - Skip Channel Command: Sending command..."); + + mOnFailureCallback_2 = new chip::Callback::Callback( + OnTestSendClusterTvChannelCommandSkipChannel_2_FailureResponse, this); + mOnSuccessCallback_2 = + new chip::Callback::Callback(OnTestSendClusterTvChannelCommandSkipChannel_2_SuccessResponse, this); + + chip::Controller::TvChannelCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint16_t countArgument = 1U; + err = cluster.SkipChannel(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel(), countArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_2; + delete mOnSuccessCallback_2; + } + + return err; + } + + static void OnTestSendClusterTvChannelCommandSkipChannel_2_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "TV Channel - Skip Channel Command: Failure Response"); + + TvChannelCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterTvChannelCommandSkipChannel_2_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "TV Channel - Skip Channel Command: Success Response"); + + TvChannelCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class LowPowerCluster : public TestCommand +{ +public: + LowPowerCluster() : TestCommand("LowPowerCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "LowPowerCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterLowPowerCommandSleep_0(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "LowPowerCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 1; + + // + // Tests methods + // + + // Test Sleep Input Status Command + typedef void (*SuccessCallback_0)(void * context); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterLowPowerCommandSleep_0() + { + ChipLogProgress(chipTool, "Low Power - Sleep Input Status Command: Sending command..."); + + mOnFailureCallback_0 = + new chip::Callback::Callback(OnTestSendClusterLowPowerCommandSleep_0_FailureResponse, this); + mOnSuccessCallback_0 = + new chip::Callback::Callback(OnTestSendClusterLowPowerCommandSleep_0_SuccessResponse, this); + + chip::Controller::LowPowerCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.Sleep(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterLowPowerCommandSleep_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Low Power - Sleep Input Status Command: Failure Response"); + + LowPowerCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterLowPowerCommandSleep_0_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Low Power - Sleep Input Status Command: Success Response"); + + LowPowerCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + +class MediaInputCluster : public TestCommand +{ +public: + MediaInputCluster() : TestCommand("MediaInputCluster"), mTestIndex(0) {} + + /////////// TestCommand Interface ///////// + void NextTest() override + { + CHIP_ERROR err = CHIP_NO_ERROR; + + if (mTestCount == mTestIndex) + { + ChipLogProgress(chipTool, "MediaInputCluster: Test complete"); + SetCommandExitStatus(CHIP_NO_ERROR); + } + + // Ensure we increment mTestIndex before we start running the relevant + // command. That way if we lose the timeslice after we send the message + // but before our function call returns, we won't end up with an + // incorrect mTestIndex value observed when we get the response. + switch (mTestIndex++) + { + case 0: + err = TestSendClusterMediaInputCommandReadAttribute_0(); + break; + case 1: + err = TestSendClusterMediaInputCommandSelectInput_1(); + break; + case 2: + err = TestSendClusterMediaInputCommandHideInputStatus_2(); + break; + case 3: + err = TestSendClusterMediaInputCommandShowInputStatus_3(); + break; + case 4: + err = TestSendClusterMediaInputCommandRenameInput_4(); + break; + } + + if (CHIP_NO_ERROR != err) + { + ChipLogProgress(chipTool, "MediaInputCluster: %s", chip::ErrorStr(err)); + SetCommandExitStatus(err); + } + } + +private: + std::atomic_uint16_t mTestIndex; + const uint16_t mTestCount = 5; + + // + // Tests methods + // + + // Test Read attribute media input list + typedef void (*SuccessCallback_0)(void * context, uint16_t count, _MediaInputInfo * mediaInputList); + chip::Callback::Callback * mOnSuccessCallback_0 = nullptr; + chip::Callback::Callback * mOnFailureCallback_0 = nullptr; + bool mIsFailureExpected_0 = 0; + + CHIP_ERROR TestSendClusterMediaInputCommandReadAttribute_0() + { + ChipLogProgress(chipTool, "Media Input - Read attribute media input list: Sending command..."); + + mOnFailureCallback_0 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandReadAttribute_0_FailureResponse, this); + mOnSuccessCallback_0 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandReadAttribute_0_SuccessResponse, this); + + chip::Controller::MediaInputCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ReadAttributeMediaInputList(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_0; + delete mOnSuccessCallback_0; + } + + return err; + } + + static void OnTestSendClusterMediaInputCommandReadAttribute_0_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Input - Read attribute media input list: Failure Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaInputCommandReadAttribute_0_SuccessResponse(void * context, uint16_t count, + _MediaInputInfo * mediaInputList) + { + ChipLogProgress(chipTool, "Media Input - Read attribute media input list: Success Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_0; + delete runner->mOnSuccessCallback_0; + + if (runner->mIsFailureExpected_0 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + if (count != 2) + { + ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "[object Object],[object Object]"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Select Input Command + typedef void (*SuccessCallback_1)(void * context); + chip::Callback::Callback * mOnSuccessCallback_1 = nullptr; + chip::Callback::Callback * mOnFailureCallback_1 = nullptr; + bool mIsFailureExpected_1 = 0; + + CHIP_ERROR TestSendClusterMediaInputCommandSelectInput_1() + { + ChipLogProgress(chipTool, "Media Input - Select Input Command: Sending command..."); + + mOnFailureCallback_1 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandSelectInput_1_FailureResponse, this); + mOnSuccessCallback_1 = + new chip::Callback::Callback(OnTestSendClusterMediaInputCommandSelectInput_1_SuccessResponse, this); + + chip::Controller::MediaInputCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint8_t indexArgument = 1; + err = cluster.SelectInput(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel(), indexArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_1; + delete mOnSuccessCallback_1; + } + + return err; + } + + static void OnTestSendClusterMediaInputCommandSelectInput_1_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Input - Select Input Command: Failure Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaInputCommandSelectInput_1_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Media Input - Select Input Command: Success Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_1; + delete runner->mOnSuccessCallback_1; + + if (runner->mIsFailureExpected_1 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Hide Input Status Command + typedef void (*SuccessCallback_2)(void * context); + chip::Callback::Callback * mOnSuccessCallback_2 = nullptr; + chip::Callback::Callback * mOnFailureCallback_2 = nullptr; + bool mIsFailureExpected_2 = 0; + + CHIP_ERROR TestSendClusterMediaInputCommandHideInputStatus_2() + { + ChipLogProgress(chipTool, "Media Input - Hide Input Status Command: Sending command..."); + + mOnFailureCallback_2 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandHideInputStatus_2_FailureResponse, this); + mOnSuccessCallback_2 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandHideInputStatus_2_SuccessResponse, this); + + chip::Controller::MediaInputCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.HideInputStatus(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_2; + delete mOnSuccessCallback_2; + } + + return err; + } + + static void OnTestSendClusterMediaInputCommandHideInputStatus_2_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Input - Hide Input Status Command: Failure Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaInputCommandHideInputStatus_2_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Media Input - Hide Input Status Command: Success Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_2; + delete runner->mOnSuccessCallback_2; + + if (runner->mIsFailureExpected_2 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Show Input Status Command + typedef void (*SuccessCallback_3)(void * context); + chip::Callback::Callback * mOnSuccessCallback_3 = nullptr; + chip::Callback::Callback * mOnFailureCallback_3 = nullptr; + bool mIsFailureExpected_3 = 0; + + CHIP_ERROR TestSendClusterMediaInputCommandShowInputStatus_3() + { + ChipLogProgress(chipTool, "Media Input - Show Input Status Command: Sending command..."); + + mOnFailureCallback_3 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandShowInputStatus_3_FailureResponse, this); + mOnSuccessCallback_3 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandShowInputStatus_3_SuccessResponse, this); + + chip::Controller::MediaInputCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + err = cluster.ShowInputStatus(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel()); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_3; + delete mOnSuccessCallback_3; + } + + return err; + } + + static void OnTestSendClusterMediaInputCommandShowInputStatus_3_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Input - Show Input Status Command: Failure Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_3; + delete runner->mOnSuccessCallback_3; + + if (runner->mIsFailureExpected_3 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaInputCommandShowInputStatus_3_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Media Input - Show Input Status Command: Success Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_3; + delete runner->mOnSuccessCallback_3; + + if (runner->mIsFailureExpected_3 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + // Test Rename Input Command + typedef void (*SuccessCallback_4)(void * context); + chip::Callback::Callback * mOnSuccessCallback_4 = nullptr; + chip::Callback::Callback * mOnFailureCallback_4 = nullptr; + bool mIsFailureExpected_4 = 0; + + CHIP_ERROR TestSendClusterMediaInputCommandRenameInput_4() + { + ChipLogProgress(chipTool, "Media Input - Rename Input Command: Sending command..."); + + mOnFailureCallback_4 = new chip::Callback::Callback( + OnTestSendClusterMediaInputCommandRenameInput_4_FailureResponse, this); + mOnSuccessCallback_4 = + new chip::Callback::Callback(OnTestSendClusterMediaInputCommandRenameInput_4_SuccessResponse, this); + + chip::Controller::MediaInputCluster cluster; + cluster.Associate(mDevice, 1); + + CHIP_ERROR err = CHIP_NO_ERROR; + + uint8_t indexArgument = 1; + chip::ByteSpan nameArgument = chip::ByteSpan(chip::Uint8::from_const_char("newName"), strlen("newName")); + err = cluster.RenameInput(mOnSuccessCallback_4->Cancel(), mOnFailureCallback_4->Cancel(), indexArgument, nameArgument); + + if (CHIP_NO_ERROR != err) + { + delete mOnFailureCallback_4; + delete mOnSuccessCallback_4; + } + + return err; + } + + static void OnTestSendClusterMediaInputCommandRenameInput_4_FailureResponse(void * context, uint8_t status) + { + ChipLogProgress(chipTool, "Media Input - Rename Input Command: Failure Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_4; + delete runner->mOnSuccessCallback_4; + + if (runner->mIsFailureExpected_4 == false) + { + ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } + + static void OnTestSendClusterMediaInputCommandRenameInput_4_SuccessResponse(void * context) + { + ChipLogProgress(chipTool, "Media Input - Rename Input Command: Success Response"); + + MediaInputCluster * runner = reinterpret_cast(context); + + delete runner->mOnFailureCallback_4; + delete runner->mOnSuccessCallback_4; + + if (runner->mIsFailureExpected_4 == true) + { + ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback"); + runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL); + return; + } + + runner->NextTest(); + } +}; + class TestCluster : public TestCommand { public: @@ -11791,8 +14949,21 @@ void registerCommandsTests(Commands & commands) const char * clusterName = "Tests"; commands_list clusterCommands = { - make_unique(), make_unique(), make_unique(), - make_unique(), make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), + make_unique(), }; commands.Register(clusterName, clusterCommands); diff --git a/examples/tv-app/linux/include/application-launcher/ApplicationLauncherManager.cpp b/examples/tv-app/linux/include/application-launcher/ApplicationLauncherManager.cpp index 1cbb2b207747a2..de0d283646f234 100644 --- a/examples/tv-app/linux/include/application-launcher/ApplicationLauncherManager.cpp +++ b/examples/tv-app/linux/include/application-launcher/ApplicationLauncherManager.cpp @@ -57,4 +57,4 @@ EmberAfApplicationLauncherResponse applicationLauncherClusterLaunchApp(EmberAfAp // (uint8_t *) &application, ZCL_STRUCT_ATTRIBUTE_TYPE); return response; -} \ No newline at end of file +} diff --git a/examples/tv-app/linux/include/keypad-input/KeypadInputManager.cpp b/examples/tv-app/linux/include/keypad-input/KeypadInputManager.cpp index 75fb774e4c7d19..7bd49fc94071da 100644 --- a/examples/tv-app/linux/include/keypad-input/KeypadInputManager.cpp +++ b/examples/tv-app/linux/include/keypad-input/KeypadInputManager.cpp @@ -50,4 +50,4 @@ EmberAfKeypadInputStatus keypadInputClusterSendKey(EmberAfKeypadInputCecKeyCode { // TODO: Insert code here return EMBER_ZCL_KEYPAD_INPUT_STATUS_SUCCESS; -} \ No newline at end of file +} diff --git a/examples/tv-app/linux/include/media-input/MediaInputManager.cpp b/examples/tv-app/linux/include/media-input/MediaInputManager.cpp index fe06853007ae83..48542edaaa5070 100644 --- a/examples/tv-app/linux/include/media-input/MediaInputManager.cpp +++ b/examples/tv-app/linux/include/media-input/MediaInputManager.cpp @@ -78,4 +78,4 @@ bool mediaInputClusterRenameInput(uint8_t input, std::string name) { // TODO: Insert code here return true; -} \ No newline at end of file +} diff --git a/examples/tv-app/linux/include/media-playback/MediaPlaybackManager.cpp b/examples/tv-app/linux/include/media-playback/MediaPlaybackManager.cpp index b608605ff070b0..ef292ef66ae8e6 100644 --- a/examples/tv-app/linux/include/media-playback/MediaPlaybackManager.cpp +++ b/examples/tv-app/linux/include/media-playback/MediaPlaybackManager.cpp @@ -76,4 +76,4 @@ EmberAfMediaPlaybackStatus mediaPlaybackClusterSendMediaPlaybackRequest(EmberAfM uint64_t deltaPositionMilliseconds) { return MediaPlaybackManager().proxyMediaPlaybackRequest(mediaPlaybackRequest, deltaPositionMilliseconds); -} \ No newline at end of file +} diff --git a/examples/tv-app/linux/include/target-navigator/TargetNavigatorManager.cpp b/examples/tv-app/linux/include/target-navigator/TargetNavigatorManager.cpp index c310377cf93180..7eb75b47ad1efb 100644 --- a/examples/tv-app/linux/include/target-navigator/TargetNavigatorManager.cpp +++ b/examples/tv-app/linux/include/target-navigator/TargetNavigatorManager.cpp @@ -66,4 +66,4 @@ EmberAfTargetNavigatorResponse targetNavigatorClusterNavigateTarget(uint8_t targ response.data = (uint8_t *) testData; response.status = EMBER_ZCL_APPLICATION_LAUNCHER_STATUS_SUCCESS; return response; -} \ No newline at end of file +} diff --git a/src/app/clusters/account-login-server/account-login-server.cpp b/src/app/clusters/account-login-server/account-login-server.cpp index c9ba6127ba6a69..1ac4f2ef3075c2 100644 --- a/src/app/clusters/account-login-server/account-login-server.cpp +++ b/src/app/clusters/account-login-server/account-login-server.cpp @@ -86,4 +86,4 @@ bool emberAfAccountLoginClusterLoginCallback(chip::app::Command * command, unsig } emberAfSendImmediateDefaultResponse(status); return true; -} \ No newline at end of file +} diff --git a/src/app/clusters/media-playback-server/media-playback-server.cpp b/src/app/clusters/media-playback-server/media-playback-server.cpp index 6f7f20a2aa1e85..d7821426f7abe3 100644 --- a/src/app/clusters/media-playback-server/media-playback-server.cpp +++ b/src/app/clusters/media-playback-server/media-playback-server.cpp @@ -178,7 +178,7 @@ bool emberAfMediaPlaybackClusterMediaSkipSeekCallback(chip::app::Command * comma { EmberAfMediaPlaybackStatus status = mediaPlaybackClusterSendMediaPlaybackRequest(EMBER_ZCL_MEDIA_PLAYBACK_REQUEST_SEEK, positionMilliseconds); - sendResponse(command, "MediaSeek", ZCL_MEDIA_SKIP_FORWARD_RESPONSE_COMMAND_ID, status); + sendResponse(command, "MediaSeek", ZCL_MEDIA_SKIP_SEEK_RESPONSE_COMMAND_ID, status); return true; } diff --git a/src/app/clusters/target-navigator-server/target-navigator-server.cpp b/src/app/clusters/target-navigator-server/target-navigator-server.cpp index 2be803b1b54666..56fd4755e4cc3c 100644 --- a/src/app/clusters/target-navigator-server/target-navigator-server.cpp +++ b/src/app/clusters/target-navigator-server/target-navigator-server.cpp @@ -72,4 +72,4 @@ bool emberAfTargetNavigatorClusterNavigateTargetCallback(chip::app::Command * co EmberAfTargetNavigatorResponse response = targetNavigatorClusterNavigateTarget(target, dataString); sendResponse(command, response); return true; -} \ No newline at end of file +} diff --git a/src/app/tests/suites/AccountLoginCluster.yaml b/src/app/tests/suites/AccountLoginCluster.yaml index 9e1b855ac678df..06bc8224ad437e 100644 --- a/src/app/tests/suites/AccountLoginCluster.yaml +++ b/src/app/tests/suites/AccountLoginCluster.yaml @@ -25,7 +25,7 @@ tests: values: - name: "tempAccountIdentifier" value: "asdf" - + - label: "Login Command" command: "Login" arguments: @@ -33,4 +33,4 @@ tests: - name: "tempAccountIdentifier" value: "asdf" - name: "setupPIN" - value: "tempPin123" \ No newline at end of file + value: "tempPin123" diff --git a/src/app/tests/suites/ApplicationBasicCluster.yaml b/src/app/tests/suites/ApplicationBasicCluster.yaml index 9716d1ef3add9a..12eecf629fb38a 100644 --- a/src/app/tests/suites/ApplicationBasicCluster.yaml +++ b/src/app/tests/suites/ApplicationBasicCluster.yaml @@ -29,10 +29,10 @@ tests: - label: "Read attribute vendor name" command: "readAttribute" attribute: "vendor name" + # TODO: Support chars validation # response: # value: "exampleVendorName1" - - label: "Read attribute vendor id" command: "readAttribute" attribute: "vendor id" @@ -42,10 +42,10 @@ tests: - label: "Read attribute name" command: "readAttribute" attribute: "application name" + # TODO: Support chars validation # response: # value: "exampleName1" - - label: "Read attribute product id" command: "readAttribute" attribute: "product id" @@ -55,12 +55,12 @@ tests: - label: "Read attribute id" command: "readAttribute" attribute: "application id" + # TODO: Support chars validation # response: # value: "appId" - - label: "Read attribute catalog vendor id" command: "readAttribute" attribute: "catalog vendor id" response: - value: 1 \ No newline at end of file + value: 1 diff --git a/src/app/tests/suites/ApplicationLauncherCluster.yaml b/src/app/tests/suites/ApplicationLauncherCluster.yaml index a2d9bece61328b..545623bd82dfa8 100644 --- a/src/app/tests/suites/ApplicationLauncherCluster.yaml +++ b/src/app/tests/suites/ApplicationLauncherCluster.yaml @@ -34,4 +34,4 @@ tests: - name: "catalogVendorId" value: 1 - name: "applicationId" - value: "appId" \ No newline at end of file + value: "appId" diff --git a/src/app/tests/suites/AudioOutputCluster.yaml b/src/app/tests/suites/AudioOutputCluster.yaml index c54dbcf27bd278..f6116a67fa399f 100644 --- a/src/app/tests/suites/AudioOutputCluster.yaml +++ b/src/app/tests/suites/AudioOutputCluster.yaml @@ -36,7 +36,7 @@ tests: values: - name: "index" value: 1 - + - label: "Rename Output Command" command: "RenameOutput" arguments: @@ -44,4 +44,4 @@ tests: - name: "index" value: 1 - name: "name" - value: "exampleName" \ No newline at end of file + value: "exampleName" diff --git a/src/app/tests/suites/KeypadInputCluster.yaml b/src/app/tests/suites/KeypadInputCluster.yaml index e9d418f8352f71..bddf3002db8819 100644 --- a/src/app/tests/suites/KeypadInputCluster.yaml +++ b/src/app/tests/suites/KeypadInputCluster.yaml @@ -24,4 +24,4 @@ tests: arguments: values: - name: "keyCode" - value: 3 \ No newline at end of file + value: 3 diff --git a/src/app/tests/suites/LowPowerCluster.yaml b/src/app/tests/suites/LowPowerCluster.yaml index 16456f448b613d..a100c7293cfea4 100644 --- a/src/app/tests/suites/LowPowerCluster.yaml +++ b/src/app/tests/suites/LowPowerCluster.yaml @@ -19,6 +19,5 @@ config: endpoint: 1 tests: - - label: "Sleep Input Status Command" - command: "Sleep" \ No newline at end of file + command: "Sleep" diff --git a/src/app/tests/suites/MediaInputCluster.yaml b/src/app/tests/suites/MediaInputCluster.yaml index fa7f92c6e6fc34..8f26fb10311501 100644 --- a/src/app/tests/suites/MediaInputCluster.yaml +++ b/src/app/tests/suites/MediaInputCluster.yaml @@ -41,7 +41,7 @@ tests: - label: "Show Input Status Command" command: "ShowInputStatus" - + - label: "Rename Input Command" command: "RenameInput" arguments: @@ -49,4 +49,4 @@ tests: - name: "index" value: 1 - name: "name" - value: "newName" \ No newline at end of file + value: "newName" diff --git a/src/app/tests/suites/MediaPlaybackCluster.yaml b/src/app/tests/suites/MediaPlaybackCluster.yaml index 66b3e535172d5a..b22a04cff09f5b 100644 --- a/src/app/tests/suites/MediaPlaybackCluster.yaml +++ b/src/app/tests/suites/MediaPlaybackCluster.yaml @@ -19,7 +19,6 @@ config: endpoint: 3 tests: - - label: "Media Playback Play Command" command: "MediaPlay" @@ -31,36 +30,36 @@ tests: - label: "Media Playback Start Over Command" command: "MediaStartOver" - + - label: "Media Playback Previous Command" command: "MediaPrevious" - label: "Media Playback Next Command" command: "MediaNext" - + - label: "Media Playback Rewind Command" command: "MediaRewind" - + - label: "Media Playback Fast Forward Command" command: "MediaFastForward" - + - label: "Media Playback Skip Forward Command" command: "MediaSkipForward" arguments: values: - name: "deltaPositionMilliseconds" value: 100 - + - label: "Media Playback Skip Backward Command" command: "MediaSkipBackward" arguments: values: - name: "deltaPositionMilliseconds" value: 100 - + - label: "Media Playback Skip Seek Command" command: "MediaSkipSeek" arguments: values: - name: "position" - value: 100 \ No newline at end of file + value: 100 diff --git a/src/app/tests/suites/TargetNavigatorCluster.yaml b/src/app/tests/suites/TargetNavigatorCluster.yaml index 6494e38bcf1b21..807f3e8010270d 100644 --- a/src/app/tests/suites/TargetNavigatorCluster.yaml +++ b/src/app/tests/suites/TargetNavigatorCluster.yaml @@ -23,11 +23,7 @@ tests: command: "readAttribute" attribute: "Target Navigator List" response: - value: - [ - { identifier: 1, name: 12 }, - { identifier: 2, name: 12 }, - ] + value: [{ identifier: 1, name: 12 }, { identifier: 2, name: 12 }] - label: "Navigate Target Command" command: "NavigateTarget" @@ -36,4 +32,4 @@ tests: - name: "target" value: 1 - name: "data" - value: 1 \ No newline at end of file + value: 1 diff --git a/src/app/tests/suites/TvChannelCluster.yaml b/src/app/tests/suites/TvChannelCluster.yaml index a6576750baed84..31d92d203696c0 100644 --- a/src/app/tests/suites/TvChannelCluster.yaml +++ b/src/app/tests/suites/TvChannelCluster.yaml @@ -25,8 +25,20 @@ tests: response: value: [ - { majorNumber: 1, minorNumber: 2, name: 12, callSign: 13, affiliateCallSign: 13 }, - { majorNumber: 2, minorNumber: 3, name: 12, callSign: 13, affiliateCallSign: 13 }, + { + majorNumber: 1, + minorNumber: 2, + name: 12, + callSign: 13, + affiliateCallSign: 13, + }, + { + majorNumber: 2, + minorNumber: 3, + name: 12, + callSign: 13, + affiliateCallSign: 13, + }, ] # TODO: Enable the test once struct response is supported # - label: "Change Channel Command" @@ -35,7 +47,7 @@ tests: # values: # - name: "match" # value: "CNN" - + - label: "Change Channel By Number Command" command: "ChangeChannelByNumber" arguments: @@ -50,4 +62,4 @@ tests: arguments: values: - name: "count" - value: 1 \ No newline at end of file + value: 1 diff --git a/src/controller/data_model/gen/CHIPClusters.cpp b/src/controller/data_model/gen/CHIPClusters.cpp index 95df537bddf817..ba0feaff2b93e9 100644 --- a/src/controller/data_model/gen/CHIPClusters.cpp +++ b/src/controller/data_model/gen/CHIPClusters.cpp @@ -258,8 +258,8 @@ CHIP_ERROR ApplicationBasicCluster::ReadAttributeCatalogVendorId(Callback::Cance BasicAttributeFilter); } -CHIP_ERROR ApplicationBasicCluster::ReadAttributeApplicationSatus(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback) +CHIP_ERROR ApplicationBasicCluster::ReadAttributeApplicationStatus(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) { chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; diff --git a/src/controller/data_model/gen/CHIPClusters.h b/src/controller/data_model/gen/CHIPClusters.h index 64ede9e12396b8..e5d578c03da691 100644 --- a/src/controller/data_model/gen/CHIPClusters.h +++ b/src/controller/data_model/gen/CHIPClusters.h @@ -112,7 +112,7 @@ class DLL_EXPORT ApplicationBasicCluster : public ClusterBase CHIP_ERROR ReadAttributeProductId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeApplicationId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCatalogVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeApplicationSatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeApplicationStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); private: diff --git a/src/controller/data_model/gen/chip-zcl-zpro-codec-api.h b/src/controller/data_model/gen/chip-zcl-zpro-codec-api.h index c7e8d2ac5c5665..81eebc4b4ac26e 100644 --- a/src/controller/data_model/gen/chip-zcl-zpro-codec-api.h +++ b/src/controller/data_model/gen/chip-zcl-zpro-codec-api.h @@ -113,7 +113,7 @@ chip::System::PacketBufferHandle encodeAccountLoginClusterReadClusterRevisionAtt | * ProductId | 0x0003 | | * ApplicationId | 0x0005 | | * CatalogVendorId | 0x0006 | -| * ApplicationSatus | 0x0007 | +| * ApplicationStatus | 0x0007 | | * ClusterRevision | 0xFFFD | \*----------------------------------------------------------------------------*/ @@ -168,10 +168,10 @@ chip::System::PacketBufferHandle encodeApplicationBasicClusterReadCatalogVendorI /** * @brief - * Encode a Application Basic server read command for the application satus attribute into buffer including the APS frame + * Encode a Application Basic server read command for the application status attribute into buffer including the APS frame */ -chip::System::PacketBufferHandle encodeApplicationBasicClusterReadApplicationSatusAttribute(uint8_t seqNum, - chip::EndpointId destinationEndpoint); +chip::System::PacketBufferHandle encodeApplicationBasicClusterReadApplicationStatusAttribute(uint8_t seqNum, + chip::EndpointId destinationEndpoint); /** * @brief diff --git a/src/controller/data_model/gen/encoder.cpp b/src/controller/data_model/gen/encoder.cpp index d7af6e385672df..85fa10d1f91072 100644 --- a/src/controller/data_model/gen/encoder.cpp +++ b/src/controller/data_model/gen/encoder.cpp @@ -413,7 +413,7 @@ PacketBufferHandle encodeAccountLoginClusterReadClusterRevisionAttribute(uint8_t | * ProductId | 0x0003 | | * ApplicationId | 0x0005 | | * CatalogVendorId | 0x0006 | -| * ApplicationSatus | 0x0007 | +| * ApplicationStatus | 0x0007 | | * ClusterRevision | 0xFFFD | \*----------------------------------------------------------------------------*/ @@ -485,11 +485,11 @@ PacketBufferHandle encodeApplicationBasicClusterReadCatalogVendorIdAttribute(uin } /* - * Attribute ApplicationSatus + * Attribute ApplicationStatus */ -PacketBufferHandle encodeApplicationBasicClusterReadApplicationSatusAttribute(uint8_t seqNum, EndpointId destinationEndpoint) +PacketBufferHandle encodeApplicationBasicClusterReadApplicationStatusAttribute(uint8_t seqNum, EndpointId destinationEndpoint) { - COMMAND_HEADER("ReadApplicationBasicApplicationSatus", APPLICATION_BASIC_CLUSTER_ID); + COMMAND_HEADER("ReadApplicationBasicApplicationStatus", APPLICATION_BASIC_CLUSTER_ID); buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0007); COMMAND_FOOTER(); } diff --git a/src/controller/python/chip/clusters/CHIPClusters.cpp b/src/controller/python/chip/clusters/CHIPClusters.cpp index 9f82670db71fcf..9be9b9edf8b3f4 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.cpp +++ b/src/controller/python/chip/clusters/CHIPClusters.cpp @@ -432,13 +432,13 @@ CHIP_ERROR chip_ime_ReadAttribute_ApplicationBasic_CatalogVendorId(chip::Control return cluster.ReadAttributeCatalogVendorId(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()); } -CHIP_ERROR chip_ime_ReadAttribute_ApplicationBasic_ApplicationSatus(chip::Controller::Device * device, - chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */) +CHIP_ERROR chip_ime_ReadAttribute_ApplicationBasic_ApplicationStatus(chip::Controller::Device * device, + chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT); chip::Controller::ApplicationBasicCluster cluster; cluster.Associate(device, ZCLendpointId); - return cluster.ReadAttributeApplicationSatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()); + return cluster.ReadAttributeApplicationStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()); } CHIP_ERROR chip_ime_ReadAttribute_ApplicationBasic_ClusterRevision(chip::Controller::Device * device, diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index ca221829f40a51..92e4f29ea702c8 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -716,7 +716,7 @@ def ListClusterAttributes(self): "attributeId": 0x0006, "type": "int", }, - "ApplicationSatus": { + "ApplicationStatus": { "attributeId": 0x0007, "type": "int", }, @@ -2747,8 +2747,8 @@ def ClusterApplicationBasic_ReadAttributeApplicationId(self, device: ctypes.c_vo return self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ApplicationId(device, ZCLendpoint, ZCLgroupid) def ClusterApplicationBasic_ReadAttributeCatalogVendorId(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_CatalogVendorId(device, ZCLendpoint, ZCLgroupid) - def ClusterApplicationBasic_ReadAttributeApplicationSatus(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): - return self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ApplicationSatus(device, ZCLendpoint, ZCLgroupid) + def ClusterApplicationBasic_ReadAttributeApplicationStatus(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): + return self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ApplicationStatus(device, ZCLendpoint, ZCLgroupid) def ClusterApplicationBasic_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterApplicationLauncher_ReadAttributeApplicationLauncherList(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -3554,9 +3554,9 @@ def InitLib(self, chipLib): # Cluster ApplicationBasic ReadAttribute CatalogVendorId self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_CatalogVendorId.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_CatalogVendorId.restype = ctypes.c_uint32 - # Cluster ApplicationBasic ReadAttribute ApplicationSatus - self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ApplicationSatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] - self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ApplicationSatus.restype = ctypes.c_uint32 + # Cluster ApplicationBasic ReadAttribute ApplicationStatus + self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ApplicationStatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] + self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ApplicationStatus.restype = ctypes.c_uint32 # Cluster ApplicationBasic ReadAttribute ClusterRevision self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ClusterRevision.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ApplicationBasic_ClusterRevision.restype = ctypes.c_uint32 diff --git a/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.h index 58d22671ebfe42..e071d79637949c 100644 --- a/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.h +++ b/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.h @@ -69,7 +69,7 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeProductIdWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeApplicationIdWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCatalogVendorIdWithResponseHandler:(ResponseHandler)responseHandler; -- (void)readAttributeApplicationSatusWithResponseHandler:(ResponseHandler)responseHandler; +- (void)readAttributeApplicationStatusWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler; @end diff --git a/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.mm index 9e9470a362cb52..3e70977834fcf5 100644 --- a/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.mm +++ b/src/darwin/Framework/CHIP/gen/CHIPClustersObjc.mm @@ -3935,7 +3935,7 @@ - (void)readAttributeCatalogVendorIdWithResponseHandler:(ResponseHandler)respons } } -- (void)readAttributeApplicationSatusWithResponseHandler:(ResponseHandler)responseHandler +- (void)readAttributeApplicationStatusWithResponseHandler:(ResponseHandler)responseHandler { CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(responseHandler, [self callbackQueue]); if (!onSuccess) { @@ -3952,7 +3952,7 @@ - (void)readAttributeApplicationSatusWithResponseHandler:(ResponseHandler)respon __block CHIP_ERROR err; dispatch_sync([self chipWorkQueue], ^{ - err = self.cppCluster.ReadAttributeApplicationSatus(onSuccess->Cancel(), onFailure->Cancel()); + err = self.cppCluster.ReadAttributeApplicationStatus(onSuccess->Cancel(), onFailure->Cancel()); }); if (err != CHIP_NO_ERROR) { diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 4ac59b6403c8c9..d5b7b02c2ef3d5 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -3072,18 +3072,18 @@ - (void)testSendClusterApplicationBasicReadAttributeCatalogVendorIdWithResponseH [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterApplicationBasicReadAttributeApplicationSatusWithResponseHandler +- (void)testSendClusterApplicationBasicReadAttributeApplicationStatusWithResponseHandler { XCTestExpectation * expectation = - [self expectationWithDescription:@"ApplicationBasicReadAttributeApplicationSatusWithResponseHandler"]; + [self expectationWithDescription:@"ApplicationBasicReadAttributeApplicationStatusWithResponseHandler"]; CHIPDevice * device = GetPairedDevice(kDeviceId); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPApplicationBasic * cluster = [[CHIPApplicationBasic alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeApplicationSatusWithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"ApplicationBasic ApplicationSatus Error: %@", err); + [cluster readAttributeApplicationStatusWithResponseHandler:^(NSError * err, NSDictionary * values) { + NSLog(@"ApplicationBasic ApplicationStatus Error: %@", err); XCTAssertEqual(err.code, 0); [expectation fulfill]; }];