text: /*
   *
   *    Copyright (c) 2021 Project CHIP Authors
   *
   *    Licensed under the Apache License, Version 2.0 (the "License");
   *    you may not use this file except in compliance with the License.
   *    You may obtain a copy of the License at
   *
   *        http://www.apache.org/licenses/LICENSE-2.0
   *
   *    Unless required by applicable law or agreed to in writing, software
   *    distributed under the License is distributed on an "AS IS" BASIS,
   *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *    See the License for the specific language governing permissions and
   *    limitations under the License.
   */
  
  // THIS FILE IS GENERATED BY ZAP
  
  #pragma once
  
  #include "TestCommand.h"
  
  class TestCluster : public TestCommand
  {
  public:
      TestCluster() : TestCommand("TestCluster"), mTestIndex(0) {}
  
      /////////// TestCommand Interface /////////
      void NextTest() override
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          if (mTestCount == mTestIndex)
          {
              ChipLogProgress(chipTool, "TestCluster: 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 = TestSendClusterTestClusterCommandTest_0();
              break;
          case 1:
              err = TestSendClusterTestClusterCommandTestNotHandled_1();
              break;
          case 2:
              err = TestSendClusterTestClusterCommandTestSpecific_2();
              break;
          case 3:
              err = TestSendClusterTestClusterCommandReadAttribute_3();
              break;
          case 4:
              err = TestSendClusterTestClusterCommandWriteAttribute_4();
              break;
          case 5:
              err = TestSendClusterTestClusterCommandReadAttribute_5();
              break;
          case 6:
              err = TestSendClusterTestClusterCommandWriteAttribute_6();
              break;
          case 7:
              err = TestSendClusterTestClusterCommandReadAttribute_7();
              break;
          case 8:
              err = TestSendClusterTestClusterCommandReadAttribute_8();
              break;
          case 9:
              err = TestSendClusterTestClusterCommandWriteAttribute_9();
              break;
          case 10:
              err = TestSendClusterTestClusterCommandReadAttribute_10();
              break;
          case 11:
              err = TestSendClusterTestClusterCommandWriteAttribute_11();
              break;
          case 12:
              err = TestSendClusterTestClusterCommandReadAttribute_12();
              break;
          case 13:
              err = TestSendClusterTestClusterCommandReadAttribute_13();
              break;
          case 14:
              err = TestSendClusterTestClusterCommandWriteAttribute_14();
              break;
          case 15:
              err = TestSendClusterTestClusterCommandReadAttribute_15();
              break;
          case 16:
              err = TestSendClusterTestClusterCommandWriteAttribute_16();
              break;
          case 17:
              err = TestSendClusterTestClusterCommandReadAttribute_17();
              break;
          case 18:
              err = TestSendClusterTestClusterCommandReadAttribute_18();
              break;
          case 19:
              err = TestSendClusterTestClusterCommandWriteAttribute_19();
              break;
          case 20:
              err = TestSendClusterTestClusterCommandReadAttribute_20();
              break;
          case 21:
              err = TestSendClusterTestClusterCommandWriteAttribute_21();
              break;
          case 22:
              err = TestSendClusterTestClusterCommandReadAttribute_22();
              break;
          case 23:
              err = TestSendClusterTestClusterCommandReadAttribute_23();
              break;
          case 24:
              err = TestSendClusterTestClusterCommandWriteAttribute_24();
              break;
          case 25:
              err = TestSendClusterTestClusterCommandReadAttribute_25();
              break;
          case 26:
              err = TestSendClusterTestClusterCommandWriteAttribute_26();
              break;
          case 27:
              err = TestSendClusterTestClusterCommandReadAttribute_27();
              break;
          case 28:
              err = TestSendClusterTestClusterCommandReadAttribute_28();
              break;
          case 29:
              err = TestSendClusterTestClusterCommandWriteAttribute_29();
              break;
          case 30:
              err = TestSendClusterTestClusterCommandReadAttribute_30();
              break;
          case 31:
              err = TestSendClusterTestClusterCommandWriteAttribute_31();
              break;
          case 32:
              err = TestSendClusterTestClusterCommandReadAttribute_32();
              break;
          case 33:
              err = TestSendClusterTestClusterCommandReadAttribute_33();
              break;
          case 34:
              err = TestSendClusterTestClusterCommandWriteAttribute_34();
              break;
          case 35:
              err = TestSendClusterTestClusterCommandReadAttribute_35();
              break;
          case 36:
              err = TestSendClusterTestClusterCommandWriteAttribute_36();
              break;
          case 37:
              err = TestSendClusterTestClusterCommandReadAttribute_37();
              break;
          case 38:
              err = TestSendClusterTestClusterCommandReadAttribute_38();
              break;
          case 39:
              err = TestSendClusterTestClusterCommandWriteAttribute_39();
              break;
          case 40:
              err = TestSendClusterTestClusterCommandReadAttribute_40();
              break;
          case 41:
              err = TestSendClusterTestClusterCommandWriteAttribute_41();
              break;
          case 42:
              err = TestSendClusterTestClusterCommandReadAttribute_42();
              break;
          case 43:
              err = TestSendClusterTestClusterCommandReadAttribute_43();
              break;
          case 44:
              err = TestSendClusterTestClusterCommandWriteAttribute_44();
              break;
          case 45:
              err = TestSendClusterTestClusterCommandReadAttribute_45();
              break;
          case 46:
              err = TestSendClusterTestClusterCommandWriteAttribute_46();
              break;
          case 47:
              err = TestSendClusterTestClusterCommandReadAttribute_47();
              break;
          case 48:
              err = TestSendClusterTestClusterCommandReadAttribute_48();
              break;
          case 49:
              err = TestSendClusterTestClusterCommandWriteAttribute_49();
              break;
          case 50:
              err = TestSendClusterTestClusterCommandReadAttribute_50();
              break;
          case 51:
              err = TestSendClusterTestClusterCommandWriteAttribute_51();
              break;
          case 52:
              err = TestSendClusterTestClusterCommandReadAttribute_52();
              break;
          case 53:
              err = TestSendClusterTestClusterCommandWriteAttribute_53();
              break;
          case 54:
              err = TestSendClusterTestClusterCommandReadAttribute_54();
              break;
          case 55:
              err = TestSendClusterTestClusterCommandReadAttribute_55();
              break;
          case 56:
              err = TestSendClusterTestClusterCommandWriteAttribute_56();
              break;
          case 57:
              err = TestSendClusterTestClusterCommandReadAttribute_57();
              break;
          case 58:
              err = TestSendClusterTestClusterCommandWriteAttribute_58();
              break;
          case 59:
              err = TestSendClusterTestClusterCommandReadAttribute_59();
              break;
          case 60:
              err = TestSendClusterTestClusterCommandWriteAttribute_60();
              break;
          case 61:
              err = TestSendClusterTestClusterCommandReadAttribute_61();
              break;
          case 62:
              err = TestSendClusterTestClusterCommandReadAttribute_62();
              break;
          case 63:
              err = TestSendClusterTestClusterCommandWriteAttribute_63();
              break;
          case 64:
              err = TestSendClusterTestClusterCommandReadAttribute_64();
              break;
          case 65:
              err = TestSendClusterTestClusterCommandWriteAttribute_65();
              break;
          case 66:
              err = TestSendClusterTestClusterCommandReadAttribute_66();
              break;
          case 67:
              err = TestSendClusterTestClusterCommandWriteAttribute_67();
              break;
          case 68:
              err = TestSendClusterTestClusterCommandReadAttribute_68();
              break;
          case 69:
              err = TestSendClusterTestClusterCommandReadAttribute_69();
              break;
          case 70:
              err = TestSendClusterTestClusterCommandWriteAttribute_70();
              break;
          case 71:
              err = TestSendClusterTestClusterCommandReadAttribute_71();
              break;
          case 72:
              err = TestSendClusterTestClusterCommandWriteAttribute_72();
              break;
          case 73:
              err = TestSendClusterTestClusterCommandReadAttribute_73();
              break;
          case 74:
              err = TestSendClusterTestClusterCommandWriteAttribute_74();
              break;
          case 75:
              err = TestSendClusterTestClusterCommandReadAttribute_75();
              break;
          case 76:
              err = TestSendClusterTestClusterCommandReadAttribute_76();
              break;
          case 77:
              err = TestSendClusterTestClusterCommandWriteAttribute_77();
              break;
          case 78:
              err = TestSendClusterTestClusterCommandReadAttribute_78();
              break;
          case 79:
              err = TestSendClusterTestClusterCommandWriteAttribute_79();
              break;
          case 80:
              err = TestSendClusterTestClusterCommandReadAttribute_80();
              break;
          case 81:
              err = TestSendClusterTestClusterCommandReadAttribute_81();
              break;
          case 82:
              err = TestSendClusterTestClusterCommandWriteAttribute_82();
              break;
          case 83:
              err = TestSendClusterTestClusterCommandReadAttribute_83();
              break;
          case 84:
              err = TestSendClusterTestClusterCommandWriteAttribute_84();
              break;
          case 85:
              err = TestSendClusterTestClusterCommandReadAttribute_85();
              break;
          case 86:
              err = TestSendClusterTestClusterCommandReadAttribute_86();
              break;
          case 87:
              err = TestSendClusterTestClusterCommandWriteAttribute_87();
              break;
          case 88:
              err = TestSendClusterTestClusterCommandReadAttribute_88();
              break;
          case 89:
              err = TestSendClusterTestClusterCommandWriteAttribute_89();
              break;
          case 90:
              err = TestSendClusterTestClusterCommandReadAttribute_90();
              break;
          case 91:
              err = TestSendClusterTestClusterCommandWriteAttribute_91();
              break;
          case 92:
              err = TestSendClusterTestClusterCommandReadAttribute_92();
              break;
          case 93:
              err = TestSendClusterTestClusterCommandWriteAttribute_93();
              break;
          case 94:
              err = TestSendClusterTestClusterCommandReadAttribute_94();
              break;
          case 95:
              err = TestSendClusterTestClusterCommandWriteAttribute_95();
              break;
          case 96:
              err = TestSendClusterTestClusterCommandReadAttribute_96();
              break;
          case 97:
              err = TestSendClusterTestClusterCommandReadAttribute_97();
              break;
          case 98:
              err = TestSendClusterTestClusterCommandReadAttribute_98();
              break;
          case 99:
              err = TestSendClusterTestClusterCommandReadAttribute_99();
              break;
          case 100:
              err = TestSendClusterTestClusterCommandWriteAttribute_100();
              break;
          }
  
          if (CHIP_NO_ERROR != err)
          {
              ChipLogProgress(chipTool, "TestCluster: %s", chip::ErrorStr(err));
              SetCommandExitStatus(err);
          }
      }
  
  private:
      std::atomic_uint16_t mTestIndex;
      const uint16_t mTestCount = 101;
  
      //
      // Tests methods
      //
  
      // Test Send Test Command
      typedef void (*SuccessCallback_0)(void * context);
      chip::Callback::Callback<SuccessCallback_0> * mOnSuccessCallback_0      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_0 = nullptr;
      bool mIsFailureExpected_0                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandTest_0()
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Command: Sending command...");
  
          mOnFailureCallback_0 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterTestClusterCommandTest_0_FailureResponse, this);
          mOnSuccessCallback_0 =
              new chip::Callback::Callback<SuccessCallback_0>(OnTestSendClusterTestClusterCommandTest_0_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.Test(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_0;
              delete mOnSuccessCallback_0;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandTest_0_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Command: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandTest_0_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Command: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 Send Test Not Handled Command
      typedef void (*SuccessCallback_1)(void * context);
      chip::Callback::Callback<SuccessCallback_1> * mOnSuccessCallback_1      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_1 = nullptr;
      bool mIsFailureExpected_1                                               = 1;
  
      CHIP_ERROR TestSendClusterTestClusterCommandTestNotHandled_1()
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Not Handled Command: Sending command...");
  
          mOnFailureCallback_1 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandTestNotHandled_1_FailureResponse, this);
          mOnSuccessCallback_1 = new chip::Callback::Callback<SuccessCallback_1>(
              OnTestSendClusterTestClusterCommandTestNotHandled_1_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.TestNotHandled(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_1;
              delete mOnSuccessCallback_1;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandTestNotHandled_1_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Not Handled Command: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandTestNotHandled_1_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Not Handled Command: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 Send Test Specific Command
      typedef void (*SuccessCallback_2)(void * context, uint8_t returnValue);
      chip::Callback::Callback<SuccessCallback_2> * mOnSuccessCallback_2      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_2 = nullptr;
      bool mIsFailureExpected_2                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandTestSpecific_2()
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Specific Command: Sending command...");
  
          mOnFailureCallback_2 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandTestSpecific_2_FailureResponse, this);
          mOnSuccessCallback_2 = new chip::Callback::Callback<SuccessCallback_2>(
              OnTestSendClusterTestClusterCommandTestSpecific_2_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.TestSpecific(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_2;
              delete mOnSuccessCallback_2;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandTestSpecific_2_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Specific Command: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandTestSpecific_2_SuccessResponse(void * context, uint8_t returnValue)
      {
          ChipLogProgress(chipTool, "Test Cluster - Send Test Specific Command: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 (returnValue != 7)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "7");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute BOOLEAN Default Value
      typedef void (*SuccessCallback_3)(void * context, uint8_t boolean);
      chip::Callback::Callback<SuccessCallback_3> * mOnSuccessCallback_3      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_3 = nullptr;
      bool mIsFailureExpected_3                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_3()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN Default Value: Sending command...");
  
          mOnFailureCallback_3 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_3_FailureResponse, this);
          mOnSuccessCallback_3 = new chip::Callback::Callback<SuccessCallback_3>(
              OnTestSendClusterTestClusterCommandReadAttribute_3_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBoolean(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_3;
              delete mOnSuccessCallback_3;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_3_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandReadAttribute_3_SuccessResponse(void * context, uint8_t boolean)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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;
          }
  
          if (boolean != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BOOLEAN True
      typedef void (*SuccessCallback_4)(void * context, uint8_t boolean);
      chip::Callback::Callback<SuccessCallback_4> * mOnSuccessCallback_4      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_4 = nullptr;
      bool mIsFailureExpected_4                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_4()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BOOLEAN True: Sending command...");
  
          mOnFailureCallback_4 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_4_FailureResponse, this);
          mOnSuccessCallback_4 = new chip::Callback::Callback<SuccessCallback_4>(
              OnTestSendClusterTestClusterCommandWriteAttribute_4_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t booleanArgument = 1;
          err = cluster.WriteAttributeBoolean(mOnSuccessCallback_4->Cancel(), mOnFailureCallback_4->Cancel(), booleanArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_4;
              delete mOnSuccessCallback_4;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_4_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BOOLEAN True: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandWriteAttribute_4_SuccessResponse(void * context, uint8_t boolean)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BOOLEAN True: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 Read attribute BOOLEAN True
      typedef void (*SuccessCallback_5)(void * context, uint8_t boolean);
      chip::Callback::Callback<SuccessCallback_5> * mOnSuccessCallback_5      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_5 = nullptr;
      bool mIsFailureExpected_5                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_5()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN True: Sending command...");
  
          mOnFailureCallback_5 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_5_FailureResponse, this);
          mOnSuccessCallback_5 = new chip::Callback::Callback<SuccessCallback_5>(
              OnTestSendClusterTestClusterCommandReadAttribute_5_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBoolean(mOnSuccessCallback_5->Cancel(), mOnFailureCallback_5->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_5;
              delete mOnSuccessCallback_5;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_5_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN True: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandReadAttribute_5_SuccessResponse(void * context, uint8_t boolean)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN True: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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;
          }
  
          if (boolean != 1)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BOOLEAN False
      typedef void (*SuccessCallback_6)(void * context, uint8_t boolean);
      chip::Callback::Callback<SuccessCallback_6> * mOnSuccessCallback_6      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_6 = nullptr;
      bool mIsFailureExpected_6                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_6()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BOOLEAN False: Sending command...");
  
          mOnFailureCallback_6 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_6_FailureResponse, this);
          mOnSuccessCallback_6 = new chip::Callback::Callback<SuccessCallback_6>(
              OnTestSendClusterTestClusterCommandWriteAttribute_6_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t booleanArgument = 0;
          err = cluster.WriteAttributeBoolean(mOnSuccessCallback_6->Cancel(), mOnFailureCallback_6->Cancel(), booleanArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_6;
              delete mOnSuccessCallback_6;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_6_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BOOLEAN False: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandWriteAttribute_6_SuccessResponse(void * context, uint8_t boolean)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BOOLEAN False: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 Read attribute BOOLEAN False
      typedef void (*SuccessCallback_7)(void * context, uint8_t boolean);
      chip::Callback::Callback<SuccessCallback_7> * mOnSuccessCallback_7      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_7 = nullptr;
      bool mIsFailureExpected_7                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_7()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN False: Sending command...");
  
          mOnFailureCallback_7 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_7_FailureResponse, this);
          mOnSuccessCallback_7 = new chip::Callback::Callback<SuccessCallback_7>(
              OnTestSendClusterTestClusterCommandReadAttribute_7_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBoolean(mOnSuccessCallback_7->Cancel(), mOnFailureCallback_7->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_7;
              delete mOnSuccessCallback_7;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_7_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN False: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandReadAttribute_7_SuccessResponse(void * context, uint8_t boolean)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BOOLEAN False: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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;
          }
  
          if (boolean != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute BITMAP8 Default Value
      typedef void (*SuccessCallback_8)(void * context, uint8_t bitmap8);
      chip::Callback::Callback<SuccessCallback_8> * mOnSuccessCallback_8      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_8 = nullptr;
      bool mIsFailureExpected_8                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_8()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Default Value: Sending command...");
  
          mOnFailureCallback_8 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_8_FailureResponse, this);
          mOnSuccessCallback_8 = new chip::Callback::Callback<SuccessCallback_8>(
              OnTestSendClusterTestClusterCommandReadAttribute_8_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap8(mOnSuccessCallback_8->Cancel(), mOnFailureCallback_8->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_8;
              delete mOnSuccessCallback_8;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_8_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandReadAttribute_8_SuccessResponse(void * context, uint8_t bitmap8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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;
          }
  
          if (bitmap8 != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP8 Max Value
      typedef void (*SuccessCallback_9)(void * context, uint8_t bitmap8);
      chip::Callback::Callback<SuccessCallback_9> * mOnSuccessCallback_9      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_9 = nullptr;
      bool mIsFailureExpected_9                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_9()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP8 Max Value: Sending command...");
  
          mOnFailureCallback_9 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_9_FailureResponse, this);
          mOnSuccessCallback_9 = new chip::Callback::Callback<SuccessCallback_9>(
              OnTestSendClusterTestClusterCommandWriteAttribute_9_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t bitmap8Argument = 255;
          err = cluster.WriteAttributeBitmap8(mOnSuccessCallback_9->Cancel(), mOnFailureCallback_9->Cancel(), bitmap8Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_9;
              delete mOnSuccessCallback_9;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_9_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP8 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandWriteAttribute_9_SuccessResponse(void * context, uint8_t bitmap8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP8 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 Read attribute BITMAP8 Max Value
      typedef void (*SuccessCallback_10)(void * context, uint8_t bitmap8);
      chip::Callback::Callback<SuccessCallback_10> * mOnSuccessCallback_10     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_10 = nullptr;
      bool mIsFailureExpected_10                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_10()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Max Value: Sending command...");
  
          mOnFailureCallback_10 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_10_FailureResponse, this);
          mOnSuccessCallback_10 = new chip::Callback::Callback<SuccessCallback_10>(
              OnTestSendClusterTestClusterCommandReadAttribute_10_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap8(mOnSuccessCallback_10->Cancel(), mOnFailureCallback_10->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_10;
              delete mOnSuccessCallback_10;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_10_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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 OnTestSendClusterTestClusterCommandReadAttribute_10_SuccessResponse(void * context, uint8_t bitmap8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(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;
          }
  
          if (bitmap8 != 255)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "255");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP8 Min Value
      typedef void (*SuccessCallback_11)(void * context, uint8_t bitmap8);
      chip::Callback::Callback<SuccessCallback_11> * mOnSuccessCallback_11     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_11 = nullptr;
      bool mIsFailureExpected_11                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_11()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP8 Min Value: Sending command...");
  
          mOnFailureCallback_11 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_11_FailureResponse, this);
          mOnSuccessCallback_11 = new chip::Callback::Callback<SuccessCallback_11>(
              OnTestSendClusterTestClusterCommandWriteAttribute_11_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t bitmap8Argument = 0;
          err = cluster.WriteAttributeBitmap8(mOnSuccessCallback_11->Cancel(), mOnFailureCallback_11->Cancel(), bitmap8Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_11;
              delete mOnSuccessCallback_11;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_11_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP8 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (runner->mIsFailureExpected_11 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_11_SuccessResponse(void * context, uint8_t bitmap8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP8 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (runner->mIsFailureExpected_11 == 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 BITMAP8 Min Value
      typedef void (*SuccessCallback_12)(void * context, uint8_t bitmap8);
      chip::Callback::Callback<SuccessCallback_12> * mOnSuccessCallback_12     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_12 = nullptr;
      bool mIsFailureExpected_12                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_12()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Min Value: Sending command...");
  
          mOnFailureCallback_12 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_12_FailureResponse, this);
          mOnSuccessCallback_12 = new chip::Callback::Callback<SuccessCallback_12>(
              OnTestSendClusterTestClusterCommandReadAttribute_12_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap8(mOnSuccessCallback_12->Cancel(), mOnFailureCallback_12->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_12;
              delete mOnSuccessCallback_12;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_12_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_12;
          delete runner->mOnSuccessCallback_12;
  
          if (runner->mIsFailureExpected_12 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_12_SuccessResponse(void * context, uint8_t bitmap8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP8 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_12;
          delete runner->mOnSuccessCallback_12;
  
          if (runner->mIsFailureExpected_12 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap8 != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute BITMAP16 Default Value
      typedef void (*SuccessCallback_13)(void * context, uint16_t bitmap16);
      chip::Callback::Callback<SuccessCallback_13> * mOnSuccessCallback_13     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_13 = nullptr;
      bool mIsFailureExpected_13                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_13()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Default Value: Sending command...");
  
          mOnFailureCallback_13 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_13_FailureResponse, this);
          mOnSuccessCallback_13 = new chip::Callback::Callback<SuccessCallback_13>(
              OnTestSendClusterTestClusterCommandReadAttribute_13_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap16(mOnSuccessCallback_13->Cancel(), mOnFailureCallback_13->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_13;
              delete mOnSuccessCallback_13;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_13_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_13;
          delete runner->mOnSuccessCallback_13;
  
          if (runner->mIsFailureExpected_13 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_13_SuccessResponse(void * context, uint16_t bitmap16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_13;
          delete runner->mOnSuccessCallback_13;
  
          if (runner->mIsFailureExpected_13 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap16 != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP16 Max Value
      typedef void (*SuccessCallback_14)(void * context, uint16_t bitmap16);
      chip::Callback::Callback<SuccessCallback_14> * mOnSuccessCallback_14     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_14 = nullptr;
      bool mIsFailureExpected_14                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_14()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP16 Max Value: Sending command...");
  
          mOnFailureCallback_14 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_14_FailureResponse, this);
          mOnSuccessCallback_14 = new chip::Callback::Callback<SuccessCallback_14>(
              OnTestSendClusterTestClusterCommandWriteAttribute_14_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t bitmap16Argument = 65535U;
          err = cluster.WriteAttributeBitmap16(mOnSuccessCallback_14->Cancel(), mOnFailureCallback_14->Cancel(), bitmap16Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_14;
              delete mOnSuccessCallback_14;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_14_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP16 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_14;
          delete runner->mOnSuccessCallback_14;
  
          if (runner->mIsFailureExpected_14 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_14_SuccessResponse(void * context, uint16_t bitmap16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP16 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_14;
          delete runner->mOnSuccessCallback_14;
  
          if (runner->mIsFailureExpected_14 == 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 BITMAP16 Max Value
      typedef void (*SuccessCallback_15)(void * context, uint16_t bitmap16);
      chip::Callback::Callback<SuccessCallback_15> * mOnSuccessCallback_15     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_15 = nullptr;
      bool mIsFailureExpected_15                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_15()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Max Value: Sending command...");
  
          mOnFailureCallback_15 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_15_FailureResponse, this);
          mOnSuccessCallback_15 = new chip::Callback::Callback<SuccessCallback_15>(
              OnTestSendClusterTestClusterCommandReadAttribute_15_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap16(mOnSuccessCallback_15->Cancel(), mOnFailureCallback_15->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_15;
              delete mOnSuccessCallback_15;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_15_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_15;
          delete runner->mOnSuccessCallback_15;
  
          if (runner->mIsFailureExpected_15 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_15_SuccessResponse(void * context, uint16_t bitmap16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_15;
          delete runner->mOnSuccessCallback_15;
  
          if (runner->mIsFailureExpected_15 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap16 != 65535U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "65535");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP16 Min Value
      typedef void (*SuccessCallback_16)(void * context, uint16_t bitmap16);
      chip::Callback::Callback<SuccessCallback_16> * mOnSuccessCallback_16     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_16 = nullptr;
      bool mIsFailureExpected_16                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_16()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP16 Min Value: Sending command...");
  
          mOnFailureCallback_16 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_16_FailureResponse, this);
          mOnSuccessCallback_16 = new chip::Callback::Callback<SuccessCallback_16>(
              OnTestSendClusterTestClusterCommandWriteAttribute_16_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t bitmap16Argument = 0U;
          err = cluster.WriteAttributeBitmap16(mOnSuccessCallback_16->Cancel(), mOnFailureCallback_16->Cancel(), bitmap16Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_16;
              delete mOnSuccessCallback_16;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_16_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP16 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_16;
          delete runner->mOnSuccessCallback_16;
  
          if (runner->mIsFailureExpected_16 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_16_SuccessResponse(void * context, uint16_t bitmap16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP16 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_16;
          delete runner->mOnSuccessCallback_16;
  
          if (runner->mIsFailureExpected_16 == 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 BITMAP16 Min Value
      typedef void (*SuccessCallback_17)(void * context, uint16_t bitmap16);
      chip::Callback::Callback<SuccessCallback_17> * mOnSuccessCallback_17     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_17 = nullptr;
      bool mIsFailureExpected_17                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_17()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Min Value: Sending command...");
  
          mOnFailureCallback_17 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_17_FailureResponse, this);
          mOnSuccessCallback_17 = new chip::Callback::Callback<SuccessCallback_17>(
              OnTestSendClusterTestClusterCommandReadAttribute_17_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap16(mOnSuccessCallback_17->Cancel(), mOnFailureCallback_17->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_17;
              delete mOnSuccessCallback_17;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_17_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_17;
          delete runner->mOnSuccessCallback_17;
  
          if (runner->mIsFailureExpected_17 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_17_SuccessResponse(void * context, uint16_t bitmap16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP16 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_17;
          delete runner->mOnSuccessCallback_17;
  
          if (runner->mIsFailureExpected_17 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap16 != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute BITMAP32 Default Value
      typedef void (*SuccessCallback_18)(void * context, uint32_t bitmap32);
      chip::Callback::Callback<SuccessCallback_18> * mOnSuccessCallback_18     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_18 = nullptr;
      bool mIsFailureExpected_18                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_18()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Default Value: Sending command...");
  
          mOnFailureCallback_18 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_18_FailureResponse, this);
          mOnSuccessCallback_18 = new chip::Callback::Callback<SuccessCallback_18>(
              OnTestSendClusterTestClusterCommandReadAttribute_18_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap32(mOnSuccessCallback_18->Cancel(), mOnFailureCallback_18->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_18;
              delete mOnSuccessCallback_18;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_18_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_18;
          delete runner->mOnSuccessCallback_18;
  
          if (runner->mIsFailureExpected_18 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_18_SuccessResponse(void * context, uint32_t bitmap32)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_18;
          delete runner->mOnSuccessCallback_18;
  
          if (runner->mIsFailureExpected_18 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap32 != 0UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP32 Max Value
      typedef void (*SuccessCallback_19)(void * context, uint32_t bitmap32);
      chip::Callback::Callback<SuccessCallback_19> * mOnSuccessCallback_19     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_19 = nullptr;
      bool mIsFailureExpected_19                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_19()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP32 Max Value: Sending command...");
  
          mOnFailureCallback_19 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_19_FailureResponse, this);
          mOnSuccessCallback_19 = new chip::Callback::Callback<SuccessCallback_19>(
              OnTestSendClusterTestClusterCommandWriteAttribute_19_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint32_t bitmap32Argument = 4294967295UL;
          err = cluster.WriteAttributeBitmap32(mOnSuccessCallback_19->Cancel(), mOnFailureCallback_19->Cancel(), bitmap32Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_19;
              delete mOnSuccessCallback_19;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_19_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP32 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_19;
          delete runner->mOnSuccessCallback_19;
  
          if (runner->mIsFailureExpected_19 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_19_SuccessResponse(void * context, uint32_t bitmap32)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP32 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_19;
          delete runner->mOnSuccessCallback_19;
  
          if (runner->mIsFailureExpected_19 == 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 BITMAP32 Max Value
      typedef void (*SuccessCallback_20)(void * context, uint32_t bitmap32);
      chip::Callback::Callback<SuccessCallback_20> * mOnSuccessCallback_20     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_20 = nullptr;
      bool mIsFailureExpected_20                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_20()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Max Value: Sending command...");
  
          mOnFailureCallback_20 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_20_FailureResponse, this);
          mOnSuccessCallback_20 = new chip::Callback::Callback<SuccessCallback_20>(
              OnTestSendClusterTestClusterCommandReadAttribute_20_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap32(mOnSuccessCallback_20->Cancel(), mOnFailureCallback_20->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_20;
              delete mOnSuccessCallback_20;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_20_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_20;
          delete runner->mOnSuccessCallback_20;
  
          if (runner->mIsFailureExpected_20 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_20_SuccessResponse(void * context, uint32_t bitmap32)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_20;
          delete runner->mOnSuccessCallback_20;
  
          if (runner->mIsFailureExpected_20 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap32 != 4294967295UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "4294967295");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP32 Min Value
      typedef void (*SuccessCallback_21)(void * context, uint32_t bitmap32);
      chip::Callback::Callback<SuccessCallback_21> * mOnSuccessCallback_21     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_21 = nullptr;
      bool mIsFailureExpected_21                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_21()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP32 Min Value: Sending command...");
  
          mOnFailureCallback_21 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_21_FailureResponse, this);
          mOnSuccessCallback_21 = new chip::Callback::Callback<SuccessCallback_21>(
              OnTestSendClusterTestClusterCommandWriteAttribute_21_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint32_t bitmap32Argument = 0UL;
          err = cluster.WriteAttributeBitmap32(mOnSuccessCallback_21->Cancel(), mOnFailureCallback_21->Cancel(), bitmap32Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_21;
              delete mOnSuccessCallback_21;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_21_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP32 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_21;
          delete runner->mOnSuccessCallback_21;
  
          if (runner->mIsFailureExpected_21 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_21_SuccessResponse(void * context, uint32_t bitmap32)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP32 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_21;
          delete runner->mOnSuccessCallback_21;
  
          if (runner->mIsFailureExpected_21 == 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 BITMAP32 Min Value
      typedef void (*SuccessCallback_22)(void * context, uint32_t bitmap32);
      chip::Callback::Callback<SuccessCallback_22> * mOnSuccessCallback_22     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_22 = nullptr;
      bool mIsFailureExpected_22                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_22()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Min Value: Sending command...");
  
          mOnFailureCallback_22 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_22_FailureResponse, this);
          mOnSuccessCallback_22 = new chip::Callback::Callback<SuccessCallback_22>(
              OnTestSendClusterTestClusterCommandReadAttribute_22_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap32(mOnSuccessCallback_22->Cancel(), mOnFailureCallback_22->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_22;
              delete mOnSuccessCallback_22;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_22_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_22;
          delete runner->mOnSuccessCallback_22;
  
          if (runner->mIsFailureExpected_22 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_22_SuccessResponse(void * context, uint32_t bitmap32)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP32 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_22;
          delete runner->mOnSuccessCallback_22;
  
          if (runner->mIsFailureExpected_22 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap32 != 0UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute BITMAP64 Default Value
      typedef void (*SuccessCallback_23)(void * context, uint64_t bitmap64);
      chip::Callback::Callback<SuccessCallback_23> * mOnSuccessCallback_23     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_23 = nullptr;
      bool mIsFailureExpected_23                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_23()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Default Value: Sending command...");
  
          mOnFailureCallback_23 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_23_FailureResponse, this);
          mOnSuccessCallback_23 = new chip::Callback::Callback<SuccessCallback_23>(
              OnTestSendClusterTestClusterCommandReadAttribute_23_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap64(mOnSuccessCallback_23->Cancel(), mOnFailureCallback_23->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_23;
              delete mOnSuccessCallback_23;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_23_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_23;
          delete runner->mOnSuccessCallback_23;
  
          if (runner->mIsFailureExpected_23 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_23_SuccessResponse(void * context, uint64_t bitmap64)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_23;
          delete runner->mOnSuccessCallback_23;
  
          if (runner->mIsFailureExpected_23 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap64 != 0ULL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP64 Max Value
      typedef void (*SuccessCallback_24)(void * context, uint64_t bitmap64);
      chip::Callback::Callback<SuccessCallback_24> * mOnSuccessCallback_24     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_24 = nullptr;
      bool mIsFailureExpected_24                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_24()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP64 Max Value: Sending command...");
  
          mOnFailureCallback_24 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_24_FailureResponse, this);
          mOnSuccessCallback_24 = new chip::Callback::Callback<SuccessCallback_24>(
              OnTestSendClusterTestClusterCommandWriteAttribute_24_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint64_t bitmap64Argument = 18446744073709551615ULL;
          err = cluster.WriteAttributeBitmap64(mOnSuccessCallback_24->Cancel(), mOnFailureCallback_24->Cancel(), bitmap64Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_24;
              delete mOnSuccessCallback_24;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_24_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP64 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_24;
          delete runner->mOnSuccessCallback_24;
  
          if (runner->mIsFailureExpected_24 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_24_SuccessResponse(void * context, uint64_t bitmap64)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP64 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_24;
          delete runner->mOnSuccessCallback_24;
  
          if (runner->mIsFailureExpected_24 == 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 BITMAP64 Max Value
      typedef void (*SuccessCallback_25)(void * context, uint64_t bitmap64);
      chip::Callback::Callback<SuccessCallback_25> * mOnSuccessCallback_25     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_25 = nullptr;
      bool mIsFailureExpected_25                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_25()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Max Value: Sending command...");
  
          mOnFailureCallback_25 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_25_FailureResponse, this);
          mOnSuccessCallback_25 = new chip::Callback::Callback<SuccessCallback_25>(
              OnTestSendClusterTestClusterCommandReadAttribute_25_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap64(mOnSuccessCallback_25->Cancel(), mOnFailureCallback_25->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_25;
              delete mOnSuccessCallback_25;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_25_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_25;
          delete runner->mOnSuccessCallback_25;
  
          if (runner->mIsFailureExpected_25 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_25_SuccessResponse(void * context, uint64_t bitmap64)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_25;
          delete runner->mOnSuccessCallback_25;
  
          if (runner->mIsFailureExpected_25 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap64 != 18446744073709551615ULL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "18446744073709551615");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute BITMAP64 Min Value
      typedef void (*SuccessCallback_26)(void * context, uint64_t bitmap64);
      chip::Callback::Callback<SuccessCallback_26> * mOnSuccessCallback_26     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_26 = nullptr;
      bool mIsFailureExpected_26                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_26()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP64 Min Value: Sending command...");
  
          mOnFailureCallback_26 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_26_FailureResponse, this);
          mOnSuccessCallback_26 = new chip::Callback::Callback<SuccessCallback_26>(
              OnTestSendClusterTestClusterCommandWriteAttribute_26_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint64_t bitmap64Argument = 0ULL;
          err = cluster.WriteAttributeBitmap64(mOnSuccessCallback_26->Cancel(), mOnFailureCallback_26->Cancel(), bitmap64Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_26;
              delete mOnSuccessCallback_26;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_26_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP64 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_26;
          delete runner->mOnSuccessCallback_26;
  
          if (runner->mIsFailureExpected_26 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_26_SuccessResponse(void * context, uint64_t bitmap64)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute BITMAP64 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_26;
          delete runner->mOnSuccessCallback_26;
  
          if (runner->mIsFailureExpected_26 == 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 BITMAP64 Min Value
      typedef void (*SuccessCallback_27)(void * context, uint64_t bitmap64);
      chip::Callback::Callback<SuccessCallback_27> * mOnSuccessCallback_27     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_27 = nullptr;
      bool mIsFailureExpected_27                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_27()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Min Value: Sending command...");
  
          mOnFailureCallback_27 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_27_FailureResponse, this);
          mOnSuccessCallback_27 = new chip::Callback::Callback<SuccessCallback_27>(
              OnTestSendClusterTestClusterCommandReadAttribute_27_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeBitmap64(mOnSuccessCallback_27->Cancel(), mOnFailureCallback_27->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_27;
              delete mOnSuccessCallback_27;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_27_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_27;
          delete runner->mOnSuccessCallback_27;
  
          if (runner->mIsFailureExpected_27 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_27_SuccessResponse(void * context, uint64_t bitmap64)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute BITMAP64 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_27;
          delete runner->mOnSuccessCallback_27;
  
          if (runner->mIsFailureExpected_27 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (bitmap64 != 0ULL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT8U Default Value
      typedef void (*SuccessCallback_28)(void * context, uint8_t int8u);
      chip::Callback::Callback<SuccessCallback_28> * mOnSuccessCallback_28     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_28 = nullptr;
      bool mIsFailureExpected_28                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_28()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Default Value: Sending command...");
  
          mOnFailureCallback_28 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_28_FailureResponse, this);
          mOnSuccessCallback_28 = new chip::Callback::Callback<SuccessCallback_28>(
              OnTestSendClusterTestClusterCommandReadAttribute_28_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt8u(mOnSuccessCallback_28->Cancel(), mOnFailureCallback_28->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_28;
              delete mOnSuccessCallback_28;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_28_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_28;
          delete runner->mOnSuccessCallback_28;
  
          if (runner->mIsFailureExpected_28 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_28_SuccessResponse(void * context, uint8_t int8u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_28;
          delete runner->mOnSuccessCallback_28;
  
          if (runner->mIsFailureExpected_28 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int8u != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT8U Max Value
      typedef void (*SuccessCallback_29)(void * context, uint8_t int8u);
      chip::Callback::Callback<SuccessCallback_29> * mOnSuccessCallback_29     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_29 = nullptr;
      bool mIsFailureExpected_29                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_29()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8U Max Value: Sending command...");
  
          mOnFailureCallback_29 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_29_FailureResponse, this);
          mOnSuccessCallback_29 = new chip::Callback::Callback<SuccessCallback_29>(
              OnTestSendClusterTestClusterCommandWriteAttribute_29_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t int8uArgument = 255;
          err = cluster.WriteAttributeInt8u(mOnSuccessCallback_29->Cancel(), mOnFailureCallback_29->Cancel(), int8uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_29;
              delete mOnSuccessCallback_29;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_29_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_29;
          delete runner->mOnSuccessCallback_29;
  
          if (runner->mIsFailureExpected_29 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_29_SuccessResponse(void * context, uint8_t int8u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_29;
          delete runner->mOnSuccessCallback_29;
  
          if (runner->mIsFailureExpected_29 == 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 INT8U Max Value
      typedef void (*SuccessCallback_30)(void * context, uint8_t int8u);
      chip::Callback::Callback<SuccessCallback_30> * mOnSuccessCallback_30     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_30 = nullptr;
      bool mIsFailureExpected_30                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_30()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Max Value: Sending command...");
  
          mOnFailureCallback_30 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_30_FailureResponse, this);
          mOnSuccessCallback_30 = new chip::Callback::Callback<SuccessCallback_30>(
              OnTestSendClusterTestClusterCommandReadAttribute_30_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt8u(mOnSuccessCallback_30->Cancel(), mOnFailureCallback_30->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_30;
              delete mOnSuccessCallback_30;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_30_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_30;
          delete runner->mOnSuccessCallback_30;
  
          if (runner->mIsFailureExpected_30 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_30_SuccessResponse(void * context, uint8_t int8u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_30;
          delete runner->mOnSuccessCallback_30;
  
          if (runner->mIsFailureExpected_30 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int8u != 255)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "255");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT8U Min Value
      typedef void (*SuccessCallback_31)(void * context, uint8_t int8u);
      chip::Callback::Callback<SuccessCallback_31> * mOnSuccessCallback_31     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_31 = nullptr;
      bool mIsFailureExpected_31                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_31()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8U Min Value: Sending command...");
  
          mOnFailureCallback_31 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_31_FailureResponse, this);
          mOnSuccessCallback_31 = new chip::Callback::Callback<SuccessCallback_31>(
              OnTestSendClusterTestClusterCommandWriteAttribute_31_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t int8uArgument = 0;
          err = cluster.WriteAttributeInt8u(mOnSuccessCallback_31->Cancel(), mOnFailureCallback_31->Cancel(), int8uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_31;
              delete mOnSuccessCallback_31;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_31_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_31;
          delete runner->mOnSuccessCallback_31;
  
          if (runner->mIsFailureExpected_31 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_31_SuccessResponse(void * context, uint8_t int8u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_31;
          delete runner->mOnSuccessCallback_31;
  
          if (runner->mIsFailureExpected_31 == 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 INT8U Min Value
      typedef void (*SuccessCallback_32)(void * context, uint8_t int8u);
      chip::Callback::Callback<SuccessCallback_32> * mOnSuccessCallback_32     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_32 = nullptr;
      bool mIsFailureExpected_32                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_32()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Min Value: Sending command...");
  
          mOnFailureCallback_32 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_32_FailureResponse, this);
          mOnSuccessCallback_32 = new chip::Callback::Callback<SuccessCallback_32>(
              OnTestSendClusterTestClusterCommandReadAttribute_32_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt8u(mOnSuccessCallback_32->Cancel(), mOnFailureCallback_32->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_32;
              delete mOnSuccessCallback_32;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_32_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_32;
          delete runner->mOnSuccessCallback_32;
  
          if (runner->mIsFailureExpected_32 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_32_SuccessResponse(void * context, uint8_t int8u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_32;
          delete runner->mOnSuccessCallback_32;
  
          if (runner->mIsFailureExpected_32 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int8u != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT16U Default Value
      typedef void (*SuccessCallback_33)(void * context, uint16_t int16u);
      chip::Callback::Callback<SuccessCallback_33> * mOnSuccessCallback_33     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_33 = nullptr;
      bool mIsFailureExpected_33                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_33()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Default Value: Sending command...");
  
          mOnFailureCallback_33 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_33_FailureResponse, this);
          mOnSuccessCallback_33 = new chip::Callback::Callback<SuccessCallback_33>(
              OnTestSendClusterTestClusterCommandReadAttribute_33_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt16u(mOnSuccessCallback_33->Cancel(), mOnFailureCallback_33->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_33;
              delete mOnSuccessCallback_33;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_33_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_33;
          delete runner->mOnSuccessCallback_33;
  
          if (runner->mIsFailureExpected_33 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_33_SuccessResponse(void * context, uint16_t int16u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_33;
          delete runner->mOnSuccessCallback_33;
  
          if (runner->mIsFailureExpected_33 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int16u != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT16U Max Value
      typedef void (*SuccessCallback_34)(void * context, uint16_t int16u);
      chip::Callback::Callback<SuccessCallback_34> * mOnSuccessCallback_34     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_34 = nullptr;
      bool mIsFailureExpected_34                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_34()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16U Max Value: Sending command...");
  
          mOnFailureCallback_34 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_34_FailureResponse, this);
          mOnSuccessCallback_34 = new chip::Callback::Callback<SuccessCallback_34>(
              OnTestSendClusterTestClusterCommandWriteAttribute_34_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t int16uArgument = 65535U;
          err = cluster.WriteAttributeInt16u(mOnSuccessCallback_34->Cancel(), mOnFailureCallback_34->Cancel(), int16uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_34;
              delete mOnSuccessCallback_34;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_34_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_34;
          delete runner->mOnSuccessCallback_34;
  
          if (runner->mIsFailureExpected_34 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_34_SuccessResponse(void * context, uint16_t int16u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_34;
          delete runner->mOnSuccessCallback_34;
  
          if (runner->mIsFailureExpected_34 == 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 INT16U Max Value
      typedef void (*SuccessCallback_35)(void * context, uint16_t int16u);
      chip::Callback::Callback<SuccessCallback_35> * mOnSuccessCallback_35     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_35 = nullptr;
      bool mIsFailureExpected_35                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_35()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Max Value: Sending command...");
  
          mOnFailureCallback_35 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_35_FailureResponse, this);
          mOnSuccessCallback_35 = new chip::Callback::Callback<SuccessCallback_35>(
              OnTestSendClusterTestClusterCommandReadAttribute_35_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt16u(mOnSuccessCallback_35->Cancel(), mOnFailureCallback_35->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_35;
              delete mOnSuccessCallback_35;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_35_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_35;
          delete runner->mOnSuccessCallback_35;
  
          if (runner->mIsFailureExpected_35 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_35_SuccessResponse(void * context, uint16_t int16u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_35;
          delete runner->mOnSuccessCallback_35;
  
          if (runner->mIsFailureExpected_35 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int16u != 65535U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "65535");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT16U Min Value
      typedef void (*SuccessCallback_36)(void * context, uint16_t int16u);
      chip::Callback::Callback<SuccessCallback_36> * mOnSuccessCallback_36     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_36 = nullptr;
      bool mIsFailureExpected_36                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_36()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16U Min Value: Sending command...");
  
          mOnFailureCallback_36 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_36_FailureResponse, this);
          mOnSuccessCallback_36 = new chip::Callback::Callback<SuccessCallback_36>(
              OnTestSendClusterTestClusterCommandWriteAttribute_36_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t int16uArgument = 0U;
          err = cluster.WriteAttributeInt16u(mOnSuccessCallback_36->Cancel(), mOnFailureCallback_36->Cancel(), int16uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_36;
              delete mOnSuccessCallback_36;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_36_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_36;
          delete runner->mOnSuccessCallback_36;
  
          if (runner->mIsFailureExpected_36 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_36_SuccessResponse(void * context, uint16_t int16u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_36;
          delete runner->mOnSuccessCallback_36;
  
          if (runner->mIsFailureExpected_36 == 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 INT16U Min Value
      typedef void (*SuccessCallback_37)(void * context, uint16_t int16u);
      chip::Callback::Callback<SuccessCallback_37> * mOnSuccessCallback_37     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_37 = nullptr;
      bool mIsFailureExpected_37                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_37()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Min Value: Sending command...");
  
          mOnFailureCallback_37 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_37_FailureResponse, this);
          mOnSuccessCallback_37 = new chip::Callback::Callback<SuccessCallback_37>(
              OnTestSendClusterTestClusterCommandReadAttribute_37_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt16u(mOnSuccessCallback_37->Cancel(), mOnFailureCallback_37->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_37;
              delete mOnSuccessCallback_37;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_37_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_37;
          delete runner->mOnSuccessCallback_37;
  
          if (runner->mIsFailureExpected_37 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_37_SuccessResponse(void * context, uint16_t int16u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_37;
          delete runner->mOnSuccessCallback_37;
  
          if (runner->mIsFailureExpected_37 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int16u != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT32U Default Value
      typedef void (*SuccessCallback_38)(void * context, uint32_t int32u);
      chip::Callback::Callback<SuccessCallback_38> * mOnSuccessCallback_38     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_38 = nullptr;
      bool mIsFailureExpected_38                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_38()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Default Value: Sending command...");
  
          mOnFailureCallback_38 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_38_FailureResponse, this);
          mOnSuccessCallback_38 = new chip::Callback::Callback<SuccessCallback_38>(
              OnTestSendClusterTestClusterCommandReadAttribute_38_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt32u(mOnSuccessCallback_38->Cancel(), mOnFailureCallback_38->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_38;
              delete mOnSuccessCallback_38;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_38_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_38;
          delete runner->mOnSuccessCallback_38;
  
          if (runner->mIsFailureExpected_38 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_38_SuccessResponse(void * context, uint32_t int32u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_38;
          delete runner->mOnSuccessCallback_38;
  
          if (runner->mIsFailureExpected_38 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int32u != 0UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT32U Max Value
      typedef void (*SuccessCallback_39)(void * context, uint32_t int32u);
      chip::Callback::Callback<SuccessCallback_39> * mOnSuccessCallback_39     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_39 = nullptr;
      bool mIsFailureExpected_39                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_39()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32U Max Value: Sending command...");
  
          mOnFailureCallback_39 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_39_FailureResponse, this);
          mOnSuccessCallback_39 = new chip::Callback::Callback<SuccessCallback_39>(
              OnTestSendClusterTestClusterCommandWriteAttribute_39_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint32_t int32uArgument = 4294967295UL;
          err = cluster.WriteAttributeInt32u(mOnSuccessCallback_39->Cancel(), mOnFailureCallback_39->Cancel(), int32uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_39;
              delete mOnSuccessCallback_39;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_39_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_39;
          delete runner->mOnSuccessCallback_39;
  
          if (runner->mIsFailureExpected_39 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_39_SuccessResponse(void * context, uint32_t int32u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_39;
          delete runner->mOnSuccessCallback_39;
  
          if (runner->mIsFailureExpected_39 == 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 INT32U Max Value
      typedef void (*SuccessCallback_40)(void * context, uint32_t int32u);
      chip::Callback::Callback<SuccessCallback_40> * mOnSuccessCallback_40     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_40 = nullptr;
      bool mIsFailureExpected_40                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_40()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Max Value: Sending command...");
  
          mOnFailureCallback_40 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_40_FailureResponse, this);
          mOnSuccessCallback_40 = new chip::Callback::Callback<SuccessCallback_40>(
              OnTestSendClusterTestClusterCommandReadAttribute_40_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt32u(mOnSuccessCallback_40->Cancel(), mOnFailureCallback_40->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_40;
              delete mOnSuccessCallback_40;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_40_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_40;
          delete runner->mOnSuccessCallback_40;
  
          if (runner->mIsFailureExpected_40 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_40_SuccessResponse(void * context, uint32_t int32u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_40;
          delete runner->mOnSuccessCallback_40;
  
          if (runner->mIsFailureExpected_40 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int32u != 4294967295UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "4294967295");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT32U Min Value
      typedef void (*SuccessCallback_41)(void * context, uint32_t int32u);
      chip::Callback::Callback<SuccessCallback_41> * mOnSuccessCallback_41     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_41 = nullptr;
      bool mIsFailureExpected_41                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_41()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32U Min Value: Sending command...");
  
          mOnFailureCallback_41 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_41_FailureResponse, this);
          mOnSuccessCallback_41 = new chip::Callback::Callback<SuccessCallback_41>(
              OnTestSendClusterTestClusterCommandWriteAttribute_41_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint32_t int32uArgument = 0UL;
          err = cluster.WriteAttributeInt32u(mOnSuccessCallback_41->Cancel(), mOnFailureCallback_41->Cancel(), int32uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_41;
              delete mOnSuccessCallback_41;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_41_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_41;
          delete runner->mOnSuccessCallback_41;
  
          if (runner->mIsFailureExpected_41 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_41_SuccessResponse(void * context, uint32_t int32u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_41;
          delete runner->mOnSuccessCallback_41;
  
          if (runner->mIsFailureExpected_41 == 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 INT32U Min Value
      typedef void (*SuccessCallback_42)(void * context, uint32_t int32u);
      chip::Callback::Callback<SuccessCallback_42> * mOnSuccessCallback_42     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_42 = nullptr;
      bool mIsFailureExpected_42                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_42()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Min Value: Sending command...");
  
          mOnFailureCallback_42 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_42_FailureResponse, this);
          mOnSuccessCallback_42 = new chip::Callback::Callback<SuccessCallback_42>(
              OnTestSendClusterTestClusterCommandReadAttribute_42_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt32u(mOnSuccessCallback_42->Cancel(), mOnFailureCallback_42->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_42;
              delete mOnSuccessCallback_42;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_42_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_42;
          delete runner->mOnSuccessCallback_42;
  
          if (runner->mIsFailureExpected_42 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_42_SuccessResponse(void * context, uint32_t int32u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_42;
          delete runner->mOnSuccessCallback_42;
  
          if (runner->mIsFailureExpected_42 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int32u != 0UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT64U Default Value
      typedef void (*SuccessCallback_43)(void * context, uint64_t int64u);
      chip::Callback::Callback<SuccessCallback_43> * mOnSuccessCallback_43     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_43 = nullptr;
      bool mIsFailureExpected_43                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_43()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Default Value: Sending command...");
  
          mOnFailureCallback_43 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_43_FailureResponse, this);
          mOnSuccessCallback_43 = new chip::Callback::Callback<SuccessCallback_43>(
              OnTestSendClusterTestClusterCommandReadAttribute_43_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt64u(mOnSuccessCallback_43->Cancel(), mOnFailureCallback_43->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_43;
              delete mOnSuccessCallback_43;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_43_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_43;
          delete runner->mOnSuccessCallback_43;
  
          if (runner->mIsFailureExpected_43 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_43_SuccessResponse(void * context, uint64_t int64u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_43;
          delete runner->mOnSuccessCallback_43;
  
          if (runner->mIsFailureExpected_43 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int64u != 0ULL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT64U Max Value
      typedef void (*SuccessCallback_44)(void * context, uint64_t int64u);
      chip::Callback::Callback<SuccessCallback_44> * mOnSuccessCallback_44     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_44 = nullptr;
      bool mIsFailureExpected_44                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_44()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64U Max Value: Sending command...");
  
          mOnFailureCallback_44 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_44_FailureResponse, this);
          mOnSuccessCallback_44 = new chip::Callback::Callback<SuccessCallback_44>(
              OnTestSendClusterTestClusterCommandWriteAttribute_44_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint64_t int64uArgument = 18446744073709551615ULL;
          err = cluster.WriteAttributeInt64u(mOnSuccessCallback_44->Cancel(), mOnFailureCallback_44->Cancel(), int64uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_44;
              delete mOnSuccessCallback_44;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_44_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_44;
          delete runner->mOnSuccessCallback_44;
  
          if (runner->mIsFailureExpected_44 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_44_SuccessResponse(void * context, uint64_t int64u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_44;
          delete runner->mOnSuccessCallback_44;
  
          if (runner->mIsFailureExpected_44 == 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 INT64U Max Value
      typedef void (*SuccessCallback_45)(void * context, uint64_t int64u);
      chip::Callback::Callback<SuccessCallback_45> * mOnSuccessCallback_45     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_45 = nullptr;
      bool mIsFailureExpected_45                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_45()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Max Value: Sending command...");
  
          mOnFailureCallback_45 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_45_FailureResponse, this);
          mOnSuccessCallback_45 = new chip::Callback::Callback<SuccessCallback_45>(
              OnTestSendClusterTestClusterCommandReadAttribute_45_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt64u(mOnSuccessCallback_45->Cancel(), mOnFailureCallback_45->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_45;
              delete mOnSuccessCallback_45;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_45_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_45;
          delete runner->mOnSuccessCallback_45;
  
          if (runner->mIsFailureExpected_45 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_45_SuccessResponse(void * context, uint64_t int64u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_45;
          delete runner->mOnSuccessCallback_45;
  
          if (runner->mIsFailureExpected_45 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int64u != 18446744073709551615ULL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "18446744073709551615");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT64U Min Value
      typedef void (*SuccessCallback_46)(void * context, uint64_t int64u);
      chip::Callback::Callback<SuccessCallback_46> * mOnSuccessCallback_46     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_46 = nullptr;
      bool mIsFailureExpected_46                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_46()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64U Min Value: Sending command...");
  
          mOnFailureCallback_46 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_46_FailureResponse, this);
          mOnSuccessCallback_46 = new chip::Callback::Callback<SuccessCallback_46>(
              OnTestSendClusterTestClusterCommandWriteAttribute_46_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint64_t int64uArgument = 0ULL;
          err = cluster.WriteAttributeInt64u(mOnSuccessCallback_46->Cancel(), mOnFailureCallback_46->Cancel(), int64uArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_46;
              delete mOnSuccessCallback_46;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_46_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_46;
          delete runner->mOnSuccessCallback_46;
  
          if (runner->mIsFailureExpected_46 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_46_SuccessResponse(void * context, uint64_t int64u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_46;
          delete runner->mOnSuccessCallback_46;
  
          if (runner->mIsFailureExpected_46 == 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 INT64U Min Value
      typedef void (*SuccessCallback_47)(void * context, uint64_t int64u);
      chip::Callback::Callback<SuccessCallback_47> * mOnSuccessCallback_47     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_47 = nullptr;
      bool mIsFailureExpected_47                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_47()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Min Value: Sending command...");
  
          mOnFailureCallback_47 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_47_FailureResponse, this);
          mOnSuccessCallback_47 = new chip::Callback::Callback<SuccessCallback_47>(
              OnTestSendClusterTestClusterCommandReadAttribute_47_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt64u(mOnSuccessCallback_47->Cancel(), mOnFailureCallback_47->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_47;
              delete mOnSuccessCallback_47;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_47_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_47;
          delete runner->mOnSuccessCallback_47;
  
          if (runner->mIsFailureExpected_47 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_47_SuccessResponse(void * context, uint64_t int64u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64U Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_47;
          delete runner->mOnSuccessCallback_47;
  
          if (runner->mIsFailureExpected_47 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int64u != 0ULL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT8S Default Value
      typedef void (*SuccessCallback_48)(void * context, int8_t int8s);
      chip::Callback::Callback<SuccessCallback_48> * mOnSuccessCallback_48     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_48 = nullptr;
      bool mIsFailureExpected_48                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_48()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Default Value: Sending command...");
  
          mOnFailureCallback_48 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_48_FailureResponse, this);
          mOnSuccessCallback_48 = new chip::Callback::Callback<SuccessCallback_48>(
              OnTestSendClusterTestClusterCommandReadAttribute_48_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt8s(mOnSuccessCallback_48->Cancel(), mOnFailureCallback_48->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_48;
              delete mOnSuccessCallback_48;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_48_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_48;
          delete runner->mOnSuccessCallback_48;
  
          if (runner->mIsFailureExpected_48 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_48_SuccessResponse(void * context, int8_t int8s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_48;
          delete runner->mOnSuccessCallback_48;
  
          if (runner->mIsFailureExpected_48 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int8s != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT8S Max Value
      typedef void (*SuccessCallback_49)(void * context, int8_t int8s);
      chip::Callback::Callback<SuccessCallback_49> * mOnSuccessCallback_49     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_49 = nullptr;
      bool mIsFailureExpected_49                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_49()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Max Value: Sending command...");
  
          mOnFailureCallback_49 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_49_FailureResponse, this);
          mOnSuccessCallback_49 = new chip::Callback::Callback<SuccessCallback_49>(
              OnTestSendClusterTestClusterCommandWriteAttribute_49_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int8_t int8sArgument = 127;
          err = cluster.WriteAttributeInt8s(mOnSuccessCallback_49->Cancel(), mOnFailureCallback_49->Cancel(), int8sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_49;
              delete mOnSuccessCallback_49;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_49_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_49;
          delete runner->mOnSuccessCallback_49;
  
          if (runner->mIsFailureExpected_49 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_49_SuccessResponse(void * context, int8_t int8s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_49;
          delete runner->mOnSuccessCallback_49;
  
          if (runner->mIsFailureExpected_49 == 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 INT8S Max Value
      typedef void (*SuccessCallback_50)(void * context, int8_t int8s);
      chip::Callback::Callback<SuccessCallback_50> * mOnSuccessCallback_50     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_50 = nullptr;
      bool mIsFailureExpected_50                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_50()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Max Value: Sending command...");
  
          mOnFailureCallback_50 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_50_FailureResponse, this);
          mOnSuccessCallback_50 = new chip::Callback::Callback<SuccessCallback_50>(
              OnTestSendClusterTestClusterCommandReadAttribute_50_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt8s(mOnSuccessCallback_50->Cancel(), mOnFailureCallback_50->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_50;
              delete mOnSuccessCallback_50;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_50_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_50;
          delete runner->mOnSuccessCallback_50;
  
          if (runner->mIsFailureExpected_50 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_50_SuccessResponse(void * context, int8_t int8s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_50;
          delete runner->mOnSuccessCallback_50;
  
          if (runner->mIsFailureExpected_50 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int8s != 127)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "127");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT8S Min Value
      typedef void (*SuccessCallback_51)(void * context, int8_t int8s);
      chip::Callback::Callback<SuccessCallback_51> * mOnSuccessCallback_51     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_51 = nullptr;
      bool mIsFailureExpected_51                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_51()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Min Value: Sending command...");
  
          mOnFailureCallback_51 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_51_FailureResponse, this);
          mOnSuccessCallback_51 = new chip::Callback::Callback<SuccessCallback_51>(
              OnTestSendClusterTestClusterCommandWriteAttribute_51_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int8_t int8sArgument = -128;
          err = cluster.WriteAttributeInt8s(mOnSuccessCallback_51->Cancel(), mOnFailureCallback_51->Cancel(), int8sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_51;
              delete mOnSuccessCallback_51;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_51_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_51;
          delete runner->mOnSuccessCallback_51;
  
          if (runner->mIsFailureExpected_51 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_51_SuccessResponse(void * context, int8_t int8s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_51;
          delete runner->mOnSuccessCallback_51;
  
          if (runner->mIsFailureExpected_51 == 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 INT8S Min Value
      typedef void (*SuccessCallback_52)(void * context, int8_t int8s);
      chip::Callback::Callback<SuccessCallback_52> * mOnSuccessCallback_52     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_52 = nullptr;
      bool mIsFailureExpected_52                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_52()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Min Value: Sending command...");
  
          mOnFailureCallback_52 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_52_FailureResponse, this);
          mOnSuccessCallback_52 = new chip::Callback::Callback<SuccessCallback_52>(
              OnTestSendClusterTestClusterCommandReadAttribute_52_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt8s(mOnSuccessCallback_52->Cancel(), mOnFailureCallback_52->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_52;
              delete mOnSuccessCallback_52;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_52_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_52;
          delete runner->mOnSuccessCallback_52;
  
          if (runner->mIsFailureExpected_52 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_52_SuccessResponse(void * context, int8_t int8s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_52;
          delete runner->mOnSuccessCallback_52;
  
          if (runner->mIsFailureExpected_52 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int8s != -128)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "-128");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT8S Default Value
      typedef void (*SuccessCallback_53)(void * context, int8_t int8s);
      chip::Callback::Callback<SuccessCallback_53> * mOnSuccessCallback_53     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_53 = nullptr;
      bool mIsFailureExpected_53                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_53()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Default Value: Sending command...");
  
          mOnFailureCallback_53 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_53_FailureResponse, this);
          mOnSuccessCallback_53 = new chip::Callback::Callback<SuccessCallback_53>(
              OnTestSendClusterTestClusterCommandWriteAttribute_53_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int8_t int8sArgument = 0;
          err = cluster.WriteAttributeInt8s(mOnSuccessCallback_53->Cancel(), mOnFailureCallback_53->Cancel(), int8sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_53;
              delete mOnSuccessCallback_53;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_53_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_53;
          delete runner->mOnSuccessCallback_53;
  
          if (runner->mIsFailureExpected_53 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_53_SuccessResponse(void * context, int8_t int8s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT8S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_53;
          delete runner->mOnSuccessCallback_53;
  
          if (runner->mIsFailureExpected_53 == 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 INT8S Default Value
      typedef void (*SuccessCallback_54)(void * context, int8_t int8s);
      chip::Callback::Callback<SuccessCallback_54> * mOnSuccessCallback_54     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_54 = nullptr;
      bool mIsFailureExpected_54                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_54()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Default Value: Sending command...");
  
          mOnFailureCallback_54 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_54_FailureResponse, this);
          mOnSuccessCallback_54 = new chip::Callback::Callback<SuccessCallback_54>(
              OnTestSendClusterTestClusterCommandReadAttribute_54_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt8s(mOnSuccessCallback_54->Cancel(), mOnFailureCallback_54->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_54;
              delete mOnSuccessCallback_54;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_54_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_54;
          delete runner->mOnSuccessCallback_54;
  
          if (runner->mIsFailureExpected_54 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_54_SuccessResponse(void * context, int8_t int8s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT8S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_54;
          delete runner->mOnSuccessCallback_54;
  
          if (runner->mIsFailureExpected_54 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int8s != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT16S Default Value
      typedef void (*SuccessCallback_55)(void * context, int16_t int16s);
      chip::Callback::Callback<SuccessCallback_55> * mOnSuccessCallback_55     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_55 = nullptr;
      bool mIsFailureExpected_55                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_55()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Default Value: Sending command...");
  
          mOnFailureCallback_55 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_55_FailureResponse, this);
          mOnSuccessCallback_55 = new chip::Callback::Callback<SuccessCallback_55>(
              OnTestSendClusterTestClusterCommandReadAttribute_55_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt16s(mOnSuccessCallback_55->Cancel(), mOnFailureCallback_55->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_55;
              delete mOnSuccessCallback_55;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_55_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_55;
          delete runner->mOnSuccessCallback_55;
  
          if (runner->mIsFailureExpected_55 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_55_SuccessResponse(void * context, int16_t int16s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_55;
          delete runner->mOnSuccessCallback_55;
  
          if (runner->mIsFailureExpected_55 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int16s != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT16S Max Value
      typedef void (*SuccessCallback_56)(void * context, int16_t int16s);
      chip::Callback::Callback<SuccessCallback_56> * mOnSuccessCallback_56     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_56 = nullptr;
      bool mIsFailureExpected_56                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_56()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Max Value: Sending command...");
  
          mOnFailureCallback_56 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_56_FailureResponse, this);
          mOnSuccessCallback_56 = new chip::Callback::Callback<SuccessCallback_56>(
              OnTestSendClusterTestClusterCommandWriteAttribute_56_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int16_t int16sArgument = 32767;
          err = cluster.WriteAttributeInt16s(mOnSuccessCallback_56->Cancel(), mOnFailureCallback_56->Cancel(), int16sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_56;
              delete mOnSuccessCallback_56;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_56_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_56;
          delete runner->mOnSuccessCallback_56;
  
          if (runner->mIsFailureExpected_56 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_56_SuccessResponse(void * context, int16_t int16s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_56;
          delete runner->mOnSuccessCallback_56;
  
          if (runner->mIsFailureExpected_56 == 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 INT16S Max Value
      typedef void (*SuccessCallback_57)(void * context, int16_t int16s);
      chip::Callback::Callback<SuccessCallback_57> * mOnSuccessCallback_57     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_57 = nullptr;
      bool mIsFailureExpected_57                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_57()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Max Value: Sending command...");
  
          mOnFailureCallback_57 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_57_FailureResponse, this);
          mOnSuccessCallback_57 = new chip::Callback::Callback<SuccessCallback_57>(
              OnTestSendClusterTestClusterCommandReadAttribute_57_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt16s(mOnSuccessCallback_57->Cancel(), mOnFailureCallback_57->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_57;
              delete mOnSuccessCallback_57;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_57_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_57;
          delete runner->mOnSuccessCallback_57;
  
          if (runner->mIsFailureExpected_57 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_57_SuccessResponse(void * context, int16_t int16s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_57;
          delete runner->mOnSuccessCallback_57;
  
          if (runner->mIsFailureExpected_57 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int16s != 32767)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "32767");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT16S Min Value
      typedef void (*SuccessCallback_58)(void * context, int16_t int16s);
      chip::Callback::Callback<SuccessCallback_58> * mOnSuccessCallback_58     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_58 = nullptr;
      bool mIsFailureExpected_58                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_58()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Min Value: Sending command...");
  
          mOnFailureCallback_58 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_58_FailureResponse, this);
          mOnSuccessCallback_58 = new chip::Callback::Callback<SuccessCallback_58>(
              OnTestSendClusterTestClusterCommandWriteAttribute_58_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int16_t int16sArgument = -32768;
          err = cluster.WriteAttributeInt16s(mOnSuccessCallback_58->Cancel(), mOnFailureCallback_58->Cancel(), int16sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_58;
              delete mOnSuccessCallback_58;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_58_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_58;
          delete runner->mOnSuccessCallback_58;
  
          if (runner->mIsFailureExpected_58 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_58_SuccessResponse(void * context, int16_t int16s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_58;
          delete runner->mOnSuccessCallback_58;
  
          if (runner->mIsFailureExpected_58 == 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 INT16S Min Value
      typedef void (*SuccessCallback_59)(void * context, int16_t int16s);
      chip::Callback::Callback<SuccessCallback_59> * mOnSuccessCallback_59     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_59 = nullptr;
      bool mIsFailureExpected_59                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_59()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Min Value: Sending command...");
  
          mOnFailureCallback_59 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_59_FailureResponse, this);
          mOnSuccessCallback_59 = new chip::Callback::Callback<SuccessCallback_59>(
              OnTestSendClusterTestClusterCommandReadAttribute_59_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt16s(mOnSuccessCallback_59->Cancel(), mOnFailureCallback_59->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_59;
              delete mOnSuccessCallback_59;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_59_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_59;
          delete runner->mOnSuccessCallback_59;
  
          if (runner->mIsFailureExpected_59 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_59_SuccessResponse(void * context, int16_t int16s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_59;
          delete runner->mOnSuccessCallback_59;
  
          if (runner->mIsFailureExpected_59 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int16s != -32768)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "-32768");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT16S Default Value
      typedef void (*SuccessCallback_60)(void * context, int16_t int16s);
      chip::Callback::Callback<SuccessCallback_60> * mOnSuccessCallback_60     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_60 = nullptr;
      bool mIsFailureExpected_60                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_60()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Default Value: Sending command...");
  
          mOnFailureCallback_60 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_60_FailureResponse, this);
          mOnSuccessCallback_60 = new chip::Callback::Callback<SuccessCallback_60>(
              OnTestSendClusterTestClusterCommandWriteAttribute_60_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int16_t int16sArgument = 0;
          err = cluster.WriteAttributeInt16s(mOnSuccessCallback_60->Cancel(), mOnFailureCallback_60->Cancel(), int16sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_60;
              delete mOnSuccessCallback_60;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_60_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_60;
          delete runner->mOnSuccessCallback_60;
  
          if (runner->mIsFailureExpected_60 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_60_SuccessResponse(void * context, int16_t int16s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT16S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_60;
          delete runner->mOnSuccessCallback_60;
  
          if (runner->mIsFailureExpected_60 == 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 INT16S Default Value
      typedef void (*SuccessCallback_61)(void * context, int16_t int16s);
      chip::Callback::Callback<SuccessCallback_61> * mOnSuccessCallback_61     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_61 = nullptr;
      bool mIsFailureExpected_61                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_61()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Default Value: Sending command...");
  
          mOnFailureCallback_61 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_61_FailureResponse, this);
          mOnSuccessCallback_61 = new chip::Callback::Callback<SuccessCallback_61>(
              OnTestSendClusterTestClusterCommandReadAttribute_61_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt16s(mOnSuccessCallback_61->Cancel(), mOnFailureCallback_61->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_61;
              delete mOnSuccessCallback_61;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_61_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_61;
          delete runner->mOnSuccessCallback_61;
  
          if (runner->mIsFailureExpected_61 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_61_SuccessResponse(void * context, int16_t int16s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT16S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_61;
          delete runner->mOnSuccessCallback_61;
  
          if (runner->mIsFailureExpected_61 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int16s != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT32S Default Value
      typedef void (*SuccessCallback_62)(void * context, int32_t int32s);
      chip::Callback::Callback<SuccessCallback_62> * mOnSuccessCallback_62     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_62 = nullptr;
      bool mIsFailureExpected_62                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_62()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Default Value: Sending command...");
  
          mOnFailureCallback_62 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_62_FailureResponse, this);
          mOnSuccessCallback_62 = new chip::Callback::Callback<SuccessCallback_62>(
              OnTestSendClusterTestClusterCommandReadAttribute_62_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt32s(mOnSuccessCallback_62->Cancel(), mOnFailureCallback_62->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_62;
              delete mOnSuccessCallback_62;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_62_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_62;
          delete runner->mOnSuccessCallback_62;
  
          if (runner->mIsFailureExpected_62 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_62_SuccessResponse(void * context, int32_t int32s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_62;
          delete runner->mOnSuccessCallback_62;
  
          if (runner->mIsFailureExpected_62 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int32s != 0L)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT32S Max Value
      typedef void (*SuccessCallback_63)(void * context, int32_t int32s);
      chip::Callback::Callback<SuccessCallback_63> * mOnSuccessCallback_63     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_63 = nullptr;
      bool mIsFailureExpected_63                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_63()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Max Value: Sending command...");
  
          mOnFailureCallback_63 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_63_FailureResponse, this);
          mOnSuccessCallback_63 = new chip::Callback::Callback<SuccessCallback_63>(
              OnTestSendClusterTestClusterCommandWriteAttribute_63_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int32_t int32sArgument = 2147483647L;
          err = cluster.WriteAttributeInt32s(mOnSuccessCallback_63->Cancel(), mOnFailureCallback_63->Cancel(), int32sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_63;
              delete mOnSuccessCallback_63;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_63_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_63;
          delete runner->mOnSuccessCallback_63;
  
          if (runner->mIsFailureExpected_63 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_63_SuccessResponse(void * context, int32_t int32s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_63;
          delete runner->mOnSuccessCallback_63;
  
          if (runner->mIsFailureExpected_63 == 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 INT32S Max Value
      typedef void (*SuccessCallback_64)(void * context, int32_t int32s);
      chip::Callback::Callback<SuccessCallback_64> * mOnSuccessCallback_64     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_64 = nullptr;
      bool mIsFailureExpected_64                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_64()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Max Value: Sending command...");
  
          mOnFailureCallback_64 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_64_FailureResponse, this);
          mOnSuccessCallback_64 = new chip::Callback::Callback<SuccessCallback_64>(
              OnTestSendClusterTestClusterCommandReadAttribute_64_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt32s(mOnSuccessCallback_64->Cancel(), mOnFailureCallback_64->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_64;
              delete mOnSuccessCallback_64;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_64_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_64;
          delete runner->mOnSuccessCallback_64;
  
          if (runner->mIsFailureExpected_64 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_64_SuccessResponse(void * context, int32_t int32s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_64;
          delete runner->mOnSuccessCallback_64;
  
          if (runner->mIsFailureExpected_64 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int32s != 2147483647L)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "2147483647");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT32S Min Value
      typedef void (*SuccessCallback_65)(void * context, int32_t int32s);
      chip::Callback::Callback<SuccessCallback_65> * mOnSuccessCallback_65     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_65 = nullptr;
      bool mIsFailureExpected_65                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_65()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Min Value: Sending command...");
  
          mOnFailureCallback_65 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_65_FailureResponse, this);
          mOnSuccessCallback_65 = new chip::Callback::Callback<SuccessCallback_65>(
              OnTestSendClusterTestClusterCommandWriteAttribute_65_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int32_t int32sArgument = -2147483648L;
          err = cluster.WriteAttributeInt32s(mOnSuccessCallback_65->Cancel(), mOnFailureCallback_65->Cancel(), int32sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_65;
              delete mOnSuccessCallback_65;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_65_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_65;
          delete runner->mOnSuccessCallback_65;
  
          if (runner->mIsFailureExpected_65 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_65_SuccessResponse(void * context, int32_t int32s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_65;
          delete runner->mOnSuccessCallback_65;
  
          if (runner->mIsFailureExpected_65 == 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 INT32S Min Value
      typedef void (*SuccessCallback_66)(void * context, int32_t int32s);
      chip::Callback::Callback<SuccessCallback_66> * mOnSuccessCallback_66     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_66 = nullptr;
      bool mIsFailureExpected_66                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_66()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Min Value: Sending command...");
  
          mOnFailureCallback_66 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_66_FailureResponse, this);
          mOnSuccessCallback_66 = new chip::Callback::Callback<SuccessCallback_66>(
              OnTestSendClusterTestClusterCommandReadAttribute_66_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt32s(mOnSuccessCallback_66->Cancel(), mOnFailureCallback_66->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_66;
              delete mOnSuccessCallback_66;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_66_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_66;
          delete runner->mOnSuccessCallback_66;
  
          if (runner->mIsFailureExpected_66 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_66_SuccessResponse(void * context, int32_t int32s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_66;
          delete runner->mOnSuccessCallback_66;
  
          if (runner->mIsFailureExpected_66 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int32s != -2147483648L)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "-2147483648");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT32S Default Value
      typedef void (*SuccessCallback_67)(void * context, int32_t int32s);
      chip::Callback::Callback<SuccessCallback_67> * mOnSuccessCallback_67     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_67 = nullptr;
      bool mIsFailureExpected_67                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_67()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Default Value: Sending command...");
  
          mOnFailureCallback_67 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_67_FailureResponse, this);
          mOnSuccessCallback_67 = new chip::Callback::Callback<SuccessCallback_67>(
              OnTestSendClusterTestClusterCommandWriteAttribute_67_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int32_t int32sArgument = 0L;
          err = cluster.WriteAttributeInt32s(mOnSuccessCallback_67->Cancel(), mOnFailureCallback_67->Cancel(), int32sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_67;
              delete mOnSuccessCallback_67;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_67_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_67;
          delete runner->mOnSuccessCallback_67;
  
          if (runner->mIsFailureExpected_67 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_67_SuccessResponse(void * context, int32_t int32s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT32S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_67;
          delete runner->mOnSuccessCallback_67;
  
          if (runner->mIsFailureExpected_67 == 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 INT32S Default Value
      typedef void (*SuccessCallback_68)(void * context, int32_t int32s);
      chip::Callback::Callback<SuccessCallback_68> * mOnSuccessCallback_68     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_68 = nullptr;
      bool mIsFailureExpected_68                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_68()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Default Value: Sending command...");
  
          mOnFailureCallback_68 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_68_FailureResponse, this);
          mOnSuccessCallback_68 = new chip::Callback::Callback<SuccessCallback_68>(
              OnTestSendClusterTestClusterCommandReadAttribute_68_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt32s(mOnSuccessCallback_68->Cancel(), mOnFailureCallback_68->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_68;
              delete mOnSuccessCallback_68;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_68_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_68;
          delete runner->mOnSuccessCallback_68;
  
          if (runner->mIsFailureExpected_68 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_68_SuccessResponse(void * context, int32_t int32s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT32S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_68;
          delete runner->mOnSuccessCallback_68;
  
          if (runner->mIsFailureExpected_68 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int32s != 0L)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute INT64S Default Value
      typedef void (*SuccessCallback_69)(void * context, int64_t int64s);
      chip::Callback::Callback<SuccessCallback_69> * mOnSuccessCallback_69     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_69 = nullptr;
      bool mIsFailureExpected_69                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_69()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Default Value: Sending command...");
  
          mOnFailureCallback_69 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_69_FailureResponse, this);
          mOnSuccessCallback_69 = new chip::Callback::Callback<SuccessCallback_69>(
              OnTestSendClusterTestClusterCommandReadAttribute_69_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt64s(mOnSuccessCallback_69->Cancel(), mOnFailureCallback_69->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_69;
              delete mOnSuccessCallback_69;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_69_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_69;
          delete runner->mOnSuccessCallback_69;
  
          if (runner->mIsFailureExpected_69 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_69_SuccessResponse(void * context, int64_t int64s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_69;
          delete runner->mOnSuccessCallback_69;
  
          if (runner->mIsFailureExpected_69 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int64s != 0LL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT64S Max Value
      typedef void (*SuccessCallback_70)(void * context, int64_t int64s);
      chip::Callback::Callback<SuccessCallback_70> * mOnSuccessCallback_70     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_70 = nullptr;
      bool mIsFailureExpected_70                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_70()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Max Value: Sending command...");
  
          mOnFailureCallback_70 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_70_FailureResponse, this);
          mOnSuccessCallback_70 = new chip::Callback::Callback<SuccessCallback_70>(
              OnTestSendClusterTestClusterCommandWriteAttribute_70_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int64_t int64sArgument = 9223372036854775807LL;
          err = cluster.WriteAttributeInt64s(mOnSuccessCallback_70->Cancel(), mOnFailureCallback_70->Cancel(), int64sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_70;
              delete mOnSuccessCallback_70;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_70_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_70;
          delete runner->mOnSuccessCallback_70;
  
          if (runner->mIsFailureExpected_70 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_70_SuccessResponse(void * context, int64_t int64s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_70;
          delete runner->mOnSuccessCallback_70;
  
          if (runner->mIsFailureExpected_70 == 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 INT64S Max Value
      typedef void (*SuccessCallback_71)(void * context, int64_t int64s);
      chip::Callback::Callback<SuccessCallback_71> * mOnSuccessCallback_71     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_71 = nullptr;
      bool mIsFailureExpected_71                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_71()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Max Value: Sending command...");
  
          mOnFailureCallback_71 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_71_FailureResponse, this);
          mOnSuccessCallback_71 = new chip::Callback::Callback<SuccessCallback_71>(
              OnTestSendClusterTestClusterCommandReadAttribute_71_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt64s(mOnSuccessCallback_71->Cancel(), mOnFailureCallback_71->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_71;
              delete mOnSuccessCallback_71;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_71_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_71;
          delete runner->mOnSuccessCallback_71;
  
          if (runner->mIsFailureExpected_71 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_71_SuccessResponse(void * context, int64_t int64s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_71;
          delete runner->mOnSuccessCallback_71;
  
          if (runner->mIsFailureExpected_71 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int64s != 9223372036854775807LL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "9223372036854775807");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT64S Min Value
      typedef void (*SuccessCallback_72)(void * context, int64_t int64s);
      chip::Callback::Callback<SuccessCallback_72> * mOnSuccessCallback_72     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_72 = nullptr;
      bool mIsFailureExpected_72                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_72()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Min Value: Sending command...");
  
          mOnFailureCallback_72 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_72_FailureResponse, this);
          mOnSuccessCallback_72 = new chip::Callback::Callback<SuccessCallback_72>(
              OnTestSendClusterTestClusterCommandWriteAttribute_72_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int64_t int64sArgument = -9223372036854775807LL;
          err = cluster.WriteAttributeInt64s(mOnSuccessCallback_72->Cancel(), mOnFailureCallback_72->Cancel(), int64sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_72;
              delete mOnSuccessCallback_72;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_72_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_72;
          delete runner->mOnSuccessCallback_72;
  
          if (runner->mIsFailureExpected_72 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_72_SuccessResponse(void * context, int64_t int64s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_72;
          delete runner->mOnSuccessCallback_72;
  
          if (runner->mIsFailureExpected_72 == 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 INT64S Min Value
      typedef void (*SuccessCallback_73)(void * context, int64_t int64s);
      chip::Callback::Callback<SuccessCallback_73> * mOnSuccessCallback_73     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_73 = nullptr;
      bool mIsFailureExpected_73                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_73()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Min Value: Sending command...");
  
          mOnFailureCallback_73 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_73_FailureResponse, this);
          mOnSuccessCallback_73 = new chip::Callback::Callback<SuccessCallback_73>(
              OnTestSendClusterTestClusterCommandReadAttribute_73_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt64s(mOnSuccessCallback_73->Cancel(), mOnFailureCallback_73->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_73;
              delete mOnSuccessCallback_73;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_73_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_73;
          delete runner->mOnSuccessCallback_73;
  
          if (runner->mIsFailureExpected_73 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_73_SuccessResponse(void * context, int64_t int64s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_73;
          delete runner->mOnSuccessCallback_73;
  
          if (runner->mIsFailureExpected_73 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int64s != -9223372036854775807LL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "-9223372036854775807");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute INT64S Default Value
      typedef void (*SuccessCallback_74)(void * context, int64_t int64s);
      chip::Callback::Callback<SuccessCallback_74> * mOnSuccessCallback_74     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_74 = nullptr;
      bool mIsFailureExpected_74                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_74()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Default Value: Sending command...");
  
          mOnFailureCallback_74 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_74_FailureResponse, this);
          mOnSuccessCallback_74 = new chip::Callback::Callback<SuccessCallback_74>(
              OnTestSendClusterTestClusterCommandWriteAttribute_74_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          int64_t int64sArgument = 0LL;
          err = cluster.WriteAttributeInt64s(mOnSuccessCallback_74->Cancel(), mOnFailureCallback_74->Cancel(), int64sArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_74;
              delete mOnSuccessCallback_74;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_74_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_74;
          delete runner->mOnSuccessCallback_74;
  
          if (runner->mIsFailureExpected_74 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_74_SuccessResponse(void * context, int64_t int64s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute INT64S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_74;
          delete runner->mOnSuccessCallback_74;
  
          if (runner->mIsFailureExpected_74 == 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 INT64S Default Value
      typedef void (*SuccessCallback_75)(void * context, int64_t int64s);
      chip::Callback::Callback<SuccessCallback_75> * mOnSuccessCallback_75     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_75 = nullptr;
      bool mIsFailureExpected_75                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_75()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Default Value: Sending command...");
  
          mOnFailureCallback_75 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_75_FailureResponse, this);
          mOnSuccessCallback_75 = new chip::Callback::Callback<SuccessCallback_75>(
              OnTestSendClusterTestClusterCommandReadAttribute_75_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInt64s(mOnSuccessCallback_75->Cancel(), mOnFailureCallback_75->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_75;
              delete mOnSuccessCallback_75;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_75_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_75;
          delete runner->mOnSuccessCallback_75;
  
          if (runner->mIsFailureExpected_75 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_75_SuccessResponse(void * context, int64_t int64s)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute INT64S Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_75;
          delete runner->mOnSuccessCallback_75;
  
          if (runner->mIsFailureExpected_75 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (int64s != 0LL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute ENUM8 Default Value
      typedef void (*SuccessCallback_76)(void * context, uint8_t enum8);
      chip::Callback::Callback<SuccessCallback_76> * mOnSuccessCallback_76     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_76 = nullptr;
      bool mIsFailureExpected_76                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_76()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Default Value: Sending command...");
  
          mOnFailureCallback_76 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_76_FailureResponse, this);
          mOnSuccessCallback_76 = new chip::Callback::Callback<SuccessCallback_76>(
              OnTestSendClusterTestClusterCommandReadAttribute_76_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeEnum8(mOnSuccessCallback_76->Cancel(), mOnFailureCallback_76->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_76;
              delete mOnSuccessCallback_76;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_76_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_76;
          delete runner->mOnSuccessCallback_76;
  
          if (runner->mIsFailureExpected_76 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_76_SuccessResponse(void * context, uint8_t enum8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_76;
          delete runner->mOnSuccessCallback_76;
  
          if (runner->mIsFailureExpected_76 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (enum8 != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute ENUM8 Max Value
      typedef void (*SuccessCallback_77)(void * context, uint8_t enum8);
      chip::Callback::Callback<SuccessCallback_77> * mOnSuccessCallback_77     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_77 = nullptr;
      bool mIsFailureExpected_77                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_77()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM8 Max Value: Sending command...");
  
          mOnFailureCallback_77 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_77_FailureResponse, this);
          mOnSuccessCallback_77 = new chip::Callback::Callback<SuccessCallback_77>(
              OnTestSendClusterTestClusterCommandWriteAttribute_77_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t enum8Argument = 255;
          err = cluster.WriteAttributeEnum8(mOnSuccessCallback_77->Cancel(), mOnFailureCallback_77->Cancel(), enum8Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_77;
              delete mOnSuccessCallback_77;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_77_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM8 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_77;
          delete runner->mOnSuccessCallback_77;
  
          if (runner->mIsFailureExpected_77 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_77_SuccessResponse(void * context, uint8_t enum8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM8 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_77;
          delete runner->mOnSuccessCallback_77;
  
          if (runner->mIsFailureExpected_77 == 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 ENUM8 Max Value
      typedef void (*SuccessCallback_78)(void * context, uint8_t enum8);
      chip::Callback::Callback<SuccessCallback_78> * mOnSuccessCallback_78     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_78 = nullptr;
      bool mIsFailureExpected_78                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_78()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Max Value: Sending command...");
  
          mOnFailureCallback_78 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_78_FailureResponse, this);
          mOnSuccessCallback_78 = new chip::Callback::Callback<SuccessCallback_78>(
              OnTestSendClusterTestClusterCommandReadAttribute_78_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeEnum8(mOnSuccessCallback_78->Cancel(), mOnFailureCallback_78->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_78;
              delete mOnSuccessCallback_78;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_78_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_78;
          delete runner->mOnSuccessCallback_78;
  
          if (runner->mIsFailureExpected_78 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_78_SuccessResponse(void * context, uint8_t enum8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_78;
          delete runner->mOnSuccessCallback_78;
  
          if (runner->mIsFailureExpected_78 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (enum8 != 255)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "255");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute ENUM8 Min Value
      typedef void (*SuccessCallback_79)(void * context, uint8_t enum8);
      chip::Callback::Callback<SuccessCallback_79> * mOnSuccessCallback_79     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_79 = nullptr;
      bool mIsFailureExpected_79                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_79()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM8 Min Value: Sending command...");
  
          mOnFailureCallback_79 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_79_FailureResponse, this);
          mOnSuccessCallback_79 = new chip::Callback::Callback<SuccessCallback_79>(
              OnTestSendClusterTestClusterCommandWriteAttribute_79_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t enum8Argument = 0;
          err = cluster.WriteAttributeEnum8(mOnSuccessCallback_79->Cancel(), mOnFailureCallback_79->Cancel(), enum8Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_79;
              delete mOnSuccessCallback_79;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_79_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM8 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_79;
          delete runner->mOnSuccessCallback_79;
  
          if (runner->mIsFailureExpected_79 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_79_SuccessResponse(void * context, uint8_t enum8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM8 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_79;
          delete runner->mOnSuccessCallback_79;
  
          if (runner->mIsFailureExpected_79 == 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 ENUM8 Min Value
      typedef void (*SuccessCallback_80)(void * context, uint8_t enum8);
      chip::Callback::Callback<SuccessCallback_80> * mOnSuccessCallback_80     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_80 = nullptr;
      bool mIsFailureExpected_80                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_80()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Min Value: Sending command...");
  
          mOnFailureCallback_80 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_80_FailureResponse, this);
          mOnSuccessCallback_80 = new chip::Callback::Callback<SuccessCallback_80>(
              OnTestSendClusterTestClusterCommandReadAttribute_80_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeEnum8(mOnSuccessCallback_80->Cancel(), mOnFailureCallback_80->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_80;
              delete mOnSuccessCallback_80;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_80_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_80;
          delete runner->mOnSuccessCallback_80;
  
          if (runner->mIsFailureExpected_80 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_80_SuccessResponse(void * context, uint8_t enum8)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM8 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_80;
          delete runner->mOnSuccessCallback_80;
  
          if (runner->mIsFailureExpected_80 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (enum8 != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute ENUM16 Default Value
      typedef void (*SuccessCallback_81)(void * context, uint16_t enum16);
      chip::Callback::Callback<SuccessCallback_81> * mOnSuccessCallback_81     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_81 = nullptr;
      bool mIsFailureExpected_81                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_81()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Default Value: Sending command...");
  
          mOnFailureCallback_81 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_81_FailureResponse, this);
          mOnSuccessCallback_81 = new chip::Callback::Callback<SuccessCallback_81>(
              OnTestSendClusterTestClusterCommandReadAttribute_81_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeEnum16(mOnSuccessCallback_81->Cancel(), mOnFailureCallback_81->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_81;
              delete mOnSuccessCallback_81;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_81_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_81;
          delete runner->mOnSuccessCallback_81;
  
          if (runner->mIsFailureExpected_81 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_81_SuccessResponse(void * context, uint16_t enum16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_81;
          delete runner->mOnSuccessCallback_81;
  
          if (runner->mIsFailureExpected_81 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (enum16 != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute ENUM16 Max Value
      typedef void (*SuccessCallback_82)(void * context, uint16_t enum16);
      chip::Callback::Callback<SuccessCallback_82> * mOnSuccessCallback_82     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_82 = nullptr;
      bool mIsFailureExpected_82                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_82()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM16 Max Value: Sending command...");
  
          mOnFailureCallback_82 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_82_FailureResponse, this);
          mOnSuccessCallback_82 = new chip::Callback::Callback<SuccessCallback_82>(
              OnTestSendClusterTestClusterCommandWriteAttribute_82_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t enum16Argument = 65535U;
          err = cluster.WriteAttributeEnum16(mOnSuccessCallback_82->Cancel(), mOnFailureCallback_82->Cancel(), enum16Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_82;
              delete mOnSuccessCallback_82;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_82_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM16 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_82;
          delete runner->mOnSuccessCallback_82;
  
          if (runner->mIsFailureExpected_82 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_82_SuccessResponse(void * context, uint16_t enum16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM16 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_82;
          delete runner->mOnSuccessCallback_82;
  
          if (runner->mIsFailureExpected_82 == 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 ENUM16 Max Value
      typedef void (*SuccessCallback_83)(void * context, uint16_t enum16);
      chip::Callback::Callback<SuccessCallback_83> * mOnSuccessCallback_83     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_83 = nullptr;
      bool mIsFailureExpected_83                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_83()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Max Value: Sending command...");
  
          mOnFailureCallback_83 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_83_FailureResponse, this);
          mOnSuccessCallback_83 = new chip::Callback::Callback<SuccessCallback_83>(
              OnTestSendClusterTestClusterCommandReadAttribute_83_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeEnum16(mOnSuccessCallback_83->Cancel(), mOnFailureCallback_83->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_83;
              delete mOnSuccessCallback_83;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_83_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Max Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_83;
          delete runner->mOnSuccessCallback_83;
  
          if (runner->mIsFailureExpected_83 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_83_SuccessResponse(void * context, uint16_t enum16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Max Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_83;
          delete runner->mOnSuccessCallback_83;
  
          if (runner->mIsFailureExpected_83 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (enum16 != 65535U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "65535");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute ENUM16 Min Value
      typedef void (*SuccessCallback_84)(void * context, uint16_t enum16);
      chip::Callback::Callback<SuccessCallback_84> * mOnSuccessCallback_84     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_84 = nullptr;
      bool mIsFailureExpected_84                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_84()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM16 Min Value: Sending command...");
  
          mOnFailureCallback_84 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_84_FailureResponse, this);
          mOnSuccessCallback_84 = new chip::Callback::Callback<SuccessCallback_84>(
              OnTestSendClusterTestClusterCommandWriteAttribute_84_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t enum16Argument = 0U;
          err = cluster.WriteAttributeEnum16(mOnSuccessCallback_84->Cancel(), mOnFailureCallback_84->Cancel(), enum16Argument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_84;
              delete mOnSuccessCallback_84;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_84_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM16 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_84;
          delete runner->mOnSuccessCallback_84;
  
          if (runner->mIsFailureExpected_84 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_84_SuccessResponse(void * context, uint16_t enum16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute ENUM16 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_84;
          delete runner->mOnSuccessCallback_84;
  
          if (runner->mIsFailureExpected_84 == 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 ENUM16 Min Value
      typedef void (*SuccessCallback_85)(void * context, uint16_t enum16);
      chip::Callback::Callback<SuccessCallback_85> * mOnSuccessCallback_85     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_85 = nullptr;
      bool mIsFailureExpected_85                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_85()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Min Value: Sending command...");
  
          mOnFailureCallback_85 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_85_FailureResponse, this);
          mOnSuccessCallback_85 = new chip::Callback::Callback<SuccessCallback_85>(
              OnTestSendClusterTestClusterCommandReadAttribute_85_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeEnum16(mOnSuccessCallback_85->Cancel(), mOnFailureCallback_85->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_85;
              delete mOnSuccessCallback_85;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_85_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Min Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_85;
          delete runner->mOnSuccessCallback_85;
  
          if (runner->mIsFailureExpected_85 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_85_SuccessResponse(void * context, uint16_t enum16)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute ENUM16 Min Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_85;
          delete runner->mOnSuccessCallback_85;
  
          if (runner->mIsFailureExpected_85 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (enum16 != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute OCTET_STRING Default Value
      typedef void (*SuccessCallback_86)(void * context, chip::ByteSpan octetString);
      chip::Callback::Callback<SuccessCallback_86> * mOnSuccessCallback_86     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_86 = nullptr;
      bool mIsFailureExpected_86                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_86()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING Default Value: Sending command...");
  
          mOnFailureCallback_86 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_86_FailureResponse, this);
          mOnSuccessCallback_86 = new chip::Callback::Callback<SuccessCallback_86>(
              OnTestSendClusterTestClusterCommandReadAttribute_86_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOctetString(mOnSuccessCallback_86->Cancel(), mOnFailureCallback_86->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_86;
              delete mOnSuccessCallback_86;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_86_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_86;
          delete runner->mOnSuccessCallback_86;
  
          if (runner->mIsFailureExpected_86 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_86_SuccessResponse(void * context, chip::ByteSpan octetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_86;
          delete runner->mOnSuccessCallback_86;
  
          if (runner->mIsFailureExpected_86 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          chip::ByteSpan octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char(""), strlen(""));
          if (!octetString.data_equal(octetStringArgument))
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute OCTET_STRING
      typedef void (*SuccessCallback_87)(void * context, chip::ByteSpan octetString);
      chip::Callback::Callback<SuccessCallback_87> * mOnSuccessCallback_87     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_87 = nullptr;
      bool mIsFailureExpected_87                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_87()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Sending command...");
  
          mOnFailureCallback_87 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_87_FailureResponse, this);
          mOnSuccessCallback_87 = new chip::Callback::Callback<SuccessCallback_87>(
              OnTestSendClusterTestClusterCommandWriteAttribute_87_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          chip::ByteSpan octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char("TestValue"), strlen("TestValue"));
          err = cluster.WriteAttributeOctetString(mOnSuccessCallback_87->Cancel(), mOnFailureCallback_87->Cancel(),
                                                  octetStringArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_87;
              delete mOnSuccessCallback_87;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_87_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_87;
          delete runner->mOnSuccessCallback_87;
  
          if (runner->mIsFailureExpected_87 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_87_SuccessResponse(void * context, chip::ByteSpan octetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_87;
          delete runner->mOnSuccessCallback_87;
  
          if (runner->mIsFailureExpected_87 == 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 OCTET_STRING
      typedef void (*SuccessCallback_88)(void * context, chip::ByteSpan octetString);
      chip::Callback::Callback<SuccessCallback_88> * mOnSuccessCallback_88     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_88 = nullptr;
      bool mIsFailureExpected_88                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_88()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING: Sending command...");
  
          mOnFailureCallback_88 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_88_FailureResponse, this);
          mOnSuccessCallback_88 = new chip::Callback::Callback<SuccessCallback_88>(
              OnTestSendClusterTestClusterCommandReadAttribute_88_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOctetString(mOnSuccessCallback_88->Cancel(), mOnFailureCallback_88->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_88;
              delete mOnSuccessCallback_88;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_88_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_88;
          delete runner->mOnSuccessCallback_88;
  
          if (runner->mIsFailureExpected_88 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_88_SuccessResponse(void * context, chip::ByteSpan octetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_88;
          delete runner->mOnSuccessCallback_88;
  
          if (runner->mIsFailureExpected_88 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          chip::ByteSpan octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char("TestValue"), strlen("TestValue"));
          if (!octetString.data_equal(octetStringArgument))
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "TestValue");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute OCTET_STRING
      typedef void (*SuccessCallback_89)(void * context, chip::ByteSpan octetString);
      chip::Callback::Callback<SuccessCallback_89> * mOnSuccessCallback_89     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_89 = nullptr;
      bool mIsFailureExpected_89                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_89()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Sending command...");
  
          mOnFailureCallback_89 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_89_FailureResponse, this);
          mOnSuccessCallback_89 = new chip::Callback::Callback<SuccessCallback_89>(
              OnTestSendClusterTestClusterCommandWriteAttribute_89_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          chip::ByteSpan octetStringArgument =
              chip::ByteSpan(chip::Uint8::from_const_char("TestValueLongerThan10"), strlen("TestValueLongerThan10"));
          err = cluster.WriteAttributeOctetString(mOnSuccessCallback_89->Cancel(), mOnFailureCallback_89->Cancel(),
                                                  octetStringArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_89;
              delete mOnSuccessCallback_89;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_89_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_89;
          delete runner->mOnSuccessCallback_89;
  
          if (runner->mIsFailureExpected_89 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_89_SuccessResponse(void * context, chip::ByteSpan octetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_89;
          delete runner->mOnSuccessCallback_89;
  
          if (runner->mIsFailureExpected_89 == 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 OCTET_STRING
      typedef void (*SuccessCallback_90)(void * context, chip::ByteSpan octetString);
      chip::Callback::Callback<SuccessCallback_90> * mOnSuccessCallback_90     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_90 = nullptr;
      bool mIsFailureExpected_90                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_90()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING: Sending command...");
  
          mOnFailureCallback_90 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_90_FailureResponse, this);
          mOnSuccessCallback_90 = new chip::Callback::Callback<SuccessCallback_90>(
              OnTestSendClusterTestClusterCommandReadAttribute_90_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOctetString(mOnSuccessCallback_90->Cancel(), mOnFailureCallback_90->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_90;
              delete mOnSuccessCallback_90;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_90_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_90;
          delete runner->mOnSuccessCallback_90;
  
          if (runner->mIsFailureExpected_90 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_90_SuccessResponse(void * context, chip::ByteSpan octetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_90;
          delete runner->mOnSuccessCallback_90;
  
          if (runner->mIsFailureExpected_90 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          chip::ByteSpan octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char("TestValue"), strlen("TestValue"));
          if (!octetString.data_equal(octetStringArgument))
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "TestValue");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute OCTET_STRING
      typedef void (*SuccessCallback_91)(void * context, chip::ByteSpan octetString);
      chip::Callback::Callback<SuccessCallback_91> * mOnSuccessCallback_91     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_91 = nullptr;
      bool mIsFailureExpected_91                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_91()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Sending command...");
  
          mOnFailureCallback_91 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_91_FailureResponse, this);
          mOnSuccessCallback_91 = new chip::Callback::Callback<SuccessCallback_91>(
              OnTestSendClusterTestClusterCommandWriteAttribute_91_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          chip::ByteSpan octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char(""), strlen(""));
          err = cluster.WriteAttributeOctetString(mOnSuccessCallback_91->Cancel(), mOnFailureCallback_91->Cancel(),
                                                  octetStringArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_91;
              delete mOnSuccessCallback_91;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_91_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_91;
          delete runner->mOnSuccessCallback_91;
  
          if (runner->mIsFailureExpected_91 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_91_SuccessResponse(void * context, chip::ByteSpan octetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_91;
          delete runner->mOnSuccessCallback_91;
  
          if (runner->mIsFailureExpected_91 == 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 LONG_OCTET_STRING Default Value
      typedef void (*SuccessCallback_92)(void * context, chip::ByteSpan longOctetString);
      chip::Callback::Callback<SuccessCallback_92> * mOnSuccessCallback_92     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_92 = nullptr;
      bool mIsFailureExpected_92                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_92()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LONG_OCTET_STRING Default Value: Sending command...");
  
          mOnFailureCallback_92 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_92_FailureResponse, this);
          mOnSuccessCallback_92 = new chip::Callback::Callback<SuccessCallback_92>(
              OnTestSendClusterTestClusterCommandReadAttribute_92_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeLongOctetString(mOnSuccessCallback_92->Cancel(), mOnFailureCallback_92->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_92;
              delete mOnSuccessCallback_92;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_92_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LONG_OCTET_STRING Default Value: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_92;
          delete runner->mOnSuccessCallback_92;
  
          if (runner->mIsFailureExpected_92 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_92_SuccessResponse(void * context, chip::ByteSpan longOctetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LONG_OCTET_STRING Default Value: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_92;
          delete runner->mOnSuccessCallback_92;
  
          if (runner->mIsFailureExpected_92 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          chip::ByteSpan longOctetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char(""), strlen(""));
          if (!longOctetString.data_equal(longOctetStringArgument))
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute LONG_OCTET_STRING
      typedef void (*SuccessCallback_93)(void * context, chip::ByteSpan longOctetString);
      chip::Callback::Callback<SuccessCallback_93> * mOnSuccessCallback_93     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_93 = nullptr;
      bool mIsFailureExpected_93                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_93()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute LONG_OCTET_STRING: Sending command...");
  
          mOnFailureCallback_93 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_93_FailureResponse, this);
          mOnSuccessCallback_93 = new chip::Callback::Callback<SuccessCallback_93>(
              OnTestSendClusterTestClusterCommandWriteAttribute_93_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          chip::ByteSpan longOctetStringArgument = chip::ByteSpan(
              chip::Uint8::from_const_char(
                  "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                  "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                  "111111111111111111111111111111111111111111111111111111111111111111111111"),
              strlen("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                     "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                     "111111111111111111111111111111111111111111111111111111111111111111111111111111"));
          err = cluster.WriteAttributeLongOctetString(mOnSuccessCallback_93->Cancel(), mOnFailureCallback_93->Cancel(),
                                                      longOctetStringArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_93;
              delete mOnSuccessCallback_93;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_93_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute LONG_OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_93;
          delete runner->mOnSuccessCallback_93;
  
          if (runner->mIsFailureExpected_93 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_93_SuccessResponse(void * context, chip::ByteSpan longOctetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute LONG_OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_93;
          delete runner->mOnSuccessCallback_93;
  
          if (runner->mIsFailureExpected_93 == 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 LONG_OCTET_STRING
      typedef void (*SuccessCallback_94)(void * context, chip::ByteSpan longOctetString);
      chip::Callback::Callback<SuccessCallback_94> * mOnSuccessCallback_94     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_94 = nullptr;
      bool mIsFailureExpected_94                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_94()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LONG_OCTET_STRING: Sending command...");
  
          mOnFailureCallback_94 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_94_FailureResponse, this);
          mOnSuccessCallback_94 = new chip::Callback::Callback<SuccessCallback_94>(
              OnTestSendClusterTestClusterCommandReadAttribute_94_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeLongOctetString(mOnSuccessCallback_94->Cancel(), mOnFailureCallback_94->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_94;
              delete mOnSuccessCallback_94;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_94_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LONG_OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_94;
          delete runner->mOnSuccessCallback_94;
  
          if (runner->mIsFailureExpected_94 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_94_SuccessResponse(void * context, chip::ByteSpan longOctetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LONG_OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_94;
          delete runner->mOnSuccessCallback_94;
  
          if (runner->mIsFailureExpected_94 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          chip::ByteSpan longOctetStringArgument = chip::ByteSpan(
              chip::Uint8::from_const_char(
                  "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                  "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                  "111111111111111111111111111111111111111111111111111111111111111111111111"),
              strlen("111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                     "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                     "111111111111111111111111111111111111111111111111111111111111111111111111111111"));
          if (!longOctetString.data_equal(longOctetStringArgument))
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'",
                           "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                           "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                           "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Write attribute LONG_OCTET_STRING
      typedef void (*SuccessCallback_95)(void * context, chip::ByteSpan longOctetString);
      chip::Callback::Callback<SuccessCallback_95> * mOnSuccessCallback_95     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_95 = nullptr;
      bool mIsFailureExpected_95                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_95()
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute LONG_OCTET_STRING: Sending command...");
  
          mOnFailureCallback_95 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_95_FailureResponse, this);
          mOnSuccessCallback_95 = new chip::Callback::Callback<SuccessCallback_95>(
              OnTestSendClusterTestClusterCommandWriteAttribute_95_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          chip::ByteSpan longOctetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char(""), strlen(""));
          err = cluster.WriteAttributeLongOctetString(mOnSuccessCallback_95->Cancel(), mOnFailureCallback_95->Cancel(),
                                                      longOctetStringArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_95;
              delete mOnSuccessCallback_95;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_95_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute LONG_OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_95;
          delete runner->mOnSuccessCallback_95;
  
          if (runner->mIsFailureExpected_95 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_95_SuccessResponse(void * context, chip::ByteSpan longOctetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Write attribute LONG_OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_95;
          delete runner->mOnSuccessCallback_95;
  
          if (runner->mIsFailureExpected_95 == 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 LIST
      typedef void (*SuccessCallback_96)(void * context, uint16_t count, uint8_t * listInt8u);
      chip::Callback::Callback<SuccessCallback_96> * mOnSuccessCallback_96     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_96 = nullptr;
      bool mIsFailureExpected_96                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_96()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST: Sending command...");
  
          mOnFailureCallback_96 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_96_FailureResponse, this);
          mOnSuccessCallback_96 = new chip::Callback::Callback<SuccessCallback_96>(
              OnTestSendClusterTestClusterCommandReadAttribute_96_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeListInt8u(mOnSuccessCallback_96->Cancel(), mOnFailureCallback_96->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_96;
              delete mOnSuccessCallback_96;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_96_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_96;
          delete runner->mOnSuccessCallback_96;
  
          if (runner->mIsFailureExpected_96 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_96_SuccessResponse(void * context, uint16_t count,
                                                                                      uint8_t * listInt8u)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_96;
          delete runner->mOnSuccessCallback_96;
  
          if (runner->mIsFailureExpected_96 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (count != 4)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1,2,3,4");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute LIST_OCTET_STRING
      typedef void (*SuccessCallback_97)(void * context, uint16_t count, chip::ByteSpan * listOctetString);
      chip::Callback::Callback<SuccessCallback_97> * mOnSuccessCallback_97     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_97 = nullptr;
      bool mIsFailureExpected_97                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_97()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST_OCTET_STRING: Sending command...");
  
          mOnFailureCallback_97 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_97_FailureResponse, this);
          mOnSuccessCallback_97 = new chip::Callback::Callback<SuccessCallback_97>(
              OnTestSendClusterTestClusterCommandReadAttribute_97_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeListOctetString(mOnSuccessCallback_97->Cancel(), mOnFailureCallback_97->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_97;
              delete mOnSuccessCallback_97;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_97_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST_OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_97;
          delete runner->mOnSuccessCallback_97;
  
          if (runner->mIsFailureExpected_97 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_97_SuccessResponse(void * context, uint16_t count,
                                                                                      chip::ByteSpan * listOctetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST_OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_97;
          delete runner->mOnSuccessCallback_97;
  
          if (runner->mIsFailureExpected_97 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (count != 4)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "Test0,Test1,Test2,Test3");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute LIST_STRUCT_OCTET_STRING
      typedef void (*SuccessCallback_98)(void * context, uint16_t count, _TestListStructOctet * listStructOctetString);
      chip::Callback::Callback<SuccessCallback_98> * mOnSuccessCallback_98     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_98 = nullptr;
      bool mIsFailureExpected_98                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_98()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST_STRUCT_OCTET_STRING: Sending command...");
  
          mOnFailureCallback_98 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_98_FailureResponse, this);
          mOnSuccessCallback_98 = new chip::Callback::Callback<SuccessCallback_98>(
              OnTestSendClusterTestClusterCommandReadAttribute_98_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeListStructOctetString(mOnSuccessCallback_98->Cancel(), mOnFailureCallback_98->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_98;
              delete mOnSuccessCallback_98;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_98_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST_STRUCT_OCTET_STRING: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_98;
          delete runner->mOnSuccessCallback_98;
  
          if (runner->mIsFailureExpected_98 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_98_SuccessResponse(void * context, uint16_t count,
                                                                                      _TestListStructOctet * listStructOctetString)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute LIST_STRUCT_OCTET_STRING: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_98;
          delete runner->mOnSuccessCallback_98;
  
          if (runner->mIsFailureExpected_98 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (count != 4)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'",
                           "[object Object],[object Object],[object Object],[object Object]");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Read attribute UNSUPPORTED
      typedef void (*SuccessCallback_99)(void * context, uint8_t unsupported);
      chip::Callback::Callback<SuccessCallback_99> * mOnSuccessCallback_99     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_99 = nullptr;
      bool mIsFailureExpected_99                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandReadAttribute_99()
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute UNSUPPORTED: Sending command...");
  
          mOnFailureCallback_99 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandReadAttribute_99_FailureResponse, this);
          mOnSuccessCallback_99 = new chip::Callback::Callback<SuccessCallback_99>(
              OnTestSendClusterTestClusterCommandReadAttribute_99_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeUnsupported(mOnSuccessCallback_99->Cancel(), mOnFailureCallback_99->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_99;
              delete mOnSuccessCallback_99;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_99_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute UNSUPPORTED: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_99;
          delete runner->mOnSuccessCallback_99;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_99 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandReadAttribute_99_SuccessResponse(void * context, uint8_t unsupported)
      {
          ChipLogProgress(chipTool, "Test Cluster - Read attribute UNSUPPORTED: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_99;
          delete runner->mOnSuccessCallback_99;
  
          if (runner->mIsFailureExpected_99 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (unsupported != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Writeattribute UNSUPPORTED
      typedef void (*SuccessCallback_100)(void * context, uint8_t unsupported);
      chip::Callback::Callback<SuccessCallback_100> * mOnSuccessCallback_100    = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_100 = nullptr;
      bool mIsFailureExpected_100                                               = 0;
  
      CHIP_ERROR TestSendClusterTestClusterCommandWriteAttribute_100()
      {
          ChipLogProgress(chipTool, "Test Cluster - Writeattribute UNSUPPORTED: Sending command...");
  
          mOnFailureCallback_100 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterTestClusterCommandWriteAttribute_100_FailureResponse, this);
          mOnSuccessCallback_100 = new chip::Callback::Callback<SuccessCallback_100>(
              OnTestSendClusterTestClusterCommandWriteAttribute_100_SuccessResponse, this);
  
          chip::Controller::TestClusterCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t unsupportedArgument = 0;
          err = cluster.WriteAttributeUnsupported(mOnSuccessCallback_100->Cancel(), mOnFailureCallback_100->Cancel(),
                                                  unsupportedArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_100;
              delete mOnSuccessCallback_100;
          }
  
          return err;
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_100_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Test Cluster - Writeattribute UNSUPPORTED: Failure Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_100;
          delete runner->mOnSuccessCallback_100;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_100 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterTestClusterCommandWriteAttribute_100_SuccessResponse(void * context, uint8_t unsupported)
      {
          ChipLogProgress(chipTool, "Test Cluster - Writeattribute UNSUPPORTED: Success Response");
  
          TestCluster * runner = reinterpret_cast<TestCluster *>(context);
  
          delete runner->mOnFailureCallback_100;
          delete runner->mOnSuccessCallback_100;
  
          if (runner->mIsFailureExpected_100 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  };
  
  class Test_TC_OO_1_1 : public TestCommand
  {
  public:
      Test_TC_OO_1_1() : TestCommand("Test_TC_OO_1_1"), mTestIndex(0) {}
  
      /////////// TestCommand Interface /////////
      void NextTest() override
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          if (mTestCount == mTestIndex)
          {
              ChipLogProgress(chipTool, "Test_TC_OO_1_1: 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 = TestSendClusterOnOffCommandReadAttribute_0();
              break;
          case 1:
              err = TestSendClusterOnOffCommandReadAttribute_1();
              break;
          case 2:
              err = TestSendClusterOnOffCommandReadAttribute_2();
              break;
          case 3:
              err = TestSendClusterOnOffCommandReadAttribute_3();
              break;
          }
  
          if (CHIP_NO_ERROR != err)
          {
              ChipLogProgress(chipTool, "Test_TC_OO_1_1: %s", chip::ErrorStr(err));
              SetCommandExitStatus(err);
          }
      }
  
  private:
      std::atomic_uint16_t mTestIndex;
      const uint16_t mTestCount = 4;
  
      //
      // Tests methods
      //
  
      // Test read the global attribute: ClusterRevision
      typedef void (*SuccessCallback_0)(void * context, uint16_t clusterRevision);
      chip::Callback::Callback<SuccessCallback_0> * mOnSuccessCallback_0      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_0 = nullptr;
      bool mIsFailureExpected_0                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_0()
      {
          ChipLogProgress(chipTool, "On/Off - read the global attribute: ClusterRevision: Sending command...");
  
          mOnFailureCallback_0 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_0_FailureResponse, this);
          mOnSuccessCallback_0 =
              new chip::Callback::Callback<SuccessCallback_0>(OnTestSendClusterOnOffCommandReadAttribute_0_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeClusterRevision(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_0;
              delete mOnSuccessCallback_0;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_0_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - read the global attribute: ClusterRevision: Failure Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_0_SuccessResponse(void * context, uint16_t clusterRevision)
      {
          ChipLogProgress(chipTool, "On/Off - read the global attribute: ClusterRevision: Success Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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 (clusterRevision != 2U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "2");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test reads back global attribute: ClusterRevision
      typedef void (*SuccessCallback_1)(void * context, uint16_t clusterRevision);
      chip::Callback::Callback<SuccessCallback_1> * mOnSuccessCallback_1      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_1 = nullptr;
      bool mIsFailureExpected_1                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_1()
      {
          ChipLogProgress(chipTool, "On/Off - reads back global attribute: ClusterRevision: Sending command...");
  
          mOnFailureCallback_1 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_1_FailureResponse, this);
          mOnSuccessCallback_1 =
              new chip::Callback::Callback<SuccessCallback_1>(OnTestSendClusterOnOffCommandReadAttribute_1_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeClusterRevision(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_1;
              delete mOnSuccessCallback_1;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_1_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - reads back global attribute: ClusterRevision: Failure Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_1_SuccessResponse(void * context, uint16_t clusterRevision)
      {
          ChipLogProgress(chipTool, "On/Off - reads back global attribute: ClusterRevision: Success Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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;
          }
  
          if (clusterRevision != 2U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "2");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test read the optional global attribute: FeatureMap
      typedef void (*SuccessCallback_2)(void * context, uint32_t featureMap);
      chip::Callback::Callback<SuccessCallback_2> * mOnSuccessCallback_2      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_2 = nullptr;
      bool mIsFailureExpected_2                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_2()
      {
          ChipLogProgress(chipTool, "On/Off - read the optional global attribute: FeatureMap: Sending command...");
  
          mOnFailureCallback_2 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_2_FailureResponse, this);
          mOnSuccessCallback_2 =
              new chip::Callback::Callback<SuccessCallback_2>(OnTestSendClusterOnOffCommandReadAttribute_2_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeFeatureMap(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_2;
              delete mOnSuccessCallback_2;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_2_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - read the optional global attribute: FeatureMap: Failure Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_2_SuccessResponse(void * context, uint32_t featureMap)
      {
          ChipLogProgress(chipTool, "On/Off - read the optional global attribute: FeatureMap: Success Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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 (featureMap != 0UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test reads back optional global attribute: FeatureMap
      typedef void (*SuccessCallback_3)(void * context, uint32_t featureMap);
      chip::Callback::Callback<SuccessCallback_3> * mOnSuccessCallback_3      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_3 = nullptr;
      bool mIsFailureExpected_3                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_3()
      {
          ChipLogProgress(chipTool, "On/Off - reads back optional global attribute: FeatureMap: Sending command...");
  
          mOnFailureCallback_3 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_3_FailureResponse, this);
          mOnSuccessCallback_3 =
              new chip::Callback::Callback<SuccessCallback_3>(OnTestSendClusterOnOffCommandReadAttribute_3_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeFeatureMap(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_3;
              delete mOnSuccessCallback_3;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_3_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - reads back optional global attribute: FeatureMap: Failure Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_3_SuccessResponse(void * context, uint32_t featureMap)
      {
          ChipLogProgress(chipTool, "On/Off - reads back optional global attribute: FeatureMap: Success Response");
  
          Test_TC_OO_1_1 * runner = reinterpret_cast<Test_TC_OO_1_1 *>(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;
          }
  
          if (featureMap != 0UL)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  };
  
  class Test_TC_OO_2_1 : public TestCommand
  {
  public:
      Test_TC_OO_2_1() : TestCommand("Test_TC_OO_2_1"), mTestIndex(0) {}
  
      /////////// TestCommand Interface /////////
      void NextTest() override
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          if (mTestCount == mTestIndex)
          {
              ChipLogProgress(chipTool, "Test_TC_OO_2_1: 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 = TestSendClusterOnOffCommandReadAttribute_0();
              break;
          case 1:
              err = TestSendClusterOnOffCommandReadAttribute_1();
              break;
          case 2:
              err = TestSendClusterOnOffCommandReadAttribute_2();
              break;
          case 3:
              err = TestSendClusterOnOffCommandReadAttribute_3();
              break;
          case 4:
              err = TestSendClusterOnOffCommandReadAttribute_4();
              break;
          case 5:
              err = TestSendClusterOnOffCommandReadAttribute_5();
              break;
          case 6:
              err = TestSendClusterOnOffCommandWriteAttribute_6();
              break;
          case 7:
              err = TestSendClusterOnOffCommandWriteAttribute_7();
              break;
          case 8:
              err = TestSendClusterOnOffCommandWriteAttribute_8();
              break;
          case 9:
              err = TestSendClusterOnOffCommandReadAttribute_9();
              break;
          case 10:
              err = TestSendClusterOnOffCommandReadAttribute_10();
              break;
          case 11:
              err = TestSendClusterOnOffCommandReadAttribute_11();
              break;
          }
  
          if (CHIP_NO_ERROR != err)
          {
              ChipLogProgress(chipTool, "Test_TC_OO_2_1: %s", chip::ErrorStr(err));
              SetCommandExitStatus(err);
          }
      }
  
  private:
      std::atomic_uint16_t mTestIndex;
      const uint16_t mTestCount = 12;
  
      //
      // Tests methods
      //
  
      // Test read the mandatory attribute: OnOff
      typedef void (*SuccessCallback_0)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_0> * mOnSuccessCallback_0      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_0 = nullptr;
      bool mIsFailureExpected_0                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_0()
      {
          ChipLogProgress(chipTool, "On/Off - read the mandatory attribute: OnOff: Sending command...");
  
          mOnFailureCallback_0 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_0_FailureResponse, this);
          mOnSuccessCallback_0 =
              new chip::Callback::Callback<SuccessCallback_0>(OnTestSendClusterOnOffCommandReadAttribute_0_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_0;
              delete mOnSuccessCallback_0;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_0_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - read the mandatory attribute: OnOff: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_0_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - read the mandatory attribute: OnOff: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 (onOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test reads back mandatory attribute: OnOff
      typedef void (*SuccessCallback_1)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_1> * mOnSuccessCallback_1      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_1 = nullptr;
      bool mIsFailureExpected_1                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_1()
      {
          ChipLogProgress(chipTool, "On/Off - reads back mandatory attribute: OnOff: Sending command...");
  
          mOnFailureCallback_1 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_1_FailureResponse, this);
          mOnSuccessCallback_1 =
              new chip::Callback::Callback<SuccessCallback_1>(OnTestSendClusterOnOffCommandReadAttribute_1_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_1;
              delete mOnSuccessCallback_1;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_1_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - reads back mandatory attribute: OnOff: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_1_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - reads back mandatory attribute: OnOff: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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;
          }
  
          if (onOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test read LT attribute: GlobalSceneControl
      typedef void (*SuccessCallback_2)(void * context, uint8_t globalSceneControl);
      chip::Callback::Callback<SuccessCallback_2> * mOnSuccessCallback_2      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_2 = nullptr;
      bool mIsFailureExpected_2                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_2()
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: GlobalSceneControl: Sending command...");
  
          mOnFailureCallback_2 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_2_FailureResponse, this);
          mOnSuccessCallback_2 =
              new chip::Callback::Callback<SuccessCallback_2>(OnTestSendClusterOnOffCommandReadAttribute_2_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeGlobalSceneControl(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_2;
              delete mOnSuccessCallback_2;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_2_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: GlobalSceneControl: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_2_SuccessResponse(void * context, uint8_t globalSceneControl)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: GlobalSceneControl: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 (globalSceneControl != 1)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test read LT attribute: OnTime
      typedef void (*SuccessCallback_3)(void * context, uint16_t onTime);
      chip::Callback::Callback<SuccessCallback_3> * mOnSuccessCallback_3      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_3 = nullptr;
      bool mIsFailureExpected_3                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_3()
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: OnTime: Sending command...");
  
          mOnFailureCallback_3 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_3_FailureResponse, this);
          mOnSuccessCallback_3 =
              new chip::Callback::Callback<SuccessCallback_3>(OnTestSendClusterOnOffCommandReadAttribute_3_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnTime(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_3;
              delete mOnSuccessCallback_3;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_3_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: OnTime: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_3_SuccessResponse(void * context, uint16_t onTime)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: OnTime: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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;
          }
  
          if (onTime != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test read LT attribute: OffWaitTime
      typedef void (*SuccessCallback_4)(void * context, uint16_t offWaitTime);
      chip::Callback::Callback<SuccessCallback_4> * mOnSuccessCallback_4      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_4 = nullptr;
      bool mIsFailureExpected_4                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_4()
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: OffWaitTime: Sending command...");
  
          mOnFailureCallback_4 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_4_FailureResponse, this);
          mOnSuccessCallback_4 =
              new chip::Callback::Callback<SuccessCallback_4>(OnTestSendClusterOnOffCommandReadAttribute_4_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOffWaitTime(mOnSuccessCallback_4->Cancel(), mOnFailureCallback_4->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_4;
              delete mOnSuccessCallback_4;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_4_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: OffWaitTime: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_4_SuccessResponse(void * context, uint16_t offWaitTime)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: OffWaitTime: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 (offWaitTime != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test read LT attribute: StartUpOnOff
      typedef void (*SuccessCallback_5)(void * context, uint8_t startUpOnOff);
      chip::Callback::Callback<SuccessCallback_5> * mOnSuccessCallback_5      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_5 = nullptr;
      bool mIsFailureExpected_5                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_5()
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: StartUpOnOff: Sending command...");
  
          mOnFailureCallback_5 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_5_FailureResponse, this);
          mOnSuccessCallback_5 =
              new chip::Callback::Callback<SuccessCallback_5>(OnTestSendClusterOnOffCommandReadAttribute_5_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeStartUpOnOff(mOnSuccessCallback_5->Cancel(), mOnFailureCallback_5->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_5;
              delete mOnSuccessCallback_5;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_5_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: StartUpOnOff: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_5_SuccessResponse(void * context, uint8_t startUpOnOff)
      {
          ChipLogProgress(chipTool, "On/Off - read LT attribute: StartUpOnOff: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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;
          }
  
          if (startUpOnOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test write the default value to LT attribute: OnTime
      typedef void (*SuccessCallback_6)(void * context, uint16_t onTime);
      chip::Callback::Callback<SuccessCallback_6> * mOnSuccessCallback_6      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_6 = nullptr;
      bool mIsFailureExpected_6                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandWriteAttribute_6()
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: OnTime: Sending command...");
  
          mOnFailureCallback_6 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandWriteAttribute_6_FailureResponse, this);
          mOnSuccessCallback_6 =
              new chip::Callback::Callback<SuccessCallback_6>(OnTestSendClusterOnOffCommandWriteAttribute_6_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t onTimeArgument = 0U;
          err = cluster.WriteAttributeOnTime(mOnSuccessCallback_6->Cancel(), mOnFailureCallback_6->Cancel(), onTimeArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_6;
              delete mOnSuccessCallback_6;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandWriteAttribute_6_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: OnTime: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandWriteAttribute_6_SuccessResponse(void * context, uint16_t onTime)
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: OnTime: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 write the default value to LT attribute: OffWaitTime
      typedef void (*SuccessCallback_7)(void * context, uint16_t offWaitTime);
      chip::Callback::Callback<SuccessCallback_7> * mOnSuccessCallback_7      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_7 = nullptr;
      bool mIsFailureExpected_7                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandWriteAttribute_7()
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: OffWaitTime: Sending command...");
  
          mOnFailureCallback_7 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandWriteAttribute_7_FailureResponse, this);
          mOnSuccessCallback_7 =
              new chip::Callback::Callback<SuccessCallback_7>(OnTestSendClusterOnOffCommandWriteAttribute_7_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint16_t offWaitTimeArgument = 0U;
          err =
              cluster.WriteAttributeOffWaitTime(mOnSuccessCallback_7->Cancel(), mOnFailureCallback_7->Cancel(), offWaitTimeArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_7;
              delete mOnSuccessCallback_7;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandWriteAttribute_7_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: OffWaitTime: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandWriteAttribute_7_SuccessResponse(void * context, uint16_t offWaitTime)
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: OffWaitTime: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 write the default value to LT attribute: StartUpOnOff
      typedef void (*SuccessCallback_8)(void * context, uint8_t startUpOnOff);
      chip::Callback::Callback<SuccessCallback_8> * mOnSuccessCallback_8      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_8 = nullptr;
      bool mIsFailureExpected_8                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandWriteAttribute_8()
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: StartUpOnOff: Sending command...");
  
          mOnFailureCallback_8 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandWriteAttribute_8_FailureResponse, this);
          mOnSuccessCallback_8 =
              new chip::Callback::Callback<SuccessCallback_8>(OnTestSendClusterOnOffCommandWriteAttribute_8_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          uint8_t startUpOnOffArgument = 0;
          err = cluster.WriteAttributeStartUpOnOff(mOnSuccessCallback_8->Cancel(), mOnFailureCallback_8->Cancel(),
                                                   startUpOnOffArgument);
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_8;
              delete mOnSuccessCallback_8;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandWriteAttribute_8_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: StartUpOnOff: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandWriteAttribute_8_SuccessResponse(void * context, uint8_t startUpOnOff)
      {
          ChipLogProgress(chipTool, "On/Off - write the default value to LT attribute: StartUpOnOff: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 reads back LT attribute: OnTime
      typedef void (*SuccessCallback_9)(void * context, uint16_t onTime);
      chip::Callback::Callback<SuccessCallback_9> * mOnSuccessCallback_9      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_9 = nullptr;
      bool mIsFailureExpected_9                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_9()
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: OnTime: Sending command...");
  
          mOnFailureCallback_9 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_9_FailureResponse, this);
          mOnSuccessCallback_9 =
              new chip::Callback::Callback<SuccessCallback_9>(OnTestSendClusterOnOffCommandReadAttribute_9_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnTime(mOnSuccessCallback_9->Cancel(), mOnFailureCallback_9->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_9;
              delete mOnSuccessCallback_9;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_9_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: OnTime: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_9_SuccessResponse(void * context, uint16_t onTime)
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: OnTime: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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;
          }
  
          if (onTime != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test reads back LT attribute: OffWaitTime
      typedef void (*SuccessCallback_10)(void * context, uint16_t offWaitTime);
      chip::Callback::Callback<SuccessCallback_10> * mOnSuccessCallback_10     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_10 = nullptr;
      bool mIsFailureExpected_10                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_10()
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: OffWaitTime: Sending command...");
  
          mOnFailureCallback_10 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_10_FailureResponse, this);
          mOnSuccessCallback_10 =
              new chip::Callback::Callback<SuccessCallback_10>(OnTestSendClusterOnOffCommandReadAttribute_10_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOffWaitTime(mOnSuccessCallback_10->Cancel(), mOnFailureCallback_10->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_10;
              delete mOnSuccessCallback_10;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_10_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: OffWaitTime: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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 OnTestSendClusterOnOffCommandReadAttribute_10_SuccessResponse(void * context, uint16_t offWaitTime)
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: OffWaitTime: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(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;
          }
  
          if (offWaitTime != 0U)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test reads back LT attribute: StartUpOnOff
      typedef void (*SuccessCallback_11)(void * context, uint8_t startUpOnOff);
      chip::Callback::Callback<SuccessCallback_11> * mOnSuccessCallback_11     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_11 = nullptr;
      bool mIsFailureExpected_11                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_11()
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: StartUpOnOff: Sending command...");
  
          mOnFailureCallback_11 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_11_FailureResponse, this);
          mOnSuccessCallback_11 =
              new chip::Callback::Callback<SuccessCallback_11>(OnTestSendClusterOnOffCommandReadAttribute_11_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeStartUpOnOff(mOnSuccessCallback_11->Cancel(), mOnFailureCallback_11->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_11;
              delete mOnSuccessCallback_11;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_11_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: StartUpOnOff: Failure Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (runner->mIsFailureExpected_11 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_11_SuccessResponse(void * context, uint8_t startUpOnOff)
      {
          ChipLogProgress(chipTool, "On/Off - reads back LT attribute: StartUpOnOff: Success Response");
  
          Test_TC_OO_2_1 * runner = reinterpret_cast<Test_TC_OO_2_1 *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (runner->mIsFailureExpected_11 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (startUpOnOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  };
  
  class Test_TC_OO_2_2 : public TestCommand
  {
  public:
      Test_TC_OO_2_2() : TestCommand("Test_TC_OO_2_2"), mTestIndex(0) {}
  
      /////////// TestCommand Interface /////////
      void NextTest() override
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          if (mTestCount == mTestIndex)
          {
              ChipLogProgress(chipTool, "Test_TC_OO_2_2: 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 = TestSendClusterOnOffCommandOff_0();
              break;
          case 1:
              err = TestSendClusterOnOffCommandReadAttribute_1();
              break;
          case 2:
              err = TestSendClusterOnOffCommandOn_2();
              break;
          case 3:
              err = TestSendClusterOnOffCommandReadAttribute_3();
              break;
          case 4:
              err = TestSendClusterOnOffCommandOff_4();
              break;
          case 5:
              err = TestSendClusterOnOffCommandReadAttribute_5();
              break;
          case 6:
              err = TestSendClusterOnOffCommandToggle_6();
              break;
          case 7:
              err = TestSendClusterOnOffCommandReadAttribute_7();
              break;
          case 8:
              err = TestSendClusterOnOffCommandToggle_8();
              break;
          case 9:
              err = TestSendClusterOnOffCommandReadAttribute_9();
              break;
          case 10:
              err = TestSendClusterOnOffCommandOn_10();
              break;
          case 11:
              err = TestSendClusterOnOffCommandReadAttribute_11();
              break;
          case 12:
              err = TestSendClusterOnOffCommandOff_12();
              break;
          case 13:
              err = TestSendClusterOnOffCommandReadAttribute_13();
              break;
          }
  
          if (CHIP_NO_ERROR != err)
          {
              ChipLogProgress(chipTool, "Test_TC_OO_2_2: %s", chip::ErrorStr(err));
              SetCommandExitStatus(err);
          }
      }
  
  private:
      std::atomic_uint16_t mTestIndex;
      const uint16_t mTestCount = 14;
  
      //
      // Tests methods
      //
  
      // Test Send Off Command
      typedef void (*SuccessCallback_0)(void * context);
      chip::Callback::Callback<SuccessCallback_0> * mOnSuccessCallback_0      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_0 = nullptr;
      bool mIsFailureExpected_0                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandOff_0()
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Sending command...");
  
          mOnFailureCallback_0 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterOnOffCommandOff_0_FailureResponse, this);
          mOnSuccessCallback_0 =
              new chip::Callback::Callback<SuccessCallback_0>(OnTestSendClusterOnOffCommandOff_0_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.Off(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_0;
              delete mOnSuccessCallback_0;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandOff_0_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandOff_0_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 Check on/off attribute value is false after off command
      typedef void (*SuccessCallback_1)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_1> * mOnSuccessCallback_1      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_1 = nullptr;
      bool mIsFailureExpected_1                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_1()
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Sending command...");
  
          mOnFailureCallback_1 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_1_FailureResponse, this);
          mOnSuccessCallback_1 =
              new chip::Callback::Callback<SuccessCallback_1>(OnTestSendClusterOnOffCommandReadAttribute_1_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_1->Cancel(), mOnFailureCallback_1->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_1;
              delete mOnSuccessCallback_1;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_1_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandReadAttribute_1_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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;
          }
  
          if (onOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Send On Command
      typedef void (*SuccessCallback_2)(void * context);
      chip::Callback::Callback<SuccessCallback_2> * mOnSuccessCallback_2      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_2 = nullptr;
      bool mIsFailureExpected_2                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandOn_2()
      {
          ChipLogProgress(chipTool, "On/Off - Send On Command: Sending command...");
  
          mOnFailureCallback_2 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterOnOffCommandOn_2_FailureResponse, this);
          mOnSuccessCallback_2 =
              new chip::Callback::Callback<SuccessCallback_2>(OnTestSendClusterOnOffCommandOn_2_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.On(mOnSuccessCallback_2->Cancel(), mOnFailureCallback_2->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_2;
              delete mOnSuccessCallback_2;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandOn_2_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Send On Command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandOn_2_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "On/Off - Send On Command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 Check on/off attribute value is true after on command
      typedef void (*SuccessCallback_3)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_3> * mOnSuccessCallback_3      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_3 = nullptr;
      bool mIsFailureExpected_3                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_3()
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after on command: Sending command...");
  
          mOnFailureCallback_3 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_3_FailureResponse, this);
          mOnSuccessCallback_3 =
              new chip::Callback::Callback<SuccessCallback_3>(OnTestSendClusterOnOffCommandReadAttribute_3_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_3;
              delete mOnSuccessCallback_3;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_3_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after on command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandReadAttribute_3_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after on command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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;
          }
  
          if (onOff != 1)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Send Off Command
      typedef void (*SuccessCallback_4)(void * context);
      chip::Callback::Callback<SuccessCallback_4> * mOnSuccessCallback_4      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_4 = nullptr;
      bool mIsFailureExpected_4                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandOff_4()
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Sending command...");
  
          mOnFailureCallback_4 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterOnOffCommandOff_4_FailureResponse, this);
          mOnSuccessCallback_4 =
              new chip::Callback::Callback<SuccessCallback_4>(OnTestSendClusterOnOffCommandOff_4_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.Off(mOnSuccessCallback_4->Cancel(), mOnFailureCallback_4->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_4;
              delete mOnSuccessCallback_4;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandOff_4_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandOff_4_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 Check on/off attribute value is false after off command
      typedef void (*SuccessCallback_5)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_5> * mOnSuccessCallback_5      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_5 = nullptr;
      bool mIsFailureExpected_5                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_5()
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Sending command...");
  
          mOnFailureCallback_5 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_5_FailureResponse, this);
          mOnSuccessCallback_5 =
              new chip::Callback::Callback<SuccessCallback_5>(OnTestSendClusterOnOffCommandReadAttribute_5_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_5->Cancel(), mOnFailureCallback_5->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_5;
              delete mOnSuccessCallback_5;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_5_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandReadAttribute_5_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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;
          }
  
          if (onOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Send Toggle Command
      typedef void (*SuccessCallback_6)(void * context);
      chip::Callback::Callback<SuccessCallback_6> * mOnSuccessCallback_6      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_6 = nullptr;
      bool mIsFailureExpected_6                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandToggle_6()
      {
          ChipLogProgress(chipTool, "On/Off - Send Toggle Command: Sending command...");
  
          mOnFailureCallback_6 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterOnOffCommandToggle_6_FailureResponse, this);
          mOnSuccessCallback_6 =
              new chip::Callback::Callback<SuccessCallback_6>(OnTestSendClusterOnOffCommandToggle_6_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.Toggle(mOnSuccessCallback_6->Cancel(), mOnFailureCallback_6->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_6;
              delete mOnSuccessCallback_6;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandToggle_6_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Send Toggle Command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandToggle_6_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "On/Off - Send Toggle Command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 Check on/off attribute value is true after toggle command
      typedef void (*SuccessCallback_7)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_7> * mOnSuccessCallback_7      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_7 = nullptr;
      bool mIsFailureExpected_7                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_7()
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after toggle command: Sending command...");
  
          mOnFailureCallback_7 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_7_FailureResponse, this);
          mOnSuccessCallback_7 =
              new chip::Callback::Callback<SuccessCallback_7>(OnTestSendClusterOnOffCommandReadAttribute_7_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_7->Cancel(), mOnFailureCallback_7->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_7;
              delete mOnSuccessCallback_7;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_7_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after toggle command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandReadAttribute_7_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after toggle command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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;
          }
  
          if (onOff != 1)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Send Toggle Command
      typedef void (*SuccessCallback_8)(void * context);
      chip::Callback::Callback<SuccessCallback_8> * mOnSuccessCallback_8      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_8 = nullptr;
      bool mIsFailureExpected_8                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandToggle_8()
      {
          ChipLogProgress(chipTool, "On/Off - Send Toggle Command: Sending command...");
  
          mOnFailureCallback_8 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterOnOffCommandToggle_8_FailureResponse, this);
          mOnSuccessCallback_8 =
              new chip::Callback::Callback<SuccessCallback_8>(OnTestSendClusterOnOffCommandToggle_8_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.Toggle(mOnSuccessCallback_8->Cancel(), mOnFailureCallback_8->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_8;
              delete mOnSuccessCallback_8;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandToggle_8_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Send Toggle Command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandToggle_8_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "On/Off - Send Toggle Command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 Check on/off attribute value is false after toggle command
      typedef void (*SuccessCallback_9)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_9> * mOnSuccessCallback_9      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_9 = nullptr;
      bool mIsFailureExpected_9                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_9()
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after toggle command: Sending command...");
  
          mOnFailureCallback_9 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_9_FailureResponse, this);
          mOnSuccessCallback_9 =
              new chip::Callback::Callback<SuccessCallback_9>(OnTestSendClusterOnOffCommandReadAttribute_9_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_9->Cancel(), mOnFailureCallback_9->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_9;
              delete mOnSuccessCallback_9;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_9_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after toggle command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandReadAttribute_9_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after toggle command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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;
          }
  
          if (onOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Send On Command
      typedef void (*SuccessCallback_10)(void * context);
      chip::Callback::Callback<SuccessCallback_10> * mOnSuccessCallback_10     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_10 = nullptr;
      bool mIsFailureExpected_10                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandOn_10()
      {
          ChipLogProgress(chipTool, "On/Off - Send On Command: Sending command...");
  
          mOnFailureCallback_10 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterOnOffCommandOn_10_FailureResponse, this);
          mOnSuccessCallback_10 =
              new chip::Callback::Callback<SuccessCallback_10>(OnTestSendClusterOnOffCommandOn_10_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.On(mOnSuccessCallback_10->Cancel(), mOnFailureCallback_10->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_10;
              delete mOnSuccessCallback_10;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandOn_10_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Send On Command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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 OnTestSendClusterOnOffCommandOn_10_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "On/Off - Send On Command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(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();
      }
  
      // Test Check on/off attribute value is true after on command
      typedef void (*SuccessCallback_11)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_11> * mOnSuccessCallback_11     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_11 = nullptr;
      bool mIsFailureExpected_11                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_11()
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after on command: Sending command...");
  
          mOnFailureCallback_11 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_11_FailureResponse, this);
          mOnSuccessCallback_11 =
              new chip::Callback::Callback<SuccessCallback_11>(OnTestSendClusterOnOffCommandReadAttribute_11_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_11->Cancel(), mOnFailureCallback_11->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_11;
              delete mOnSuccessCallback_11;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_11_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after on command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (runner->mIsFailureExpected_11 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_11_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is true after on command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (runner->mIsFailureExpected_11 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (onOff != 1)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "1");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Send Off Command
      typedef void (*SuccessCallback_12)(void * context);
      chip::Callback::Callback<SuccessCallback_12> * mOnSuccessCallback_12     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_12 = nullptr;
      bool mIsFailureExpected_12                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandOff_12()
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Sending command...");
  
          mOnFailureCallback_12 =
              new chip::Callback::Callback<DefaultFailureCallback>(OnTestSendClusterOnOffCommandOff_12_FailureResponse, this);
          mOnSuccessCallback_12 =
              new chip::Callback::Callback<SuccessCallback_12>(OnTestSendClusterOnOffCommandOff_12_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.Off(mOnSuccessCallback_12->Cancel(), mOnFailureCallback_12->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_12;
              delete mOnSuccessCallback_12;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandOff_12_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(context);
  
          delete runner->mOnFailureCallback_12;
          delete runner->mOnSuccessCallback_12;
  
          if (runner->mIsFailureExpected_12 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterOnOffCommandOff_12_SuccessResponse(void * context)
      {
          ChipLogProgress(chipTool, "On/Off - Send Off Command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(context);
  
          delete runner->mOnFailureCallback_12;
          delete runner->mOnSuccessCallback_12;
  
          if (runner->mIsFailureExpected_12 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Check on/off attribute value is false after off command
      typedef void (*SuccessCallback_13)(void * context, uint8_t onOff);
      chip::Callback::Callback<SuccessCallback_13> * mOnSuccessCallback_13     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_13 = nullptr;
      bool mIsFailureExpected_13                                               = 0;
  
      CHIP_ERROR TestSendClusterOnOffCommandReadAttribute_13()
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Sending command...");
  
          mOnFailureCallback_13 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterOnOffCommandReadAttribute_13_FailureResponse, this);
          mOnSuccessCallback_13 =
              new chip::Callback::Callback<SuccessCallback_13>(OnTestSendClusterOnOffCommandReadAttribute_13_SuccessResponse, this);
  
          chip::Controller::OnOffCluster cluster;
          cluster.Associate(mDevice, 1);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeOnOff(mOnSuccessCallback_13->Cancel(), mOnFailureCallback_13->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_13;
              delete mOnSuccessCallback_13;
          }
  
          return err;
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_13_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Failure Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(context);
  
          delete runner->mOnFailureCallback_13;
          delete runner->mOnSuccessCallback_13;
  
          if (runner->mIsFailureExpected_13 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterOnOffCommandReadAttribute_13_SuccessResponse(void * context, uint8_t onOff)
      {
          ChipLogProgress(chipTool, "On/Off - Check on/off attribute value is false after off command: Success Response");
  
          Test_TC_OO_2_2 * runner = reinterpret_cast<Test_TC_OO_2_2 *>(context);
  
          delete runner->mOnFailureCallback_13;
          delete runner->mOnSuccessCallback_13;
  
          if (runner->mIsFailureExpected_13 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          if (onOff != 0)
          {
              ChipLogError(chipTool, "Error: Value mismatch. Expected: '%s'", "0");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  };
  
  class Test_TC_DM_1_1 : public TestCommand
  {
  public:
      Test_TC_DM_1_1() : TestCommand("Test_TC_DM_1_1"), mTestIndex(0) {}
  
      /////////// TestCommand Interface /////////
      void NextTest() override
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          if (mTestCount == mTestIndex)
          {
              ChipLogProgress(chipTool, "Test_TC_DM_1_1: 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 = TestSendClusterBasicCommandReadAttribute_0();
              break;
          case 1:
              err = TestSendClusterBasicCommandReadAttribute_1();
              break;
          case 2:
              err = TestSendClusterBasicCommandReadAttribute_2();
              break;
          case 3:
              err = TestSendClusterBasicCommandReadAttribute_3();
              break;
          case 4:
              err = TestSendClusterBasicCommandReadAttribute_4();
              break;
          case 5:
              err = TestSendClusterBasicCommandReadAttribute_5();
              break;
          case 6:
              err = TestSendClusterBasicCommandReadAttribute_6();
              break;
          case 7:
              err = TestSendClusterBasicCommandReadAttribute_7();
              break;
          case 8:
              err = TestSendClusterBasicCommandReadAttribute_8();
              break;
          case 9:
              err = TestSendClusterBasicCommandReadAttribute_9();
              break;
          case 10:
              err = TestSendClusterBasicCommandReadAttribute_10();
              break;
          case 11:
              err = TestSendClusterBasicCommandReadAttribute_11();
              break;
          case 12:
              err = TestSendClusterBasicCommandReadAttribute_12();
              break;
          case 13:
              err = TestSendClusterBasicCommandReadAttribute_13();
              break;
          case 14:
              err = TestSendClusterBasicCommandReadAttribute_14();
              break;
          case 15:
              err = TestSendClusterBasicCommandReadAttribute_15();
              break;
          case 16:
              err = TestSendClusterBasicCommandReadAttribute_16();
              break;
          case 17:
              err = TestSendClusterBasicCommandReadAttribute_17();
              break;
          }
  
          if (CHIP_NO_ERROR != err)
          {
              ChipLogProgress(chipTool, "Test_TC_DM_1_1: %s", chip::ErrorStr(err));
              SetCommandExitStatus(err);
          }
      }
  
  private:
      std::atomic_uint16_t mTestIndex;
      const uint16_t mTestCount = 18;
  
      //
      // Tests methods
      //
  
      // Test Query Interaction Model Version
      typedef void (*SuccessCallback_0)(void * context, uint16_t interactionModelVersion);
      chip::Callback::Callback<SuccessCallback_0> * mOnSuccessCallback_0      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_0 = nullptr;
      bool mIsFailureExpected_0                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_0()
      {
          ChipLogProgress(chipTool, "Basic - Query Interaction Model Version: Sending command...");
  
          mOnFailureCallback_0 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_0_FailureResponse, this);
          mOnSuccessCallback_0 =
              new chip::Callback::Callback<SuccessCallback_0>(OnTestSendClusterBasicCommandReadAttribute_0_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeInteractionModelVersion(mOnSuccessCallback_0->Cancel(), mOnFailureCallback_0->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_0;
              delete mOnSuccessCallback_0;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_0_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query Interaction Model Version: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_0_SuccessResponse(void * context, uint16_t interactionModelVersion)
      {
          ChipLogProgress(chipTool, "Basic - Query Interaction Model Version: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: interactionModelVersion type checking is not implemented yet. Expected type: '%s'",
                       "uint16");
  
          runner->NextTest();
      }
  
      // Test Query Vendor Name
      typedef void (*SuccessCallback_1)(void * context, chip::ByteSpan vendorName);
      chip::Callback::Callback<SuccessCallback_1> * mOnSuccessCallback_1      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_1 = nullptr;
      bool mIsFailureExpected_1                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_1()
      {
          ChipLogProgress(chipTool, "Basic - Query Vendor Name: Sending command...");
  
          mOnFailureCallback_1 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_1_FailureResponse, this);
          mOnSuccessCallback_1 =
              new chip::Callback::Callback<SuccessCallback_1>(OnTestSendClusterBasicCommandReadAttribute_1_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          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 OnTestSendClusterBasicCommandReadAttribute_1_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query Vendor Name: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_1_SuccessResponse(void * context, chip::ByteSpan vendorName)
      {
          ChipLogProgress(chipTool, "Basic - Query Vendor Name: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: vendorName type checking is not implemented yet. Expected type: '%s'", "string");
  
          if (vendorName.size() > 32)
          {
              ChipLogError(chipTool, "Error: vendorName is too long. Max size is 32 but got '%zu'", vendorName.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query VendorID
      typedef void (*SuccessCallback_2)(void * context, uint16_t vendorID);
      chip::Callback::Callback<SuccessCallback_2> * mOnSuccessCallback_2      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_2 = nullptr;
      bool mIsFailureExpected_2                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_2()
      {
          ChipLogProgress(chipTool, "Basic - Query VendorID: Sending command...");
  
          mOnFailureCallback_2 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_2_FailureResponse, this);
          mOnSuccessCallback_2 =
              new chip::Callback::Callback<SuccessCallback_2>(OnTestSendClusterBasicCommandReadAttribute_2_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          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 OnTestSendClusterBasicCommandReadAttribute_2_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query VendorID: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_2_SuccessResponse(void * context, uint16_t vendorID)
      {
          ChipLogProgress(chipTool, "Basic - Query VendorID: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: vendorID type checking is not implemented yet. Expected type: '%s'", "uint16");
  
          runner->NextTest();
      }
  
      // Test Query Product Name
      typedef void (*SuccessCallback_3)(void * context, chip::ByteSpan productName);
      chip::Callback::Callback<SuccessCallback_3> * mOnSuccessCallback_3      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_3 = nullptr;
      bool mIsFailureExpected_3                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_3()
      {
          ChipLogProgress(chipTool, "Basic - Query Product Name: Sending command...");
  
          mOnFailureCallback_3 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_3_FailureResponse, this);
          mOnSuccessCallback_3 =
              new chip::Callback::Callback<SuccessCallback_3>(OnTestSendClusterBasicCommandReadAttribute_3_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeProductName(mOnSuccessCallback_3->Cancel(), mOnFailureCallback_3->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_3;
              delete mOnSuccessCallback_3;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_3_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query Product Name: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_3_SuccessResponse(void * context, chip::ByteSpan productName)
      {
          ChipLogProgress(chipTool, "Basic - Query Product Name: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: productName type checking is not implemented yet. Expected type: '%s'", "string");
  
          if (productName.size() > 32)
          {
              ChipLogError(chipTool, "Error: productName is too long. Max size is 32 but got '%zu'", productName.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query ProductID
      typedef void (*SuccessCallback_4)(void * context, uint16_t productID);
      chip::Callback::Callback<SuccessCallback_4> * mOnSuccessCallback_4      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_4 = nullptr;
      bool mIsFailureExpected_4                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_4()
      {
          ChipLogProgress(chipTool, "Basic - Query ProductID: Sending command...");
  
          mOnFailureCallback_4 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_4_FailureResponse, this);
          mOnSuccessCallback_4 =
              new chip::Callback::Callback<SuccessCallback_4>(OnTestSendClusterBasicCommandReadAttribute_4_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          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 OnTestSendClusterBasicCommandReadAttribute_4_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query ProductID: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_4_SuccessResponse(void * context, uint16_t productID)
      {
          ChipLogProgress(chipTool, "Basic - Query ProductID: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: productID type checking is not implemented yet. Expected type: '%s'", "uint16");
  
          runner->NextTest();
      }
  
      // Test Query User Label
      typedef void (*SuccessCallback_5)(void * context, chip::ByteSpan userLabel);
      chip::Callback::Callback<SuccessCallback_5> * mOnSuccessCallback_5      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_5 = nullptr;
      bool mIsFailureExpected_5                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_5()
      {
          ChipLogProgress(chipTool, "Basic - Query User Label: Sending command...");
  
          mOnFailureCallback_5 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_5_FailureResponse, this);
          mOnSuccessCallback_5 =
              new chip::Callback::Callback<SuccessCallback_5>(OnTestSendClusterBasicCommandReadAttribute_5_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeUserLabel(mOnSuccessCallback_5->Cancel(), mOnFailureCallback_5->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_5;
              delete mOnSuccessCallback_5;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_5_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query User Label: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_5_SuccessResponse(void * context, chip::ByteSpan userLabel)
      {
          ChipLogProgress(chipTool, "Basic - Query User Label: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: userLabel type checking is not implemented yet. Expected type: '%s'", "string");
  
          if (userLabel.size() > 32)
          {
              ChipLogError(chipTool, "Error: userLabel is too long. Max size is 32 but got '%zu'", userLabel.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query User Location
      typedef void (*SuccessCallback_6)(void * context, chip::ByteSpan location);
      chip::Callback::Callback<SuccessCallback_6> * mOnSuccessCallback_6      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_6 = nullptr;
      bool mIsFailureExpected_6                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_6()
      {
          ChipLogProgress(chipTool, "Basic - Query User Location: Sending command...");
  
          mOnFailureCallback_6 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_6_FailureResponse, this);
          mOnSuccessCallback_6 =
              new chip::Callback::Callback<SuccessCallback_6>(OnTestSendClusterBasicCommandReadAttribute_6_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeLocation(mOnSuccessCallback_6->Cancel(), mOnFailureCallback_6->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_6;
              delete mOnSuccessCallback_6;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_6_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query User Location: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_6_SuccessResponse(void * context, chip::ByteSpan location)
      {
          ChipLogProgress(chipTool, "Basic - Query User Location: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: location type checking is not implemented yet. Expected type: '%s'", "string");
  
          ChipLogError(chipTool, "Warning: location format checking is not implemented yet. Expected format: '%s'",
                       "ISO 3166-1 alpha-2");
  
          if (location.size() > 2)
          {
              ChipLogError(chipTool, "Error: location is too long. Max size is 2 but got '%zu'", location.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query HardwareVersion
      typedef void (*SuccessCallback_7)(void * context, uint16_t hardwareVersion);
      chip::Callback::Callback<SuccessCallback_7> * mOnSuccessCallback_7      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_7 = nullptr;
      bool mIsFailureExpected_7                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_7()
      {
          ChipLogProgress(chipTool, "Basic - Query HardwareVersion: Sending command...");
  
          mOnFailureCallback_7 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_7_FailureResponse, this);
          mOnSuccessCallback_7 =
              new chip::Callback::Callback<SuccessCallback_7>(OnTestSendClusterBasicCommandReadAttribute_7_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeHardwareVersion(mOnSuccessCallback_7->Cancel(), mOnFailureCallback_7->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_7;
              delete mOnSuccessCallback_7;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_7_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query HardwareVersion: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_7_SuccessResponse(void * context, uint16_t hardwareVersion)
      {
          ChipLogProgress(chipTool, "Basic - Query HardwareVersion: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: hardwareVersion type checking is not implemented yet. Expected type: '%s'", "uint16");
  
          runner->NextTest();
      }
  
      // Test Query HardwareVersionString
      typedef void (*SuccessCallback_8)(void * context, chip::ByteSpan hardwareVersionString);
      chip::Callback::Callback<SuccessCallback_8> * mOnSuccessCallback_8      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_8 = nullptr;
      bool mIsFailureExpected_8                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_8()
      {
          ChipLogProgress(chipTool, "Basic - Query HardwareVersionString: Sending command...");
  
          mOnFailureCallback_8 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_8_FailureResponse, this);
          mOnSuccessCallback_8 =
              new chip::Callback::Callback<SuccessCallback_8>(OnTestSendClusterBasicCommandReadAttribute_8_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeHardwareVersionString(mOnSuccessCallback_8->Cancel(), mOnFailureCallback_8->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_8;
              delete mOnSuccessCallback_8;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_8_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query HardwareVersionString: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_8_SuccessResponse(void * context, chip::ByteSpan hardwareVersionString)
      {
          ChipLogProgress(chipTool, "Basic - Query HardwareVersionString: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: hardwareVersionString type checking is not implemented yet. Expected type: '%s'",
                       "string");
  
          if (hardwareVersionString.size() < 1)
          {
              ChipLogError(chipTool, "Error: hardwareVersionString is too short. Min size is 1 but got '%zu'",
                           hardwareVersionString.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          if (hardwareVersionString.size() > 64)
          {
              ChipLogError(chipTool, "Error: hardwareVersionString is too long. Max size is 64 but got '%zu'",
                           hardwareVersionString.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query SoftwareVersion
      typedef void (*SuccessCallback_9)(void * context, uint32_t softwareVersion);
      chip::Callback::Callback<SuccessCallback_9> * mOnSuccessCallback_9      = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_9 = nullptr;
      bool mIsFailureExpected_9                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_9()
      {
          ChipLogProgress(chipTool, "Basic - Query SoftwareVersion: Sending command...");
  
          mOnFailureCallback_9 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_9_FailureResponse, this);
          mOnSuccessCallback_9 =
              new chip::Callback::Callback<SuccessCallback_9>(OnTestSendClusterBasicCommandReadAttribute_9_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeSoftwareVersion(mOnSuccessCallback_9->Cancel(), mOnFailureCallback_9->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_9;
              delete mOnSuccessCallback_9;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_9_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query SoftwareVersion: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_9_SuccessResponse(void * context, uint32_t softwareVersion)
      {
          ChipLogProgress(chipTool, "Basic - Query SoftwareVersion: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: softwareVersion type checking is not implemented yet. Expected type: '%s'", "uint32");
  
          runner->NextTest();
      }
  
      // Test Query SoftwareVersionString
      typedef void (*SuccessCallback_10)(void * context, chip::ByteSpan softwareVersionString);
      chip::Callback::Callback<SuccessCallback_10> * mOnSuccessCallback_10     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_10 = nullptr;
      bool mIsFailureExpected_10                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_10()
      {
          ChipLogProgress(chipTool, "Basic - Query SoftwareVersionString: Sending command...");
  
          mOnFailureCallback_10 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_10_FailureResponse, this);
          mOnSuccessCallback_10 =
              new chip::Callback::Callback<SuccessCallback_10>(OnTestSendClusterBasicCommandReadAttribute_10_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeSoftwareVersionString(mOnSuccessCallback_10->Cancel(), mOnFailureCallback_10->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_10;
              delete mOnSuccessCallback_10;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_10_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query SoftwareVersionString: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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 OnTestSendClusterBasicCommandReadAttribute_10_SuccessResponse(void * context, chip::ByteSpan softwareVersionString)
      {
          ChipLogProgress(chipTool, "Basic - Query SoftwareVersionString: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(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;
          }
  
          ChipLogError(chipTool, "Warning: softwareVersionString type checking is not implemented yet. Expected type: '%s'",
                       "string");
  
          ChipLogError(chipTool, "Warning: softwareVersionString format checking is not implemented yet. Expected format: '%s'",
                       "ASCII");
  
          if (softwareVersionString.size() < 1)
          {
              ChipLogError(chipTool, "Error: softwareVersionString is too short. Min size is 1 but got '%zu'",
                           softwareVersionString.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          if (softwareVersionString.size() > 64)
          {
              ChipLogError(chipTool, "Error: softwareVersionString is too long. Max size is 64 but got '%zu'",
                           softwareVersionString.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query ManufacturingDate
      typedef void (*SuccessCallback_11)(void * context, chip::ByteSpan manufacturingDate);
      chip::Callback::Callback<SuccessCallback_11> * mOnSuccessCallback_11     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_11 = nullptr;
      bool mIsFailureExpected_11                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_11()
      {
          ChipLogProgress(chipTool, "Basic - Query ManufacturingDate: Sending command...");
  
          mOnFailureCallback_11 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_11_FailureResponse, this);
          mOnSuccessCallback_11 =
              new chip::Callback::Callback<SuccessCallback_11>(OnTestSendClusterBasicCommandReadAttribute_11_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeManufacturingDate(mOnSuccessCallback_11->Cancel(), mOnFailureCallback_11->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_11;
              delete mOnSuccessCallback_11;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_11_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query ManufacturingDate: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_11 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_11_SuccessResponse(void * context, chip::ByteSpan manufacturingDate)
      {
          ChipLogProgress(chipTool, "Basic - Query ManufacturingDate: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_11;
          delete runner->mOnSuccessCallback_11;
  
          if (runner->mIsFailureExpected_11 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          ChipLogError(chipTool, "Warning: manufacturingDate type checking is not implemented yet. Expected type: '%s'", "string");
  
          ChipLogError(chipTool, "Warning: manufacturingDate format checking is not implemented yet. Expected format: '%s'",
                       "ISO 8601");
  
          if (manufacturingDate.size() < 8)
          {
              ChipLogError(chipTool, "Error: manufacturingDate is too short. Min size is 8 but got '%zu'", manufacturingDate.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          if (manufacturingDate.size() > 16)
          {
              ChipLogError(chipTool, "Error: manufacturingDate is too long. Max size is 16 but got '%zu'", manufacturingDate.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query PartNumber
      typedef void (*SuccessCallback_12)(void * context, chip::ByteSpan partNumber);
      chip::Callback::Callback<SuccessCallback_12> * mOnSuccessCallback_12     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_12 = nullptr;
      bool mIsFailureExpected_12                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_12()
      {
          ChipLogProgress(chipTool, "Basic - Query PartNumber: Sending command...");
  
          mOnFailureCallback_12 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_12_FailureResponse, this);
          mOnSuccessCallback_12 =
              new chip::Callback::Callback<SuccessCallback_12>(OnTestSendClusterBasicCommandReadAttribute_12_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributePartNumber(mOnSuccessCallback_12->Cancel(), mOnFailureCallback_12->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_12;
              delete mOnSuccessCallback_12;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_12_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query PartNumber: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_12;
          delete runner->mOnSuccessCallback_12;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_12 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_12_SuccessResponse(void * context, chip::ByteSpan partNumber)
      {
          ChipLogProgress(chipTool, "Basic - Query PartNumber: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_12;
          delete runner->mOnSuccessCallback_12;
  
          if (runner->mIsFailureExpected_12 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          ChipLogError(chipTool, "Warning: partNumber type checking is not implemented yet. Expected type: '%s'", "string");
  
          if (partNumber.size() > 32)
          {
              ChipLogError(chipTool, "Error: partNumber is too long. Max size is 32 but got '%zu'", partNumber.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query ProductURL
      typedef void (*SuccessCallback_13)(void * context, chip::ByteSpan productURL);
      chip::Callback::Callback<SuccessCallback_13> * mOnSuccessCallback_13     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_13 = nullptr;
      bool mIsFailureExpected_13                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_13()
      {
          ChipLogProgress(chipTool, "Basic - Query ProductURL: Sending command...");
  
          mOnFailureCallback_13 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_13_FailureResponse, this);
          mOnSuccessCallback_13 =
              new chip::Callback::Callback<SuccessCallback_13>(OnTestSendClusterBasicCommandReadAttribute_13_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeProductURL(mOnSuccessCallback_13->Cancel(), mOnFailureCallback_13->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_13;
              delete mOnSuccessCallback_13;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_13_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query ProductURL: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_13;
          delete runner->mOnSuccessCallback_13;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_13 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_13_SuccessResponse(void * context, chip::ByteSpan productURL)
      {
          ChipLogProgress(chipTool, "Basic - Query ProductURL: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_13;
          delete runner->mOnSuccessCallback_13;
  
          if (runner->mIsFailureExpected_13 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          ChipLogError(chipTool, "Warning: productURL type checking is not implemented yet. Expected type: '%s'", "string");
  
          ChipLogError(chipTool, "Warning: productURL format checking is not implemented yet. Expected format: '%s'", "RFC3986");
  
          if (productURL.size() > 256)
          {
              ChipLogError(chipTool, "Error: productURL is too long. Max size is 256 but got '%zu'", productURL.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query ProductLabel
      typedef void (*SuccessCallback_14)(void * context, chip::ByteSpan productLabel);
      chip::Callback::Callback<SuccessCallback_14> * mOnSuccessCallback_14     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_14 = nullptr;
      bool mIsFailureExpected_14                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_14()
      {
          ChipLogProgress(chipTool, "Basic - Query ProductLabel: Sending command...");
  
          mOnFailureCallback_14 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_14_FailureResponse, this);
          mOnSuccessCallback_14 =
              new chip::Callback::Callback<SuccessCallback_14>(OnTestSendClusterBasicCommandReadAttribute_14_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeProductLabel(mOnSuccessCallback_14->Cancel(), mOnFailureCallback_14->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_14;
              delete mOnSuccessCallback_14;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_14_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query ProductLabel: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_14;
          delete runner->mOnSuccessCallback_14;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_14 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_14_SuccessResponse(void * context, chip::ByteSpan productLabel)
      {
          ChipLogProgress(chipTool, "Basic - Query ProductLabel: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_14;
          delete runner->mOnSuccessCallback_14;
  
          if (runner->mIsFailureExpected_14 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          ChipLogError(chipTool, "Warning: productLabel type checking is not implemented yet. Expected type: '%s'", "string");
  
          if (productLabel.size() > 64)
          {
              ChipLogError(chipTool, "Error: productLabel is too long. Max size is 64 but got '%zu'", productLabel.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query SerialNumber
      typedef void (*SuccessCallback_15)(void * context, chip::ByteSpan serialNumber);
      chip::Callback::Callback<SuccessCallback_15> * mOnSuccessCallback_15     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_15 = nullptr;
      bool mIsFailureExpected_15                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_15()
      {
          ChipLogProgress(chipTool, "Basic - Query SerialNumber: Sending command...");
  
          mOnFailureCallback_15 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_15_FailureResponse, this);
          mOnSuccessCallback_15 =
              new chip::Callback::Callback<SuccessCallback_15>(OnTestSendClusterBasicCommandReadAttribute_15_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeSerialNumber(mOnSuccessCallback_15->Cancel(), mOnFailureCallback_15->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_15;
              delete mOnSuccessCallback_15;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_15_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query SerialNumber: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_15;
          delete runner->mOnSuccessCallback_15;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_15 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_15_SuccessResponse(void * context, chip::ByteSpan serialNumber)
      {
          ChipLogProgress(chipTool, "Basic - Query SerialNumber: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_15;
          delete runner->mOnSuccessCallback_15;
  
          if (runner->mIsFailureExpected_15 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          ChipLogError(chipTool, "Warning: serialNumber type checking is not implemented yet. Expected type: '%s'", "string");
  
          if (serialNumber.size() > 32)
          {
              ChipLogError(chipTool, "Error: serialNumber is too long. Max size is 32 but got '%zu'", serialNumber.size());
              runner->SetCommandExitStatus(false);
              return;
          }
  
          runner->NextTest();
      }
  
      // Test Query LocalConfigDisabled
      typedef void (*SuccessCallback_16)(void * context, uint8_t localConfigDisabled);
      chip::Callback::Callback<SuccessCallback_16> * mOnSuccessCallback_16     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_16 = nullptr;
      bool mIsFailureExpected_16                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_16()
      {
          ChipLogProgress(chipTool, "Basic - Query LocalConfigDisabled: Sending command...");
  
          mOnFailureCallback_16 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_16_FailureResponse, this);
          mOnSuccessCallback_16 =
              new chip::Callback::Callback<SuccessCallback_16>(OnTestSendClusterBasicCommandReadAttribute_16_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeLocalConfigDisabled(mOnSuccessCallback_16->Cancel(), mOnFailureCallback_16->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_16;
              delete mOnSuccessCallback_16;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_16_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query LocalConfigDisabled: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_16;
          delete runner->mOnSuccessCallback_16;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_16 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_16_SuccessResponse(void * context, uint8_t localConfigDisabled)
      {
          ChipLogProgress(chipTool, "Basic - Query LocalConfigDisabled: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_16;
          delete runner->mOnSuccessCallback_16;
  
          if (runner->mIsFailureExpected_16 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          ChipLogError(chipTool, "Warning: localConfigDisabled type checking is not implemented yet. Expected type: '%s'", "boolean");
  
          runner->NextTest();
      }
  
      // Test Query Reachable
      typedef void (*SuccessCallback_17)(void * context, uint8_t reachable);
      chip::Callback::Callback<SuccessCallback_17> * mOnSuccessCallback_17     = nullptr;
      chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback_17 = nullptr;
      bool mIsFailureExpected_17                                               = 0;
  
      CHIP_ERROR TestSendClusterBasicCommandReadAttribute_17()
      {
          ChipLogProgress(chipTool, "Basic - Query Reachable: Sending command...");
  
          mOnFailureCallback_17 = new chip::Callback::Callback<DefaultFailureCallback>(
              OnTestSendClusterBasicCommandReadAttribute_17_FailureResponse, this);
          mOnSuccessCallback_17 =
              new chip::Callback::Callback<SuccessCallback_17>(OnTestSendClusterBasicCommandReadAttribute_17_SuccessResponse, this);
  
          chip::Controller::BasicCluster cluster;
          cluster.Associate(mDevice, 0);
  
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          err = cluster.ReadAttributeReachable(mOnSuccessCallback_17->Cancel(), mOnFailureCallback_17->Cancel());
  
          if (CHIP_NO_ERROR != err)
          {
              delete mOnFailureCallback_17;
              delete mOnSuccessCallback_17;
          }
  
          return err;
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_17_FailureResponse(void * context, uint8_t status)
      {
          ChipLogProgress(chipTool, "Basic - Query Reachable: Failure Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_17;
          delete runner->mOnSuccessCallback_17;
  
          if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE)
          {
              runner->NextTest();
              return;
          }
  
          if (runner->mIsFailureExpected_17 == false)
          {
              ChipLogError(chipTool, "Error: The test was expecting a success callback. Got failure callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          runner->NextTest();
      }
  
      static void OnTestSendClusterBasicCommandReadAttribute_17_SuccessResponse(void * context, uint8_t reachable)
      {
          ChipLogProgress(chipTool, "Basic - Query Reachable: Success Response");
  
          Test_TC_DM_1_1 * runner = reinterpret_cast<Test_TC_DM_1_1 *>(context);
  
          delete runner->mOnFailureCallback_17;
          delete runner->mOnSuccessCallback_17;
  
          if (runner->mIsFailureExpected_17 == true)
          {
              ChipLogError(chipTool, "Error: The test was expecting a failure callback. Got success callback");
              runner->SetCommandExitStatus(CHIP_ERROR_INTERNAL);
              return;
          }
  
          ChipLogError(chipTool, "Warning: reachable type checking is not implemented yet. Expected type: '%s'", "boolean");
  
          runner->NextTest();
      }
  };
  
  class Test_TC_DM_3_1 : public TestCommand
  {
  public:
      Test_TC_DM_3_1() : TestCommand("Test_TC_DM_3_1"), mTestIndex(0) {}
  
      /////////// TestCommand Interface /////////
      void NextTest() override
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
  
          if (mTestCount == mTestIndex)
          {
              ChipLogProgress(chipTool, "Test_TC_DM_3_1: 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++)
          {
          }
  
          if (CHIP_NO_ERROR != err)
          {
              ChipLogProgress(chipTool, "Test_TC_DM_3_1: %s", chip::ErrorStr(err));
              SetCommandExitStatus(err);
          }
      }
  
  private:
      std::atomic_uint16_t mTestIndex;
      const uint16_t mTestCount = 0;
  
      //
      // Tests methods
      //
  };
  
  void registerCommandsTests(Commands & commands)
  {
      const char * clusterName = "Tests";
  
      commands_list clusterCommands = {
          make_unique<TestCluster>(),    make_unique<Test_TC_OO_1_1>(), make_unique<Test_TC_OO_2_1>(),
          make_unique<Test_TC_OO_2_2>(), make_unique<Test_TC_DM_1_1>(), make_unique<Test_TC_DM_3_1>(),
      };
  
      commands.Register(clusterName, clusterCommands);
  }
  