From e5571e4392b3532f0bcaa13fe9b404c53cc39124 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 8 Oct 2025 15:01:40 -0300
Subject: [PATCH 01/18] TC_SU_2_8 test with base class

---
 examples/ota-provider-app/linux/main.cpp      | 816 +++++++++---------
 .../ota-provider-common/BdxOtaSender.cpp      | 451 +++++-----
 .../ota-provider-common/BdxOtaSender.h        |  62 +-
 .../suites/certification/Test_TC_SU_2_8.yaml  |  91 --
 src/python_testing/TC_SUTestBase.py           | 492 +++++++++++
 src/python_testing/TC_SU_2_8.py               | 459 ++++++++++
 .../matter/testing/apps.py                    | 137 +--
 .../matter/typings/matter/testing/apps.pyi    |  18 +-
 src/python_testing/test_metadata.yaml         |   6 +-
 9 files changed, 1726 insertions(+), 806 deletions(-)
 delete mode 100644 src/app/tests/suites/certification/Test_TC_SU_2_8.yaml
 create mode 100644 src/python_testing/TC_SUTestBase.py
 create mode 100644 src/python_testing/TC_SU_2_8.py

diff --git a/examples/ota-provider-app/linux/main.cpp b/examples/ota-provider-app/linux/main.cpp
index 2b0743a421c137..58c7181bc4e728 100644
--- a/examples/ota-provider-app/linux/main.cpp
+++ b/examples/ota-provider-app/linux/main.cpp
@@ -16,400 +16,422 @@
  *    limitations under the License.
  */
 
-#include <app/clusters/ota-provider/CodegenIntegration.h>
-#include <app/clusters/ota-provider/DefaultOTAProviderUserConsent.h>
-#include <app/clusters/ota-provider/ota-provider-delegate.h>
-#include <app/server/Server.h>
-#include <app/util/util.h>
-#include <json/json.h>
-#include <ota-provider-common/BdxOtaSender.h>
-#include <ota-provider-common/OTAProviderExample.h>
-
-#include "AppMain.h"
-
-#include <fstream>
-#include <iostream>
-#include <optional>
-#include <unistd.h>
-
-using chip::BitFlags;
-using chip::app::Clusters::OTAProviderDelegate;
-using chip::ArgParser::OptionDef;
-using chip::ArgParser::OptionSet;
-using chip::ArgParser::PrintArgError;
-using chip::bdx::TransferControlFlags;
-using chip::Messaging::ExchangeManager;
-using namespace chip::app::Clusters::OtaSoftwareUpdateProvider;
-
-// TODO: this should probably be done dynamically
-constexpr chip::EndpointId kOtaProviderEndpoint = 0;
-
-constexpr uint16_t kOptionUpdateAction              = 'a';
-constexpr uint16_t kOptionUserConsentNeeded         = 'c';
-constexpr uint16_t kOptionFilepath                  = 'f';
-constexpr uint16_t kOptionImageUri                  = 'i';
-constexpr uint16_t kOptionMaxBDXBlockSize           = 'm';
-constexpr uint16_t kOptionOtaImageList              = 'o';
-constexpr uint16_t kOptionDelayedApplyActionTimeSec = 'p';
-constexpr uint16_t kOptionQueryImageStatus          = 'q';
-constexpr uint16_t kOptionDelayedQueryActionTimeSec = 't';
-constexpr uint16_t kOptionUserConsentState          = 'u';
-constexpr uint16_t kOptionIgnoreQueryImage          = 'x';
-constexpr uint16_t kOptionIgnoreApplyUpdate         = 'y';
-constexpr uint16_t kOptionPollInterval              = 'P';
-
-OTAProviderExample gOtaProvider;
-chip::ota::DefaultOTAProviderUserConsent gUserConsentProvider;
-
-// Global variables used for passing the CLI arguments to the OTAProviderExample object
-static OTAQueryStatus gQueryImageStatus              = OTAQueryStatus::kUpdateAvailable;
-static OTAApplyUpdateAction gOptionUpdateAction      = OTAApplyUpdateAction::kProceed;
-static uint32_t gDelayedQueryActionTimeSec           = 0;
-static uint32_t gDelayedApplyActionTimeSec           = 0;
-static const char * gOtaFilepath                     = nullptr;
-static const char * gOtaImageListFilepath            = nullptr;
-static const char * gImageUri                        = nullptr;
-static chip::ota::UserConsentState gUserConsentState = chip::ota::UserConsentState::kUnknown;
-static bool gUserConsentNeeded                       = false;
-static uint32_t gIgnoreQueryImageCount               = 0;
-static uint32_t gIgnoreApplyUpdateCount              = 0;
-static uint32_t gPollInterval                        = 0;
-static std::optional<uint16_t> gMaxBDXBlockSize      = std::nullopt;
-
-// Parses the JSON filepath and extracts DeviceSoftwareVersionModel parameters
-static bool ParseJsonFileAndPopulateCandidates(const char * filepath,
-                                               std::vector<OTAProviderExample::DeviceSoftwareVersionModel> & candidates)
-{
-    bool ret = false;
-    Json::Value root;
-    Json::CharReaderBuilder builder;
-    JSONCPP_STRING errs;
-    std::ifstream ifs;
-
-    builder["collectComments"] = true; // allow C/C++ type comments in JSON file
-    ifs.open(filepath);
-
-    if (!ifs.good())
-    {
-        ChipLogError(SoftwareUpdate, "Error opening ifstream with file: \"%s\"", filepath);
-        return ret;
-    }
-
-    if (!parseFromStream(builder, ifs, &root, &errs))
-    {
-        ChipLogError(SoftwareUpdate, "Error parsing JSON from file: \"%s\"", filepath);
-        return ret;
-    }
-
-    const Json::Value devSofVerModValue = root["deviceSoftwareVersionModel"];
-    if (!devSofVerModValue || !devSofVerModValue.isArray())
-    {
-        ChipLogError(SoftwareUpdate, "Error: Key deviceSoftwareVersionModel not found or its value is not of type Array");
-    }
-    else
-    {
-        for (auto iter : devSofVerModValue)
-        {
-            OTAProviderExample::DeviceSoftwareVersionModel candidate;
-            candidate.vendorId        = static_cast<chip::VendorId>(iter.get("vendorId", 1).asUInt());
-            candidate.productId       = static_cast<uint16_t>(iter.get("productId", 1).asUInt());
-            candidate.softwareVersion = static_cast<uint32_t>(iter.get("softwareVersion", 10).asUInt64());
-            chip::Platform::CopyString(candidate.softwareVersionString, iter.get("softwareVersionString", "1.0.0").asCString());
-            candidate.cDVersionNumber              = static_cast<uint16_t>(iter.get("cDVersionNumber", 0).asUInt());
-            candidate.softwareVersionValid         = iter.get("softwareVersionValid", true).asBool() ? true : false;
-            candidate.minApplicableSoftwareVersion = static_cast<uint32_t>(iter.get("minApplicableSoftwareVersion", 0).asUInt64());
-            candidate.maxApplicableSoftwareVersion =
-                static_cast<uint32_t>(iter.get("maxApplicableSoftwareVersion", 1000).asUInt64());
-            chip::Platform::CopyString(candidate.otaURL, iter.get("otaURL", "https://test.com").asCString());
-            candidates.push_back(candidate);
-            ret = true;
-        }
-    }
-    return ret;
-}
-
-bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue)
-{
-    bool retval = true;
-    static bool kOptionFilepathSelected;
-    static bool kOptionOtaImageListSelected;
-
-    switch (aIdentifier)
-    {
-    case kOptionFilepath:
-        kOptionFilepathSelected = true;
-        if (0 != access(aValue, R_OK))
-        {
-            PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
-            retval = false;
-        }
-        else if (kOptionOtaImageListSelected)
-        {
-            PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
-            retval = false;
-        }
-        else
-        {
-            gOtaFilepath = aValue;
-        }
-        break;
-    case kOptionImageUri:
-        gImageUri = aValue;
-        break;
-    case kOptionOtaImageList:
-        kOptionOtaImageListSelected = true;
-        if (0 != access(aValue, R_OK))
-        {
-            PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
-            retval = false;
-        }
-        else if (kOptionFilepathSelected)
-        {
-            PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
-            retval = false;
-        }
-        else
-        {
-            gOtaImageListFilepath = aValue;
-        }
-        break;
-    case kOptionQueryImageStatus:
-        if (strcmp(aValue, "updateAvailable") == 0)
-        {
-            gQueryImageStatus = OTAQueryStatus::kUpdateAvailable;
-        }
-        else if (strcmp(aValue, "busy") == 0)
-        {
-            gQueryImageStatus = OTAQueryStatus::kBusy;
-        }
-        else if (strcmp(aValue, "updateNotAvailable") == 0)
-        {
-            gQueryImageStatus = OTAQueryStatus::kNotAvailable;
-        }
-        else
-        {
-            PrintArgError("%s: ERROR: Invalid queryImageStatus parameter:  %s\n", aProgram, aValue);
-            retval = false;
-        }
-        break;
-    case kOptionIgnoreQueryImage:
-        gIgnoreQueryImageCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-        break;
-    case kOptionIgnoreApplyUpdate:
-        gIgnoreApplyUpdateCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-        break;
-    case kOptionUpdateAction:
-        if (strcmp(aValue, "proceed") == 0)
-        {
-            gOptionUpdateAction = OTAApplyUpdateAction::kProceed;
-        }
-        else if (strcmp(aValue, "awaitNextAction") == 0)
-        {
-            gOptionUpdateAction = OTAApplyUpdateAction::kAwaitNextAction;
-        }
-        else if (strcmp(aValue, "discontinue") == 0)
-        {
-            gOptionUpdateAction = OTAApplyUpdateAction::kDiscontinue;
-        }
-        else
-        {
-            PrintArgError("%s: ERROR: Invalid applyUpdateAction parameter:  %s\n", aProgram, aValue);
-            retval = false;
-        }
-        break;
-    case kOptionDelayedQueryActionTimeSec:
-        gDelayedQueryActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-        break;
-    case kOptionDelayedApplyActionTimeSec:
-        gDelayedApplyActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-        break;
-    case kOptionUserConsentState:
-        if (strcmp(aValue, "granted") == 0)
-        {
-            gUserConsentState = chip::ota::UserConsentState::kGranted;
-        }
-        else if (strcmp(aValue, "denied") == 0)
-        {
-            gUserConsentState = chip::ota::UserConsentState::kDenied;
-        }
-        else if (strcmp(aValue, "deferred") == 0)
-        {
-            gUserConsentState = chip::ota::UserConsentState::kObtaining;
-        }
-        else
-        {
-            PrintArgError("%s: ERROR: Invalid UserConsent parameter:  %s\n", aProgram, aValue);
-            retval = false;
-        }
-        break;
-    case kOptionUserConsentNeeded:
-        gUserConsentNeeded = true;
-        break;
-    case kOptionPollInterval:
-        gPollInterval = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-        break;
-    case kOptionMaxBDXBlockSize: {
-        auto blockSize = static_cast<uint16_t>(strtoul(aValue, NULL, 0));
-        if (blockSize == 0)
-        {
-            PrintArgError("%s: ERROR: Invalid maxBDXBlockSize parameter: %s\n", aProgram, aValue);
-            retval = false;
-        }
-        else
-        {
-            gMaxBDXBlockSize = blockSize;
-        }
-        break;
-    }
-
-    default:
-        PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);
-        retval = false;
-        break;
-    }
-
-    return (retval);
-}
-
-OptionDef cmdLineOptionsDef[] = {
-    { "applyUpdateAction", chip::ArgParser::kArgumentRequired, kOptionUpdateAction },
-    { "userConsentNeeded", chip::ArgParser::kNoArgument, kOptionUserConsentNeeded },
-    { "filepath", chip::ArgParser::kArgumentRequired, kOptionFilepath },
-    { "imageUri", chip::ArgParser::kArgumentRequired, kOptionImageUri },
-    { "otaImageList", chip::ArgParser::kArgumentRequired, kOptionOtaImageList },
-    { "delayedApplyActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedApplyActionTimeSec },
-    { "queryImageStatus", chip::ArgParser::kArgumentRequired, kOptionQueryImageStatus },
-    { "delayedQueryActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedQueryActionTimeSec },
-    { "userConsentState", chip::ArgParser::kArgumentRequired, kOptionUserConsentState },
-    { "ignoreQueryImage", chip::ArgParser::kArgumentRequired, kOptionIgnoreQueryImage },
-    { "ignoreApplyUpdate", chip::ArgParser::kArgumentRequired, kOptionIgnoreApplyUpdate },
-    { "pollInterval", chip::ArgParser::kArgumentRequired, kOptionPollInterval },
-    { "maxBDXBlockSize", chip::ArgParser::kArgumentRequired, kOptionMaxBDXBlockSize },
-    {},
-};
-
-OptionSet cmdLineOptions = { HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS",
-                             "  -a, --applyUpdateAction <proceed | awaitNextAction | discontinue>\n"
-                             "        Value for the Action field in the first ApplyUpdateResponse.\n"
-                             "        For all subsequent responses, the value of proceed will be used.\n"
-                             "  -c, --userConsentNeeded\n"
-                             "        If supplied, value of the UserConsentNeeded field in the QueryImageResponse\n"
-                             "        is set to true. This is only applicable if value of the RequestorCanConsent\n"
-                             "        field in QueryImage Command is true.\n"
-                             "        Otherwise, value of the UserConsentNeeded field is false.\n"
-                             "  -f, --filepath <file path>\n"
-                             "        Path to a file containing an OTA image\n"
-                             "  -i, --imageUri <uri>\n"
-                             "        Value for the ImageURI field in the QueryImageResponse.\n"
-                             "        If none is supplied, a valid URI is generated.\n"
-                             "  -m, --maxBDXBlockSize <size>\n"
-                             "        Value for the maximum BDX block size to use for the transfer.\n"
-                             "        If none is supplied, a default value will be used.\n"
-                             "  -o, --otaImageList <file path>\n"
-                             "        Path to a file containing a list of OTA images\n"
-                             "  -p, --delayedApplyActionTimeSec <time in seconds>\n"
-                             "        Value for the DelayedActionTime field in the first ApplyUpdateResponse.\n"
-                             "        For all subsequent responses, the value of zero will be used.\n"
-                             "  -q, --queryImageStatus <updateAvailable | busy | updateNotAvailable>\n"
-                             "        Value for the Status field in the first QueryImageResponse.\n"
-                             "        For all subsequent responses, the value of updateAvailable will be used.\n"
-                             "  -t, --delayedQueryActionTimeSec <time in seconds>\n"
-                             "        Value for the DelayedActionTime field in the first QueryImageResponse.\n"
-                             "        For all subsequent responses, the value of zero will be used.\n"
-                             "  -u, --userConsentState <granted | denied | deferred>\n"
-                             "        The user consent state for the first QueryImageResponse. For all subsequent\n"
-                             "        responses, the value of granted will be used.\n"
-                             "        Note that --queryImageStatus overrides this option.\n"
-                             "        granted: Status field in the first QueryImageResponse is set to updateAvailable\n"
-                             "        denied: Status field in the first QueryImageResponse is set to updateNotAvailable\n"
-                             "        deferred: Status field in the first QueryImageResponse is set to busy\n"
-                             "  -x, --ignoreQueryImage <ignore count>\n"
-                             "        The number of times to ignore the QueryImage Command and not send a response.\n"
-                             "  -y, --ignoreApplyUpdate <ignore count>\n"
-                             "        The number of times to ignore the ApplyUpdateRequest Command and not send a response.\n"
-                             "  -P, --pollInterval <time in milliseconds>\n"
-                             "        Poll interval for the BDX transfer \n" };
-
-OptionSet * allOptions[] = { &cmdLineOptions, nullptr };
-
-void ApplicationInit()
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    BdxOtaSender * bdxOtaSender = gOtaProvider.GetBdxOtaSender();
-    VerifyOrReturn(bdxOtaSender != nullptr);
-    err = chip::Server::GetInstance().GetExchangeManager().RegisterUnsolicitedMessageHandlerForProtocol(chip::Protocols::BDX::Id,
-                                                                                                        bdxOtaSender);
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogDetail(SoftwareUpdate, "RegisterUnsolicitedMessageHandler failed: %s", chip::ErrorStr(err));
-        return;
-    }
-
-    ChipLogDetail(SoftwareUpdate, "Using OTA file: %s", gOtaFilepath ? gOtaFilepath : "(none)");
-
-    if (gOtaFilepath != nullptr)
-    {
-        gOtaProvider.SetOTAFilePath(gOtaFilepath);
-    }
-
-    if (gImageUri != nullptr)
-    {
-        gOtaProvider.SetImageUri(gImageUri);
-    }
-
-    gOtaProvider.SetIgnoreQueryImageCount(gIgnoreQueryImageCount);
-    gOtaProvider.SetIgnoreApplyUpdateCount(gIgnoreApplyUpdateCount);
-    gOtaProvider.SetQueryImageStatus(gQueryImageStatus);
-    gOtaProvider.SetApplyUpdateAction(gOptionUpdateAction);
-    gOtaProvider.SetDelayedQueryActionTimeSec(gDelayedQueryActionTimeSec);
-    gOtaProvider.SetDelayedApplyActionTimeSec(gDelayedApplyActionTimeSec);
-
-    if (gUserConsentState != chip::ota::UserConsentState::kUnknown)
-    {
-        gUserConsentProvider.SetGlobalUserConsentState(gUserConsentState);
-        gOtaProvider.SetUserConsentDelegate(&gUserConsentProvider);
-    }
-
-    if (gUserConsentNeeded)
-    {
-        gOtaProvider.SetUserConsentNeeded(true);
-    }
-
-    if (gPollInterval != 0)
-    {
-        gOtaProvider.SetPollInterval(gPollInterval);
-    }
-
-    if (gMaxBDXBlockSize)
-    {
-        gOtaProvider.SetMaxBDXBlockSize(*gMaxBDXBlockSize);
-    }
-
-    ChipLogDetail(SoftwareUpdate, "Using ImageList file: %s", gOtaImageListFilepath ? gOtaImageListFilepath : "(none)");
-
-    if (gOtaImageListFilepath != nullptr)
-    {
-        // Parse JSON file and load the ota candidates
-        std::vector<OTAProviderExample::DeviceSoftwareVersionModel> candidates;
-        ParseJsonFileAndPopulateCandidates(gOtaImageListFilepath, candidates);
-        gOtaProvider.SetOTACandidates(candidates);
-    }
-
-    if ((gOtaFilepath == nullptr) && (gOtaImageListFilepath == nullptr))
-    {
-        ChipLogError(SoftwareUpdate, "Either an OTA file or image list file must be specified");
-        chipDie();
-    }
-
-    chip::app::Clusters::OTAProvider::SetDelegate(kOtaProviderEndpoint, &gOtaProvider);
-}
-
-void ApplicationShutdown() {}
-
-int main(int argc, char * argv[])
-{
-    VerifyOrDie(ChipLinuxAppInit(argc, argv, &cmdLineOptions) == 0);
-    ChipLinuxAppMainLoop();
-    return 0;
-}
+ #include <app/clusters/ota-provider/CodegenIntegration.h>
+ #include <app/clusters/ota-provider/DefaultOTAProviderUserConsent.h>
+ #include <app/clusters/ota-provider/ota-provider-delegate.h>
+ #include <app/server/Server.h>
+ #include <app/util/util.h>
+ #include <json/json.h>
+ #include <ota-provider-common/BdxOtaSender.h>
+ #include <ota-provider-common/OTAProviderExample.h>
+ 
+ #include "AppMain.h"
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <optional>
+ #include <unistd.h>
+ 
+ using chip::BitFlags;
+ using chip::app::Clusters::OTAProviderDelegate;
+ using chip::ArgParser::OptionDef;
+ using chip::ArgParser::OptionSet;
+ using chip::ArgParser::PrintArgError;
+ using chip::bdx::TransferControlFlags;
+ using chip::Messaging::ExchangeManager;
+ using namespace chip::app::Clusters::OtaSoftwareUpdateProvider;
+ 
+ // TODO: this should probably be done dynamically
+ constexpr chip::EndpointId kOtaProviderEndpoint = 0;
+ 
+ constexpr uint16_t kOptionUpdateAction              = 'a';
+ constexpr uint16_t kOptionUserConsentNeeded         = 'c';
+ constexpr uint16_t kOptionFilepath                  = 'f';
+ constexpr uint16_t kOptionImageUri                  = 'i';
+ constexpr uint16_t kOptionMaxBDXBlockSize           = 'm';
+ constexpr uint16_t kOptionOtaImageList              = 'o';
+ constexpr uint16_t kOptionDelayedApplyActionTimeSec = 'p';
+ constexpr uint16_t kOptionQueryImageStatus          = 'q';
+ constexpr uint16_t kOptionDelayedQueryActionTimeSec = 't';
+ constexpr uint16_t kOptionUserConsentState          = 'u';
+ constexpr uint16_t kOptionIgnoreQueryImage          = 'x';
+ constexpr uint16_t kOptionIgnoreApplyUpdate         = 'y';
+ constexpr uint16_t kOptionPollInterval              = 'P';
+ 
+ OTAProviderExample gOtaProvider;
+ chip::ota::DefaultOTAProviderUserConsent gUserConsentProvider;
+ 
+ // Global variables used for passing the CLI arguments to the OTAProviderExample object
+ static OTAQueryStatus gQueryImageStatus              = OTAQueryStatus::kUpdateAvailable;
+ static OTAApplyUpdateAction gOptionUpdateAction      = OTAApplyUpdateAction::kProceed;
+ static uint32_t gDelayedQueryActionTimeSec           = 0;
+ static uint32_t gDelayedApplyActionTimeSec           = 0;
+ static const char * gOtaFilepath                     = nullptr;
+ static const char * gOtaImageListFilepath            = nullptr;
+ static const char * gImageUri                        = nullptr;
+ static chip::ota::UserConsentState gUserConsentState = chip::ota::UserConsentState::kUnknown;
+ static bool gUserConsentNeeded                       = false;
+ static uint32_t gIgnoreQueryImageCount               = 0;
+ static uint32_t gIgnoreApplyUpdateCount              = 0;
+ static uint32_t gPollInterval                        = 0;
+ static std::optional<uint16_t> gMaxBDXBlockSize      = std::nullopt;
+ 
+ // Parses the JSON filepath and extracts DeviceSoftwareVersionModel parameters
+ static bool ParseJsonFileAndPopulateCandidates(const char * filepath,
+                                                std::vector<OTAProviderExample::DeviceSoftwareVersionModel> & candidates)
+ {
+     bool ret = false;
+     Json::Value root;
+     Json::CharReaderBuilder builder;
+     JSONCPP_STRING errs;
+     std::ifstream ifs;
+ 
+     builder["collectComments"] = true; // allow C/C++ type comments in JSON file
+     ifs.open(filepath);
+ 
+     if (!ifs.good())
+     {
+         ChipLogError(SoftwareUpdate, "Error opening ifstream with file: \"%s\"", filepath);
+         return ret;
+     }
+ 
+     if (!parseFromStream(builder, ifs, &root, &errs))
+     {
+         ChipLogError(SoftwareUpdate, "Error parsing JSON from file: \"%s\"", filepath);
+         return ret;
+     }
+ 
+     const Json::Value devSofVerModValue = root["deviceSoftwareVersionModel"];
+     if (!devSofVerModValue || !devSofVerModValue.isArray())
+     {
+         ChipLogError(SoftwareUpdate, "Error: Key deviceSoftwareVersionModel not found or its value is not of type Array");
+     }
+     else
+     {
+         for (auto iter : devSofVerModValue)
+         {
+             OTAProviderExample::DeviceSoftwareVersionModel candidate;
+             candidate.vendorId        = static_cast<chip::VendorId>(iter.get("vendorId", 1).asUInt());
+             candidate.productId       = static_cast<uint16_t>(iter.get("productId", 1).asUInt());
+             candidate.softwareVersion = static_cast<uint32_t>(iter.get("softwareVersion", 10).asUInt64());
+             chip::Platform::CopyString(candidate.softwareVersionString, iter.get("softwareVersionString", "1.0.0").asCString());
+             candidate.cDVersionNumber              = static_cast<uint16_t>(iter.get("cDVersionNumber", 0).asUInt());
+             candidate.softwareVersionValid         = iter.get("softwareVersionValid", true).asBool() ? true : false;
+             candidate.minApplicableSoftwareVersion = static_cast<uint32_t>(iter.get("minApplicableSoftwareVersion", 0).asUInt64());
+             candidate.maxApplicableSoftwareVersion =
+                 static_cast<uint32_t>(iter.get("maxApplicableSoftwareVersion", 1000).asUInt64());
+             chip::Platform::CopyString(candidate.otaURL, iter.get("otaURL", "https://test.com").asCString());
+             candidates.push_back(candidate);
+             ret = true;
+         }
+     }
+     return ret;
+ }
+ 
+ bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue)
+ {
+     bool retval = true;
+     static bool kOptionFilepathSelected;
+     static bool kOptionOtaImageListSelected;
+ 
+     switch (aIdentifier)
+     {
+     case kOptionFilepath:
+         kOptionFilepathSelected = true;
+         if (0 != access(aValue, R_OK))
+         {
+             PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
+             retval = false;
+         }
+         else if (kOptionOtaImageListSelected)
+         {
+             PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
+             retval = false;
+         }
+         else
+         {
+             gOtaFilepath = aValue;
+         }
+         break;
+     case kOptionImageUri:
+         gImageUri = aValue;
+         break;
+     case kOptionOtaImageList:
+         kOptionOtaImageListSelected = true;
+         if (0 != access(aValue, R_OK))
+         {
+             PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
+             retval = false;
+         }
+         else if (kOptionFilepathSelected)
+         {
+             PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
+             retval = false;
+         }
+         else
+         {
+             gOtaImageListFilepath = aValue;
+         }
+         break;
+     case kOptionQueryImageStatus:
+         if (strcmp(aValue, "updateAvailable") == 0)
+         {
+             gQueryImageStatus = OTAQueryStatus::kUpdateAvailable;
+         }
+         else if (strcmp(aValue, "busy") == 0)
+         {
+             gQueryImageStatus = OTAQueryStatus::kBusy;
+         }
+         else if (strcmp(aValue, "updateNotAvailable") == 0)
+         {
+             gQueryImageStatus = OTAQueryStatus::kNotAvailable;
+         }
+         else
+         {
+             PrintArgError("%s: ERROR: Invalid queryImageStatus parameter:  %s\n", aProgram, aValue);
+             retval = false;
+         }
+         break;
+     case kOptionIgnoreQueryImage:
+         gIgnoreQueryImageCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+         break;
+     case kOptionIgnoreApplyUpdate:
+         gIgnoreApplyUpdateCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+         break;
+     case kOptionUpdateAction:
+         if (strcmp(aValue, "proceed") == 0)
+         {
+             gOptionUpdateAction = OTAApplyUpdateAction::kProceed;
+         }
+         else if (strcmp(aValue, "awaitNextAction") == 0)
+         {
+             gOptionUpdateAction = OTAApplyUpdateAction::kAwaitNextAction;
+         }
+         else if (strcmp(aValue, "discontinue") == 0)
+         {
+             gOptionUpdateAction = OTAApplyUpdateAction::kDiscontinue;
+         }
+         else
+         {
+             PrintArgError("%s: ERROR: Invalid applyUpdateAction parameter:  %s\n", aProgram, aValue);
+             retval = false;
+         }
+         break;
+     case kOptionDelayedQueryActionTimeSec:
+         gDelayedQueryActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+         break;
+     case kOptionDelayedApplyActionTimeSec:
+         gDelayedApplyActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+         break;
+     case kOptionUserConsentState:
+         if (strcmp(aValue, "granted") == 0)
+         {
+             gUserConsentState = chip::ota::UserConsentState::kGranted;
+         }
+         else if (strcmp(aValue, "denied") == 0)
+         {
+             gUserConsentState = chip::ota::UserConsentState::kDenied;
+         }
+         else if (strcmp(aValue, "deferred") == 0)
+         {
+             gUserConsentState = chip::ota::UserConsentState::kObtaining;
+         }
+         else
+         {
+             PrintArgError("%s: ERROR: Invalid UserConsent parameter:  %s\n", aProgram, aValue);
+             retval = false;
+         }
+         break;
+     case kOptionUserConsentNeeded:
+         gUserConsentNeeded = true;
+         break;
+     case kOptionPollInterval:
+         gPollInterval = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+         break;
+     case kOptionMaxBDXBlockSize: {
+         auto blockSize = static_cast<uint16_t>(strtoul(aValue, NULL, 0));
+         if (blockSize == 0)
+         {
+             PrintArgError("%s: ERROR: Invalid maxBDXBlockSize parameter: %s\n", aProgram, aValue);
+             retval = false;
+         }
+         else
+         {
+             gMaxBDXBlockSize = blockSize;
+         }
+         break;
+     }
+ 
+     default:
+         PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);
+         retval = false;
+         break;
+     }
+ 
+     return (retval);
+ }
+ 
+ OptionDef cmdLineOptionsDef[] = {
+     { "applyUpdateAction", chip::ArgParser::kArgumentRequired, kOptionUpdateAction },
+     { "userConsentNeeded", chip::ArgParser::kNoArgument, kOptionUserConsentNeeded },
+     { "filepath", chip::ArgParser::kArgumentRequired, kOptionFilepath },
+     { "imageUri", chip::ArgParser::kArgumentRequired, kOptionImageUri },
+     { "otaImageList", chip::ArgParser::kArgumentRequired, kOptionOtaImageList },
+     { "delayedApplyActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedApplyActionTimeSec },
+     { "queryImageStatus", chip::ArgParser::kArgumentRequired, kOptionQueryImageStatus },
+     { "delayedQueryActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedQueryActionTimeSec },
+     { "userConsentState", chip::ArgParser::kArgumentRequired, kOptionUserConsentState },
+     { "ignoreQueryImage", chip::ArgParser::kArgumentRequired, kOptionIgnoreQueryImage },
+     { "ignoreApplyUpdate", chip::ArgParser::kArgumentRequired, kOptionIgnoreApplyUpdate },
+     { "pollInterval", chip::ArgParser::kArgumentRequired, kOptionPollInterval },
+     { "maxBDXBlockSize", chip::ArgParser::kArgumentRequired, kOptionMaxBDXBlockSize },
+     {},
+ };
+ 
+ OptionSet cmdLineOptions = { HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS",
+                              "  -a, --applyUpdateAction <proceed | awaitNextAction | discontinue>\n"
+                              "        Value for the Action field in the first ApplyUpdateResponse.\n"
+                              "        For all subsequent responses, the value of proceed will be used.\n"
+                              "  -c, --userConsentNeeded\n"
+                              "        If supplied, value of the UserConsentNeeded field in the QueryImageResponse\n"
+                              "        is set to true. This is only applicable if value of the RequestorCanConsent\n"
+                              "        field in QueryImage Command is true.\n"
+                              "        Otherwise, value of the UserConsentNeeded field is false.\n"
+                              "  -f, --filepath <file path>\n"
+                              "        Path to a file containing an OTA image\n"
+                              "  -i, --imageUri <uri>\n"
+                              "        Value for the ImageURI field in the QueryImageResponse.\n"
+                              "        If none is supplied, a valid URI is generated.\n"
+                              "  -m, --maxBDXBlockSize <size>\n"
+                              "        Value for the maximum BDX block size to use for the transfer.\n"
+                              "        If none is supplied, a default value will be used.\n"
+                              "  -o, --otaImageList <file path>\n"
+                              "        Path to a file containing a list of OTA images\n"
+                              "  -p, --delayedApplyActionTimeSec <time in seconds>\n"
+                              "        Value for the DelayedActionTime field in the first ApplyUpdateResponse.\n"
+                              "        For all subsequent responses, the value of zero will be used.\n"
+                              "  -q, --queryImageStatus <updateAvailable | busy | updateNotAvailable>\n"
+                              "        Value for the Status field in the first QueryImageResponse.\n"
+                              "        For all subsequent responses, the value of updateAvailable will be used.\n"
+                              "  -t, --delayedQueryActionTimeSec <time in seconds>\n"
+                              "        Value for the DelayedActionTime field in the first QueryImageResponse.\n"
+                              "        For all subsequent responses, the value of zero will be used.\n"
+                              "  -u, --userConsentState <granted | denied | deferred>\n"
+                              "        The user consent state for the first QueryImageResponse. For all subsequent\n"
+                              "        responses, the value of granted will be used.\n"
+                              "        Note that --queryImageStatus overrides this option.\n"
+                              "        granted: Status field in the first QueryImageResponse is set to updateAvailable\n"
+                              "        denied: Status field in the first QueryImageResponse is set to updateNotAvailable\n"
+                              "        deferred: Status field in the first QueryImageResponse is set to busy\n"
+                              "  -x, --ignoreQueryImage <ignore count>\n"
+                              "        The number of times to ignore the QueryImage Command and not send a response.\n"
+                              "  -y, --ignoreApplyUpdate <ignore count>\n"
+                              "        The number of times to ignore the ApplyUpdateRequest Command and not send a response.\n"
+                              "  -P, --pollInterval <time in milliseconds>\n"
+                              "        Poll interval for the BDX transfer \n" };
+ 
+ OptionSet * allOptions[] = { &cmdLineOptions, nullptr };
+ 
+ void ApplicationInit()
+ {
+     CHIP_ERROR err = CHIP_NO_ERROR;
+ 
+     BdxOtaSender * bdxOtaSender = gOtaProvider.GetBdxOtaSender();
+     VerifyOrReturn(bdxOtaSender != nullptr);
+     err = chip::Server::GetInstance().GetExchangeManager().RegisterUnsolicitedMessageHandlerForProtocol(chip::Protocols::BDX::Id,
+                                                                                                         bdxOtaSender);
+     if (err != CHIP_NO_ERROR)
+     {
+         ChipLogDetail(SoftwareUpdate, "RegisterUnsolicitedMessageHandler failed: %s", chip::ErrorStr(err));
+         return;
+     }
+ 
+     ChipLogDetail(SoftwareUpdate, "Using OTA file: %s", gOtaFilepath ? gOtaFilepath : "(none)");
+ 
+     if (gOtaFilepath != nullptr)
+     {
+         gOtaProvider.SetOTAFilePath(gOtaFilepath);
+     }
+ 
+     if (gImageUri != nullptr)
+     {
+         gOtaProvider.SetImageUri(gImageUri);
+     }
+ 
+     gOtaProvider.SetIgnoreQueryImageCount(gIgnoreQueryImageCount);
+     gOtaProvider.SetIgnoreApplyUpdateCount(gIgnoreApplyUpdateCount);
+     gOtaProvider.SetQueryImageStatus(gQueryImageStatus);
+     gOtaProvider.SetApplyUpdateAction(gOptionUpdateAction);
+     gOtaProvider.SetDelayedQueryActionTimeSec(gDelayedQueryActionTimeSec);
+     gOtaProvider.SetDelayedApplyActionTimeSec(gDelayedApplyActionTimeSec);
+ 
+     if (gUserConsentState != chip::ota::UserConsentState::kUnknown)
+     {
+         gUserConsentProvider.SetGlobalUserConsentState(gUserConsentState);
+         gOtaProvider.SetUserConsentDelegate(&gUserConsentProvider);
+     }
+ 
+     if (gUserConsentNeeded)
+     {
+         gOtaProvider.SetUserConsentNeeded(true);
+     }
+ 
+     if (gPollInterval != 0)
+     {
+         gOtaProvider.SetPollInterval(gPollInterval);
+     }
+ 
+     if (gMaxBDXBlockSize)
+     {
+         gOtaProvider.SetMaxBDXBlockSize(*gMaxBDXBlockSize);
+     }
+ 
+     ChipLogDetail(SoftwareUpdate, "Using ImageList file: %s", gOtaImageListFilepath ? gOtaImageListFilepath : "(none)");
+ 
+     if (gOtaImageListFilepath != nullptr)
+     {
+         // Parse JSON file and load the ota candidates
+         std::vector<OTAProviderExample::DeviceSoftwareVersionModel> candidates;
+         ParseJsonFileAndPopulateCandidates(gOtaImageListFilepath, candidates);
+         gOtaProvider.SetOTACandidates(candidates);
+     }
+ 
+     if ((gOtaFilepath == nullptr) && (gOtaImageListFilepath == nullptr))
+     {
+         ChipLogError(SoftwareUpdate, "Either an OTA file or image list file must be specified");
+         chipDie();
+     }
+ 
+     chip::app::Clusters::OTAProvider::SetDelegate(kOtaProviderEndpoint, &gOtaProvider);
+ }
+ 
+ void ApplicationShutdown() {}
+ 
+ namespace {
+ class OtaProviderAppMainLoopImplementation : public AppMainLoopImplementation
+ {
+ public:
+     void RunMainLoop() override { chip::DeviceLayer::PlatformMgr().RunEventLoop(); }
+     void SignalSafeStopMainLoop() override
+     {
+         chip::DeviceLayer::PlatformMgr().ScheduleWork([](intptr_t) {
+             ChipLogDetail(SoftwareUpdate, "Scheduling BdxOtaSender to ABORT TRANSFER");
+ 
+             gOtaProvider.GetBdxOtaSender()->AbortTransfer();
+ 
+             chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
+         });
+ 
+         chip::Server::GetInstance().GenerateShutDownEvent();
+     }
+ };
+ } // namespace
+ 
+ int main(int argc, char * argv[])
+ {
+     OtaProviderAppMainLoopImplementation ml_impl{};
+ 
+     VerifyOrDie(ChipLinuxAppInit(argc, argv, &cmdLineOptions) == 0);
+     ChipLinuxAppMainLoop(&ml_impl);
+     return 0;
+ }
\ No newline at end of file
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
index 12f6e76997fe79..e8c7a6488af478 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
@@ -15,224 +15,233 @@
  *    limitations under the License.
  */
 
-#include <ota-provider-common/BdxOtaSender.h>
-
-#include <lib/core/CHIPError.h>
-#include <lib/support/BitFlags.h>
-#include <lib/support/CHIPMemString.h>
-#include <messaging/ExchangeContext.h>
-#include <messaging/Flags.h>
-#include <protocols/bdx/BdxTransferSession.h>
-
-#include <fstream>
-
-using chip::bdx::StatusCode;
-using chip::bdx::TransferControlFlags;
-using chip::bdx::TransferSession;
-
-BdxOtaSender::BdxOtaSender()
-{
-    memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
-}
-
-CHIP_ERROR BdxOtaSender::InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId)
-{
-    if (mInitialized)
-    {
-        // Reset stale connection from the Same Node if exists
-        if ((mFabricIndex.HasValue() && mFabricIndex.Value() == fabricIndex) && (mNodeId.HasValue() && mNodeId.Value() == nodeId))
-        {
-            Reset();
-        }
-        // Prevent a new node connection since another is active
-        else if ((mFabricIndex.HasValue() && mFabricIndex.Value() != fabricIndex) ||
-                 (mNodeId.HasValue() && mNodeId.Value() != nodeId))
-        {
-            return CHIP_ERROR_BUSY;
-        }
-        else
-        {
-            return CHIP_ERROR_INTERNAL;
-        }
-    }
-    mFabricIndex.SetValue(fabricIndex);
-    mNodeId.SetValue(nodeId);
-    mInitialized = true;
-    return CHIP_NO_ERROR;
-}
-
-void BdxOtaSender::HandleTransferSessionOutput(TransferSession::OutputEvent & event)
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    if (event.EventType != TransferSession::OutputEventType::kNone)
-    {
-        ChipLogDetail(BDX, "OutputEvent type: %s", event.ToString(event.EventType));
-    }
-
-    switch (event.EventType)
-    {
-    case TransferSession::OutputEventType::kNone:
-        break;
-    case TransferSession::OutputEventType::kMsgToSend: {
-        chip::Messaging::SendFlags sendFlags;
-        if (!event.msgTypeData.HasMessageType(chip::Protocols::SecureChannel::MsgType::StatusReport))
-        {
-            // All messages sent from the Sender expect a response, except for a StatusReport which would indicate an error and the
-            // end of the transfer.
-            sendFlags.Set(chip::Messaging::SendMessageFlags::kExpectResponse);
-        }
-        VerifyOrReturn(mExchangeCtx != nullptr);
-        err = mExchangeCtx->SendMessage(event.msgTypeData.ProtocolId, event.msgTypeData.MessageType, std::move(event.MsgData),
-                                        sendFlags);
-
-        if (err == CHIP_NO_ERROR)
-        {
-            if (!sendFlags.Has(chip::Messaging::SendMessageFlags::kExpectResponse))
-            {
-                // After sending the StatusReport, exchange context gets closed so, set mExchangeCtx to null
-                mExchangeCtx = nullptr;
-            }
-        }
-        else
-        {
-            ChipLogError(BDX, "SendMessage failed: %" CHIP_ERROR_FORMAT, err.Format());
-            Reset();
-        }
-
-        break;
-    }
-    case TransferSession::OutputEventType::kInitReceived: {
-        // TransferSession will automatically reject a transfer if there are no
-        // common supported control modes. It will also default to the smaller
-        // block size.
-        TransferSession::TransferAcceptData acceptData;
-        acceptData.ControlMode  = TransferControlFlags::kReceiverDrive; // OTA must use receiver drive
-        acceptData.MaxBlockSize = mTransfer.GetTransferBlockSize();
-        acceptData.StartOffset  = mTransfer.GetStartOffset();
-        acceptData.Length       = mTransfer.GetTransferLength();
-        VerifyOrReturn(mTransfer.AcceptTransfer(acceptData) == CHIP_NO_ERROR,
-                       ChipLogError(BDX, "AcceptTransfer failed: %" CHIP_ERROR_FORMAT, err.Format()));
-
-        // Store the file designator used during block query
-        uint16_t fdl       = 0;
-        const uint8_t * fd = mTransfer.GetFileDesignator(fdl);
-        VerifyOrReturn(fdl < chip::bdx::kMaxFileDesignatorLen,
-                       ChipLogError(BDX, "Cannot store file designator with length = %d", fdl));
-        memcpy(mFileDesignator, fd, fdl);
-        mFileDesignator[fdl] = 0;
-
-        break;
-    }
-    case TransferSession::OutputEventType::kQueryReceived:
-    case TransferSession::OutputEventType::kQueryWithSkipReceived: {
-        TransferSession::BlockData blockData;
-        uint16_t blockSize   = mTransfer.GetTransferBlockSize();
-        uint16_t bytesToRead = blockSize;
-        uint64_t bytesToSkip = 0;
-
-        if (event.EventType == TransferSession::OutputEventType::kQueryWithSkipReceived)
-        {
-            bytesToSkip = event.bytesToSkip.BytesToSkip;
-        }
-        uint64_t seekOffset = mNumBytesSent + bytesToSkip;
-
-        // TODO: This should be a utility function in TransferSession
-        if ((mTransfer.GetTransferLength() > 0) && ((seekOffset + blockSize) > mTransfer.GetTransferLength()))
-        {
-            // cast should be safe because of condition above
-            bytesToRead = static_cast<uint16_t>(mTransfer.GetTransferLength() - seekOffset);
-        }
-
-        chip::System::PacketBufferHandle blockBuf = chip::System::PacketBufferHandle::New(bytesToRead);
-        if (blockBuf.IsNull())
-        {
-            // TODO(#13981): AbortTransfer() needs to support GeneralStatusCode failures as well as BDX specific errors.
-            mTransfer.AbortTransfer(StatusCode::kUnknown);
-            return;
-        }
-
-        std::ifstream otaFile(mFileDesignator, std::ifstream::in);
-        if (!otaFile.good())
-        {
-            ChipLogError(BDX, "OTA file open failed");
-            mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
-            return;
-        }
-
-        if (seekOffset > static_cast<uint64_t>(std::numeric_limits<std::streamoff>::max()))
-        {
-            ChipLogError(BDX, "Seek offset too large");
-            mTransfer.AbortTransfer(StatusCode::kLengthTooLarge);
-            return;
-        }
-        otaFile.seekg(static_cast<std::streamoff>(seekOffset));
-        otaFile.read(reinterpret_cast<char *>(blockBuf->Start()), bytesToRead);
-        if (!(otaFile.good() || otaFile.eof()))
-        {
-            ChipLogError(BDX, "OTA file read failed");
-            mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
-            return;
-        }
-
-        blockData.Data   = blockBuf->Start();
-        blockData.Length = static_cast<size_t>(otaFile.gcount());
-        blockData.IsEof  = (blockData.Length < blockSize) ||
-            (seekOffset + static_cast<uint64_t>(blockData.Length) == mTransfer.GetTransferLength() || (otaFile.peek() == EOF));
-        mNumBytesSent = static_cast<uint32_t>(seekOffset + blockData.Length);
-        otaFile.close();
-
-        err = mTransfer.PrepareBlock(blockData);
-        if (err != CHIP_NO_ERROR)
-        {
-            ChipLogError(BDX, "PrepareBlock failed: %" CHIP_ERROR_FORMAT, err.Format());
-            mTransfer.AbortTransfer(StatusCode::kUnknown);
-        }
-        break;
-    }
-    case TransferSession::OutputEventType::kAckReceived:
-        break;
-    case TransferSession::OutputEventType::kAckEOFReceived:
-        ChipLogDetail(BDX, "Transfer completed, got AckEOF");
-        Reset();
-        break;
-    case TransferSession::OutputEventType::kStatusReceived:
-        ChipLogError(BDX, "Got StatusReport %x", static_cast<uint16_t>(event.statusData.statusCode));
-        Reset();
-        break;
-    case TransferSession::OutputEventType::kInternalError:
-        ChipLogError(BDX, "InternalError");
-        Reset();
-        break;
-    case TransferSession::OutputEventType::kTransferTimeout:
-        ChipLogError(BDX, "Transfer timed out");
-        Reset();
-        break;
-    case TransferSession::OutputEventType::kAcceptReceived:
-    case TransferSession::OutputEventType::kBlockReceived:
-    default:
-        // TransferSession should prevent this case from happening.
-        ChipLogError(BDX, "Unsupported event type");
-    }
-}
-
-/* Reset() calls bdx::TransferSession::Reset() which sets the output event type to
- * TransferSession::OutputEventType::kNone. So, bdx::TransferFacilitator::PollForOutput()
- * will call HandleTransferSessionOutput() with event TransferSession::OutputEventType::kNone.
- * Since we are ignoring kNone events so, it is okay HandleTransferSessionOutput() being called with event kNone
- */
-void BdxOtaSender::Reset()
-{
-    mFabricIndex.ClearValue();
-    mNodeId.ClearValue();
-    ResetTransfer();
-    if (mExchangeCtx != nullptr)
-    {
-        mExchangeCtx->Close();
-        mExchangeCtx = nullptr;
-    }
-
-    mInitialized  = false;
-    mNumBytesSent = 0;
-    memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
-}
+ #include <ota-provider-common/BdxOtaSender.h>
+
+ #include <lib/core/CHIPError.h>
+ #include <lib/support/BitFlags.h>
+ #include <lib/support/CHIPMemString.h>
+ #include <messaging/ExchangeContext.h>
+ #include <messaging/Flags.h>
+ #include <protocols/bdx/BdxTransferSession.h>
+ 
+ #include <fstream>
+ 
+ using chip::bdx::StatusCode;
+ using chip::bdx::TransferControlFlags;
+ using chip::bdx::TransferSession;
+ 
+ BdxOtaSender::BdxOtaSender()
+ {
+     memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
+ }
+ 
+ CHIP_ERROR BdxOtaSender::InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId)
+ {
+     if (mInitialized)
+     {
+         // Reset stale connection from the Same Node if exists
+         if ((mFabricIndex.HasValue() && mFabricIndex.Value() == fabricIndex) && (mNodeId.HasValue() && mNodeId.Value() == nodeId))
+         {
+             Reset();
+         }
+         // Prevent a new node connection since another is active
+         else if ((mFabricIndex.HasValue() && mFabricIndex.Value() != fabricIndex) ||
+                  (mNodeId.HasValue() && mNodeId.Value() != nodeId))
+         {
+             return CHIP_ERROR_BUSY;
+         }
+         else
+         {
+             return CHIP_ERROR_INTERNAL;
+         }
+     }
+     mFabricIndex.SetValue(fabricIndex);
+     mNodeId.SetValue(nodeId);
+     mInitialized = true;
+     return CHIP_NO_ERROR;
+ }
+ 
+ void BdxOtaSender::HandleTransferSessionOutput(TransferSession::OutputEvent & event)
+ {
+     CHIP_ERROR err = CHIP_NO_ERROR;
+ 
+     if (event.EventType != TransferSession::OutputEventType::kNone)
+     {
+         ChipLogDetail(BDX, "OutputEvent type: %s", event.ToString(event.EventType));
+     }
+ 
+     switch (event.EventType)
+     {
+     case TransferSession::OutputEventType::kNone:
+         break;
+     case TransferSession::OutputEventType::kMsgToSend: {
+         chip::Messaging::SendFlags sendFlags;
+         if (!event.msgTypeData.HasMessageType(chip::Protocols::SecureChannel::MsgType::StatusReport))
+         {
+             // All messages sent from the Sender expect a response, except for a StatusReport which would indicate an error and the
+             // end of the transfer.
+             sendFlags.Set(chip::Messaging::SendMessageFlags::kExpectResponse);
+         }
+         VerifyOrReturn(mExchangeCtx != nullptr);
+         err = mExchangeCtx->SendMessage(event.msgTypeData.ProtocolId, event.msgTypeData.MessageType, std::move(event.MsgData),
+                                         sendFlags);
+ 
+         if (err == CHIP_NO_ERROR)
+         {
+             if (!sendFlags.Has(chip::Messaging::SendMessageFlags::kExpectResponse))
+             {
+                 // After sending the StatusReport, exchange context gets closed so, set mExchangeCtx to null
+                 mExchangeCtx = nullptr;
+             }
+         }
+         else
+         {
+             ChipLogError(BDX, "SendMessage failed: %" CHIP_ERROR_FORMAT, err.Format());
+             Reset();
+         }
+ 
+         break;
+     }
+     case TransferSession::OutputEventType::kInitReceived: {
+         // TransferSession will automatically reject a transfer if there are no
+         // common supported control modes. It will also default to the smaller
+         // block size.
+         TransferSession::TransferAcceptData acceptData;
+         acceptData.ControlMode  = TransferControlFlags::kReceiverDrive; // OTA must use receiver drive
+         acceptData.MaxBlockSize = mTransfer.GetTransferBlockSize();
+         acceptData.StartOffset  = mTransfer.GetStartOffset();
+         acceptData.Length       = mTransfer.GetTransferLength();
+         VerifyOrReturn(mTransfer.AcceptTransfer(acceptData) == CHIP_NO_ERROR,
+                        ChipLogError(BDX, "AcceptTransfer failed: %" CHIP_ERROR_FORMAT, err.Format()));
+ 
+         // Store the file designator used during block query
+         uint16_t fdl       = 0;
+         const uint8_t * fd = mTransfer.GetFileDesignator(fdl);
+         VerifyOrReturn(fdl < chip::bdx::kMaxFileDesignatorLen,
+                        ChipLogError(BDX, "Cannot store file designator with length = %d", fdl));
+         memcpy(mFileDesignator, fd, fdl);
+         mFileDesignator[fdl] = 0;
+ 
+         break;
+     }
+     case TransferSession::OutputEventType::kQueryReceived:
+     case TransferSession::OutputEventType::kQueryWithSkipReceived: {
+         TransferSession::BlockData blockData;
+         uint16_t blockSize   = mTransfer.GetTransferBlockSize();
+         uint16_t bytesToRead = blockSize;
+         uint64_t bytesToSkip = 0;
+ 
+         if (event.EventType == TransferSession::OutputEventType::kQueryWithSkipReceived)
+         {
+             bytesToSkip = event.bytesToSkip.BytesToSkip;
+         }
+         uint64_t seekOffset = mNumBytesSent + bytesToSkip;
+ 
+         // TODO: This should be a utility function in TransferSession
+         if ((mTransfer.GetTransferLength() > 0) && ((seekOffset + blockSize) > mTransfer.GetTransferLength()))
+         {
+             // cast should be safe because of condition above
+             bytesToRead = static_cast<uint16_t>(mTransfer.GetTransferLength() - seekOffset);
+         }
+ 
+         chip::System::PacketBufferHandle blockBuf = chip::System::PacketBufferHandle::New(bytesToRead);
+         if (blockBuf.IsNull())
+         {
+             // TODO(#13981): AbortTransfer() needs to support GeneralStatusCode failures as well as BDX specific errors.
+             mTransfer.AbortTransfer(StatusCode::kUnknown);
+             return;
+         }
+ 
+         std::ifstream otaFile(mFileDesignator, std::ifstream::in);
+         if (!otaFile.good())
+         {
+             ChipLogError(BDX, "OTA file open failed");
+             mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
+             return;
+         }
+ 
+         if (seekOffset > static_cast<uint64_t>(std::numeric_limits<std::streamoff>::max()))
+         {
+             ChipLogError(BDX, "Seek offset too large");
+             mTransfer.AbortTransfer(StatusCode::kLengthTooLarge);
+             return;
+         }
+         otaFile.seekg(static_cast<std::streamoff>(seekOffset));
+         otaFile.read(reinterpret_cast<char *>(blockBuf->Start()), bytesToRead);
+         if (!(otaFile.good() || otaFile.eof()))
+         {
+             ChipLogError(BDX, "OTA file read failed");
+             mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
+             return;
+         }
+ 
+         blockData.Data   = blockBuf->Start();
+         blockData.Length = static_cast<size_t>(otaFile.gcount());
+         blockData.IsEof  = (blockData.Length < blockSize) ||
+             (seekOffset + static_cast<uint64_t>(blockData.Length) == mTransfer.GetTransferLength() || (otaFile.peek() == EOF));
+         mNumBytesSent = static_cast<uint32_t>(seekOffset + blockData.Length);
+         otaFile.close();
+ 
+         err = mTransfer.PrepareBlock(blockData);
+         if (err != CHIP_NO_ERROR)
+         {
+             ChipLogError(BDX, "PrepareBlock failed: %" CHIP_ERROR_FORMAT, err.Format());
+             mTransfer.AbortTransfer(StatusCode::kUnknown);
+         }
+         break;
+     }
+     case TransferSession::OutputEventType::kAckReceived:
+         break;
+     case TransferSession::OutputEventType::kAckEOFReceived:
+         ChipLogDetail(BDX, "Transfer completed, got AckEOF");
+         Reset();
+         break;
+     case TransferSession::OutputEventType::kStatusReceived:
+         ChipLogError(BDX, "Got StatusReport %x", static_cast<uint16_t>(event.statusData.statusCode));
+         Reset();
+         break;
+     case TransferSession::OutputEventType::kInternalError:
+         ChipLogError(BDX, "InternalError");
+         Reset();
+         break;
+     case TransferSession::OutputEventType::kTransferTimeout:
+         ChipLogError(BDX, "Transfer timed out");
+         Reset();
+         break;
+     case TransferSession::OutputEventType::kAcceptReceived:
+     case TransferSession::OutputEventType::kBlockReceived:
+     default:
+         // TransferSession should prevent this case from happening.
+         ChipLogError(BDX, "Unsupported event type");
+     }
+ }
+ 
+ /* Reset() calls bdx::TransferSession::Reset() which sets the output event type to
+  * TransferSession::OutputEventType::kNone. So, bdx::TransferFacilitator::PollForOutput()
+  * will call HandleTransferSessionOutput() with event TransferSession::OutputEventType::kNone.
+  * Since we are ignoring kNone events so, it is okay HandleTransferSessionOutput() being called with event kNone
+  */
+ void BdxOtaSender::Reset()
+ {
+     mFabricIndex.ClearValue();
+     mNodeId.ClearValue();
+     ResetTransfer();
+     if (mExchangeCtx != nullptr)
+     {
+         mExchangeCtx->Close();
+         mExchangeCtx = nullptr;
+     }
+ 
+     mInitialized  = false;
+     mNumBytesSent = 0;
+     memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
+ }
+ 
+ void BdxOtaSender::AbortTransfer()
+ {
+     if (mInitialized)
+     {
+         mTransfer.AbortTransfer(StatusCode::kUnknown);
+         PollForOutput();
+     }
+ }
\ No newline at end of file
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
index 6cc303486ed891..93fd7665c2fabf 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
@@ -15,33 +15,35 @@
  *    limitations under the License.
  */
 
-#include <protocols/bdx/BdxTransferSession.h>
-#include <protocols/bdx/TransferFacilitator.h>
-
-#pragma once
-
-class BdxOtaSender : public chip::bdx::Responder
-{
-public:
-    BdxOtaSender();
-
-    // Initializes BDX transfer-related metadata. Should always be called first.
-    CHIP_ERROR InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId);
-
-private:
-    // Inherited from bdx::TransferFacilitator
-    void HandleTransferSessionOutput(chip::bdx::TransferSession::OutputEvent & event) override;
-
-    void Reset();
-
-    // Null-terminated string representing file designator
-    char mFileDesignator[chip::bdx::kMaxFileDesignatorLen];
-
-    uint32_t mNumBytesSent = 0;
-
-    bool mInitialized = false;
-
-    chip::Optional<chip::FabricIndex> mFabricIndex;
-
-    chip::Optional<chip::NodeId> mNodeId;
-};
+ #include <protocols/bdx/BdxTransferSession.h>
+ #include <protocols/bdx/TransferFacilitator.h>
+ 
+ #pragma once
+ 
+ class BdxOtaSender : public chip::bdx::Responder
+ {
+ public:
+     BdxOtaSender();
+ 
+     // Initializes BDX transfer-related metadata. Should always be called first.
+     CHIP_ERROR InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId);
+ 
+     void AbortTransfer();
+ 
+ private:
+     // Inherited from bdx::TransferFacilitator
+     void HandleTransferSessionOutput(chip::bdx::TransferSession::OutputEvent & event) override;
+ 
+     void Reset();
+ 
+     // Null-terminated string representing file designator
+     char mFileDesignator[chip::bdx::kMaxFileDesignatorLen];
+ 
+     uint32_t mNumBytesSent = 0;
+ 
+     bool mInitialized = false;
+ 
+     chip::Optional<chip::FabricIndex> mFabricIndex;
+ 
+     chip::Optional<chip::NodeId> mNodeId;
+ };
\ No newline at end of file
diff --git a/src/app/tests/suites/certification/Test_TC_SU_2_8.yaml b/src/app/tests/suites/certification/Test_TC_SU_2_8.yaml
deleted file mode 100644
index a7a4ed9582f5fd..00000000000000
--- a/src/app/tests/suites/certification/Test_TC_SU_2_8.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# 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.
-# Auto-generated scripts for harness use only, please review before automation. The endpoints and cluster names are currently set to default
-
-name: 3.6.1. [TC-SU-2.8] OTA functionality in Multi Fabric scenario
-
-PICS:
-    - MCORE.OTA.Requestor
-
-config:
-    nodeId: 0x12344321
-    cluster: "Basic Information"
-    endpoint: 0
-
-tests:
-    - label: "Step 1: DUT sends a QueryImage command to TH1/OTA-P."
-      verification: |
-          ./chip-tool otasoftwareupdaterequestor write default-otaproviders '[{"fabricIndex": 1, "providerNodeID": 123, "endpoint": 0}]' 321 0
-
-          where 321  is OTA Requestor node ID and 123 is OTA Provider node ID
-
-          Verify on the OTA Provider logs receives QueryImage with following fields:
-           - VendorId - Should match the value reported by the Basic Information Cluster VendorID attribute of the DUT.
-            - ProductId - Should match the value reported by the Basic Information Cluster ProductID attribute of the DUT.
-           - HardwareVersion - If present, verify that it matches the value reported by the Basic Information Cluster HardwareVersion attribute of the DUT.
-           - SoftwareVersion - Should match the value reported by the Basic Information Cluster SoftwareVersion attribute of the DUT.
-           - Verify the field ProtocolsSupported lists the BDX Synchronous protocol.
-           - Verify the default value of RequestorCanConsent is set to False unless DUT sets it to True.
-           - If the Location field is present, verify that the value is same as Basic Information Cluster Location Attribute of the DUT.
-
-          [1645743053317] [97806:20280749] CHIP: [ZCL] OTA Provider received QueryImage
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   VendorID: 0xfff1
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   ProductID: 32769
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   SoftwareVersion: 0
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   ProtocolsSupported: [
-          [1645743053317] [97806:20280749] CHIP: [ZCL]     0
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   ]
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   HardwareVersion: 0
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   Location: XX
-          [1645743053317] [97806:20280749] CHIP: [ZCL]   RequestorCanConsent: 0
-      disabled: true
-
-    - label:
-          "Step 2: DUT sends a QueryImage command to TH1/OTA-P. TH1/OTA-P does
-          not respond with QueryImageResponse."
-      PICS: MCORE.OTA.Retry
-      verification: |
-          ./chip-tool otasoftwareupdaterequestor write default-otaproviders '[{"fabricIndex": 1, "providerNodeID": 123, "endpoint": 0}]' 321 0
-
-          Verify SUCCESS status response On TH(chip-tool) log:
-
-          [1686302244.664128][30278:30280] CHIP:DMG:                         StatusIB =
-          [1686302244.664157][30278:30280] CHIP:DMG:                         {
-          [1686302244.664198][30278:30280] CHIP:DMG:                                 status = 0x00 (SUCCESS),
-          [1686302244.664228][30278:30280] CHIP:DMG:                         },
-
-
-           ./chip-tool otasoftwareupdaterequestor write default-otaproviders '[{"fabricIndex": 2, "providerNodeID": 222, "endpoint": 0}]' 321 0 --commissioner-name beta
-
-          Verify SUCCESS status response On TH(chip-tool) log:
-
-          [1686302244.664128][30278:30280] CHIP:DMG:                         StatusIB =
-          [1686302244.664157][30278:30280] CHIP:DMG:                         {
-          [1686302244.664198][30278:30280] CHIP:DMG:                                 status = 0x00 (SUCCESS),
-          [1686302244.664228][30278:30280] CHIP:DMG:                         },
-
-          Kill Default OTA Provider for fabric index 1 before DUT sends a query
-
-          Verify that the DUT sends a QueryImage command to TH2/OTA-P when failing to reach out to TH1/OTA-P after a finite number of unsuccessful attempts.
-      disabled: true
-
-    - label:
-          "Step 3: DUT sends a QueryImage command to TH2/OTA-P. TH2/OTA-P sends
-          a QueryImageResponse back to the DUT. Status is set to
-          UpdateAvailable."
-      verification: |
-          ./chip-tool otasoftwareupdaterequestor write default-otaproviders '[{"fabricIndex": 2, "providerNodeID": 1, "endpoint": 0}]' 0x858 0 --commissioner-name beta
-
-          Verify there is a transfer of the software image from TH2/OTA-P to the DUT
-      disabled: true
diff --git a/src/python_testing/TC_SUTestBase.py b/src/python_testing/TC_SUTestBase.py
new file mode 100644
index 00000000000000..7fed246d6eed7b
--- /dev/null
+++ b/src/python_testing/TC_SUTestBase.py
@@ -0,0 +1,492 @@
+#
+#    Copyright (c) 2025 Project CHIP Authors
+#    All rights reserved.
+#
+#    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.
+
+
+import logging
+from datetime import datetime
+from os import environ, getcwd, path
+from typing import Optional, Union
+
+from mobly import asserts
+
+import matter.clusters as Clusters
+from matter import ChipDeviceCtrl
+from matter.clusters.Types import NullValue
+from matter.interaction_model import Status
+from matter.testing.apps import OtaImagePath, OTAProviderSubprocess
+from matter.testing.matter_testing import MatterBaseTest
+
+logger = logging.getLogger(__name__)
+
+
+class SoftwareUpdateBaseTest(MatterBaseTest):
+    """This is the base test class for SoftwareUpdate Test Cases"""
+
+    current_provider_app_proc: Union[OTAProviderSubprocess, None] = None
+    current_requestor_app_proc: Union[OTAProviderSubprocess, None] = None
+
+    def start_provider(self,
+                       version: int = 2,
+                       setup_pincode: int = 20202021,
+                       discriminator: int = 1234,
+                       port: int = 5541,
+                       storage_dir='/tmp',
+                       extra_args: list = [],
+                       kvs_path: Optional[str] = None,
+                       log_file: Optional[str] = None, expected_output: str = "Status: Satisfied",
+                       timeout: int = 10):
+        """Start the provider process using the provided configuration.
+
+        Args:
+            version (int, optional): Provider app version to load. Defaults to 2.
+            setup_pincode (int, optional): Setup pincode for the provider process. Defaults to 20202021.
+            discriminator (int, optional): Discriminator for the provider process. Defaults to 1234.
+            port (int, optional): Port for the provider process. Defaults to 5541.
+            storage_dir (str, optional): Storage dir for the provider proccess. Defaults to '/tmp'.
+            extra_args (list, optional): Extra args to send to the provider process. Defaults to [].
+            kvs_path(str): Str of the path for the kvs path, if not will use temp file.
+            log_file (Optional[str], optional): Destination for the app process logs. Defaults to None.
+            expected_output (str): Expected string to see after a default timeout. Defaults to "Status: Satisfied".
+            timeout (int): Timeout to wait for the expected output. Defaults to 10 seconds
+        """
+        logger.info(f"Launching provider app with version {version}")
+        # Image to launch
+        ota_app = ""
+        if environ.get("OTA_PROVIDER_APP") is not None:
+            ota_app = environ.get("OTA_PROVIDER_APP")
+        else:
+            ota_app = f"{getcwd()}/out/debug/chip-ota-provider-app"
+
+        # Ota image
+        ota_image_path = OtaImagePath(path=self.get_ota_image_path(version=version))
+        # Ideally we send the logs to a fixed location to avoid conflicts
+
+        if log_file is None:
+            now = datetime.now()
+            ts = int(now.timestamp())
+            log_file = f'/tmp/provider_{ts}.log'
+        logger.info(f"Writing Provider logs at : {log_file}")
+        # Launch the Provider subprocess using the Wrapper
+        proc = OTAProviderSubprocess(
+            ota_app,
+            storage_dir=storage_dir,
+            port=port,
+            discriminator=discriminator,
+            passcode=setup_pincode,
+            ota_source=ota_image_path,
+            extra_args=extra_args,
+            kvs_path=kvs_path,
+            log_file=log_file,
+            err_log_file=log_file)
+        proc.start(
+            expected_output=expected_output,
+            timeout=timeout)
+
+        self.current_provider_app_proc = proc
+        logger.info(f"Provider started with PID:  {self.current_provider_app_proc.get_pid()}")
+
+    def get_ota_image_path(self, version: int = 2) -> str:
+        """Get the path ota image used for the provider.
+
+        Args:
+            version (int): App version . Defaults to 2.
+
+        Returns:
+            str: Path of the ota image
+        """
+
+        ota_image = ""
+        if environ.get(f"SU_OTA_REQUESTOR_V{version}") is not None:
+            ota_image = environ.get(f"SU_OTA_REQUESTOR_V{version}")
+        else:
+            ota_image = f"{getcwd()}/chip-ota-requestor-app_v{version}.min.ota"
+
+        return ota_image
+
+    async def announce_ota_provider(self,
+                                    controller: ChipDeviceCtrl,
+                                    provider_node_id: int,
+                                    requestor_node_id: int,
+                                    reason: Clusters.OtaSoftwareUpdateRequestor.Enums.AnnouncementReasonEnum = Clusters.OtaSoftwareUpdateRequestor.Enums.AnnouncementReasonEnum.kUpdateAvailable,
+                                    vendor_id: int = 0xFFF1,
+                                    endpoint: int = 0):
+        """Announce the OTA provider that a software update is requested.
+
+        Args:
+            controller (ChipDeviceCtrl): Controller for DUT
+            provider_node_id (int): Node id for the provider
+            requestor_node_id (int): Node id for the requestor
+            reason (Clusters.OtaSoftwareUpdateRequestor.Enums.AnnouncementReasonEnum, optional): Update Reason. Defaults to Clusters.OtaSoftwareUpdateRequestor.Enums.AnnouncementReasonEnum.kUpdateAvailable.
+            vendor_id (int, optional): Vendor id. Defaults to 0xFFF1.
+            endpoint (int, optional): Endpoint id. Defaults to 0.
+
+        Returns:
+            _type_: _description_
+        """
+        cmd_announce_ota_provider = Clusters.OtaSoftwareUpdateRequestor.Commands.AnnounceOTAProvider(
+            providerNodeID=provider_node_id,
+            vendorID=vendor_id,
+            announcementReason=reason,
+            metadataForNode=None,
+            endpoint=endpoint
+        )
+        logger.info("Sending AnnounceOTA Provider Command")
+        cmd_resp = await self.send_single_cmd(
+            cmd=cmd_announce_ota_provider,
+            dev_ctrl=controller,
+            node_id=requestor_node_id,
+            endpoint=endpoint,
+        )
+        logger.info(f"Announce command sent {cmd_resp}")
+        return cmd_resp
+
+    async def write_ota_providers(self, controller: ChipDeviceCtrl, provider_node_id: int, endpoint: int = 0):
+        """Write the provider list in the requestor to initiate the SU.
+
+        Args:
+            controller (ChipDeviceCtrl): Controller to write the providers.
+            provider_node_id (int): Node where the provider is localted.
+            endpoint (int, optional): Endpoint to write the providerss. Defaults to 0.
+        """
+
+        current_otap_info = await self.read_single_attribute_check_success(
+            dev_ctrl=controller,
+            cluster=Clusters.OtaSoftwareUpdateRequestor,
+            attribute=Clusters.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders
+        )
+        logger.info(f"OTA Providers: {current_otap_info}")
+
+        # Create Provider Location into Requestor
+        provider_location_struct = Clusters.OtaSoftwareUpdateRequestor.Structs.ProviderLocation(
+            providerNodeID=provider_node_id,
+            endpoint=endpoint,
+            fabricIndex=controller.fabricId
+        )
+
+        # Create the OTA Provider Attribute
+        ota_providers_attr = Clusters.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders(value=[provider_location_struct])
+
+        # Write the Attribute
+        resp = await controller.WriteAttribute(
+            attributes=[(endpoint, ota_providers_attr)],
+            nodeid=self.dut_node_id,
+        )
+        asserts.assert_equal(resp[0].Status, Status.Success, "Failed to write Default OTA Providers Attribute")
+
+        # Read Updated OTAProviders
+        after_otap_info = await self.read_single_attribute_check_success(
+            dev_ctrl=controller,
+            cluster=Clusters.OtaSoftwareUpdateRequestor,
+            attribute=Clusters.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders
+        )
+        logger.info(f"OTA Providers List: {after_otap_info}")
+
+    async def verify_version_applied_basic_information(self, controller: ChipDeviceCtrl, node_id: int, target_version: int):
+        """Verify the version from the BasicInformationCluster and compares against the provider target version.
+
+        Args:
+            controller (ChipDeviceCtrl): Controller 
+            node_id (int): Node to request
+            target_version (int): Version to compare
+        """
+
+        basicinfo_softwareversion = await self.read_single_attribute_check_success(
+            dev_ctrl=controller,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.SoftwareVersion,
+            node_id=node_id)
+        asserts.assert_equal(basicinfo_softwareversion, target_version,
+                             f"Version from basic info cluster is not {target_version}, current cluster version is {basicinfo_softwareversion}")
+
+    def get_downloaded_ota_image_info(self, ota_path='/tmp/test.bin') -> dict:
+        """Return the data of the downloaded image from the provider.
+
+        Args:
+            ota_path (str, optional): _description_. Defaults to '/tmp/test.bin'.
+
+        Returns:
+            dict: Dict with the image info.
+        """
+        ota_image_info = {
+            "path": ota_path,
+            "exists": False,
+            "size": 0,
+        }
+        try:
+            ota_image_info['size'] = path.getsize(ota_path)
+            ota_image_info['exists'] = True
+        except OSError:
+            logger.info(f"OTA IMAGE at {ota_path} does not exists")
+            return ota_image_info
+
+        return ota_image_info
+
+    def verify_state_transition_event(self,
+                                      event_report: Clusters.OtaSoftwareUpdateRequestor.Events.StateTransition,
+                                      previous_state,
+                                      new_state,
+                                      target_version: Optional[int] = None,
+                                      reason: Optional[int] = None):
+        """Verify the values of the StateTransitionEvent from the EventHandler given the provided arguments.
+
+        Args:
+            event_report (Clusters.OtaSoftwareUpdateRequestor.Events.StateTransition): StateTransition Event report to verify.
+            previous_state (UpdateStateEnum:int): Int or UpdateStateEnum value for the previous state.
+            new_state (UpdateStateEnum:int): Int or UpdateStateEnum value for the new or current state.
+            target_version (Optional[int], optional): Software version to verify if not provided ignore this check.. Defaults to None.
+            reason (Optional[int], optional): UpdateStateEnum reason of the event, if not provided ignore. Defaults to None.
+        """
+        logger.info(f"Verifying the event {event_report}")
+        asserts.assert_equal(event_report.previousState, previous_state, f"Previous state was not {previous_state}")
+        asserts.assert_equal(event_report.newState,  new_state, f"New state is not {new_state}")
+        if target_version is not None:
+            asserts.assert_equal(event_report.targetSoftwareVersion,  target_version, f"Target version is not {target_version}")
+        if reason is not None:
+            asserts.assert_equal(event_report.reason,  reason, f"Reason is not {reason}")
+
+    def create_acl_entry(self,
+                         dev_ctrl: ChipDeviceCtrl.ChipDeviceController,
+                         provider_node_id: int,
+                         requestor_node_id: Optional[int] = None,
+                         acl_entries: Optional[list[Clusters.AccessControl.Structs.AccessControlEntryStruct]] = None,
+                         ):
+        """Create ACL entries to allow OTA requestors to access the provider.
+
+        Args:
+            dev_ctrl: Device controller for sending commands
+            provider_node_id: Node ID of the OTA provider
+            requestor_node_id: Optional specific requestor node ID for targeted access
+            acl_entries: Optional[list[Clusters.AccessControl.Structs.AccessControlEntryStruct]]. ACL list to write ino the requestor.
+
+        Returns:
+            Result of the ACL write operation
+        """
+        # Standard ACL entry for OTA Provider cluster
+        admin_node_id = dev_ctrl.nodeId if hasattr(dev_ctrl, 'nodeId') else self.DEFAULT_ADMIN_NODE_ID
+        requestor_subjects = [requestor_node_id] if requestor_node_id else NullValue
+
+        if acl_entries is None:
+            # If there are not ACL entries using proper struct constructors create the default.
+            acl_entries = [
+                # Admin entry
+                Clusters.AccessControl.Structs.AccessControlEntryStruct(  # type: ignore
+                    privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kAdminister,  # type: ignore
+                    authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,  # type: ignore
+                    subjects=[admin_node_id],  # type: ignore
+                    targets=NullValue
+                ),
+                # Operate entry
+                Clusters.AccessControl.Structs.AccessControlEntryStruct(  # type: ignore
+                    privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kOperate,  # type: ignore
+                    authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,  # type: ignore
+                    subjects=requestor_subjects,  # type: ignore
+                    targets=[
+                        Clusters.AccessControl.Structs.AccessControlTargetStruct(  # type: ignore
+                            cluster=Clusters.OtaSoftwareUpdateProvider.id,  # type: ignore
+                            endpoint=NullValue,
+                            deviceType=NullValue
+                        )
+                    ],
+                )
+            ]
+
+        # Create the attribute descriptor for the ACL attribute
+        acl_attribute = Clusters.AccessControl.Attributes.Acl(acl_entries)
+
+        return dev_ctrl.WriteAttribute(
+            nodeid=provider_node_id,
+            attributes=[(0, acl_attribute)]
+        )
+
+
+class ACLHandler:
+    """
+    Utility class to handle Access Control List (ACL) operations for OTA Provider and Requestor.
+    """
+
+    DEFAULT_ADMIN_NODE_ID = 112233
+
+    def __init__(self, controller):
+        """
+        Initialize the ACL handler.
+
+        Args:
+            controller: The controller used to perform ACL write operations.
+        """
+        self.controller = controller
+
+    async def write_acl(self, node_id: int, acl: list):
+        """
+        Writes the Access Control List (ACL) to the DUT device using the specified controller.
+
+        Args:
+            node_id: Node ID of the target device (provider or requestor).
+            acl (list): List of AccessControlEntryStruct objects defining ACL permissions.
+
+        Raises:
+            AssertionError: If writing the ACL attribute fails (status is not Status.Success).
+        """
+        acl_attribute = Clusters.AccessControl.Attributes.Acl(acl)
+        result = await self.controller.WriteAttribute(
+            nodeid=node_id,
+            attributes=[(0, acl_attribute)]
+        )
+        if result[0].Status != Status.Success:
+            raise RuntimeError(f"ACL write failed for node {node_id}: {result[0].Status}")
+        return True
+
+    def create_acl_entry(self, dev_ctrl: ChipDeviceCtrl.ChipDeviceController, provider_node_id: int, requestor_node_id: Optional[int] = None):
+        """Create ACL entries to allow OTA requestors to access the provider.
+
+        Args:
+            dev_ctrl: Device controller for sending commands
+            provider_node_id: Node ID of the OTA provider
+            requestor_node_id: Optional specific requestor node ID for targeted access
+
+        Returns:
+            Result of the ACL write operation
+        """
+        # Standard ACL entry for OTA Provider cluster
+        admin_node_id = dev_ctrl.nodeId if hasattr(dev_ctrl, 'nodeId') else self.DEFAULT_ADMIN_NODE_ID
+        requestor_subjects = [requestor_node_id] if requestor_node_id else NullValue
+
+        # Create ACL entries using proper struct constructors
+        acl_entries = [
+            # Admin entry
+            Clusters.AccessControl.Structs.AccessControlEntryStruct(  # type: ignore
+                privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kAdminister,  # type: ignore
+                authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,  # type: ignore
+                subjects=[admin_node_id],  # type: ignore
+                targets=NullValue
+            ),
+            # Operate entry
+            Clusters.AccessControl.Structs.AccessControlEntryStruct(  # type: ignore
+                privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kOperate,  # type: ignore
+                authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,  # type: ignore
+                subjects=requestor_subjects,  # type: ignore
+                targets=[
+                    Clusters.AccessControl.Structs.AccessControlTargetStruct(  # type: ignore
+                        cluster=Clusters.OtaSoftwareUpdateProvider.id,  # type: ignore
+                        endpoint=NullValue,
+                        deviceType=NullValue
+                    )
+                ],
+            )
+        ]
+
+        # Create the attribute descriptor for the ACL attribute
+        acl_attribute = Clusters.AccessControl.Attributes.Acl(acl_entries)
+
+        return dev_ctrl.WriteAttribute(
+            nodeid=provider_node_id,
+            attributes=[(0, acl_attribute)]
+        )
+
+    async def set_acl_for_requestor(
+            self,
+            requestor_node: int,
+            provider_node: int,
+            fabric_index: int,
+            original_requestor_acls: list
+    ):
+        """
+        Read existing ACLs on Requestor, add minimal ACL for Provider, and write back.
+
+        Args:
+            requestor_node: Node ID of the Requestor device.
+            provider_node: Node ID of the Provider device.
+            fabric_index: Fabric index for the ACL entry.
+            original_requestor_acls: Existing ACLs for the Requestor.
+
+        Returns:
+            The original requestor ACLs (unchanged).
+        """
+
+        # Add minimal ACL for Provider
+        acl_operate_provider = Clusters.AccessControl.Structs.AccessControlEntryStruct(
+            fabricIndex=fabric_index,
+            privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kOperate,
+            authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,
+            subjects=[provider_node],
+            targets=[Clusters.AccessControl.Structs.AccessControlTargetStruct(
+                endpoint=0,
+                cluster=Clusters.OtaSoftwareUpdateRequestor.id
+            )]
+        )
+
+        # Combine existing + new ACLs
+        combined_acls = original_requestor_acls + [acl_operate_provider]
+        await self.write_acl(requestor_node, combined_acls)
+
+    async def set_acl_for_provider(
+            self,
+            provider_node: int,
+            requestor_node: int,
+            fabric_index: int,
+            original_provider_acls: list
+    ):
+        """
+        Read existing ACLs on Provider, add minimal ACL for Requestor, and write back.
+
+        Args:
+            provider_node: Node ID of the Provider device.
+            requestor_node: Node ID of the Requestor device.
+            fabric_index: Fabric index for the ACL entry.
+            original_provider_acls: Existing ACLs for the Provider.
+
+        Returns:
+            The original provider ACLs (unchanged).
+        """
+
+        # Add minimal ACL for Requestor
+        acl_operate_requestor = Clusters.AccessControl.Structs.AccessControlEntryStruct(
+            fabricIndex=fabric_index,
+            privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kOperate,
+            authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,
+            subjects=[requestor_node],
+            targets=[Clusters.AccessControl.Structs.AccessControlTargetStruct(
+                endpoint=0,
+                cluster=Clusters.OtaSoftwareUpdateProvider.id
+            )]
+        )
+
+        # Combine existing + new ACLs
+        combined_acls = original_provider_acls + [acl_operate_requestor]
+        await self.write_acl(provider_node, combined_acls)
+
+    async def set_ota_acls(
+            self,
+            requestor_node: int,
+            provider_node: int,
+            fabric_index: int,
+            original_requestor_acls: list,
+            original_provider_acls: list
+    ):
+        """
+        Set ACLs both ways and preserve originals.
+
+        Args:
+            requestor_node: Node ID of the Requestor.
+            provider_node: Node ID of the Provider.
+            fabric_index: Fabric index for ACL entries.
+            original_requestor_acls: Existing ACLs on Requestor.
+            original_provider_acls: Existing ACLs on Provider.
+
+        Returns:
+            original_requestor_acls, original_provider_acls
+        """
+        await self.set_acl_for_requestor(requestor_node, provider_node, fabric_index, original_requestor_acls)
+        await self.set_acl_for_provider(provider_node, requestor_node, fabric_index, original_provider_acls)
diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
new file mode 100644
index 00000000000000..44883a74a9f52e
--- /dev/null
+++ b/src/python_testing/TC_SU_2_8.py
@@ -0,0 +1,459 @@
+#
+#    Copyright (c) 2025 Project CHIP Authors
+#    All rights reserved.
+#
+#    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.
+#
+
+# See https://github.com/project-chip/connectedhomeip/blob/master/docs/testing/python.md#defining-the-ci-test-arguments
+# for details about the block below.
+#
+# === BEGIN CI TEST ARGUMENTS ===
+# test-runner-runs:
+#   run1:
+#     app: ${OTA_REQUESTOR_APP}
+#     app-args: >
+#       --discriminator 1234
+#       --passcode 20202021
+#       --secured-device-port 5541
+#       --KVS /tmp/chip_kvs_requestor
+#       --autoApplyImage
+#       --trace-to json:${TRACE_APP}.json
+#     script-args: >
+#       --storage-path admin_storage.json
+#       --commissioning-method on-network
+#       --discriminator 1234
+#       --passcode 20202021
+#       --endpoint 0
+#       --trace-to json:${TRACE_TEST_JSON}.json
+#       --trace-to perfetto:${TRACE_TEST_PERFETTO}.perfetto
+#     factory-reset: true
+#     quiet: true
+# === END CI TEST ARGUMENTS ===
+
+import asyncio
+import logging
+import re
+from subprocess import run
+
+from mobly import asserts
+from TC_SUTestBase import SoftwareUpdateBaseTest
+
+import matter.clusters as Clusters
+from matter import ChipDeviceCtrl
+from matter.interaction_model import Status
+from matter.testing.apps import OtaImagePath, OTAProviderSubprocess
+from matter.testing.event_attribute_reporting import EventSubscriptionHandler
+from matter.testing.matter_testing import MatterBaseTest, TestStep, async_test_body, default_matter_test_main
+
+ANSI_RE = re.compile(r"\x1B\[[0-?]*[-/]*[@-~]]")
+HEX_OR_DEC = re.compile(r"(0x[0-9a-fA-F]+|\d+)")
+VENDOR_RE = re.compile(r"VendorID:\s*(0x[0-9a-fA-F]+|\d+)")
+PRODUCT_RE = re.compile(r"ProductID:\s*(0x[0-9a-fA-F]+|\d+)")
+SWVER_RE = re.compile(r"SoftwareVersion:\s*(0x[0-9a-fA-F]+|\d+)")
+PROTO_RE = re.compile(r"ProtocolsSupported:\s*\[(.*?)\]", re.DOTALL)
+HWVER_RE = re.compile(r"HardwareVersion:\s*(0x[0-9a-fA-F]+|\d+)")
+LOC_RE = re.compile(r"Location:\s*([A-Za-z0.9]+)")
+RCC_RE = re.compile(r"RequestorCanConsent:\s*(0x[0-9a-fA-F]+|\d+)")
+
+FIELDS = {
+    "vendor_id": VENDOR_RE,
+    "product_id": PRODUCT_RE,
+    "software_version": SWVER_RE,
+    "hardware_version": HWVER_RE,
+    "location": LOC_RE,
+    "requestor_can_consent": RCC_RE
+}
+
+
+class TC_SU_2_8(SoftwareUpdateBaseTest, MatterBaseTest):
+    """
+    This test case verifies that the DUT is able to successfully send a QueryImage command to the OTA-P in multi fabric scenario.
+    """
+
+    def desc_TC_SU_2_8(self) -> str:
+        return "[TC-SU-2.8] OTA functionality in Multi Fabric scenario"
+
+    def pics_TC_SU_2_8(self):
+        """Return the PICS definitions associated with this test."""
+        pics = [
+            "MCORE.OTA.Requestor",
+        ]
+        return pics
+
+    def steps_TC_SU_2_8(self) -> list[TestStep]:
+        steps = [
+            TestStep(0, "Commissioning, already done.", is_commissioning=True),
+            TestStep(1, "DUT sends a QueryImage commands to TH1/OTA-P.",
+                     "Verify the QueryImage command received on the server has the following mandatory fields."
+                     "VendorId - Should match the value reported by the Basic Information Cluster VendorID attribute of the DUT."
+                     "ProductId - Should match the value reported by the Basic Information Cluster ProductID attribute of the DUT."
+                     "HardwareVersion - If present, verify that it matches the value reported by the Basic Information Cluster HardwareVersion attribute of the DUT."
+                     "SoftwareVersion - Should match the value reported by the Basic Information Cluster SoftwareVersion attribute of the DUT."
+                     "Verify the field ProtocolsSupported lists the BDX Synchronous protocol."
+                     "If (MCORE.OTA.HTTPS_Supported) HTTPS protocol should be listed."
+                     "Verify the default value of RequestorCanConsent is set to False unless DUT sets it to True."
+                     "If the Location field is present, verify that the value is same as Basic Information Cluster Location Attribute of the DUT."),
+            TestStep(2, "Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P.",
+                     "TH1/OTA-P does not respond with QueryImage response command. StateTransition goes from idle to querying, then a download error happens and finally it goes back to idle."
+                     "Subscribe to events for OtaSoftwareUpdateRequestor cluster and verify StateTransition reaches downloading state. Also check if the targetSoftwareVersion is 2."),
+        ]
+        return steps
+
+    def parse_query_block(self, block: dict) -> dict:
+        text = ANSI_RE.sub("", '\n'.join(block.get("after", [])))
+
+        out = {}
+
+        for name, rx in FIELDS.items():
+            m = rx.search(text)
+            if m:
+                val = m.group(1) if m.lastindex else m.group(0)
+                if name == "location":
+                    out[name] = val
+                else:
+                    out[name] = int(val, 0)
+
+        m = PROTO_RE.search(text)
+        out["protocols_supported"] = (
+            [int(n, 0) for n in HEX_OR_DEC.findall(m.group(1))] if m else []
+        )
+
+        return out
+
+    @async_test_body
+    async def test_TC_SU_2_8(self):
+
+        # Variables for TH1-OTA Provider
+        p1_node = 10
+        p1_node_invalid = 13
+        p1_disc = 1112
+
+        # Variables for TH2-OTA Provider
+        p2_node = 11
+        p2_disc = 1111
+
+        p_pass = 20202021
+
+        provider_port = 5540
+
+        app_path = "./out/debug/chip-ota-provider-app"
+        provider_ota_file = OtaImagePath(path="firmware_v2.ota")
+
+        # States
+        idle = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kIdle
+        querying = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kQuerying
+        downloading = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kDownloading
+        applying = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kApplying
+
+        target_version = 3
+
+        endpoint = self.get_endpoint(default=0)
+        dut_node_id = self.dut_node_id
+        requestor_node_id = self.dut_node_id
+        th1 = self.default_controller
+        fabric_id_th2 = th1.fabricId + 1
+        vendor_id = self.matter_test_config.admin_vendor_id
+        product_id = 32769  # Default value
+
+        logging.info(f"Endpoint: {endpoint}.")
+        logging.info(f"DUT Node ID: {dut_node_id}.")
+        logging.info(f"Requestor Node ID: {requestor_node_id}.")
+        logging.info(f"Vendor ID: {vendor_id}.")
+        logging.info(f"Product ID: {product_id}.")
+
+        logging.info(f"TH1 fabric id: {th1.fabricId}.")
+        logging.info(f"TH2 fabric id: {fabric_id_th2}.")
+
+        # Commissioning step
+        self.step(0)
+
+        # Start OTA Provider
+        logging.info("Starting OTA Provider 1")
+
+        provider_1 = OTAProviderSubprocess(
+            app=app_path,
+            storage_dir='/tmp',
+            port=provider_port,
+            discriminator=p1_disc,
+            passcode=p_pass,
+            ota_source=provider_ota_file,
+            log_file='/tmp/provider_1.log',
+            err_log_file='/tmp/provider_1.log'
+        )
+
+        provider_1.start()
+
+        # Commissioning Provider-TH1
+        logging.info("Commissioning OTA Provider to TH1")
+
+        resp = await th1.CommissionOnNetwork(
+            nodeId=p1_node,
+            setupPinCode=p_pass,
+            filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
+            filter=p1_disc
+        )
+
+        logging.info(f"Commissioning response: {resp}.")
+
+        # DUT sends a QueryImage commands to TH1/OTA-P
+        self.step(1)
+
+        # Define ACL entry
+        await self.create_acl_entry(dev_ctrl=th1, provider_node_id=p1_node, requestor_node_id=requestor_node_id)
+
+        # Write default OTA providers
+        await self.write_ota_providers(th1, p1_node, endpoint)
+
+        # Announce after subscription
+        await self.announce_ota_provider(controller=th1, provider_node_id=p1_node, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
+
+        await asyncio.sleep(5)
+
+        blocks = provider_1.read_from_logs("QueryImage", regex=True, before=0, after=15)
+
+        parsed = {}
+        for b in blocks:
+            info = self.parse_query_block(b)
+            for k, v in info.items():
+                parsed.setdefault(k, v)
+
+        logging.info(f"Parsed fields: {parsed}")
+
+        # Check VendorID
+        vendor_id_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.VendorID
+        )
+
+        asserts.assert_equal(vendor_id_basic_information,
+                             parsed['vendor_id'], f"Vendor ID is {parsed['vendor_id']} and it should be {vendor_id_basic_information}")
+
+        # Check ProductID
+        product_id_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.ProductID
+        )
+
+        asserts.assert_equal(product_id_basic_information,
+                             parsed['product_id'], f"Product ID is {parsed['product_id']} and it should be {product_id_basic_information}")
+
+        # Check HardwareVersion
+        hardware_version_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.HardwareVersion
+        )
+
+        asserts.assert_equal(hardware_version_basic_information,
+                             parsed['hardware_version'], f"Hardware Version is {parsed['hardware_version']} and it should be {hardware_version_basic_information}")
+
+        # Check SoftwareVersion
+        software_version_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.SoftwareVersion
+        )
+
+        asserts.assert_equal(software_version_basic_information,
+                             parsed['software_version'], f"Software Version is {parsed['software_version']} and it should be {software_version_basic_information}")
+
+        # Check ProtocolsSupported protocols_supported
+        asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous in parsed['protocols_supported'],
+                            f"kBDXSynchronous: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
+
+        # Check MCORE.OTA.HTTPS
+        if self.check_pics("MCORE.OTA.HTTPS"):
+            asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps in parsed['protocols_supported'],
+                                f"kHttps: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
+
+        # Check RequestorCanConsent
+        asserts.assert_equal(parsed['requestor_can_consent'], 0,
+                             f"Requestor Can Consent is {parsed['requestor_can_consent']} instead of 0")
+
+        # Check Location
+        if parsed['location']:
+            location_basic_information = await self.read_single_attribute_check_success(
+                dev_ctrl=th1,
+                cluster=Clusters.BasicInformation,
+                attribute=Clusters.BasicInformation.Attributes.Location
+            )
+
+            asserts.assert_equal(location_basic_information,
+                                 parsed['location'], f"Location is {parsed['location']} and it should be {location_basic_information}")
+
+        # Event Handler
+        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
+                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+
+        applying_event = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+        asserts.assert_equal(applying, applying_event.newState,
+                             f"New state is {applying_event.newState} and it should be {applying}")
+
+        event_cb.reset()
+        await event_cb.cancel()
+
+        # Stop provider
+        await asyncio.sleep(2)
+        try:
+            provider_1.terminate()
+        except Exception as e:
+            logging.warning(f"Provider termination raised: {e}")
+        run("rm -rf /tmp/chip_kvs", shell=True)
+        await asyncio.sleep(2)
+
+        th1.ExpireSessions(nodeid=p1_node)
+
+        # Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P
+        self.step(2)
+
+        provider_ota_file = OtaImagePath(path="firmware_v3.ota")
+
+        logging.info("Starting OTA Provider 2")
+        provider_2 = OTAProviderSubprocess(
+            app=app_path,
+            storage_dir='/tmp',
+            port=provider_port,
+            discriminator=p2_disc,
+            passcode=p_pass,
+            ota_source=provider_ota_file,
+            log_file='/tmp/provider_2.log',
+            err_log_file='/tmp/provider_2.log'
+        )
+
+        provider_2.start()
+
+        # Create TH2
+        logging.info("Setting up TH2.")
+        th2_certificate_auth = self.certificate_authority_manager.NewCertificateAuthority()
+        th2_fabric_admin = th2_certificate_auth.NewFabricAdmin(vendorId=vendor_id, fabricId=fabric_id_th2)
+        th2 = th2_fabric_admin.NewController(nodeId=2, useTestCommissioner=True)
+
+        logging.info("Opening commissioning window on DUT.")
+        params = await self.open_commissioning_window(th1, dut_node_id)
+
+        # Commission TH2/DUT (requestor)
+        resp = await th2.CommissionOnNetwork(
+            nodeId=requestor_node_id,
+            setupPinCode=params.commissioningParameters.setupPinCode,
+            filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
+            filter=params.randomDiscriminator
+        )
+
+        logging.info(f"TH2 commissioned: {resp}.")
+
+        # Commissioning Provider-TH2
+        logging.info("Commissioning OTA Provider to TH2")
+
+        resp = await th2.CommissionOnNetwork(
+            nodeId=p2_node,
+            setupPinCode=p_pass,
+            filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
+            filter=p2_disc
+        )
+
+        logging.info(f"Commissioning response: {resp}.")
+
+        # ACL permissions are not required
+
+        if fabric_id_th2 == th1.fabricId:
+            raise AssertionError(f"Fabric IDs are the same for TH1: {th1.fabricId} and TH2: {fabric_id_th2}.")
+
+        # Event Handler
+        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
+                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+
+        # Write default OTA providers TH1 with p1_node which does not exist
+        await self.write_ota_providers(th1, p1_node_invalid, endpoint)
+
+        # Do not announce TH1-OTA Provider
+
+        # Expect events idle to querying, downloadError and then back to idle
+        querying_event = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+        asserts.assert_equal(querying, querying_event.newState,
+                             f"New state is {querying_event.newState} and it should be {querying}")
+
+        download_error = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.DownloadError, 50000)
+
+        logging.info(f"Download Error: {download_error}")
+
+        idle_event = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 50000)
+        asserts.assert_equal(idle, idle_event.newState,
+                             f"New state is {idle_event.newState} and it should be {idle}")
+
+        logging.info("Cleaning DefaultOTAProviders.")
+        resp = await th1.WriteAttribute(
+            dut_node_id,
+            [(endpoint, Clusters.Objects.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders([]))]
+        )
+        asserts.assert_equal(resp[0].Status, Status.Success, "Clean DefaultOTAProviders failed.")
+
+        event_cb.reset()
+        await event_cb.cancel()
+        await asyncio.sleep(2)
+
+        # Subscribe to events
+        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        await event_cb.start(dev_ctrl=th2, node_id=requestor_node_id, endpoint=endpoint,
+                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+
+        # Define ACL entry
+        await self.create_acl_entry(dev_ctrl=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id)
+
+        # Write default OTA providers TH2
+        await self.write_ota_providers(th2, p2_node, endpoint)
+
+        # Announce after subscription
+        await self.announce_ota_provider(controller=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
+
+        event_idle_to_querying = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+
+        self.verify_state_transition_event(event_report=event_idle_to_querying, previous_state=idle, new_state=querying)
+
+        event_querying_to_downloading = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+
+        self.verify_state_transition_event(event_report=event_querying_to_downloading,
+                                           previous_state=querying, new_state=downloading, target_version=target_version)
+
+        event_cb.reset()
+        await event_cb.cancel()
+
+        logging.info("Cleaning DefaultOTAProviders.")
+        resp = await th2.WriteAttribute(
+            dut_node_id,
+            [(endpoint, Clusters.Objects.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders([]))]
+        )
+        asserts.assert_equal(resp[0].Status, Status.Success, "Clean DefaultOTAProviders failed.")
+
+        await asyncio.sleep(2)
+        try:
+            provider_2.terminate()
+        except Exception as e:
+            logging.warning(f"Provider termination raised: {e}")
+
+        await asyncio.sleep(2)
+        th2.ExpireSessions(nodeid=p2_node)
+
+
+if __name__ == "__main__":
+    default_matter_test_main()
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py b/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py
index dd7f20b670eea7..abe00b0486600a 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py
@@ -12,15 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 import os
 import signal
 import tempfile
 from dataclasses import dataclass
-from typing import Optional, Union
+from sys import stderr, stdout
+from typing import BinaryIO, Optional, Union
 
-import matter.clusters as Clusters
-from matter.ChipDeviceCtrl import ChipDeviceController
-from matter.clusters.Types import NullValue
 from matter.testing.tasks import Subprocess
 
 
@@ -53,9 +52,14 @@ class AppServerSubprocess(Subprocess):
     PREFIX = b"[SERVER]"
 
     def __init__(self, app: str, storage_dir: str, discriminator: int,
-                 passcode: int, port: int = 5540, extra_args: list[str] = []):
+                 passcode: int, port: int = 5540, extra_args: list[str] = [], kvs_path: Optional[str] = None, f_stdout: BinaryIO = stdout.buffer, f_stderr: BinaryIO = stderr.buffer):
         # Create a temporary KVS file and keep the descriptor to avoid leaks.
-        self.kvs_fd, kvs_path = tempfile.mkstemp(dir=storage_dir, prefix="kvs-app-")
+
+        if kvs_path is not None:
+            self.kvs_fd = None
+            kvs_path = kvs_path
+        else:
+            self.kvs_fd, kvs_path = tempfile.mkstemp(dir=storage_dir, prefix="kvs-app-")
         try:
             # Build the command list
             command = [app]
@@ -71,17 +75,19 @@ def __init__(self, app: str, storage_dir: str, discriminator: int,
 
             # Start the server application
             super().__init__(*command,  # Pass the constructed command list
-                             output_cb=lambda line, is_stderr: self.PREFIX + line)
+                             output_cb=lambda line, is_stderr: self.PREFIX + line, f_stdout=f_stdout, f_stderr=f_stderr)
         except Exception:
             # Do not leak KVS file descriptor on failure
-            os.close(self.kvs_fd)
-            raise
+            if self.kvs_fd is not None:
+                os.close(self.kvs_fd)
+                raise
 
     def __del__(self):
         # Do not leak KVS file descriptor.
         if hasattr(self, "kvs_fd"):
             try:
-                os.close(self.kvs_fd)
+                if self.kvs_fd is not None:
+                    os.close(self.kvs_fd)
             except OSError:
                 pass
 
@@ -144,75 +150,86 @@ class OTAProviderSubprocess(AppServerSubprocess):
     """Wrapper class for starting an OTA Provider application server in a subprocess."""
 
     DEFAULT_ADMIN_NODE_ID = 112233
+    log_file = ""
+    err_log_file = ""
 
     # Prefix for log messages from the OTA provider application.
     PREFIX = b"[OTA-PROVIDER]"
 
     def __init__(self, app: str, storage_dir: str, discriminator: int,
                  passcode: int, ota_source: Union[OtaImagePath, ImageListPath],
-                 port: int = 5541, extra_args: list[str] = []):
+                 port: int = 5541, extra_args: list[str] = [], kvs_path: Optional[str] = None, log_file: Union[str, BinaryIO] = stdout.buffer, err_log_file: Union[str, BinaryIO] = stderr.buffer):
         """Initialize the OTA Provider subprocess.
 
         Args:
-            app: Path to the chip-ota-provider-app executable
-            storage_dir: Directory for persistent storage
-            discriminator: Discriminator for commissioning
-            passcode: Passcode for commissioning
-            port: UDP port for secure connections (default: 5541)
-            ota_source: Either OtaImagePath or ImageListPath specifying the OTA image source
-            extra_args: Additional command line arguments
+            app(str): Path to the chip-ota-provider-app executable
+            storage_dir(str): Directory for persistent storage
+            discriminator(int): Discriminator for commissioning
+            passcode(int): Passcode for commissioning
+            port(int): UDP port for secure connections (default: 5541)
+            ota_source(OtaImagePath,ImageListPath): Either OtaImagePath or ImageListPath specifying the OTA image source
+            extra_args(list): Additional command line arguments
+            kvs_path(str): Str of the path for the kvs path, if not will use temp file.
+            log_file(str,BinaryIO): Path to create the BinaryIO logger for stdoutput, if not use the default stdout.buffer.
+            err_log_file(str,BinaryIO): Path to create the BinaryIO logger for stderr, if not use the default stderr.buffer.
         """
+        # Create the BinaryIO fp allow to use
+        if isinstance(log_file, str):
+            f_stdout = open(log_file, 'ab')
+            self.log_file = log_file
+
+        if isinstance(err_log_file, str):
+            f_stderr = open(err_log_file, 'ab')
+            self.err_log_file = err_log_file
 
         # Build OTA-specific arguments using the ota_source property
         combined_extra_args = ota_source.ota_args + extra_args
 
         # Initialize with the combined arguments
         super().__init__(app=app, storage_dir=storage_dir, discriminator=discriminator,
-                         passcode=passcode, port=port, extra_args=combined_extra_args)
+                         passcode=passcode, port=port, extra_args=combined_extra_args, kvs_path=kvs_path, f_stdout=f_stdout, f_stderr=f_stderr)
+
+    def kill(self):
+        self.p.send_signal(signal.SIGKILL)
 
-    def create_acl_entry(self, dev_ctrl: ChipDeviceController, provider_node_id: int, requestor_node_id: Optional[int] = None):
-        """Create ACL entries to allow OTA requestors to access the provider.
+    def get_pid(self) -> int:
+        return self.p.pid
+
+    def read_from_logs(self, pattern: str, before: int = 4, after: int = 4) -> list[dict]:
+        """Search for a string a return the matches. 
 
         Args:
-            dev_ctrl: Device controller for sending commands
-            provider_node_id: Node ID of the OTA provider
-            requestor_node_id: Optional specific requestor node ID for targeted access
+            pattern (str): _description_
+            before (int, optional): Number of lines before the found line. Defaults to 4.
+            after (int, optional): Number of lines after the found line. Defaults to 4.
+
+        Raises:
+            FileNotFoundError: _description_
 
         Returns:
-            Result of the ACL write operation
+            list[dict]: List with a dict of the info retrieved.
         """
-        # Standard ACL entry for OTA Provider cluster
-        admin_node_id = dev_ctrl.nodeId if hasattr(dev_ctrl, 'nodeId') else self.DEFAULT_ADMIN_NODE_ID
-        requestor_subjects = [requestor_node_id] if requestor_node_id else NullValue
-
-        # Create ACL entries using proper struct constructors
-        acl_entries = [
-            # Admin entry
-            Clusters.AccessControl.Structs.AccessControlEntryStruct(  # type: ignore
-                privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kAdminister,  # type: ignore
-                authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,  # type: ignore
-                subjects=[admin_node_id],  # type: ignore
-                targets=NullValue
-            ),
-            # Operate entry
-            Clusters.AccessControl.Structs.AccessControlEntryStruct(  # type: ignore
-                privilege=Clusters.AccessControl.Enums.AccessControlEntryPrivilegeEnum.kOperate,  # type: ignore
-                authMode=Clusters.AccessControl.Enums.AccessControlEntryAuthModeEnum.kCase,  # type: ignore
-                subjects=requestor_subjects,  # type: ignore
-                targets=[
-                    Clusters.AccessControl.Structs.AccessControlTargetStruct(  # type: ignore
-                        cluster=Clusters.OtaSoftwareUpdateProvider.id,  # type: ignore
-                        endpoint=NullValue,
-                        deviceType=NullValue
-                    )
-                ],
-            )
-        ]
-
-        # Create the attribute descriptor for the ACL attribute
-        acl_attribute = Clusters.AccessControl.Attributes.Acl(acl_entries)
-
-        return dev_ctrl.WriteAttribute(
-            nodeid=provider_node_id,
-            attributes=[(0, acl_attribute)]
-        )
+        if not os.path.exists(self.log_file):
+            raise FileNotFoundError
+
+        # read all lines at the moment
+        all_lines = None
+        with open(self.log_file, 'rb') as fp:
+            all_lines = fp.readlines()
+
+        found_lines = []
+
+        for index, line in enumerate(all_lines):
+            n_line = line.decode("utf-8", 'replace')
+            if pattern in n_line:
+                before_lines = all_lines[(index-before):index]
+                after_lines = all_lines[index+1:(index+after+1)]
+                match = {
+                    'before': list(map(lambda x: x.decode("utf-8"), before_lines)),
+                    'match': n_line,
+                    'line': index,
+                    'after': list(map(lambda x: x.decode("utf-8"), after_lines))
+                }
+                found_lines.append(match)
+
+        return found_lines
diff --git a/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi b/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi
index 1ca66103cf239d..4d6e3db086148b 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi
+++ b/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi
@@ -1,11 +1,12 @@
 # src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.py
 
 from dataclasses import dataclass
-from typing import Any, List, Optional, Union
+from sys import stderr, stdout
+from typing import Any, BinaryIO, List, Optional, Union
 
-from matter.ChipDeviceCtrl import ChipDeviceController
 from matter.testing.tasks import Subprocess
 
+
 @dataclass
 class OtaImagePath:
     path: str
@@ -42,11 +43,16 @@ class JFControllerSubprocess(Subprocess):
 class OTAProviderSubprocess(AppServerSubprocess):
     DEFAULT_ADMIN_NODE_ID: int
     PREFIX: bytes
+    log_file = ""
+    err_log_file = ""
 
     def __init__(self, app: str, storage_dir: str, discriminator: int,
                  passcode: int, ota_source: Union[OtaImagePath, ImageListPath],
-                 port: int = 5541, extra_args: List[str] = ...,
-                 kvs_path: Optional[str] = ..., persist_kvs: bool = ...) -> None: ...
+                 port: int = 5541, extra_args: list[str] = [], kvs_path: Optional[str] = None,
+                 log_file: Union[str, BinaryIO] = stdout.buffer, err_log_file: Union[str, BinaryIO] = stderr.buffer): ...
+
+    def kill(self) -> None: ...
+
+    def get_pid(self) -> int: ...
 
-    def create_acl_entry(self, dev_ctrl: ChipDeviceController, provider_node_id: int,
-                         requestor_node_id: Optional[int] = None) -> Any: ...
+    def read_from_logs(self, pattern: str, regex: bool = True, before: int = 4, after: int = 4) -> list[dict]: ...
diff --git a/src/python_testing/test_metadata.yaml b/src/python_testing/test_metadata.yaml
index 3c55b3a9c9945e..8c026ff3941cd4 100644
--- a/src/python_testing/test_metadata.yaml
+++ b/src/python_testing/test_metadata.yaml
@@ -23,6 +23,8 @@ not_automated:
       reason: Can not run thread CNET tests in CI
     - name: TC_CNET_4_22.py
       reason: It has no CI execution block, is not executed in CI
+    - name: TC_SU_2_8.py
+      reason: CI script not implemented 
     - name: TC_DGGEN_3_2.py
       reason:
           src/python_testing/test_testing/test_TC_DGGEN_3_2.py is the Unit test
@@ -67,6 +69,8 @@ not_automated:
       reason: Shared code for TC_SEPR, not a standalone test
     - name: TC_SETRF_TestBase.py
       reason: Shared code for TC_SETRF, not a standalone test
+    - name: TC_SUTestBase.py
+      reason: Shared code for TC_SU, not a standalone test
     - name: TC_COMMTR_TestBase.py
       reason: Shared code for TC_COMMTR, not a standalone test
     - name: TC_MTRIDTestBase.py
@@ -169,4 +173,4 @@ slow_tests:
     - { name: TC_TIMESYNC_2_12.py, duration: 20 seconds }
     - { name: TC_TIMESYNC_2_7.py, duration: 20 seconds }
     - { name: TC_TIMESYNC_2_8.py, duration: 1.5 minutes }
-    - { name: TC_CLCTRL_4_1.py, duration: 45 seconds }
+    - { name: TC_CLCTRL_4_1.py, duration: 45 seconds }
\ No newline at end of file

From 860c30e85e7ee717c1f8f9188b977ed032799628 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 8 Oct 2025 15:13:54 -0300
Subject: [PATCH 02/18] Restyle

---
 examples/ota-provider-app/linux/main.cpp      | 872 +++++++++---------
 .../ota-provider-common/BdxOtaSender.cpp      | 488 +++++-----
 .../ota-provider-common/BdxOtaSender.h        |  96 +-
 3 files changed, 728 insertions(+), 728 deletions(-)

diff --git a/examples/ota-provider-app/linux/main.cpp b/examples/ota-provider-app/linux/main.cpp
index 58c7181bc4e728..838cb8d6677cc1 100644
--- a/examples/ota-provider-app/linux/main.cpp
+++ b/examples/ota-provider-app/linux/main.cpp
@@ -1,437 +1,437 @@
 /*
- *
- *    Copyright (c) 2020-2022 Project CHIP Authors
- *    All rights reserved.
- *
- *    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.
- */
-
- #include <app/clusters/ota-provider/CodegenIntegration.h>
- #include <app/clusters/ota-provider/DefaultOTAProviderUserConsent.h>
- #include <app/clusters/ota-provider/ota-provider-delegate.h>
- #include <app/server/Server.h>
- #include <app/util/util.h>
- #include <json/json.h>
- #include <ota-provider-common/BdxOtaSender.h>
- #include <ota-provider-common/OTAProviderExample.h>
- 
- #include "AppMain.h"
- 
- #include <fstream>
- #include <iostream>
- #include <optional>
- #include <unistd.h>
- 
- using chip::BitFlags;
- using chip::app::Clusters::OTAProviderDelegate;
- using chip::ArgParser::OptionDef;
- using chip::ArgParser::OptionSet;
- using chip::ArgParser::PrintArgError;
- using chip::bdx::TransferControlFlags;
- using chip::Messaging::ExchangeManager;
- using namespace chip::app::Clusters::OtaSoftwareUpdateProvider;
- 
- // TODO: this should probably be done dynamically
- constexpr chip::EndpointId kOtaProviderEndpoint = 0;
- 
- constexpr uint16_t kOptionUpdateAction              = 'a';
- constexpr uint16_t kOptionUserConsentNeeded         = 'c';
- constexpr uint16_t kOptionFilepath                  = 'f';
- constexpr uint16_t kOptionImageUri                  = 'i';
- constexpr uint16_t kOptionMaxBDXBlockSize           = 'm';
- constexpr uint16_t kOptionOtaImageList              = 'o';
- constexpr uint16_t kOptionDelayedApplyActionTimeSec = 'p';
- constexpr uint16_t kOptionQueryImageStatus          = 'q';
- constexpr uint16_t kOptionDelayedQueryActionTimeSec = 't';
- constexpr uint16_t kOptionUserConsentState          = 'u';
- constexpr uint16_t kOptionIgnoreQueryImage          = 'x';
- constexpr uint16_t kOptionIgnoreApplyUpdate         = 'y';
- constexpr uint16_t kOptionPollInterval              = 'P';
- 
- OTAProviderExample gOtaProvider;
- chip::ota::DefaultOTAProviderUserConsent gUserConsentProvider;
- 
- // Global variables used for passing the CLI arguments to the OTAProviderExample object
- static OTAQueryStatus gQueryImageStatus              = OTAQueryStatus::kUpdateAvailable;
- static OTAApplyUpdateAction gOptionUpdateAction      = OTAApplyUpdateAction::kProceed;
- static uint32_t gDelayedQueryActionTimeSec           = 0;
- static uint32_t gDelayedApplyActionTimeSec           = 0;
- static const char * gOtaFilepath                     = nullptr;
- static const char * gOtaImageListFilepath            = nullptr;
- static const char * gImageUri                        = nullptr;
- static chip::ota::UserConsentState gUserConsentState = chip::ota::UserConsentState::kUnknown;
- static bool gUserConsentNeeded                       = false;
- static uint32_t gIgnoreQueryImageCount               = 0;
- static uint32_t gIgnoreApplyUpdateCount              = 0;
- static uint32_t gPollInterval                        = 0;
- static std::optional<uint16_t> gMaxBDXBlockSize      = std::nullopt;
- 
- // Parses the JSON filepath and extracts DeviceSoftwareVersionModel parameters
- static bool ParseJsonFileAndPopulateCandidates(const char * filepath,
-                                                std::vector<OTAProviderExample::DeviceSoftwareVersionModel> & candidates)
- {
-     bool ret = false;
-     Json::Value root;
-     Json::CharReaderBuilder builder;
-     JSONCPP_STRING errs;
-     std::ifstream ifs;
- 
-     builder["collectComments"] = true; // allow C/C++ type comments in JSON file
-     ifs.open(filepath);
- 
-     if (!ifs.good())
-     {
-         ChipLogError(SoftwareUpdate, "Error opening ifstream with file: \"%s\"", filepath);
-         return ret;
-     }
- 
-     if (!parseFromStream(builder, ifs, &root, &errs))
-     {
-         ChipLogError(SoftwareUpdate, "Error parsing JSON from file: \"%s\"", filepath);
-         return ret;
-     }
- 
-     const Json::Value devSofVerModValue = root["deviceSoftwareVersionModel"];
-     if (!devSofVerModValue || !devSofVerModValue.isArray())
-     {
-         ChipLogError(SoftwareUpdate, "Error: Key deviceSoftwareVersionModel not found or its value is not of type Array");
-     }
-     else
-     {
-         for (auto iter : devSofVerModValue)
-         {
-             OTAProviderExample::DeviceSoftwareVersionModel candidate;
-             candidate.vendorId        = static_cast<chip::VendorId>(iter.get("vendorId", 1).asUInt());
-             candidate.productId       = static_cast<uint16_t>(iter.get("productId", 1).asUInt());
-             candidate.softwareVersion = static_cast<uint32_t>(iter.get("softwareVersion", 10).asUInt64());
-             chip::Platform::CopyString(candidate.softwareVersionString, iter.get("softwareVersionString", "1.0.0").asCString());
-             candidate.cDVersionNumber              = static_cast<uint16_t>(iter.get("cDVersionNumber", 0).asUInt());
-             candidate.softwareVersionValid         = iter.get("softwareVersionValid", true).asBool() ? true : false;
-             candidate.minApplicableSoftwareVersion = static_cast<uint32_t>(iter.get("minApplicableSoftwareVersion", 0).asUInt64());
-             candidate.maxApplicableSoftwareVersion =
-                 static_cast<uint32_t>(iter.get("maxApplicableSoftwareVersion", 1000).asUInt64());
-             chip::Platform::CopyString(candidate.otaURL, iter.get("otaURL", "https://test.com").asCString());
-             candidates.push_back(candidate);
-             ret = true;
-         }
-     }
-     return ret;
- }
- 
- bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue)
- {
-     bool retval = true;
-     static bool kOptionFilepathSelected;
-     static bool kOptionOtaImageListSelected;
- 
-     switch (aIdentifier)
-     {
-     case kOptionFilepath:
-         kOptionFilepathSelected = true;
-         if (0 != access(aValue, R_OK))
-         {
-             PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
-             retval = false;
-         }
-         else if (kOptionOtaImageListSelected)
-         {
-             PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
-             retval = false;
-         }
-         else
-         {
-             gOtaFilepath = aValue;
-         }
-         break;
-     case kOptionImageUri:
-         gImageUri = aValue;
-         break;
-     case kOptionOtaImageList:
-         kOptionOtaImageListSelected = true;
-         if (0 != access(aValue, R_OK))
-         {
-             PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
-             retval = false;
-         }
-         else if (kOptionFilepathSelected)
-         {
-             PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
-             retval = false;
-         }
-         else
-         {
-             gOtaImageListFilepath = aValue;
-         }
-         break;
-     case kOptionQueryImageStatus:
-         if (strcmp(aValue, "updateAvailable") == 0)
-         {
-             gQueryImageStatus = OTAQueryStatus::kUpdateAvailable;
-         }
-         else if (strcmp(aValue, "busy") == 0)
-         {
-             gQueryImageStatus = OTAQueryStatus::kBusy;
-         }
-         else if (strcmp(aValue, "updateNotAvailable") == 0)
-         {
-             gQueryImageStatus = OTAQueryStatus::kNotAvailable;
-         }
-         else
-         {
-             PrintArgError("%s: ERROR: Invalid queryImageStatus parameter:  %s\n", aProgram, aValue);
-             retval = false;
-         }
-         break;
-     case kOptionIgnoreQueryImage:
-         gIgnoreQueryImageCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-         break;
-     case kOptionIgnoreApplyUpdate:
-         gIgnoreApplyUpdateCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-         break;
-     case kOptionUpdateAction:
-         if (strcmp(aValue, "proceed") == 0)
-         {
-             gOptionUpdateAction = OTAApplyUpdateAction::kProceed;
-         }
-         else if (strcmp(aValue, "awaitNextAction") == 0)
-         {
-             gOptionUpdateAction = OTAApplyUpdateAction::kAwaitNextAction;
-         }
-         else if (strcmp(aValue, "discontinue") == 0)
-         {
-             gOptionUpdateAction = OTAApplyUpdateAction::kDiscontinue;
-         }
-         else
-         {
-             PrintArgError("%s: ERROR: Invalid applyUpdateAction parameter:  %s\n", aProgram, aValue);
-             retval = false;
-         }
-         break;
-     case kOptionDelayedQueryActionTimeSec:
-         gDelayedQueryActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-         break;
-     case kOptionDelayedApplyActionTimeSec:
-         gDelayedApplyActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-         break;
-     case kOptionUserConsentState:
-         if (strcmp(aValue, "granted") == 0)
-         {
-             gUserConsentState = chip::ota::UserConsentState::kGranted;
-         }
-         else if (strcmp(aValue, "denied") == 0)
-         {
-             gUserConsentState = chip::ota::UserConsentState::kDenied;
-         }
-         else if (strcmp(aValue, "deferred") == 0)
-         {
-             gUserConsentState = chip::ota::UserConsentState::kObtaining;
-         }
-         else
-         {
-             PrintArgError("%s: ERROR: Invalid UserConsent parameter:  %s\n", aProgram, aValue);
-             retval = false;
-         }
-         break;
-     case kOptionUserConsentNeeded:
-         gUserConsentNeeded = true;
-         break;
-     case kOptionPollInterval:
-         gPollInterval = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
-         break;
-     case kOptionMaxBDXBlockSize: {
-         auto blockSize = static_cast<uint16_t>(strtoul(aValue, NULL, 0));
-         if (blockSize == 0)
-         {
-             PrintArgError("%s: ERROR: Invalid maxBDXBlockSize parameter: %s\n", aProgram, aValue);
-             retval = false;
-         }
-         else
-         {
-             gMaxBDXBlockSize = blockSize;
-         }
-         break;
-     }
- 
-     default:
-         PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);
-         retval = false;
-         break;
-     }
- 
-     return (retval);
- }
- 
- OptionDef cmdLineOptionsDef[] = {
-     { "applyUpdateAction", chip::ArgParser::kArgumentRequired, kOptionUpdateAction },
-     { "userConsentNeeded", chip::ArgParser::kNoArgument, kOptionUserConsentNeeded },
-     { "filepath", chip::ArgParser::kArgumentRequired, kOptionFilepath },
-     { "imageUri", chip::ArgParser::kArgumentRequired, kOptionImageUri },
-     { "otaImageList", chip::ArgParser::kArgumentRequired, kOptionOtaImageList },
-     { "delayedApplyActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedApplyActionTimeSec },
-     { "queryImageStatus", chip::ArgParser::kArgumentRequired, kOptionQueryImageStatus },
-     { "delayedQueryActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedQueryActionTimeSec },
-     { "userConsentState", chip::ArgParser::kArgumentRequired, kOptionUserConsentState },
-     { "ignoreQueryImage", chip::ArgParser::kArgumentRequired, kOptionIgnoreQueryImage },
-     { "ignoreApplyUpdate", chip::ArgParser::kArgumentRequired, kOptionIgnoreApplyUpdate },
-     { "pollInterval", chip::ArgParser::kArgumentRequired, kOptionPollInterval },
-     { "maxBDXBlockSize", chip::ArgParser::kArgumentRequired, kOptionMaxBDXBlockSize },
-     {},
- };
- 
- OptionSet cmdLineOptions = { HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS",
-                              "  -a, --applyUpdateAction <proceed | awaitNextAction | discontinue>\n"
-                              "        Value for the Action field in the first ApplyUpdateResponse.\n"
-                              "        For all subsequent responses, the value of proceed will be used.\n"
-                              "  -c, --userConsentNeeded\n"
-                              "        If supplied, value of the UserConsentNeeded field in the QueryImageResponse\n"
-                              "        is set to true. This is only applicable if value of the RequestorCanConsent\n"
-                              "        field in QueryImage Command is true.\n"
-                              "        Otherwise, value of the UserConsentNeeded field is false.\n"
-                              "  -f, --filepath <file path>\n"
-                              "        Path to a file containing an OTA image\n"
-                              "  -i, --imageUri <uri>\n"
-                              "        Value for the ImageURI field in the QueryImageResponse.\n"
-                              "        If none is supplied, a valid URI is generated.\n"
-                              "  -m, --maxBDXBlockSize <size>\n"
-                              "        Value for the maximum BDX block size to use for the transfer.\n"
-                              "        If none is supplied, a default value will be used.\n"
-                              "  -o, --otaImageList <file path>\n"
-                              "        Path to a file containing a list of OTA images\n"
-                              "  -p, --delayedApplyActionTimeSec <time in seconds>\n"
-                              "        Value for the DelayedActionTime field in the first ApplyUpdateResponse.\n"
-                              "        For all subsequent responses, the value of zero will be used.\n"
-                              "  -q, --queryImageStatus <updateAvailable | busy | updateNotAvailable>\n"
-                              "        Value for the Status field in the first QueryImageResponse.\n"
-                              "        For all subsequent responses, the value of updateAvailable will be used.\n"
-                              "  -t, --delayedQueryActionTimeSec <time in seconds>\n"
-                              "        Value for the DelayedActionTime field in the first QueryImageResponse.\n"
-                              "        For all subsequent responses, the value of zero will be used.\n"
-                              "  -u, --userConsentState <granted | denied | deferred>\n"
-                              "        The user consent state for the first QueryImageResponse. For all subsequent\n"
-                              "        responses, the value of granted will be used.\n"
-                              "        Note that --queryImageStatus overrides this option.\n"
-                              "        granted: Status field in the first QueryImageResponse is set to updateAvailable\n"
-                              "        denied: Status field in the first QueryImageResponse is set to updateNotAvailable\n"
-                              "        deferred: Status field in the first QueryImageResponse is set to busy\n"
-                              "  -x, --ignoreQueryImage <ignore count>\n"
-                              "        The number of times to ignore the QueryImage Command and not send a response.\n"
-                              "  -y, --ignoreApplyUpdate <ignore count>\n"
-                              "        The number of times to ignore the ApplyUpdateRequest Command and not send a response.\n"
-                              "  -P, --pollInterval <time in milliseconds>\n"
-                              "        Poll interval for the BDX transfer \n" };
- 
- OptionSet * allOptions[] = { &cmdLineOptions, nullptr };
- 
- void ApplicationInit()
- {
-     CHIP_ERROR err = CHIP_NO_ERROR;
- 
-     BdxOtaSender * bdxOtaSender = gOtaProvider.GetBdxOtaSender();
-     VerifyOrReturn(bdxOtaSender != nullptr);
-     err = chip::Server::GetInstance().GetExchangeManager().RegisterUnsolicitedMessageHandlerForProtocol(chip::Protocols::BDX::Id,
-                                                                                                         bdxOtaSender);
-     if (err != CHIP_NO_ERROR)
-     {
-         ChipLogDetail(SoftwareUpdate, "RegisterUnsolicitedMessageHandler failed: %s", chip::ErrorStr(err));
-         return;
-     }
- 
-     ChipLogDetail(SoftwareUpdate, "Using OTA file: %s", gOtaFilepath ? gOtaFilepath : "(none)");
- 
-     if (gOtaFilepath != nullptr)
-     {
-         gOtaProvider.SetOTAFilePath(gOtaFilepath);
-     }
- 
-     if (gImageUri != nullptr)
-     {
-         gOtaProvider.SetImageUri(gImageUri);
-     }
- 
-     gOtaProvider.SetIgnoreQueryImageCount(gIgnoreQueryImageCount);
-     gOtaProvider.SetIgnoreApplyUpdateCount(gIgnoreApplyUpdateCount);
-     gOtaProvider.SetQueryImageStatus(gQueryImageStatus);
-     gOtaProvider.SetApplyUpdateAction(gOptionUpdateAction);
-     gOtaProvider.SetDelayedQueryActionTimeSec(gDelayedQueryActionTimeSec);
-     gOtaProvider.SetDelayedApplyActionTimeSec(gDelayedApplyActionTimeSec);
- 
-     if (gUserConsentState != chip::ota::UserConsentState::kUnknown)
-     {
-         gUserConsentProvider.SetGlobalUserConsentState(gUserConsentState);
-         gOtaProvider.SetUserConsentDelegate(&gUserConsentProvider);
-     }
- 
-     if (gUserConsentNeeded)
-     {
-         gOtaProvider.SetUserConsentNeeded(true);
-     }
- 
-     if (gPollInterval != 0)
-     {
-         gOtaProvider.SetPollInterval(gPollInterval);
-     }
- 
-     if (gMaxBDXBlockSize)
-     {
-         gOtaProvider.SetMaxBDXBlockSize(*gMaxBDXBlockSize);
-     }
- 
-     ChipLogDetail(SoftwareUpdate, "Using ImageList file: %s", gOtaImageListFilepath ? gOtaImageListFilepath : "(none)");
- 
-     if (gOtaImageListFilepath != nullptr)
-     {
-         // Parse JSON file and load the ota candidates
-         std::vector<OTAProviderExample::DeviceSoftwareVersionModel> candidates;
-         ParseJsonFileAndPopulateCandidates(gOtaImageListFilepath, candidates);
-         gOtaProvider.SetOTACandidates(candidates);
-     }
- 
-     if ((gOtaFilepath == nullptr) && (gOtaImageListFilepath == nullptr))
-     {
-         ChipLogError(SoftwareUpdate, "Either an OTA file or image list file must be specified");
-         chipDie();
-     }
- 
-     chip::app::Clusters::OTAProvider::SetDelegate(kOtaProviderEndpoint, &gOtaProvider);
- }
- 
- void ApplicationShutdown() {}
- 
- namespace {
- class OtaProviderAppMainLoopImplementation : public AppMainLoopImplementation
- {
- public:
-     void RunMainLoop() override { chip::DeviceLayer::PlatformMgr().RunEventLoop(); }
-     void SignalSafeStopMainLoop() override
-     {
-         chip::DeviceLayer::PlatformMgr().ScheduleWork([](intptr_t) {
-             ChipLogDetail(SoftwareUpdate, "Scheduling BdxOtaSender to ABORT TRANSFER");
- 
-             gOtaProvider.GetBdxOtaSender()->AbortTransfer();
- 
-             chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
-         });
- 
-         chip::Server::GetInstance().GenerateShutDownEvent();
-     }
- };
- } // namespace
- 
- int main(int argc, char * argv[])
- {
-     OtaProviderAppMainLoopImplementation ml_impl{};
- 
-     VerifyOrDie(ChipLinuxAppInit(argc, argv, &cmdLineOptions) == 0);
-     ChipLinuxAppMainLoop(&ml_impl);
-     return 0;
- }
\ No newline at end of file
+*
+*    Copyright (c) 2020-2022 Project CHIP Authors
+*    All rights reserved.
+*
+*    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.
+*/
+
+#include <app/clusters/ota-provider/CodegenIntegration.h>
+#include <app/clusters/ota-provider/DefaultOTAProviderUserConsent.h>
+#include <app/clusters/ota-provider/ota-provider-delegate.h>
+#include <app/server/Server.h>
+#include <app/util/util.h>
+#include <json/json.h>
+#include <ota-provider-common/BdxOtaSender.h>
+#include <ota-provider-common/OTAProviderExample.h>
+
+#include "AppMain.h"
+
+#include <fstream>
+#include <iostream>
+#include <optional>
+#include <unistd.h>
+
+using chip::BitFlags;
+using chip::app::Clusters::OTAProviderDelegate;
+using chip::ArgParser::OptionDef;
+using chip::ArgParser::OptionSet;
+using chip::ArgParser::PrintArgError;
+using chip::bdx::TransferControlFlags;
+using chip::Messaging::ExchangeManager;
+using namespace chip::app::Clusters::OtaSoftwareUpdateProvider;
+
+// TODO: this should probably be done dynamically
+constexpr chip::EndpointId kOtaProviderEndpoint = 0;
+
+constexpr uint16_t kOptionUpdateAction              = 'a';
+constexpr uint16_t kOptionUserConsentNeeded         = 'c';
+constexpr uint16_t kOptionFilepath                  = 'f';
+constexpr uint16_t kOptionImageUri                  = 'i';
+constexpr uint16_t kOptionMaxBDXBlockSize           = 'm';
+constexpr uint16_t kOptionOtaImageList              = 'o';
+constexpr uint16_t kOptionDelayedApplyActionTimeSec = 'p';
+constexpr uint16_t kOptionQueryImageStatus          = 'q';
+constexpr uint16_t kOptionDelayedQueryActionTimeSec = 't';
+constexpr uint16_t kOptionUserConsentState          = 'u';
+constexpr uint16_t kOptionIgnoreQueryImage          = 'x';
+constexpr uint16_t kOptionIgnoreApplyUpdate         = 'y';
+constexpr uint16_t kOptionPollInterval              = 'P';
+
+OTAProviderExample gOtaProvider;
+chip::ota::DefaultOTAProviderUserConsent gUserConsentProvider;
+
+// Global variables used for passing the CLI arguments to the OTAProviderExample object
+static OTAQueryStatus gQueryImageStatus              = OTAQueryStatus::kUpdateAvailable;
+static OTAApplyUpdateAction gOptionUpdateAction      = OTAApplyUpdateAction::kProceed;
+static uint32_t gDelayedQueryActionTimeSec           = 0;
+static uint32_t gDelayedApplyActionTimeSec           = 0;
+static const char * gOtaFilepath                     = nullptr;
+static const char * gOtaImageListFilepath            = nullptr;
+static const char * gImageUri                        = nullptr;
+static chip::ota::UserConsentState gUserConsentState = chip::ota::UserConsentState::kUnknown;
+static bool gUserConsentNeeded                       = false;
+static uint32_t gIgnoreQueryImageCount               = 0;
+static uint32_t gIgnoreApplyUpdateCount              = 0;
+static uint32_t gPollInterval                        = 0;
+static std::optional<uint16_t> gMaxBDXBlockSize      = std::nullopt;
+
+// Parses the JSON filepath and extracts DeviceSoftwareVersionModel parameters
+static bool ParseJsonFileAndPopulateCandidates(const char * filepath,
+                                               std::vector<OTAProviderExample::DeviceSoftwareVersionModel> & candidates)
+{
+    bool ret = false;
+    Json::Value root;
+    Json::CharReaderBuilder builder;
+    JSONCPP_STRING errs;
+    std::ifstream ifs;
+
+    builder["collectComments"] = true; // allow C/C++ type comments in JSON file
+    ifs.open(filepath);
+
+    if (!ifs.good())
+    {
+        ChipLogError(SoftwareUpdate, "Error opening ifstream with file: \"%s\"", filepath);
+        return ret;
+    }
+
+    if (!parseFromStream(builder, ifs, &root, &errs))
+    {
+        ChipLogError(SoftwareUpdate, "Error parsing JSON from file: \"%s\"", filepath);
+        return ret;
+    }
+
+    const Json::Value devSofVerModValue = root["deviceSoftwareVersionModel"];
+    if (!devSofVerModValue || !devSofVerModValue.isArray())
+    {
+        ChipLogError(SoftwareUpdate, "Error: Key deviceSoftwareVersionModel not found or its value is not of type Array");
+    }
+    else
+    {
+        for (auto iter : devSofVerModValue)
+        {
+            OTAProviderExample::DeviceSoftwareVersionModel candidate;
+            candidate.vendorId        = static_cast<chip::VendorId>(iter.get("vendorId", 1).asUInt());
+            candidate.productId       = static_cast<uint16_t>(iter.get("productId", 1).asUInt());
+            candidate.softwareVersion = static_cast<uint32_t>(iter.get("softwareVersion", 10).asUInt64());
+            chip::Platform::CopyString(candidate.softwareVersionString, iter.get("softwareVersionString", "1.0.0").asCString());
+            candidate.cDVersionNumber              = static_cast<uint16_t>(iter.get("cDVersionNumber", 0).asUInt());
+            candidate.softwareVersionValid         = iter.get("softwareVersionValid", true).asBool() ? true : false;
+            candidate.minApplicableSoftwareVersion = static_cast<uint32_t>(iter.get("minApplicableSoftwareVersion", 0).asUInt64());
+            candidate.maxApplicableSoftwareVersion =
+                static_cast<uint32_t>(iter.get("maxApplicableSoftwareVersion", 1000).asUInt64());
+            chip::Platform::CopyString(candidate.otaURL, iter.get("otaURL", "https://test.com").asCString());
+            candidates.push_back(candidate);
+            ret = true;
+        }
+    }
+    return ret;
+}
+
+bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue)
+{
+    bool retval = true;
+    static bool kOptionFilepathSelected;
+    static bool kOptionOtaImageListSelected;
+
+    switch (aIdentifier)
+    {
+    case kOptionFilepath:
+        kOptionFilepathSelected = true;
+        if (0 != access(aValue, R_OK))
+        {
+            PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
+            retval = false;
+        }
+        else if (kOptionOtaImageListSelected)
+        {
+            PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
+            retval = false;
+        }
+        else
+        {
+            gOtaFilepath = aValue;
+        }
+        break;
+    case kOptionImageUri:
+        gImageUri = aValue;
+        break;
+    case kOptionOtaImageList:
+        kOptionOtaImageListSelected = true;
+        if (0 != access(aValue, R_OK))
+        {
+            PrintArgError("%s: not permitted to read %s\n", aProgram, aValue);
+            retval = false;
+        }
+        else if (kOptionFilepathSelected)
+        {
+            PrintArgError("%s: Cannot have both OptionOtaImageList and kOptionOtaFilepath \n", aProgram);
+            retval = false;
+        }
+        else
+        {
+            gOtaImageListFilepath = aValue;
+        }
+        break;
+    case kOptionQueryImageStatus:
+        if (strcmp(aValue, "updateAvailable") == 0)
+        {
+            gQueryImageStatus = OTAQueryStatus::kUpdateAvailable;
+        }
+        else if (strcmp(aValue, "busy") == 0)
+        {
+            gQueryImageStatus = OTAQueryStatus::kBusy;
+        }
+        else if (strcmp(aValue, "updateNotAvailable") == 0)
+        {
+            gQueryImageStatus = OTAQueryStatus::kNotAvailable;
+        }
+        else
+        {
+            PrintArgError("%s: ERROR: Invalid queryImageStatus parameter:  %s\n", aProgram, aValue);
+            retval = false;
+        }
+        break;
+    case kOptionIgnoreQueryImage:
+        gIgnoreQueryImageCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+        break;
+    case kOptionIgnoreApplyUpdate:
+        gIgnoreApplyUpdateCount = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+        break;
+    case kOptionUpdateAction:
+        if (strcmp(aValue, "proceed") == 0)
+        {
+            gOptionUpdateAction = OTAApplyUpdateAction::kProceed;
+        }
+        else if (strcmp(aValue, "awaitNextAction") == 0)
+        {
+            gOptionUpdateAction = OTAApplyUpdateAction::kAwaitNextAction;
+        }
+        else if (strcmp(aValue, "discontinue") == 0)
+        {
+            gOptionUpdateAction = OTAApplyUpdateAction::kDiscontinue;
+        }
+        else
+        {
+            PrintArgError("%s: ERROR: Invalid applyUpdateAction parameter:  %s\n", aProgram, aValue);
+            retval = false;
+        }
+        break;
+    case kOptionDelayedQueryActionTimeSec:
+        gDelayedQueryActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+        break;
+    case kOptionDelayedApplyActionTimeSec:
+        gDelayedApplyActionTimeSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+        break;
+    case kOptionUserConsentState:
+        if (strcmp(aValue, "granted") == 0)
+        {
+            gUserConsentState = chip::ota::UserConsentState::kGranted;
+        }
+        else if (strcmp(aValue, "denied") == 0)
+        {
+            gUserConsentState = chip::ota::UserConsentState::kDenied;
+        }
+        else if (strcmp(aValue, "deferred") == 0)
+        {
+            gUserConsentState = chip::ota::UserConsentState::kObtaining;
+        }
+        else
+        {
+            PrintArgError("%s: ERROR: Invalid UserConsent parameter:  %s\n", aProgram, aValue);
+            retval = false;
+        }
+        break;
+    case kOptionUserConsentNeeded:
+        gUserConsentNeeded = true;
+        break;
+    case kOptionPollInterval:
+        gPollInterval = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
+        break;
+    case kOptionMaxBDXBlockSize: {
+        auto blockSize = static_cast<uint16_t>(strtoul(aValue, NULL, 0));
+        if (blockSize == 0)
+        {
+            PrintArgError("%s: ERROR: Invalid maxBDXBlockSize parameter: %s\n", aProgram, aValue);
+            retval = false;
+        }
+        else
+        {
+            gMaxBDXBlockSize = blockSize;
+        }
+        break;
+    }
+
+    default:
+        PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);
+        retval = false;
+        break;
+    }
+
+    return (retval);
+}
+
+OptionDef cmdLineOptionsDef[] = {
+    { "applyUpdateAction", chip::ArgParser::kArgumentRequired, kOptionUpdateAction },
+    { "userConsentNeeded", chip::ArgParser::kNoArgument, kOptionUserConsentNeeded },
+    { "filepath", chip::ArgParser::kArgumentRequired, kOptionFilepath },
+    { "imageUri", chip::ArgParser::kArgumentRequired, kOptionImageUri },
+    { "otaImageList", chip::ArgParser::kArgumentRequired, kOptionOtaImageList },
+    { "delayedApplyActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedApplyActionTimeSec },
+    { "queryImageStatus", chip::ArgParser::kArgumentRequired, kOptionQueryImageStatus },
+    { "delayedQueryActionTimeSec", chip::ArgParser::kArgumentRequired, kOptionDelayedQueryActionTimeSec },
+    { "userConsentState", chip::ArgParser::kArgumentRequired, kOptionUserConsentState },
+    { "ignoreQueryImage", chip::ArgParser::kArgumentRequired, kOptionIgnoreQueryImage },
+    { "ignoreApplyUpdate", chip::ArgParser::kArgumentRequired, kOptionIgnoreApplyUpdate },
+    { "pollInterval", chip::ArgParser::kArgumentRequired, kOptionPollInterval },
+    { "maxBDXBlockSize", chip::ArgParser::kArgumentRequired, kOptionMaxBDXBlockSize },
+    {},
+};
+
+OptionSet cmdLineOptions = { HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS",
+                             "  -a, --applyUpdateAction <proceed | awaitNextAction | discontinue>\n"
+                             "        Value for the Action field in the first ApplyUpdateResponse.\n"
+                             "        For all subsequent responses, the value of proceed will be used.\n"
+                             "  -c, --userConsentNeeded\n"
+                             "        If supplied, value of the UserConsentNeeded field in the QueryImageResponse\n"
+                             "        is set to true. This is only applicable if value of the RequestorCanConsent\n"
+                             "        field in QueryImage Command is true.\n"
+                             "        Otherwise, value of the UserConsentNeeded field is false.\n"
+                             "  -f, --filepath <file path>\n"
+                             "        Path to a file containing an OTA image\n"
+                             "  -i, --imageUri <uri>\n"
+                             "        Value for the ImageURI field in the QueryImageResponse.\n"
+                             "        If none is supplied, a valid URI is generated.\n"
+                             "  -m, --maxBDXBlockSize <size>\n"
+                             "        Value for the maximum BDX block size to use for the transfer.\n"
+                             "        If none is supplied, a default value will be used.\n"
+                             "  -o, --otaImageList <file path>\n"
+                             "        Path to a file containing a list of OTA images\n"
+                             "  -p, --delayedApplyActionTimeSec <time in seconds>\n"
+                             "        Value for the DelayedActionTime field in the first ApplyUpdateResponse.\n"
+                             "        For all subsequent responses, the value of zero will be used.\n"
+                             "  -q, --queryImageStatus <updateAvailable | busy | updateNotAvailable>\n"
+                             "        Value for the Status field in the first QueryImageResponse.\n"
+                             "        For all subsequent responses, the value of updateAvailable will be used.\n"
+                             "  -t, --delayedQueryActionTimeSec <time in seconds>\n"
+                             "        Value for the DelayedActionTime field in the first QueryImageResponse.\n"
+                             "        For all subsequent responses, the value of zero will be used.\n"
+                             "  -u, --userConsentState <granted | denied | deferred>\n"
+                             "        The user consent state for the first QueryImageResponse. For all subsequent\n"
+                             "        responses, the value of granted will be used.\n"
+                             "        Note that --queryImageStatus overrides this option.\n"
+                             "        granted: Status field in the first QueryImageResponse is set to updateAvailable\n"
+                             "        denied: Status field in the first QueryImageResponse is set to updateNotAvailable\n"
+                             "        deferred: Status field in the first QueryImageResponse is set to busy\n"
+                             "  -x, --ignoreQueryImage <ignore count>\n"
+                             "        The number of times to ignore the QueryImage Command and not send a response.\n"
+                             "  -y, --ignoreApplyUpdate <ignore count>\n"
+                             "        The number of times to ignore the ApplyUpdateRequest Command and not send a response.\n"
+                             "  -P, --pollInterval <time in milliseconds>\n"
+                             "        Poll interval for the BDX transfer \n" };
+
+OptionSet * allOptions[] = { &cmdLineOptions, nullptr };
+
+void ApplicationInit()
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    BdxOtaSender * bdxOtaSender = gOtaProvider.GetBdxOtaSender();
+    VerifyOrReturn(bdxOtaSender != nullptr);
+    err = chip::Server::GetInstance().GetExchangeManager().RegisterUnsolicitedMessageHandlerForProtocol(chip::Protocols::BDX::Id,
+                                                                                                        bdxOtaSender);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogDetail(SoftwareUpdate, "RegisterUnsolicitedMessageHandler failed: %s", chip::ErrorStr(err));
+        return;
+    }
+
+    ChipLogDetail(SoftwareUpdate, "Using OTA file: %s", gOtaFilepath ? gOtaFilepath : "(none)");
+
+    if (gOtaFilepath != nullptr)
+    {
+        gOtaProvider.SetOTAFilePath(gOtaFilepath);
+    }
+
+    if (gImageUri != nullptr)
+    {
+        gOtaProvider.SetImageUri(gImageUri);
+    }
+
+    gOtaProvider.SetIgnoreQueryImageCount(gIgnoreQueryImageCount);
+    gOtaProvider.SetIgnoreApplyUpdateCount(gIgnoreApplyUpdateCount);
+    gOtaProvider.SetQueryImageStatus(gQueryImageStatus);
+    gOtaProvider.SetApplyUpdateAction(gOptionUpdateAction);
+    gOtaProvider.SetDelayedQueryActionTimeSec(gDelayedQueryActionTimeSec);
+    gOtaProvider.SetDelayedApplyActionTimeSec(gDelayedApplyActionTimeSec);
+
+    if (gUserConsentState != chip::ota::UserConsentState::kUnknown)
+    {
+        gUserConsentProvider.SetGlobalUserConsentState(gUserConsentState);
+        gOtaProvider.SetUserConsentDelegate(&gUserConsentProvider);
+    }
+
+    if (gUserConsentNeeded)
+    {
+        gOtaProvider.SetUserConsentNeeded(true);
+    }
+
+    if (gPollInterval != 0)
+    {
+        gOtaProvider.SetPollInterval(gPollInterval);
+    }
+
+    if (gMaxBDXBlockSize)
+    {
+        gOtaProvider.SetMaxBDXBlockSize(*gMaxBDXBlockSize);
+    }
+
+    ChipLogDetail(SoftwareUpdate, "Using ImageList file: %s", gOtaImageListFilepath ? gOtaImageListFilepath : "(none)");
+
+    if (gOtaImageListFilepath != nullptr)
+    {
+        // Parse JSON file and load the ota candidates
+        std::vector<OTAProviderExample::DeviceSoftwareVersionModel> candidates;
+        ParseJsonFileAndPopulateCandidates(gOtaImageListFilepath, candidates);
+        gOtaProvider.SetOTACandidates(candidates);
+    }
+
+    if ((gOtaFilepath == nullptr) && (gOtaImageListFilepath == nullptr))
+    {
+        ChipLogError(SoftwareUpdate, "Either an OTA file or image list file must be specified");
+        chipDie();
+    }
+
+    chip::app::Clusters::OTAProvider::SetDelegate(kOtaProviderEndpoint, &gOtaProvider);
+}
+
+void ApplicationShutdown() {}
+
+namespace {
+class OtaProviderAppMainLoopImplementation : public AppMainLoopImplementation
+{
+public:
+    void RunMainLoop() override { chip::DeviceLayer::PlatformMgr().RunEventLoop(); }
+    void SignalSafeStopMainLoop() override
+    {
+        chip::DeviceLayer::PlatformMgr().ScheduleWork([](intptr_t) {
+            ChipLogDetail(SoftwareUpdate, "Scheduling BdxOtaSender to ABORT TRANSFER");
+
+            gOtaProvider.GetBdxOtaSender()->AbortTransfer();
+
+            chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
+        });
+
+        chip::Server::GetInstance().GenerateShutDownEvent();
+    }
+};
+} // namespace
+
+int main(int argc, char * argv[])
+{
+    OtaProviderAppMainLoopImplementation ml_impl{};
+
+    VerifyOrDie(ChipLinuxAppInit(argc, argv, &cmdLineOptions) == 0);
+    ChipLinuxAppMainLoop(&ml_impl);
+    return 0;
+}
\ No newline at end of file
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
index e8c7a6488af478..f39f436a748639 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
@@ -1,247 +1,247 @@
 /*
- *
- *    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.
+*
+*    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.
+*/
+
+#include <ota-provider-common/BdxOtaSender.h>
+
+#include <lib/core/CHIPError.h>
+#include <lib/support/BitFlags.h>
+#include <lib/support/CHIPMemString.h>
+#include <messaging/ExchangeContext.h>
+#include <messaging/Flags.h>
+#include <protocols/bdx/BdxTransferSession.h>
+
+#include <fstream>
+
+using chip::bdx::StatusCode;
+using chip::bdx::TransferControlFlags;
+using chip::bdx::TransferSession;
+
+BdxOtaSender::BdxOtaSender()
+{
+    memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
+}
+
+CHIP_ERROR BdxOtaSender::InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId)
+{
+    if (mInitialized)
+    {
+        // Reset stale connection from the Same Node if exists
+        if ((mFabricIndex.HasValue() && mFabricIndex.Value() == fabricIndex) && (mNodeId.HasValue() && mNodeId.Value() == nodeId))
+        {
+            Reset();
+        }
+        // Prevent a new node connection since another is active
+        else if ((mFabricIndex.HasValue() && mFabricIndex.Value() != fabricIndex) ||
+                 (mNodeId.HasValue() && mNodeId.Value() != nodeId))
+        {
+            return CHIP_ERROR_BUSY;
+        }
+        else
+        {
+            return CHIP_ERROR_INTERNAL;
+        }
+    }
+    mFabricIndex.SetValue(fabricIndex);
+    mNodeId.SetValue(nodeId);
+    mInitialized = true;
+    return CHIP_NO_ERROR;
+}
+
+void BdxOtaSender::HandleTransferSessionOutput(TransferSession::OutputEvent & event)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    if (event.EventType != TransferSession::OutputEventType::kNone)
+    {
+        ChipLogDetail(BDX, "OutputEvent type: %s", event.ToString(event.EventType));
+    }
+
+    switch (event.EventType)
+    {
+    case TransferSession::OutputEventType::kNone:
+        break;
+    case TransferSession::OutputEventType::kMsgToSend: {
+        chip::Messaging::SendFlags sendFlags;
+        if (!event.msgTypeData.HasMessageType(chip::Protocols::SecureChannel::MsgType::StatusReport))
+        {
+            // All messages sent from the Sender expect a response, except for a StatusReport which would indicate an error and the
+            // end of the transfer.
+            sendFlags.Set(chip::Messaging::SendMessageFlags::kExpectResponse);
+        }
+        VerifyOrReturn(mExchangeCtx != nullptr);
+        err = mExchangeCtx->SendMessage(event.msgTypeData.ProtocolId, event.msgTypeData.MessageType, std::move(event.MsgData),
+                                        sendFlags);
+
+        if (err == CHIP_NO_ERROR)
+        {
+            if (!sendFlags.Has(chip::Messaging::SendMessageFlags::kExpectResponse))
+            {
+                // After sending the StatusReport, exchange context gets closed so, set mExchangeCtx to null
+                mExchangeCtx = nullptr;
+            }
+        }
+        else
+        {
+            ChipLogError(BDX, "SendMessage failed: %" CHIP_ERROR_FORMAT, err.Format());
+            Reset();
+        }
+
+        break;
+    }
+    case TransferSession::OutputEventType::kInitReceived: {
+        // TransferSession will automatically reject a transfer if there are no
+        // common supported control modes. It will also default to the smaller
+        // block size.
+        TransferSession::TransferAcceptData acceptData;
+        acceptData.ControlMode  = TransferControlFlags::kReceiverDrive; // OTA must use receiver drive
+        acceptData.MaxBlockSize = mTransfer.GetTransferBlockSize();
+        acceptData.StartOffset  = mTransfer.GetStartOffset();
+        acceptData.Length       = mTransfer.GetTransferLength();
+        VerifyOrReturn(mTransfer.AcceptTransfer(acceptData) == CHIP_NO_ERROR,
+                       ChipLogError(BDX, "AcceptTransfer failed: %" CHIP_ERROR_FORMAT, err.Format()));
+
+        // Store the file designator used during block query
+        uint16_t fdl       = 0;
+        const uint8_t * fd = mTransfer.GetFileDesignator(fdl);
+        VerifyOrReturn(fdl < chip::bdx::kMaxFileDesignatorLen,
+                       ChipLogError(BDX, "Cannot store file designator with length = %d", fdl));
+        memcpy(mFileDesignator, fd, fdl);
+        mFileDesignator[fdl] = 0;
+
+        break;
+    }
+    case TransferSession::OutputEventType::kQueryReceived:
+    case TransferSession::OutputEventType::kQueryWithSkipReceived: {
+        TransferSession::BlockData blockData;
+        uint16_t blockSize   = mTransfer.GetTransferBlockSize();
+        uint16_t bytesToRead = blockSize;
+        uint64_t bytesToSkip = 0;
+
+        if (event.EventType == TransferSession::OutputEventType::kQueryWithSkipReceived)
+        {
+            bytesToSkip = event.bytesToSkip.BytesToSkip;
+        }
+        uint64_t seekOffset = mNumBytesSent + bytesToSkip;
+
+        // TODO: This should be a utility function in TransferSession
+        if ((mTransfer.GetTransferLength() > 0) && ((seekOffset + blockSize) > mTransfer.GetTransferLength()))
+        {
+            // cast should be safe because of condition above
+            bytesToRead = static_cast<uint16_t>(mTransfer.GetTransferLength() - seekOffset);
+        }
+
+        chip::System::PacketBufferHandle blockBuf = chip::System::PacketBufferHandle::New(bytesToRead);
+        if (blockBuf.IsNull())
+        {
+            // TODO(#13981): AbortTransfer() needs to support GeneralStatusCode failures as well as BDX specific errors.
+            mTransfer.AbortTransfer(StatusCode::kUnknown);
+            return;
+        }
+
+        std::ifstream otaFile(mFileDesignator, std::ifstream::in);
+        if (!otaFile.good())
+        {
+            ChipLogError(BDX, "OTA file open failed");
+            mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
+            return;
+        }
+
+        if (seekOffset > static_cast<uint64_t>(std::numeric_limits<std::streamoff>::max()))
+        {
+            ChipLogError(BDX, "Seek offset too large");
+            mTransfer.AbortTransfer(StatusCode::kLengthTooLarge);
+            return;
+        }
+        otaFile.seekg(static_cast<std::streamoff>(seekOffset));
+        otaFile.read(reinterpret_cast<char *>(blockBuf->Start()), bytesToRead);
+        if (!(otaFile.good() || otaFile.eof()))
+        {
+            ChipLogError(BDX, "OTA file read failed");
+            mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
+            return;
+        }
+
+        blockData.Data   = blockBuf->Start();
+        blockData.Length = static_cast<size_t>(otaFile.gcount());
+        blockData.IsEof  = (blockData.Length < blockSize) ||
+            (seekOffset + static_cast<uint64_t>(blockData.Length) == mTransfer.GetTransferLength() || (otaFile.peek() == EOF));
+        mNumBytesSent = static_cast<uint32_t>(seekOffset + blockData.Length);
+        otaFile.close();
+
+        err = mTransfer.PrepareBlock(blockData);
+        if (err != CHIP_NO_ERROR)
+        {
+            ChipLogError(BDX, "PrepareBlock failed: %" CHIP_ERROR_FORMAT, err.Format());
+            mTransfer.AbortTransfer(StatusCode::kUnknown);
+        }
+        break;
+    }
+    case TransferSession::OutputEventType::kAckReceived:
+        break;
+    case TransferSession::OutputEventType::kAckEOFReceived:
+        ChipLogDetail(BDX, "Transfer completed, got AckEOF");
+        Reset();
+        break;
+    case TransferSession::OutputEventType::kStatusReceived:
+        ChipLogError(BDX, "Got StatusReport %x", static_cast<uint16_t>(event.statusData.statusCode));
+        Reset();
+        break;
+    case TransferSession::OutputEventType::kInternalError:
+        ChipLogError(BDX, "InternalError");
+        Reset();
+        break;
+    case TransferSession::OutputEventType::kTransferTimeout:
+        ChipLogError(BDX, "Transfer timed out");
+        Reset();
+        break;
+    case TransferSession::OutputEventType::kAcceptReceived:
+    case TransferSession::OutputEventType::kBlockReceived:
+    default:
+        // TransferSession should prevent this case from happening.
+        ChipLogError(BDX, "Unsupported event type");
+    }
+}
+
+/* Reset() calls bdx::TransferSession::Reset() which sets the output event type to
+ * TransferSession::OutputEventType::kNone. So, bdx::TransferFacilitator::PollForOutput()
+ * will call HandleTransferSessionOutput() with event TransferSession::OutputEventType::kNone.
+ * Since we are ignoring kNone events so, it is okay HandleTransferSessionOutput() being called with event kNone
  */
+void BdxOtaSender::Reset()
+{
+    mFabricIndex.ClearValue();
+    mNodeId.ClearValue();
+    ResetTransfer();
+    if (mExchangeCtx != nullptr)
+    {
+        mExchangeCtx->Close();
+        mExchangeCtx = nullptr;
+    }
+
+    mInitialized  = false;
+    mNumBytesSent = 0;
+    memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
+}
 
- #include <ota-provider-common/BdxOtaSender.h>
-
- #include <lib/core/CHIPError.h>
- #include <lib/support/BitFlags.h>
- #include <lib/support/CHIPMemString.h>
- #include <messaging/ExchangeContext.h>
- #include <messaging/Flags.h>
- #include <protocols/bdx/BdxTransferSession.h>
- 
- #include <fstream>
- 
- using chip::bdx::StatusCode;
- using chip::bdx::TransferControlFlags;
- using chip::bdx::TransferSession;
- 
- BdxOtaSender::BdxOtaSender()
- {
-     memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
- }
- 
- CHIP_ERROR BdxOtaSender::InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId)
- {
-     if (mInitialized)
-     {
-         // Reset stale connection from the Same Node if exists
-         if ((mFabricIndex.HasValue() && mFabricIndex.Value() == fabricIndex) && (mNodeId.HasValue() && mNodeId.Value() == nodeId))
-         {
-             Reset();
-         }
-         // Prevent a new node connection since another is active
-         else if ((mFabricIndex.HasValue() && mFabricIndex.Value() != fabricIndex) ||
-                  (mNodeId.HasValue() && mNodeId.Value() != nodeId))
-         {
-             return CHIP_ERROR_BUSY;
-         }
-         else
-         {
-             return CHIP_ERROR_INTERNAL;
-         }
-     }
-     mFabricIndex.SetValue(fabricIndex);
-     mNodeId.SetValue(nodeId);
-     mInitialized = true;
-     return CHIP_NO_ERROR;
- }
- 
- void BdxOtaSender::HandleTransferSessionOutput(TransferSession::OutputEvent & event)
- {
-     CHIP_ERROR err = CHIP_NO_ERROR;
- 
-     if (event.EventType != TransferSession::OutputEventType::kNone)
-     {
-         ChipLogDetail(BDX, "OutputEvent type: %s", event.ToString(event.EventType));
-     }
- 
-     switch (event.EventType)
-     {
-     case TransferSession::OutputEventType::kNone:
-         break;
-     case TransferSession::OutputEventType::kMsgToSend: {
-         chip::Messaging::SendFlags sendFlags;
-         if (!event.msgTypeData.HasMessageType(chip::Protocols::SecureChannel::MsgType::StatusReport))
-         {
-             // All messages sent from the Sender expect a response, except for a StatusReport which would indicate an error and the
-             // end of the transfer.
-             sendFlags.Set(chip::Messaging::SendMessageFlags::kExpectResponse);
-         }
-         VerifyOrReturn(mExchangeCtx != nullptr);
-         err = mExchangeCtx->SendMessage(event.msgTypeData.ProtocolId, event.msgTypeData.MessageType, std::move(event.MsgData),
-                                         sendFlags);
- 
-         if (err == CHIP_NO_ERROR)
-         {
-             if (!sendFlags.Has(chip::Messaging::SendMessageFlags::kExpectResponse))
-             {
-                 // After sending the StatusReport, exchange context gets closed so, set mExchangeCtx to null
-                 mExchangeCtx = nullptr;
-             }
-         }
-         else
-         {
-             ChipLogError(BDX, "SendMessage failed: %" CHIP_ERROR_FORMAT, err.Format());
-             Reset();
-         }
- 
-         break;
-     }
-     case TransferSession::OutputEventType::kInitReceived: {
-         // TransferSession will automatically reject a transfer if there are no
-         // common supported control modes. It will also default to the smaller
-         // block size.
-         TransferSession::TransferAcceptData acceptData;
-         acceptData.ControlMode  = TransferControlFlags::kReceiverDrive; // OTA must use receiver drive
-         acceptData.MaxBlockSize = mTransfer.GetTransferBlockSize();
-         acceptData.StartOffset  = mTransfer.GetStartOffset();
-         acceptData.Length       = mTransfer.GetTransferLength();
-         VerifyOrReturn(mTransfer.AcceptTransfer(acceptData) == CHIP_NO_ERROR,
-                        ChipLogError(BDX, "AcceptTransfer failed: %" CHIP_ERROR_FORMAT, err.Format()));
- 
-         // Store the file designator used during block query
-         uint16_t fdl       = 0;
-         const uint8_t * fd = mTransfer.GetFileDesignator(fdl);
-         VerifyOrReturn(fdl < chip::bdx::kMaxFileDesignatorLen,
-                        ChipLogError(BDX, "Cannot store file designator with length = %d", fdl));
-         memcpy(mFileDesignator, fd, fdl);
-         mFileDesignator[fdl] = 0;
- 
-         break;
-     }
-     case TransferSession::OutputEventType::kQueryReceived:
-     case TransferSession::OutputEventType::kQueryWithSkipReceived: {
-         TransferSession::BlockData blockData;
-         uint16_t blockSize   = mTransfer.GetTransferBlockSize();
-         uint16_t bytesToRead = blockSize;
-         uint64_t bytesToSkip = 0;
- 
-         if (event.EventType == TransferSession::OutputEventType::kQueryWithSkipReceived)
-         {
-             bytesToSkip = event.bytesToSkip.BytesToSkip;
-         }
-         uint64_t seekOffset = mNumBytesSent + bytesToSkip;
- 
-         // TODO: This should be a utility function in TransferSession
-         if ((mTransfer.GetTransferLength() > 0) && ((seekOffset + blockSize) > mTransfer.GetTransferLength()))
-         {
-             // cast should be safe because of condition above
-             bytesToRead = static_cast<uint16_t>(mTransfer.GetTransferLength() - seekOffset);
-         }
- 
-         chip::System::PacketBufferHandle blockBuf = chip::System::PacketBufferHandle::New(bytesToRead);
-         if (blockBuf.IsNull())
-         {
-             // TODO(#13981): AbortTransfer() needs to support GeneralStatusCode failures as well as BDX specific errors.
-             mTransfer.AbortTransfer(StatusCode::kUnknown);
-             return;
-         }
- 
-         std::ifstream otaFile(mFileDesignator, std::ifstream::in);
-         if (!otaFile.good())
-         {
-             ChipLogError(BDX, "OTA file open failed");
-             mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
-             return;
-         }
- 
-         if (seekOffset > static_cast<uint64_t>(std::numeric_limits<std::streamoff>::max()))
-         {
-             ChipLogError(BDX, "Seek offset too large");
-             mTransfer.AbortTransfer(StatusCode::kLengthTooLarge);
-             return;
-         }
-         otaFile.seekg(static_cast<std::streamoff>(seekOffset));
-         otaFile.read(reinterpret_cast<char *>(blockBuf->Start()), bytesToRead);
-         if (!(otaFile.good() || otaFile.eof()))
-         {
-             ChipLogError(BDX, "OTA file read failed");
-             mTransfer.AbortTransfer(StatusCode::kFileDesignatorUnknown);
-             return;
-         }
- 
-         blockData.Data   = blockBuf->Start();
-         blockData.Length = static_cast<size_t>(otaFile.gcount());
-         blockData.IsEof  = (blockData.Length < blockSize) ||
-             (seekOffset + static_cast<uint64_t>(blockData.Length) == mTransfer.GetTransferLength() || (otaFile.peek() == EOF));
-         mNumBytesSent = static_cast<uint32_t>(seekOffset + blockData.Length);
-         otaFile.close();
- 
-         err = mTransfer.PrepareBlock(blockData);
-         if (err != CHIP_NO_ERROR)
-         {
-             ChipLogError(BDX, "PrepareBlock failed: %" CHIP_ERROR_FORMAT, err.Format());
-             mTransfer.AbortTransfer(StatusCode::kUnknown);
-         }
-         break;
-     }
-     case TransferSession::OutputEventType::kAckReceived:
-         break;
-     case TransferSession::OutputEventType::kAckEOFReceived:
-         ChipLogDetail(BDX, "Transfer completed, got AckEOF");
-         Reset();
-         break;
-     case TransferSession::OutputEventType::kStatusReceived:
-         ChipLogError(BDX, "Got StatusReport %x", static_cast<uint16_t>(event.statusData.statusCode));
-         Reset();
-         break;
-     case TransferSession::OutputEventType::kInternalError:
-         ChipLogError(BDX, "InternalError");
-         Reset();
-         break;
-     case TransferSession::OutputEventType::kTransferTimeout:
-         ChipLogError(BDX, "Transfer timed out");
-         Reset();
-         break;
-     case TransferSession::OutputEventType::kAcceptReceived:
-     case TransferSession::OutputEventType::kBlockReceived:
-     default:
-         // TransferSession should prevent this case from happening.
-         ChipLogError(BDX, "Unsupported event type");
-     }
- }
- 
- /* Reset() calls bdx::TransferSession::Reset() which sets the output event type to
-  * TransferSession::OutputEventType::kNone. So, bdx::TransferFacilitator::PollForOutput()
-  * will call HandleTransferSessionOutput() with event TransferSession::OutputEventType::kNone.
-  * Since we are ignoring kNone events so, it is okay HandleTransferSessionOutput() being called with event kNone
-  */
- void BdxOtaSender::Reset()
- {
-     mFabricIndex.ClearValue();
-     mNodeId.ClearValue();
-     ResetTransfer();
-     if (mExchangeCtx != nullptr)
-     {
-         mExchangeCtx->Close();
-         mExchangeCtx = nullptr;
-     }
- 
-     mInitialized  = false;
-     mNumBytesSent = 0;
-     memset(mFileDesignator, 0, chip::bdx::kMaxFileDesignatorLen);
- }
- 
- void BdxOtaSender::AbortTransfer()
- {
-     if (mInitialized)
-     {
-         mTransfer.AbortTransfer(StatusCode::kUnknown);
-         PollForOutput();
-     }
- }
\ No newline at end of file
+void BdxOtaSender::AbortTransfer()
+{
+    if (mInitialized)
+    {
+        mTransfer.AbortTransfer(StatusCode::kUnknown);
+        PollForOutput();
+    }
+}
\ No newline at end of file
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
index 93fd7665c2fabf..b81949cf7d2c84 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
@@ -1,49 +1,49 @@
 /*
- *
- *    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.
- */
-
- #include <protocols/bdx/BdxTransferSession.h>
- #include <protocols/bdx/TransferFacilitator.h>
- 
- #pragma once
- 
- class BdxOtaSender : public chip::bdx::Responder
- {
- public:
-     BdxOtaSender();
- 
-     // Initializes BDX transfer-related metadata. Should always be called first.
-     CHIP_ERROR InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId);
- 
-     void AbortTransfer();
- 
- private:
-     // Inherited from bdx::TransferFacilitator
-     void HandleTransferSessionOutput(chip::bdx::TransferSession::OutputEvent & event) override;
- 
-     void Reset();
- 
-     // Null-terminated string representing file designator
-     char mFileDesignator[chip::bdx::kMaxFileDesignatorLen];
- 
-     uint32_t mNumBytesSent = 0;
- 
-     bool mInitialized = false;
- 
-     chip::Optional<chip::FabricIndex> mFabricIndex;
- 
-     chip::Optional<chip::NodeId> mNodeId;
- };
\ No newline at end of file
+*
+*    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.
+*/
+
+#include <protocols/bdx/BdxTransferSession.h>
+#include <protocols/bdx/TransferFacilitator.h>
+
+#pragma once
+
+class BdxOtaSender : public chip::bdx::Responder
+{
+public:
+    BdxOtaSender();
+
+    // Initializes BDX transfer-related metadata. Should always be called first.
+    CHIP_ERROR InitializeTransfer(chip::FabricIndex fabricIndex, chip::NodeId nodeId);
+
+    void AbortTransfer();
+
+private:
+    // Inherited from bdx::TransferFacilitator
+    void HandleTransferSessionOutput(chip::bdx::TransferSession::OutputEvent & event) override;
+
+    void Reset();
+
+    // Null-terminated string representing file designator
+    char mFileDesignator[chip::bdx::kMaxFileDesignatorLen];
+
+    uint32_t mNumBytesSent = 0;
+
+    bool mInitialized = false;
+
+    chip::Optional<chip::FabricIndex> mFabricIndex;
+
+    chip::Optional<chip::NodeId> mNodeId;
+};
\ No newline at end of file

From 4e6f818457ceebbde9eb6eecd31d7a48fb059a41 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 8 Oct 2025 15:16:47 -0300
Subject: [PATCH 03/18] Restyle

---
 examples/ota-provider-app/linux/main.cpp      | 32 +++++++++----------
 .../ota-provider-common/BdxOtaSender.cpp      | 30 ++++++++---------
 .../ota-provider-common/BdxOtaSender.h        | 30 ++++++++---------
 3 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/examples/ota-provider-app/linux/main.cpp b/examples/ota-provider-app/linux/main.cpp
index 838cb8d6677cc1..b995173e58591c 100644
--- a/examples/ota-provider-app/linux/main.cpp
+++ b/examples/ota-provider-app/linux/main.cpp
@@ -1,20 +1,20 @@
 /*
-*
-*    Copyright (c) 2020-2022 Project CHIP Authors
-*    All rights reserved.
-*
-*    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.
-*/
+ *
+ *    Copyright (c) 2020-2022 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    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.
+ */
 
 #include <app/clusters/ota-provider/CodegenIntegration.h>
 #include <app/clusters/ota-provider/DefaultOTAProviderUserConsent.h>
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
index f39f436a748639..65b2f4d7674e4a 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
@@ -1,19 +1,19 @@
 /*
-*
-*    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.
-*/
+ *
+ *    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.
+ */
 
 #include <ota-provider-common/BdxOtaSender.h>
 
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
index b81949cf7d2c84..2cfb37319a1718 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
@@ -1,19 +1,19 @@
 /*
-*
-*    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.
-*/
+ *
+ *    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.
+ */
 
 #include <protocols/bdx/BdxTransferSession.h>
 #include <protocols/bdx/TransferFacilitator.h>

From ebfef1bfc945cfb625deff665bf416f4d969fc62 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 8 Oct 2025 15:20:29 -0300
Subject: [PATCH 04/18] Restyle

---
 src/python_testing/test_metadata.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/python_testing/test_metadata.yaml b/src/python_testing/test_metadata.yaml
index 8c026ff3941cd4..fdf25cc321bb78 100644
--- a/src/python_testing/test_metadata.yaml
+++ b/src/python_testing/test_metadata.yaml
@@ -24,7 +24,7 @@ not_automated:
     - name: TC_CNET_4_22.py
       reason: It has no CI execution block, is not executed in CI
     - name: TC_SU_2_8.py
-      reason: CI script not implemented 
+      reason: CI script not implemented
     - name: TC_DGGEN_3_2.py
       reason:
           src/python_testing/test_testing/test_TC_DGGEN_3_2.py is the Unit test
@@ -173,4 +173,4 @@ slow_tests:
     - { name: TC_TIMESYNC_2_12.py, duration: 20 seconds }
     - { name: TC_TIMESYNC_2_7.py, duration: 20 seconds }
     - { name: TC_TIMESYNC_2_8.py, duration: 1.5 minutes }
-    - { name: TC_CLCTRL_4_1.py, duration: 45 seconds }
\ No newline at end of file
+    - { name: TC_CLCTRL_4_1.py, duration: 45 seconds }

From a62a8b769fbdcff079a54572fd5542c9f4f009fd Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 8 Oct 2025 15:23:24 -0300
Subject: [PATCH 05/18] Restyle

---
 examples/ota-provider-app/linux/main.cpp                       | 2 +-
 examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp | 2 +-
 examples/ota-provider-app/ota-provider-common/BdxOtaSender.h   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/ota-provider-app/linux/main.cpp b/examples/ota-provider-app/linux/main.cpp
index b995173e58591c..9d9aedd0edda31 100644
--- a/examples/ota-provider-app/linux/main.cpp
+++ b/examples/ota-provider-app/linux/main.cpp
@@ -434,4 +434,4 @@ int main(int argc, char * argv[])
     VerifyOrDie(ChipLinuxAppInit(argc, argv, &cmdLineOptions) == 0);
     ChipLinuxAppMainLoop(&ml_impl);
     return 0;
-}
\ No newline at end of file
+}
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
index 65b2f4d7674e4a..0fb27bf71a21e0 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.cpp
@@ -244,4 +244,4 @@ void BdxOtaSender::AbortTransfer()
         mTransfer.AbortTransfer(StatusCode::kUnknown);
         PollForOutput();
     }
-}
\ No newline at end of file
+}
diff --git a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
index 2cfb37319a1718..2838f9465c5c11 100644
--- a/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
+++ b/examples/ota-provider-app/ota-provider-common/BdxOtaSender.h
@@ -46,4 +46,4 @@ class BdxOtaSender : public chip::bdx::Responder
     chip::Optional<chip::FabricIndex> mFabricIndex;
 
     chip::Optional<chip::NodeId> mNodeId;
-};
\ No newline at end of file
+};

From b0a5611c6554e8e33c919e70a4e68326f625a4fa Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 8 Oct 2025 20:13:32 +0000
Subject: [PATCH 06/18] Minor adjustments

---
 src/python_testing/TC_SU_2_8.py                          | 2 +-
 .../matter/testing/event_attribute_reporting.py          | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index 44883a74a9f52e..a54fc14d1f48b9 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -220,7 +220,7 @@ async def test_TC_SU_2_8(self):
 
         await asyncio.sleep(5)
 
-        blocks = provider_1.read_from_logs("QueryImage", regex=True, before=0, after=15)
+        blocks = provider_1.read_from_logs("QueryImage", before=0, after=15)
 
         parsed = {}
         for b in blocks:
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/event_attribute_reporting.py b/src/python_testing/matter_testing_infrastructure/matter/testing/event_attribute_reporting.py
index 2275b10fc02203..c90c07b9119ab7 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/event_attribute_reporting.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/event_attribute_reporting.py
@@ -188,6 +188,15 @@ def get_size(self) -> int:
     def get_event_from_queue(self, block: bool, timeout: int):
         return self._q.get(block, timeout)
 
+    async def cancel(self):
+        """This cancels a subscription."""
+        # Wait for the asyncio.CancelledError to be called before returning
+        try:
+            self._subscription.Shutdown()
+            await asyncio.sleep(5)
+        except asyncio.CancelledError:
+            pass
+
 
 class AttributeSubscriptionHandler:
     """

From a88c3937ce216e2e9c77829783624c2bad2ff849 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Thu, 9 Oct 2025 14:33:23 +0000
Subject: [PATCH 07/18] Update version

---
 src/python_testing/TC_SU_2_8.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index a54fc14d1f48b9..b218cf81cebd2c 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -106,7 +106,7 @@ def steps_TC_SU_2_8(self) -> list[TestStep]:
                      "If the Location field is present, verify that the value is same as Basic Information Cluster Location Attribute of the DUT."),
             TestStep(2, "Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P.",
                      "TH1/OTA-P does not respond with QueryImage response command. StateTransition goes from idle to querying, then a download error happens and finally it goes back to idle."
-                     "Subscribe to events for OtaSoftwareUpdateRequestor cluster and verify StateTransition reaches downloading state. Also check if the targetSoftwareVersion is 2."),
+                     "Subscribe to events for OtaSoftwareUpdateRequestor cluster and verify StateTransition reaches downloading state. Also check if the targetSoftwareVersion is 3."),
         ]
         return steps
 

From a30803d289b174888e751d705ed09698d889e7f3 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Tue, 14 Oct 2025 14:21:30 +0000
Subject: [PATCH 08/18] Cancel download step to make test faster

---
 src/python_testing/TC_SU_2_8.py | 29 +++++++++--------------------
 1 file changed, 9 insertions(+), 20 deletions(-)

diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index b218cf81cebd2c..ea848696a724e4 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -188,6 +188,7 @@ async def test_TC_SU_2_8(self):
             discriminator=p1_disc,
             passcode=p_pass,
             ota_source=provider_ota_file,
+            kvs_path='/tmp/chip_kvs_provider',
             log_file='/tmp/provider_1.log',
             err_log_file='/tmp/provider_1.log'
         )
@@ -218,7 +219,7 @@ async def test_TC_SU_2_8(self):
         # Announce after subscription
         await self.announce_ota_provider(controller=th1, provider_node_id=p1_node, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
 
-        await asyncio.sleep(5)
+        await asyncio.sleep(2)
 
         blocks = provider_1.read_from_logs("QueryImage", before=0, after=15)
 
@@ -299,24 +300,18 @@ async def test_TC_SU_2_8(self):
         await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
                              fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
 
-        applying_event = event_cb.wait_for_event_report(
-            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
-        asserts.assert_equal(applying, applying_event.newState,
-                             f"New state is {applying_event.newState} and it should be {applying}")
-
-        event_cb.reset()
-        await event_cb.cancel()
-
         # Stop provider
         await asyncio.sleep(2)
         try:
             provider_1.terminate()
         except Exception as e:
             logging.warning(f"Provider termination raised: {e}")
-        run("rm -rf /tmp/chip_kvs", shell=True)
-        await asyncio.sleep(2)
 
         th1.ExpireSessions(nodeid=p1_node)
+        await asyncio.sleep(2)
+
+        event_cb.reset()
+        await event_cb.cancel()
 
         # Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P
         self.step(2)
@@ -331,6 +326,7 @@ async def test_TC_SU_2_8(self):
             discriminator=p2_disc,
             passcode=p_pass,
             ota_source=provider_ota_file,
+            kvs_path='/tmp/chip_kvs_provider_2',
             log_file='/tmp/provider_2.log',
             err_log_file='/tmp/provider_2.log'
         )
@@ -381,7 +377,8 @@ async def test_TC_SU_2_8(self):
         # Write default OTA providers TH1 with p1_node which does not exist
         await self.write_ota_providers(th1, p1_node_invalid, endpoint)
 
-        # Do not announce TH1-OTA Provider
+        # Announce TH1-OTA Provider
+        await self.announce_ota_provider(controller=th1, provider_node_id=p1_node_invalid, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
 
         # Expect events idle to querying, downloadError and then back to idle
         querying_event = event_cb.wait_for_event_report(
@@ -399,13 +396,6 @@ async def test_TC_SU_2_8(self):
         asserts.assert_equal(idle, idle_event.newState,
                              f"New state is {idle_event.newState} and it should be {idle}")
 
-        logging.info("Cleaning DefaultOTAProviders.")
-        resp = await th1.WriteAttribute(
-            dut_node_id,
-            [(endpoint, Clusters.Objects.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders([]))]
-        )
-        asserts.assert_equal(resp[0].Status, Status.Success, "Clean DefaultOTAProviders failed.")
-
         event_cb.reset()
         await event_cb.cancel()
         await asyncio.sleep(2)
@@ -451,7 +441,6 @@ async def test_TC_SU_2_8(self):
         except Exception as e:
             logging.warning(f"Provider termination raised: {e}")
 
-        await asyncio.sleep(2)
         th2.ExpireSessions(nodeid=p2_node)
 
 

From e1486ca9244641745fbf75df1948014bec66aa1d Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Tue, 14 Oct 2025 11:29:42 -0300
Subject: [PATCH 09/18] Remove unused variable

---
 src/python_testing/TC_SU_2_8.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index ea848696a724e4..93f6b2c430a27a 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -154,7 +154,6 @@ async def test_TC_SU_2_8(self):
         idle = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kIdle
         querying = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kQuerying
         downloading = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kDownloading
-        applying = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kApplying
 
         target_version = 3
 

From 74ae5ee2662e130001da5ef50d9a83f9db336c70 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Tue, 14 Oct 2025 11:38:46 -0300
Subject: [PATCH 10/18] Remove unused import

---
 src/python_testing/TC_SU_2_8.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index 93f6b2c430a27a..a3df6cdc3bb3ef 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -44,7 +44,6 @@
 import asyncio
 import logging
 import re
-from subprocess import run
 
 from mobly import asserts
 from TC_SUTestBase import SoftwareUpdateBaseTest

From 74bec57bb4412b24a953f8c99545221d6562d056 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 22 Oct 2025 18:48:12 +0000
Subject: [PATCH 11/18] Remove product id

---
 src/python_testing/TC_SU_2_8.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index a3df6cdc3bb3ef..11b6a96e8178e1 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -162,13 +162,11 @@ async def test_TC_SU_2_8(self):
         th1 = self.default_controller
         fabric_id_th2 = th1.fabricId + 1
         vendor_id = self.matter_test_config.admin_vendor_id
-        product_id = 32769  # Default value
 
         logging.info(f"Endpoint: {endpoint}.")
         logging.info(f"DUT Node ID: {dut_node_id}.")
         logging.info(f"Requestor Node ID: {requestor_node_id}.")
         logging.info(f"Vendor ID: {vendor_id}.")
-        logging.info(f"Product ID: {product_id}.")
 
         logging.info(f"TH1 fabric id: {th1.fabricId}.")
         logging.info(f"TH2 fabric id: {fabric_id_th2}.")

From 3dd48950eebaaeaf5191f3f7528afb74769c0334 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 29 Oct 2025 18:43:58 +0000
Subject: [PATCH 12/18] First draft

---
 examples/ota-provider-app/linux/main.cpp      | 18 +++-
 .../ota-provider-common/BUILD.gn              |  8 +-
 .../OtaProviderAppCommandDelegate.cpp         | 89 +++++++++++++++++++
 .../OtaProviderAppCommandDelegate.h           | 48 ++++++++++
 4 files changed, 161 insertions(+), 2 deletions(-)
 create mode 100644 examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
 create mode 100644 examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h

diff --git a/examples/ota-provider-app/linux/main.cpp b/examples/ota-provider-app/linux/main.cpp
index 9d9aedd0edda31..fbb63b34c9b3fd 100644
--- a/examples/ota-provider-app/linux/main.cpp
+++ b/examples/ota-provider-app/linux/main.cpp
@@ -24,6 +24,7 @@
 #include <json/json.h>
 #include <ota-provider-common/BdxOtaSender.h>
 #include <ota-provider-common/OTAProviderExample.h>
+#include <ota-provider-common/OtaProviderAppCommandDelegate.h>
 
 #include "AppMain.h"
 
@@ -59,6 +60,8 @@ constexpr uint16_t kOptionIgnoreApplyUpdate         = 'y';
 constexpr uint16_t kOptionPollInterval              = 'P';
 
 OTAProviderExample gOtaProvider;
+NamedPipeCommands sChipNamedPipeCommands;
+OtaProviderAppCommandDelegate sOtaProviderAppCommandDelegate;
 chip::ota::DefaultOTAProviderUserConsent gUserConsentProvider;
 
 // Global variables used for passing the CLI arguments to the OTAProviderExample object
@@ -403,9 +406,22 @@ void ApplicationInit()
     }
 
     chip::app::Clusters::OTAProvider::SetDelegate(kOtaProviderEndpoint, &gOtaProvider);
+
+    std::string path = std::string(LinuxDeviceOptions::GetInstance().app_pipe);
+    if ((!path.empty()) and (sChipNamedPipeCommands.Start(path, &sOtaProviderAppCommandDelegate) != CHIP_NO_ERROR))
+    {
+        ChipLogError(NotSpecified, "Failed to start CHIP NamedPipeCommand");
+        sChipNamedPipeCommands.Stop();
+    }
 }
 
-void ApplicationShutdown() {}
+void ApplicationShutdown()
+{
+    if (sChipNamedPipeCommands.Stop() != CHIP_NO_ERROR)
+    {
+        ChipLogError(NotSpecified, "Failed to stop CHIP NamedPipeCommands");
+    }
+}
 
 namespace {
 class OtaProviderAppMainLoopImplementation : public AppMainLoopImplementation
diff --git a/examples/ota-provider-app/ota-provider-common/BUILD.gn b/examples/ota-provider-app/ota-provider-common/BUILD.gn
index cf920862ca072d..40fd1fd8cd3ac4 100644
--- a/examples/ota-provider-app/ota-provider-common/BUILD.gn
+++ b/examples/ota-provider-app/ota-provider-common/BUILD.gn
@@ -17,7 +17,10 @@ import("//build_overrides/chip.gni")
 import("${chip_root}/src/app/chip_data_model.gni")
 
 config("config") {
-  include_dirs = [ ".." ]
+  include_dirs = [
+    "..",
+    "${chip_root}/examples/platform/linux",
+  ]
 }
 
 chip_data_model("ota-provider-common") {
@@ -28,9 +31,12 @@ chip_data_model("ota-provider-common") {
     "BdxOtaSender.h",
     "OTAProviderExample.cpp",
     "OTAProviderExample.h",
+    "OtaProviderAppCommandDelegate.cpp",
+    "OtaProviderAppCommandDelegate.h",
   ]
 
   deps = [
+    "${chip_root}/examples/platform/linux:app-main",
     "${chip_root}/src/app/clusters/ota-provider:user-consent",
     "${chip_root}/src/protocols/bdx",
   ]
diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
new file mode 100644
index 00000000000000..6d476644e6147f
--- /dev/null
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
@@ -0,0 +1,89 @@
+/*
+ *json
+ *    Copyright (c) 2025 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    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.
+ */
+
+#include "OtaProviderAppCommandDelegate.h"
+#include <platform/PlatformManager.h>
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::app::Clusters;
+using namespace chip::DeviceLayer;
+
+OtaProviderAppCommandHandler * OtaProviderAppCommandHandler::FromJSON(const char *)
+{
+    Json::Reader reader;
+    Json::Value value;
+
+    if (!reader.parse(json, value))
+    {
+        ChipLogError(NotSpecified,
+                     "OTA Provider Example: Error parsing JSON with error %s:", reader.getFormattedErrorMessages().c_str());
+        return nullptr;
+    }
+
+    if (value.empty() || !value.isObject())
+    {
+        ChipLogError(NotSpecified, "OTA Provider Example: Invalid JSON command received");
+        return nullptr;
+    }
+
+    if (!value.isMember("Name") || !value["Name"].isString())
+    {
+        ChipLogError(NotSpecified, "OTA Provider Example: Invalid JSON command received: command name is missing");
+        return nullptr;
+    }
+
+    return chip::Platform::New<OtaProviderAppCommandHandler>(std::move(value));
+}
+
+std::string OtaProviderAppCommandHandler::GetQueryImageResponse()
+{
+    return "Test";
+}
+
+void OtaProviderAppCommandHandler::HandleCommand(intptr_t context)
+{
+    auto * self      = reinterpret_cast<OtaProviderAppCommandHandler *>(context);
+    std::string name = self->mJsonValue["Name"].asString();
+
+    VerifyOrExit(!self->mJsonValue.empty(), ChipLogError(NotSpecified, "Invalid JSON event command received"));
+
+    if (name == "GetQueryImageResponse")
+    {
+        std::string queryImage = self->GetQueryImageResponse();
+    }
+    else
+    {
+        ChipLogError(NotSpecified, "Unhandled command: Should never happen");
+    }
+
+exit:
+    chip::Platform::Delete(self);
+}
+
+void OtaProviderAppCommandDelegate::OnEventCommandReceived(const char * json)
+{
+    auto handler = OtaProviderAppCommandHandler::FromJSON(json);
+    if (nullptr == handler)
+    {
+        ChipLogError(NotSpecified, "Camera App: Unable to instantiate a command handler");
+        return;
+    }
+
+    chip::DeviceLayer::PlatformMgr().ScheduleWork(OtaProviderAppCommandHandler::HandleCommand, reinterpret_cast<intptr_t>(handler));
+}
diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
new file mode 100644
index 00000000000000..b767c988f393d8
--- /dev/null
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
@@ -0,0 +1,48 @@
+/*
+ *
+ *    Copyright (c) 2025 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    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.
+ */
+
+#pragma once
+
+#include "NamedPipeCommands.h"
+
+#include <json/json.h>
+#include <platform/DiagnosticDataProvider.h>
+
+#include <string>
+
+class OtaProviderAppCommandHandler {
+public:
+    static OtaProviderAppCommandHandler * FromJSON(const char * json);
+
+    static void HandleCommand(intptr_t context);
+
+    OtaProviderAppCommandHandler(Json::Value && jsonValue)
+        : mJsonValue(std::move(jsonValue))
+    {
+    }
+
+private:
+    Json::Value mJsonValue;
+
+    std::string GetQueryImageResponse();
+};
+
+class OtaProviderAppCommandDelegate : public NamedPipeCommandDelegate {
+public:
+    void OnEventCommandReceived(const char * json) override;
+};

From a88d19b337213cb8e4cff185ad6f05baff18d4f5 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Thu, 30 Oct 2025 19:09:46 +0000
Subject: [PATCH 13/18] Implement write

---
 examples/ota-provider-app/linux/main.cpp      |   6 +-
 .../OtaProviderAppCommandDelegate.cpp         |   4 +-
 examples/platform/linux/NamedPipeCommands.cpp |  47 +++++-
 examples/platform/linux/NamedPipeCommands.h   |  11 +-
 examples/platform/linux/Options.h             |  40 ++---
 src/python_testing/TC_SU_2_8.py               | 143 +++++++++---------
 .../matter/testing/matter_test_config.py      |   1 +
 .../matter/testing/matter_testing.py          |  20 +++
 .../matter/testing/runner.py                  |  12 +-
 9 files changed, 178 insertions(+), 106 deletions(-)

diff --git a/examples/ota-provider-app/linux/main.cpp b/examples/ota-provider-app/linux/main.cpp
index fbb63b34c9b3fd..c76c6679e70c8b 100644
--- a/examples/ota-provider-app/linux/main.cpp
+++ b/examples/ota-provider-app/linux/main.cpp
@@ -407,8 +407,10 @@ void ApplicationInit()
 
     chip::app::Clusters::OTAProvider::SetDelegate(kOtaProviderEndpoint, &gOtaProvider);
 
-    std::string path = std::string(LinuxDeviceOptions::GetInstance().app_pipe);
-    if ((!path.empty()) and (sChipNamedPipeCommands.Start(path, &sOtaProviderAppCommandDelegate) != CHIP_NO_ERROR))
+    std::string path     = std::string(LinuxDeviceOptions::GetInstance().app_pipe);
+    std::string path_out = std::string(LinuxDeviceOptions::GetInstance().app_pipe_out);
+
+    if ((!path.empty()) and (sChipNamedPipeCommands.Start(path, path_out, &sOtaProviderAppCommandDelegate) != CHIP_NO_ERROR))
     {
         ChipLogError(NotSpecified, "Failed to start CHIP NamedPipeCommand");
         sChipNamedPipeCommands.Stop();
diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
index 6d476644e6147f..ba0fd92f0387ea 100644
--- a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
@@ -24,7 +24,7 @@ using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::DeviceLayer;
 
-OtaProviderAppCommandHandler * OtaProviderAppCommandHandler::FromJSON(const char *)
+OtaProviderAppCommandHandler * OtaProviderAppCommandHandler::FromJSON(const char * json)
 {
     Json::Reader reader;
     Json::Value value;
@@ -81,7 +81,7 @@ void OtaProviderAppCommandDelegate::OnEventCommandReceived(const char * json)
     auto handler = OtaProviderAppCommandHandler::FromJSON(json);
     if (nullptr == handler)
     {
-        ChipLogError(NotSpecified, "Camera App: Unable to instantiate a command handler");
+        ChipLogError(NotSpecified, "OTA Provider App: Unable to instantiate a command handler");
         return;
     }
 
diff --git a/examples/platform/linux/NamedPipeCommands.cpp b/examples/platform/linux/NamedPipeCommands.cpp
index e07ea242f0faae..94fb15b589c69a 100644
--- a/examples/platform/linux/NamedPipeCommands.cpp
+++ b/examples/platform/linux/NamedPipeCommands.cpp
@@ -35,9 +35,10 @@ CHIP_ERROR NamedPipeCommands::Start(std::string & path, NamedPipeCommandDelegate
     VerifyOrReturnError(!mStarted, CHIP_NO_ERROR);
     VerifyOrReturnError(delegate != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
 
-    mStarted           = true;
-    mDelegate          = delegate;
-    mChipEventFifoPath = path;
+    mStarted              = true;
+    mDelegate             = delegate;
+    mChipEventFifoPath    = path;
+    mChipEventFifoPathOut = "";
 
     // Creating the named file(FIFO)
     VerifyOrReturnError((mkfifo(path.c_str(), 0666) == 0) || (errno == EEXIST), CHIP_ERROR_OPEN_FAILED);
@@ -48,6 +49,27 @@ CHIP_ERROR NamedPipeCommands::Start(std::string & path, NamedPipeCommandDelegate
     return CHIP_NO_ERROR;
 }
 
+CHIP_ERROR NamedPipeCommands::Start(std::string & path, std::string & path_out, NamedPipeCommandDelegate * delegate)
+{
+    VerifyOrReturnError(!mStarted, CHIP_NO_ERROR);
+    VerifyOrReturnError(delegate != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    mStarted              = true;
+    mDelegate             = delegate;
+    mChipEventFifoPath    = path;
+    mChipEventFifoPathOut = path_out;
+
+    // Creating the named file(FIFO)
+    VerifyOrReturnError((mkfifo(path.c_str(), 0666) == 0) || (errno == EEXIST), CHIP_ERROR_OPEN_FAILED);
+    VerifyOrReturnError(
+        pthread_create(&mChipEventCommandListener, nullptr, EventCommandListenerTask, reinterpret_cast<void *>(this)) == 0,
+        CHIP_ERROR_UNEXPECTED_EVENT);
+
+    VerifyOrReturnError((mkfifo(path_out.c_str(), 0666) == 0) || (errno == EEXIST), CHIP_ERROR_OPEN_FAILED);
+
+    return CHIP_NO_ERROR;
+}
+
 CHIP_ERROR NamedPipeCommands::Stop()
 {
     VerifyOrReturnError(mStarted, CHIP_NO_ERROR);
@@ -63,9 +85,28 @@ CHIP_ERROR NamedPipeCommands::Stop()
     VerifyOrReturnError(unlink(mChipEventFifoPath.c_str()) == 0, CHIP_ERROR_WRITE_FAILED);
     mChipEventFifoPath.clear();
 
+    if (mChipEventFifoPath != "")
+    {
+        VerifyOrReturnError(unlink(mChipEventFifoPathOut.c_str()) == 0, CHIP_ERROR_WRITE_FAILED);
+        mChipEventFifoPathOut.clear();
+    }
+
     return CHIP_NO_ERROR;
 }
 
+void NamedPipeCommands::WriteToOutPipe()
+{
+    // NamedPipeCommands * self = reinterpret_cast<NamedPipeCommands *>(arg);
+    //
+    // int fd = open(self->mChipEventFifoPathOut.c_str(), O_RDONLY);
+    // if (fd == -1)
+    // {
+    //     ChipLogError(NotSpecified, "Failed to open Event FIFO");
+    //     break;
+    // }
+    // write(fd, data, kChipEventCmdBufSize);
+}
+
 void * NamedPipeCommands::EventCommandListenerTask(void * arg)
 {
     char readbuf[kChipEventCmdBufSize];
diff --git a/examples/platform/linux/NamedPipeCommands.h b/examples/platform/linux/NamedPipeCommands.h
index ceacec36ca5593..9cccf3af06d486 100644
--- a/examples/platform/linux/NamedPipeCommands.h
+++ b/examples/platform/linux/NamedPipeCommands.h
@@ -22,24 +22,25 @@
 #include <pthread.h>
 #include <string>
 
-class NamedPipeCommandDelegate
-{
+class NamedPipeCommandDelegate {
 public:
-    virtual ~NamedPipeCommandDelegate()                    = default;
+    virtual ~NamedPipeCommandDelegate() = default;
     virtual void OnEventCommandReceived(const char * json) = 0;
 };
 
-class NamedPipeCommands
-{
+class NamedPipeCommands {
 public:
     CHIP_ERROR Start(std::string & path, NamedPipeCommandDelegate * delegate);
+    CHIP_ERROR Start(std::string & path, std::string & path_out, NamedPipeCommandDelegate * delegate);
     CHIP_ERROR Stop();
 
 private:
     bool mStarted = false;
     pthread_t mChipEventCommandListener;
     std::string mChipEventFifoPath;
+    std::string mChipEventFifoPathOut;
     NamedPipeCommandDelegate * mDelegate = nullptr;
 
     static void * EventCommandListenerTask(void * arg);
+    void WriteToOutPipe();
 };
diff --git a/examples/platform/linux/Options.h b/examples/platform/linux/Options.h
index ae6c1b7afa4e9f..b40b305131c177 100644
--- a/examples/platform/linux/Options.h
+++ b/examples/platform/linux/Options.h
@@ -45,44 +45,44 @@
 #include <access/AccessRestrictionProvider.h>
 #endif
 
-struct LinuxDeviceOptions
-{
+struct LinuxDeviceOptions {
     chip::PayloadContents payload;
     chip::Optional<uint16_t> discriminator;
     chip::Optional<std::vector<uint8_t>> spake2pVerifier;
     chip::Optional<std::vector<uint8_t>> spake2pSalt;
     chip::Optional<std::string> dacProviderFile;
     uint32_t spake2pIterations = 0; // When not provided (0), will default elsewhere
-    uint32_t mBleDevice        = 0;
-    bool wifiSupports5g        = false;
-    bool mWiFi                 = false;
-    bool mThread               = false;
-    bool cameraDeferredOffer   = false;
-    bool cameraTestVideosrc    = false;
-    bool cameraTestAudiosrc    = false;
-    bool cameraAudioPlayback   = false;
+    uint32_t mBleDevice = 0;
+    bool wifiSupports5g = false;
+    bool mWiFi = false;
+    bool mThread = false;
+    bool cameraDeferredOffer = false;
+    bool cameraTestVideosrc = false;
+    bool cameraTestAudiosrc = false;
+    bool cameraAudioPlayback = false;
     chip::Optional<std::string> cameraVideoDevice;
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
-    bool mWiFiPAF                = false;
+    bool mWiFiPAF = false;
     const char * mWiFiPAFExtCmds = nullptr;
-    uint32_t mPublishId          = 0;
+    uint32_t mPublishId = 0;
 #endif
 #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE || CHIP_DEVICE_ENABLE_PORT_PARAMS
-    uint16_t securedDevicePort         = CHIP_PORT;
+    uint16_t securedDevicePort = CHIP_PORT;
     uint16_t unsecuredCommissionerPort = CHIP_UDC_PORT;
 #endif // CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE || CHIP_DEVICE_ENABLE_PORT_PARAMS
 #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE
-    uint16_t securedCommissionerPort    = CHIP_PORT + 12; // TODO: why + 12?
+    uint16_t securedCommissionerPort = CHIP_PORT + 12; // TODO: why + 12?
     chip::FabricId commissionerFabricId = chip::kUndefinedFabricId;
 #endif // CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE
-    const char * command                = nullptr;
-    const char * PICS                   = nullptr;
-    const char * KVS                    = nullptr;
-    const char * app_pipe               = "";
+    const char * command = nullptr;
+    const char * PICS = nullptr;
+    const char * KVS = nullptr;
+    const char * app_pipe = "";
+    const char * app_pipe_out = "";
     chip::Inet::InterfaceId interfaceId = chip::Inet::InterfaceId::Null();
 #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
     bool traceStreamDecodeEnabled = false;
-    bool traceStreamToLogEnabled  = false;
+    bool traceStreamToLogEnabled = false;
     chip::Optional<std::string> traceStreamFilename;
 #endif // CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
     chip::Credentials::DeviceAttestationCredentialsProvider * dacProvider = nullptr;
@@ -94,7 +94,7 @@ struct LinuxDeviceOptions
     uint16_t rpcServerPort = 33000;
 #endif
 #if CONFIG_BUILD_FOR_HOST_UNIT_TEST
-    int32_t subscriptionCapacity                   = CHIP_IM_MAX_NUM_SUBSCRIPTIONS;
+    int32_t subscriptionCapacity = CHIP_IM_MAX_NUM_SUBSCRIPTIONS;
     int32_t subscriptionResumptionRetryIntervalSec = -1;
 #endif
 #if CHIP_CONFIG_USE_ACCESS_RESTRICTIONS
diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index 11b6a96e8178e1..f0633ece857d2a 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -217,79 +217,76 @@ async def test_TC_SU_2_8(self):
 
         await asyncio.sleep(2)
 
-        blocks = provider_1.read_from_logs("QueryImage", before=0, after=15)
-
-        parsed = {}
-        for b in blocks:
-            info = self.parse_query_block(b)
-            for k, v in info.items():
-                parsed.setdefault(k, v)
-
-        logging.info(f"Parsed fields: {parsed}")
-
-        # Check VendorID
-        vendor_id_basic_information = await self.read_single_attribute_check_success(
-            dev_ctrl=th1,
-            cluster=Clusters.BasicInformation,
-            attribute=Clusters.BasicInformation.Attributes.VendorID
-        )
-
-        asserts.assert_equal(vendor_id_basic_information,
-                             parsed['vendor_id'], f"Vendor ID is {parsed['vendor_id']} and it should be {vendor_id_basic_information}")
-
-        # Check ProductID
-        product_id_basic_information = await self.read_single_attribute_check_success(
-            dev_ctrl=th1,
-            cluster=Clusters.BasicInformation,
-            attribute=Clusters.BasicInformation.Attributes.ProductID
-        )
-
-        asserts.assert_equal(product_id_basic_information,
-                             parsed['product_id'], f"Product ID is {parsed['product_id']} and it should be {product_id_basic_information}")
-
-        # Check HardwareVersion
-        hardware_version_basic_information = await self.read_single_attribute_check_success(
-            dev_ctrl=th1,
-            cluster=Clusters.BasicInformation,
-            attribute=Clusters.BasicInformation.Attributes.HardwareVersion
-        )
-
-        asserts.assert_equal(hardware_version_basic_information,
-                             parsed['hardware_version'], f"Hardware Version is {parsed['hardware_version']} and it should be {hardware_version_basic_information}")
-
-        # Check SoftwareVersion
-        software_version_basic_information = await self.read_single_attribute_check_success(
-            dev_ctrl=th1,
-            cluster=Clusters.BasicInformation,
-            attribute=Clusters.BasicInformation.Attributes.SoftwareVersion
-        )
-
-        asserts.assert_equal(software_version_basic_information,
-                             parsed['software_version'], f"Software Version is {parsed['software_version']} and it should be {software_version_basic_information}")
-
-        # Check ProtocolsSupported protocols_supported
-        asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous in parsed['protocols_supported'],
-                            f"kBDXSynchronous: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
-
-        # Check MCORE.OTA.HTTPS
-        if self.check_pics("MCORE.OTA.HTTPS"):
-            asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps in parsed['protocols_supported'],
-                                f"kHttps: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
-
-        # Check RequestorCanConsent
-        asserts.assert_equal(parsed['requestor_can_consent'], 0,
-                             f"Requestor Can Consent is {parsed['requestor_can_consent']} instead of 0")
-
-        # Check Location
-        if parsed['location']:
-            location_basic_information = await self.read_single_attribute_check_success(
-                dev_ctrl=th1,
-                cluster=Clusters.BasicInformation,
-                attribute=Clusters.BasicInformation.Attributes.Location
-            )
-
-            asserts.assert_equal(location_basic_information,
-                                 parsed['location'], f"Location is {parsed['location']} and it should be {location_basic_information}")
+        command = {"Name": "GetQueryImageResponse"}
+        fifo_out = "/tmp/fifo_out_2_8"
+        self.write_to_app_pipe(command)
+        response_data = self.read_from_app_pipe('GetQueryImageResponse', fifo_out)
+
+        logging.info(f"Response data: {response_data}")
+
+        # # Check VendorID
+        # vendor_id_basic_information = await self.read_single_attribute_check_success(
+        #     dev_ctrl=th1,
+        #     cluster=Clusters.BasicInformation,
+        #     attribute=Clusters.BasicInformation.Attributes.VendorID
+        # )
+
+        # asserts.assert_equal(vendor_id_basic_information,
+        #                      parsed['vendor_id'], f"Vendor ID is {parsed['vendor_id']} and it should be {vendor_id_basic_information}")
+
+        # # Check ProductID
+        # product_id_basic_information = await self.read_single_attribute_check_success(
+        #     dev_ctrl=th1,
+        #     cluster=Clusters.BasicInformation,
+        #     attribute=Clusters.BasicInformation.Attributes.ProductID
+        # )
+
+        # asserts.assert_equal(product_id_basic_information,
+        #                      parsed['product_id'], f"Product ID is {parsed['product_id']} and it should be {product_id_basic_information}")
+
+        # # Check HardwareVersion
+        # hardware_version_basic_information = await self.read_single_attribute_check_success(
+        #     dev_ctrl=th1,
+        #     cluster=Clusters.BasicInformation,
+        #     attribute=Clusters.BasicInformation.Attributes.HardwareVersion
+        # )
+
+        # asserts.assert_equal(hardware_version_basic_information,
+        #                      parsed['hardware_version'], f"Hardware Version is {parsed['hardware_version']} and it should be {hardware_version_basic_information}")
+
+        # # Check SoftwareVersion
+        # software_version_basic_information = await self.read_single_attribute_check_success(
+        #     dev_ctrl=th1,
+        #     cluster=Clusters.BasicInformation,
+        #     attribute=Clusters.BasicInformation.Attributes.SoftwareVersion
+        # )
+
+        # asserts.assert_equal(software_version_basic_information,
+        #                      parsed['software_version'], f"Software Version is {parsed['software_version']} and it should be {software_version_basic_information}")
+
+        # # Check ProtocolsSupported protocols_supported
+        # asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous in parsed['protocols_supported'],
+        #                     f"kBDXSynchronous: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
+
+        # # Check MCORE.OTA.HTTPS
+        # if self.check_pics("MCORE.OTA.HTTPS"):
+        #     asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps in parsed['protocols_supported'],
+        #                         f"kHttps: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
+
+        # # Check RequestorCanConsent
+        # asserts.assert_equal(parsed['requestor_can_consent'], 0,
+        #                      f"Requestor Can Consent is {parsed['requestor_can_consent']} instead of 0")
+
+        # # Check Location
+        # if parsed['location']:
+        #     location_basic_information = await self.read_single_attribute_check_success(
+        #         dev_ctrl=th1,
+        #         cluster=Clusters.BasicInformation,
+        #         attribute=Clusters.BasicInformation.Attributes.Location
+        #     )
+
+        #     asserts.assert_equal(location_basic_information,
+        #                          parsed['location'], f"Location is {parsed['location']} and it should be {location_basic_information}")
 
         # Event Handler
         event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_test_config.py b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_test_config.py
index 83dbad25b08ef8..e7d456bdacd755 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_test_config.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_test_config.py
@@ -40,6 +40,7 @@ class MatterTestConfig:
     endpoint: typing.Union[int, None] = 0
     app_pid: int = 0
     pipe_name: typing.Union[str, None] = None
+    pipe_name_out: typing.Union[str, None] = None
     fail_on_skipped_tests: bool = False
 
     commissioning_method: Optional[str] = None
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
index a9bed0941cabe9..db74cd9d53a801 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
@@ -970,6 +970,26 @@ async def write_single_attribute(self, attribute_value: ClusterObjects.ClusterAt
                                  f"Expected write success for write to attribute {attribute_value} on endpoint {endpoint_id}")
         return write_result[0].Status
 
+    def read_from_app_pipe(self, app_pipe_out: Optional[str] = None):
+        # If is not empty from the args, verify if the fifo file exists.
+        if app_pipe_out is not None and not os.path.exists(app_pipe_out):
+            LOGGER.error("Named pipe %r does NOT exist" % app_pipe_out)
+            raise FileNotFoundError("CANNOT FIND %r" % app_pipe_out)
+
+        if app_pipe_out is None:
+            app_pipe_out = self.matter_test_config.pipe_name_out
+
+        if not isinstance(app_pipe_out, str):
+            raise TypeError("The named pipe must be provided as a string value")
+
+        data = ""
+
+        with open(app_pipe_out, "r") as app_pipe_fp:
+            LOGGER.info(f"Reading out-of-band command response to file: {app_pipe_out}")
+            data = json.load(app_pipe_out)
+
+        return data
+
     def write_to_app_pipe(self, command_dict: dict, app_pipe: Optional[str] = None):
         """
         Send an out-of-band command to a Matter app.
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py b/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py
index 7850a3457532b8..9d6261019ad6a5 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py
@@ -748,6 +748,13 @@ def convert_args_to_matter_config(args: argparse.Namespace):
         LOGGER.error("Named pipe %r does NOT exist" % config.pipe_name)
         raise FileNotFoundError("CANNOT FIND %r" % config.pipe_name)
 
+    config.pipe_name_out = args.pipe_name_out
+    if config.pipe_name_out is not None and not os.path.exists(config.pipe_name_out):
+        # Named pipes are unique, so we MUST have consistent paths
+        # Verify from start the named pipe exists.
+        LOGGER.error("Named pipe %r does NOT exist" % config.pipe_name_out)
+        raise FileNotFoundError("CANNOT FIND %r" % config.pipe_name_out)
+
     config.fail_on_skipped_tests = args.fail_on_skipped
 
     config.legacy = args.use_legacy_test_event_triggers
@@ -806,7 +813,10 @@ def parse_matter_test_args(argv: Optional[List[str]] = None):
                              help='Node ID for primary DUT communication, '
                              'and NodeID to assign if commissioning (default: %d)' % TestingDefaults.DUT_NODE_ID, nargs="+")
     basic_group.add_argument('--endpoint', type=int, default=None, help="Endpoint under test")
-    basic_group.add_argument('--app-pipe', type=str, default=None, help="The full path of the app to send an out-of-band command")
+    basic_group.add_argument('--app-pipe', type=str, default=None,
+                             help="The full path of the app to receive an out-of-band command")
+    basic_group.add_argument('--app-pipe-out', type=str, default=None,
+                             help="The full path of the app to send an out-of-band command")
     basic_group.add_argument('--restart-flag-file', type=str, default=None,
                              help="The full path of the file to use to signal a restart to the app")
     basic_group.add_argument('--timeout', type=int, help="Test timeout in seconds")

From e94bb95b88b9aae31ffa90d8073de2f60f20d0e2 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Tue, 4 Nov 2025 17:09:41 +0000
Subject: [PATCH 14/18] Adding write to pipe out functionality

---
 examples/ota-provider-app/linux/main.cpp      |   4 +
 .../OtaProviderAppCommandDelegate.cpp         |  54 +++-
 .../OtaProviderAppCommandDelegate.h           |  18 +-
 examples/platform/linux/NamedPipeCommands.cpp |  28 +-
 examples/platform/linux/NamedPipeCommands.h   |   4 +-
 examples/platform/linux/Options.cpp           |   9 +
 src/python_testing/TC_SU_2_8.py               | 299 ++++++++----------
 .../matter/testing/apps.py                    |  15 +-
 .../matter/testing/matter_testing.py          |   4 +-
 .../matter/testing/runner.py                  |   2 +-
 .../matter/typings/matter/testing/apps.pyi    |   4 +-
 11 files changed, 248 insertions(+), 193 deletions(-)

diff --git a/examples/ota-provider-app/linux/main.cpp b/examples/ota-provider-app/linux/main.cpp
index c76c6679e70c8b..754169a7b971c6 100644
--- a/examples/ota-provider-app/linux/main.cpp
+++ b/examples/ota-provider-app/linux/main.cpp
@@ -415,6 +415,10 @@ void ApplicationInit()
         ChipLogError(NotSpecified, "Failed to start CHIP NamedPipeCommand");
         sChipNamedPipeCommands.Stop();
     }
+    else
+    {
+        sOtaProviderAppCommandDelegate.SetPipes(&sChipNamedPipeCommands);
+    }
 }
 
 void ApplicationShutdown()
diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
index ba0fd92f0387ea..7553ae1bb2a232 100644
--- a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
@@ -24,7 +24,7 @@ using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::DeviceLayer;
 
-OtaProviderAppCommandHandler * OtaProviderAppCommandHandler::FromJSON(const char * json)
+OtaProviderAppCommandHandler * OtaProviderAppCommandHandler::FromJSON(const char * json, OtaProviderAppCommandDelegate * delegate)
 {
     Json::Reader reader;
     Json::Value value;
@@ -48,24 +48,60 @@ OtaProviderAppCommandHandler * OtaProviderAppCommandHandler::FromJSON(const char
         return nullptr;
     }
 
-    return chip::Platform::New<OtaProviderAppCommandHandler>(std::move(value));
+    return chip::Platform::New<OtaProviderAppCommandHandler>(std::move(value), delegate);
 }
 
-std::string OtaProviderAppCommandHandler::GetQueryImageResponse()
+static std::string ToString(const Json::Value & v)
 {
-    return "Test";
+    Json::StreamWriterBuilder w;
+    w["identation"] = "";
+    return Json::writeString(w, v);
+}
+
+Json::Value OtaProviderAppCommandHandler::BuildOtaProviderSnapshot(uint16_t endpoint)
+{
+    Json::Value payload(Json::objectValue);
+
+    payload["QueryImageStatus"] = "Test"; // static_cast<uint32_t>(gQueryImageStatus);
+
+    return payload;
 }
 
 void OtaProviderAppCommandHandler::HandleCommand(intptr_t context)
 {
-    auto * self      = reinterpret_cast<OtaProviderAppCommandHandler *>(context);
-    std::string name = self->mJsonValue["Name"].asString();
+    auto * self = reinterpret_cast<OtaProviderAppCommandHandler *>(context);
+    std::string name;
+    std::string cluster;
+    uint16_t endpoint                        = 0;
+    OtaProviderAppCommandDelegate * delegate = nullptr;
 
     VerifyOrExit(!self->mJsonValue.empty(), ChipLogError(NotSpecified, "Invalid JSON event command received"));
 
-    if (name == "GetQueryImageResponse")
+    name     = self->mJsonValue["Name"].asString();
+    cluster  = self->mJsonValue.get("Cluster", "").asString();
+    endpoint = static_cast<uint16_t>(self->mJsonValue.get("Endpoint", 0).asUInt());
+    delegate = self->mDelegate;
+
+    if (name == "Snapshot")
     {
-        std::string queryImage = self->GetQueryImageResponse();
+        Json::Value out(Json::objectValue);
+        out["Name"]     = "SnapshotResponse";
+        out["Cluster"]  = cluster;
+        out["Endpoint"] = endpoint;
+
+        if (cluster == "OtaSoftwareUpdateProvider")
+        {
+            out["Payload"] = self->BuildOtaProviderSnapshot(endpoint);
+        }
+        else
+        {
+            out["Error"] = "Unsupported cluster for snapshot";
+        }
+
+        if (delegate && delegate->GetPipes())
+        {
+            delegate->GetPipes()->WriteToOutPipe(ToString(out));
+        }
     }
     else
     {
@@ -78,7 +114,7 @@ void OtaProviderAppCommandHandler::HandleCommand(intptr_t context)
 
 void OtaProviderAppCommandDelegate::OnEventCommandReceived(const char * json)
 {
-    auto handler = OtaProviderAppCommandHandler::FromJSON(json);
+    auto handler = OtaProviderAppCommandHandler::FromJSON(json, this);
     if (nullptr == handler)
     {
         ChipLogError(NotSpecified, "OTA Provider App: Unable to instantiate a command handler");
diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
index b767c988f393d8..c3c1f432cd6b33 100644
--- a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
@@ -25,24 +25,32 @@
 
 #include <string>
 
+class OtaProviderAppCommandDelegate;
+
 class OtaProviderAppCommandHandler {
 public:
-    static OtaProviderAppCommandHandler * FromJSON(const char * json);
+    static OtaProviderAppCommandHandler * FromJSON(const char * json, OtaProviderAppCommandDelegate * delegate);
 
     static void HandleCommand(intptr_t context);
+    Json::Value BuildOtaProviderSnapshot(uint16_t endpoint);
 
-    OtaProviderAppCommandHandler(Json::Value && jsonValue)
-        : mJsonValue(std::move(jsonValue))
+    OtaProviderAppCommandHandler(Json::Value && v, OtaProviderAppCommandDelegate * d)
+        : mJsonValue(std::move(v))
+        , mDelegate(d)
     {
     }
 
 private:
     Json::Value mJsonValue;
-
-    std::string GetQueryImageResponse();
+    OtaProviderAppCommandDelegate * mDelegate = nullptr;
 };
 
 class OtaProviderAppCommandDelegate : public NamedPipeCommandDelegate {
 public:
     void OnEventCommandReceived(const char * json) override;
+    void SetPipes(NamedPipeCommands * pipes) { mPipes = pipes; }
+    NamedPipeCommands * GetPipes() const { return mPipes; }
+
+private:
+    NamedPipeCommands * mPipes = nullptr;
 };
diff --git a/examples/platform/linux/NamedPipeCommands.cpp b/examples/platform/linux/NamedPipeCommands.cpp
index 94fb15b589c69a..b4106351350ff8 100644
--- a/examples/platform/linux/NamedPipeCommands.cpp
+++ b/examples/platform/linux/NamedPipeCommands.cpp
@@ -67,6 +67,9 @@ CHIP_ERROR NamedPipeCommands::Start(std::string & path, std::string & path_out,
 
     VerifyOrReturnError((mkfifo(path_out.c_str(), 0666) == 0) || (errno == EEXIST), CHIP_ERROR_OPEN_FAILED);
 
+    mOutFd = open(path_out.c_str(), O_RDWR | O_NONBLOCK);
+    VerifyOrReturnError(mOutFd != -1, CHIP_ERROR_OPEN_FAILED);
+
     return CHIP_NO_ERROR;
 }
 
@@ -82,10 +85,16 @@ CHIP_ERROR NamedPipeCommands::Stop()
     // Wait further for the thread to terminate if we had previously created it.
     VerifyOrReturnError(pthread_join(mChipEventCommandListener, nullptr) == 0, CHIP_ERROR_SHUT_DOWN);
 
+    if (mOutFd != -1)
+    {
+        close(mOutFd);
+        mOutFd = -1;
+    }
+
     VerifyOrReturnError(unlink(mChipEventFifoPath.c_str()) == 0, CHIP_ERROR_WRITE_FAILED);
     mChipEventFifoPath.clear();
 
-    if (mChipEventFifoPath != "")
+    if (!mChipEventFifoPath.empty())
     {
         VerifyOrReturnError(unlink(mChipEventFifoPathOut.c_str()) == 0, CHIP_ERROR_WRITE_FAILED);
         mChipEventFifoPathOut.clear();
@@ -94,17 +103,14 @@ CHIP_ERROR NamedPipeCommands::Stop()
     return CHIP_NO_ERROR;
 }
 
-void NamedPipeCommands::WriteToOutPipe()
+void NamedPipeCommands::WriteToOutPipe(const std::string & json)
 {
-    // NamedPipeCommands * self = reinterpret_cast<NamedPipeCommands *>(arg);
-    //
-    // int fd = open(self->mChipEventFifoPathOut.c_str(), O_RDONLY);
-    // if (fd == -1)
-    // {
-    //     ChipLogError(NotSpecified, "Failed to open Event FIFO");
-    //     break;
-    // }
-    // write(fd, data, kChipEventCmdBufSize);
+    if (mOutFd == -1 || json.empty())
+        return;
+
+    (void) write(mOutFd, json.c_str(), json.size());
+    (void) write(mOutFd, "\n", 1);
+    close(mOutFd);
 }
 
 void * NamedPipeCommands::EventCommandListenerTask(void * arg)
diff --git a/examples/platform/linux/NamedPipeCommands.h b/examples/platform/linux/NamedPipeCommands.h
index 9cccf3af06d486..785402072f5982 100644
--- a/examples/platform/linux/NamedPipeCommands.h
+++ b/examples/platform/linux/NamedPipeCommands.h
@@ -33,6 +33,8 @@ class NamedPipeCommands {
     CHIP_ERROR Start(std::string & path, NamedPipeCommandDelegate * delegate);
     CHIP_ERROR Start(std::string & path, std::string & path_out, NamedPipeCommandDelegate * delegate);
     CHIP_ERROR Stop();
+    void WriteToOutPipe(const std::string & json);
+    const std::string & OutPath() const { return mChipEventFifoPathOut; }
 
 private:
     bool mStarted = false;
@@ -40,7 +42,7 @@ class NamedPipeCommands {
     std::string mChipEventFifoPath;
     std::string mChipEventFifoPathOut;
     NamedPipeCommandDelegate * mDelegate = nullptr;
+    int mOutFd = -1;
 
     static void * EventCommandListenerTask(void * arg);
-    void WriteToOutPipe();
 };
diff --git a/examples/platform/linux/Options.cpp b/examples/platform/linux/Options.cpp
index d9987460651b25..324824b94fef70 100644
--- a/examples/platform/linux/Options.cpp
+++ b/examples/platform/linux/Options.cpp
@@ -93,6 +93,7 @@ enum
     kDeviceOption_KVS,
     kDeviceOption_InterfaceId,
     kDeviceOption_AppPipe,
+    kDeviceOption_AppPipeOut,
     kDeviceOption_Spake2pVerifierBase64,
     kDeviceOption_Spake2pSaltBase64,
     kDeviceOption_Spake2pIterations,
@@ -201,6 +202,7 @@ OptionDef sDeviceOptionDefs[] = {
     { "KVS", kArgumentRequired, kDeviceOption_KVS },
     { "interface-id", kArgumentRequired, kDeviceOption_InterfaceId },
     { "app-pipe", kArgumentRequired, kDeviceOption_AppPipe },
+    { "app-pipe-out", kArgumentRequired, kDeviceOption_AppPipeOut },
 #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
     { "trace_file", kArgumentRequired, kDeviceOption_TraceFile },
     { "trace_log", kArgumentRequired, kDeviceOption_TraceLog },
@@ -364,6 +366,9 @@ const char * sDeviceOptionHelp =
     "\n"
     "  --app-pipe <filepath>\n"
     "       Custom path for the current application to send out of band commands.\n"
+    "\n"
+    "  --app-pipe-out <filepath>\n"
+    "       Custom path for the current application to send out of band commands to the test.\n"
 #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
     "\n"
     "  --trace_file <file>\n"
@@ -715,6 +720,10 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier,
         LinuxDeviceOptions::GetInstance().app_pipe = aValue;
         break;
 
+    case kDeviceOption_AppPipeOut:
+        LinuxDeviceOptions::GetInstance().app_pipe_out = aValue;
+        break;
+
     case kDeviceOption_InterfaceId:
         LinuxDeviceOptions::GetInstance().interfaceId =
             Inet::InterfaceId(static_cast<chip::Inet::InterfaceId::PlatformType>(atoi(aValue)));
diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index f0633ece857d2a..607b8cb18b7e38 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -102,34 +102,13 @@ def steps_TC_SU_2_8(self) -> list[TestStep]:
                      "Verify the field ProtocolsSupported lists the BDX Synchronous protocol."
                      "If (MCORE.OTA.HTTPS_Supported) HTTPS protocol should be listed."
                      "Verify the default value of RequestorCanConsent is set to False unless DUT sets it to True."
-                     "If the Location field is present, verify that the value is same as Basic Information Cluster Location Attribute of the DUT."),
-            TestStep(2, "Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P.",
-                     "TH1/OTA-P does not respond with QueryImage response command. StateTransition goes from idle to querying, then a download error happens and finally it goes back to idle."
-                     "Subscribe to events for OtaSoftwareUpdateRequestor cluster and verify StateTransition reaches downloading state. Also check if the targetSoftwareVersion is 3."),
+                     "If the Location field is present, verify that the value is same as Basic Information Cluster Location Attribute of the DUT.")  # ,
+            # TestStep(2, "Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P.",
+            #          "TH1/OTA-P does not respond with QueryImage response command. StateTransition goes from idle to querying, then a download error happens and finally it goes back to idle."
+            #          "Subscribe to events for OtaSoftwareUpdateRequestor cluster and verify StateTransition reaches downloading state. Also check if the targetSoftwareVersion is 3."),
         ]
         return steps
 
-    def parse_query_block(self, block: dict) -> dict:
-        text = ANSI_RE.sub("", '\n'.join(block.get("after", [])))
-
-        out = {}
-
-        for name, rx in FIELDS.items():
-            m = rx.search(text)
-            if m:
-                val = m.group(1) if m.lastindex else m.group(0)
-                if name == "location":
-                    out[name] = val
-                else:
-                    out[name] = int(val, 0)
-
-        m = PROTO_RE.search(text)
-        out["protocols_supported"] = (
-            [int(n, 0) for n in HEX_OR_DEC.findall(m.group(1))] if m else []
-        )
-
-        return out
-
     @async_test_body
     async def test_TC_SU_2_8(self):
 
@@ -147,7 +126,7 @@ async def test_TC_SU_2_8(self):
         provider_port = 5540
 
         app_path = "./out/debug/chip-ota-provider-app"
-        provider_ota_file = OtaImagePath(path="firmware_v2.ota")
+        provider_ota_file = OtaImagePath(path="firmware_v3.ota")
 
         # States
         idle = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kIdle
@@ -186,7 +165,9 @@ async def test_TC_SU_2_8(self):
             ota_source=provider_ota_file,
             kvs_path='/tmp/chip_kvs_provider',
             log_file='/tmp/provider_1.log',
-            err_log_file='/tmp/provider_1.log'
+            err_log_file='/tmp/provider_1.log',
+            app_pipe='/tmp/su_2_8_fifo',
+            app_pipe_out='/tmp/su_2_8_fifo_out'
         )
 
         provider_1.start()
@@ -217,10 +198,10 @@ async def test_TC_SU_2_8(self):
 
         await asyncio.sleep(2)
 
-        command = {"Name": "GetQueryImageResponse"}
-        fifo_out = "/tmp/fifo_out_2_8"
+        command = {"Name": "Snapshot", "Cluster": "OtaSoftwareUpdateProvider", "Endpoint": 0}
+        fifo_out = "/tmp/su_2_8_fifo_out"
         self.write_to_app_pipe(command)
-        response_data = self.read_from_app_pipe('GetQueryImageResponse', fifo_out)
+        response_data = self.read_from_app_pipe(fifo_out)
 
         logging.info(f"Response data: {response_data}")
 
@@ -289,152 +270,152 @@ async def test_TC_SU_2_8(self):
         #                          parsed['location'], f"Location is {parsed['location']} and it should be {location_basic_information}")
 
         # Event Handler
-        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
-        await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
-                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+        # event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        # await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
+        #                      fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
 
         # Stop provider
-        await asyncio.sleep(2)
-        try:
-            provider_1.terminate()
-        except Exception as e:
-            logging.warning(f"Provider termination raised: {e}")
-
-        th1.ExpireSessions(nodeid=p1_node)
-        await asyncio.sleep(2)
-
-        event_cb.reset()
-        await event_cb.cancel()
+        # await asyncio.sleep(2)
+        # try:
+        #     provider_1.terminate()
+        # except Exception as e:
+        #     logging.warning(f"Provider termination raised: {e}")
+#
+        # th1.ExpireSessions(nodeid=p1_node)
+        # await asyncio.sleep(2)
+#
+        # event_cb.reset()
+        # await event_cb.cancel()
 
         # Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P
-        self.step(2)
-
-        provider_ota_file = OtaImagePath(path="firmware_v3.ota")
-
-        logging.info("Starting OTA Provider 2")
-        provider_2 = OTAProviderSubprocess(
-            app=app_path,
-            storage_dir='/tmp',
-            port=provider_port,
-            discriminator=p2_disc,
-            passcode=p_pass,
-            ota_source=provider_ota_file,
-            kvs_path='/tmp/chip_kvs_provider_2',
-            log_file='/tmp/provider_2.log',
-            err_log_file='/tmp/provider_2.log'
-        )
-
-        provider_2.start()
+        # self.step(2)
 
+        # provider_ota_file = OtaImagePath(path="firmware_v3.ota")
+#
+        # logging.info("Starting OTA Provider 2")
+        # provider_2 = OTAProviderSubprocess(
+        #    app=app_path,
+        #    storage_dir='/tmp',
+        #    port=provider_port,
+        #    discriminator=p2_disc,
+        #    passcode=p_pass,
+        #    ota_source=provider_ota_file,
+        #    kvs_path='/tmp/chip_kvs_provider_2',
+        #    log_file='/tmp/provider_2.log',
+        #    err_log_file='/tmp/provider_2.log'
+        # )
+#
+        # provider_2.start()
+#
         # Create TH2
-        logging.info("Setting up TH2.")
-        th2_certificate_auth = self.certificate_authority_manager.NewCertificateAuthority()
-        th2_fabric_admin = th2_certificate_auth.NewFabricAdmin(vendorId=vendor_id, fabricId=fabric_id_th2)
-        th2 = th2_fabric_admin.NewController(nodeId=2, useTestCommissioner=True)
-
-        logging.info("Opening commissioning window on DUT.")
-        params = await self.open_commissioning_window(th1, dut_node_id)
-
+        # logging.info("Setting up TH2.")
+        # th2_certificate_auth = self.certificate_authority_manager.NewCertificateAuthority()
+        # th2_fabric_admin = th2_certificate_auth.NewFabricAdmin(vendorId=vendor_id, fabricId=fabric_id_th2)
+        # th2 = th2_fabric_admin.NewController(nodeId=2, useTestCommissioner=True)
+#
+        # logging.info("Opening commissioning window on DUT.")
+        # params = await self.open_commissioning_window(th1, dut_node_id)
+#
         # Commission TH2/DUT (requestor)
-        resp = await th2.CommissionOnNetwork(
-            nodeId=requestor_node_id,
-            setupPinCode=params.commissioningParameters.setupPinCode,
-            filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
-            filter=params.randomDiscriminator
-        )
-
-        logging.info(f"TH2 commissioned: {resp}.")
-
+        # resp = await th2.CommissionOnNetwork(
+        #    nodeId=requestor_node_id,
+        #    setupPinCode=params.commissioningParameters.setupPinCode,
+        #    filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
+        #    filter=params.randomDiscriminator
+        # )
+#
+        # logging.info(f"TH2 commissioned: {resp}.")
+#
         # Commissioning Provider-TH2
-        logging.info("Commissioning OTA Provider to TH2")
-
-        resp = await th2.CommissionOnNetwork(
-            nodeId=p2_node,
-            setupPinCode=p_pass,
-            filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
-            filter=p2_disc
-        )
-
-        logging.info(f"Commissioning response: {resp}.")
-
+        # logging.info("Commissioning OTA Provider to TH2")
+#
+        # resp = await th2.CommissionOnNetwork(
+        #    nodeId=p2_node,
+        #    setupPinCode=p_pass,
+        #    filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
+        #    filter=p2_disc
+        # )
+#
+        # logging.info(f"Commissioning response: {resp}.")
+#
         # ACL permissions are not required
-
-        if fabric_id_th2 == th1.fabricId:
-            raise AssertionError(f"Fabric IDs are the same for TH1: {th1.fabricId} and TH2: {fabric_id_th2}.")
-
+#
+        # if fabric_id_th2 == th1.fabricId:
+        #    raise AssertionError(f"Fabric IDs are the same for TH1: {th1.fabricId} and TH2: {fabric_id_th2}.")
+#
         # Event Handler
-        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
-        await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
-                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
-
+        # event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        # await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
+        #                     fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+#
         # Write default OTA providers TH1 with p1_node which does not exist
-        await self.write_ota_providers(th1, p1_node_invalid, endpoint)
-
+        # await self.write_ota_providers(th1, p1_node_invalid, endpoint)
+#
         # Announce TH1-OTA Provider
-        await self.announce_ota_provider(controller=th1, provider_node_id=p1_node_invalid, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
-
+        # await self.announce_ota_provider(controller=th1, provider_node_id=p1_node_invalid, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
+#
         # Expect events idle to querying, downloadError and then back to idle
-        querying_event = event_cb.wait_for_event_report(
-            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
-        asserts.assert_equal(querying, querying_event.newState,
-                             f"New state is {querying_event.newState} and it should be {querying}")
-
-        download_error = event_cb.wait_for_event_report(
-            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.DownloadError, 50000)
-
-        logging.info(f"Download Error: {download_error}")
-
-        idle_event = event_cb.wait_for_event_report(
-            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 50000)
-        asserts.assert_equal(idle, idle_event.newState,
-                             f"New state is {idle_event.newState} and it should be {idle}")
-
-        event_cb.reset()
-        await event_cb.cancel()
-        await asyncio.sleep(2)
-
+        # querying_event = event_cb.wait_for_event_report(
+        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+        # asserts.assert_equal(querying, querying_event.newState,
+        #                     f"New state is {querying_event.newState} and it should be {querying}")
+#
+        # download_error = event_cb.wait_for_event_report(
+        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.DownloadError, 50000)
+#
+        # logging.info(f"Download Error: {download_error}")
+#
+        # idle_event = event_cb.wait_for_event_report(
+        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 50000)
+        # asserts.assert_equal(idle, idle_event.newState,
+        #                     f"New state is {idle_event.newState} and it should be {idle}")
+#
+        # event_cb.reset()
+        # await event_cb.cancel()
+        # await asyncio.sleep(2)
+#
         # Subscribe to events
-        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
-        await event_cb.start(dev_ctrl=th2, node_id=requestor_node_id, endpoint=endpoint,
-                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
-
+        # event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        # await event_cb.start(dev_ctrl=th2, node_id=requestor_node_id, endpoint=endpoint,
+        #                     fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+#
         # Define ACL entry
-        await self.create_acl_entry(dev_ctrl=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id)
-
+        # await self.create_acl_entry(dev_ctrl=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id)
+#
         # Write default OTA providers TH2
-        await self.write_ota_providers(th2, p2_node, endpoint)
-
+        # await self.write_ota_providers(th2, p2_node, endpoint)
+#
         # Announce after subscription
-        await self.announce_ota_provider(controller=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
-
-        event_idle_to_querying = event_cb.wait_for_event_report(
-            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
-
-        self.verify_state_transition_event(event_report=event_idle_to_querying, previous_state=idle, new_state=querying)
-
-        event_querying_to_downloading = event_cb.wait_for_event_report(
-            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
-
-        self.verify_state_transition_event(event_report=event_querying_to_downloading,
-                                           previous_state=querying, new_state=downloading, target_version=target_version)
-
-        event_cb.reset()
-        await event_cb.cancel()
-
-        logging.info("Cleaning DefaultOTAProviders.")
-        resp = await th2.WriteAttribute(
-            dut_node_id,
-            [(endpoint, Clusters.Objects.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders([]))]
-        )
-        asserts.assert_equal(resp[0].Status, Status.Success, "Clean DefaultOTAProviders failed.")
-
-        await asyncio.sleep(2)
-        try:
-            provider_2.terminate()
-        except Exception as e:
-            logging.warning(f"Provider termination raised: {e}")
-
-        th2.ExpireSessions(nodeid=p2_node)
+        # await self.announce_ota_provider(controller=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
+#
+        # event_idle_to_querying = event_cb.wait_for_event_report(
+        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+#
+        # self.verify_state_transition_event(event_report=event_idle_to_querying, previous_state=idle, new_state=querying)
+#
+        # event_querying_to_downloading = event_cb.wait_for_event_report(
+        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+#
+        # self.verify_state_transition_event(event_report=event_querying_to_downloading,
+        #                                   previous_state=querying, new_state=downloading, target_version=target_version)
+#
+        # event_cb.reset()
+        # await event_cb.cancel()
+#
+        # logging.info("Cleaning DefaultOTAProviders.")
+        # resp = await th2.WriteAttribute(
+        #    dut_node_id,
+        #    [(endpoint, Clusters.Objects.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders([]))]
+        # )
+        # asserts.assert_equal(resp[0].Status, Status.Success, "Clean DefaultOTAProviders failed.")
+#
+        # await asyncio.sleep(2)
+        # try:
+        #    provider_2.terminate()
+        # except Exception as e:
+        #    logging.warning(f"Provider termination raised: {e}")
+#
+        # th2.ExpireSessions(nodeid=p2_node)
 
 
 if __name__ == "__main__":
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py b/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py
index abe00b0486600a..aca618542c989d 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/apps.py
@@ -52,7 +52,7 @@ class AppServerSubprocess(Subprocess):
     PREFIX = b"[SERVER]"
 
     def __init__(self, app: str, storage_dir: str, discriminator: int,
-                 passcode: int, port: int = 5540, extra_args: list[str] = [], kvs_path: Optional[str] = None, f_stdout: BinaryIO = stdout.buffer, f_stderr: BinaryIO = stderr.buffer):
+                 passcode: int, port: int = 5540, extra_args: list[str] = [], kvs_path: Optional[str] = None, f_stdout: BinaryIO = stdout.buffer, f_stderr: BinaryIO = stderr.buffer, app_pipe: Optional[str] = None, app_pipe_out: Optional[str] = None):
         # Create a temporary KVS file and keep the descriptor to avoid leaks.
 
         if kvs_path is not None:
@@ -66,6 +66,15 @@ def __init__(self, app: str, storage_dir: str, discriminator: int,
             if extra_args:
                 command.extend(extra_args)
 
+            if app_pipe is not None:
+                command.extend([
+                    "--app-pipe", str(app_pipe)
+                ])
+            if app_pipe_out is not None:
+                command.extend([
+                    "--app-pipe-out", str(app_pipe_out)
+                ])
+
             command.extend([
                 "--KVS", kvs_path,
                 '--secured-device-port', str(port),
@@ -158,7 +167,7 @@ class OTAProviderSubprocess(AppServerSubprocess):
 
     def __init__(self, app: str, storage_dir: str, discriminator: int,
                  passcode: int, ota_source: Union[OtaImagePath, ImageListPath],
-                 port: int = 5541, extra_args: list[str] = [], kvs_path: Optional[str] = None, log_file: Union[str, BinaryIO] = stdout.buffer, err_log_file: Union[str, BinaryIO] = stderr.buffer):
+                 port: int = 5541, extra_args: list[str] = [], kvs_path: Optional[str] = None, log_file: Union[str, BinaryIO] = stdout.buffer, err_log_file: Union[str, BinaryIO] = stderr.buffer, app_pipe: Optional[str] = None, app_pipe_out: Optional[str] = None):
         """Initialize the OTA Provider subprocess.
 
         Args:
@@ -187,7 +196,7 @@ def __init__(self, app: str, storage_dir: str, discriminator: int,
 
         # Initialize with the combined arguments
         super().__init__(app=app, storage_dir=storage_dir, discriminator=discriminator,
-                         passcode=passcode, port=port, extra_args=combined_extra_args, kvs_path=kvs_path, f_stdout=f_stdout, f_stderr=f_stderr)
+                         passcode=passcode, port=port, extra_args=combined_extra_args, kvs_path=kvs_path, f_stdout=f_stdout, f_stderr=f_stderr, app_pipe=app_pipe, app_pipe_out=app_pipe_out)
 
     def kill(self):
         self.p.send_signal(signal.SIGKILL)
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
index db74cd9d53a801..9d2e37fd935b67 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
@@ -984,9 +984,9 @@ def read_from_app_pipe(self, app_pipe_out: Optional[str] = None):
 
         data = ""
 
-        with open(app_pipe_out, "r") as app_pipe_fp:
+        with open(app_pipe_out, "r") as app_pipe_out_fp:
             LOGGER.info(f"Reading out-of-band command response to file: {app_pipe_out}")
-            data = json.load(app_pipe_out)
+            data = json.load(app_pipe_out_fp)
 
         return data
 
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py b/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py
index 9d6261019ad6a5..21be06e3c3b30b 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/runner.py
@@ -748,7 +748,7 @@ def convert_args_to_matter_config(args: argparse.Namespace):
         LOGGER.error("Named pipe %r does NOT exist" % config.pipe_name)
         raise FileNotFoundError("CANNOT FIND %r" % config.pipe_name)
 
-    config.pipe_name_out = args.pipe_name_out
+    config.pipe_name_out = args.app_pipe_out
     if config.pipe_name_out is not None and not os.path.exists(config.pipe_name_out):
         # Named pipes are unique, so we MUST have consistent paths
         # Verify from start the named pipe exists.
diff --git a/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi b/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi
index 4d6e3db086148b..bbdcd970873e9f 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi
+++ b/src/python_testing/matter_testing_infrastructure/matter/typings/matter/testing/apps.pyi
@@ -24,7 +24,7 @@ class ImageListPath:
 class AppServerSubprocess(Subprocess):
     PREFIX: bytes
     def __init__(self, app: str, storage_dir: str, discriminator: int,
-                 passcode: int, port: int = 5540, extra_args: List[str] = ...) -> None: ...
+                 passcode: int, port: int = 5540, app_pipe: Optional[str] = None, app_pipe_out: Optional[str] = None, extra_args: List[str] = ...) -> None: ...
 
 
 class IcdAppServerSubprocess(AppServerSubprocess):
@@ -49,7 +49,7 @@ class OTAProviderSubprocess(AppServerSubprocess):
     def __init__(self, app: str, storage_dir: str, discriminator: int,
                  passcode: int, ota_source: Union[OtaImagePath, ImageListPath],
                  port: int = 5541, extra_args: list[str] = [], kvs_path: Optional[str] = None,
-                 log_file: Union[str, BinaryIO] = stdout.buffer, err_log_file: Union[str, BinaryIO] = stderr.buffer): ...
+                 log_file: Union[str, BinaryIO] = stdout.buffer, err_log_file: Union[str, BinaryIO] = stderr.buffer, app_pipe: Optional[str] = None, app_pipe_out: Optional[str] = None): ...
 
     def kill(self) -> None: ...
 

From b543e95576bc9456bfb57d8b31e47616a32d01a3 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Tue, 4 Nov 2025 18:47:52 +0000
Subject: [PATCH 15/18] Implement read fifo

---
 src/python_testing/TC_SU_2_8.py                    |  3 ++-
 .../matter/testing/matter_testing.py               | 14 +++++++++-----
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index 607b8cb18b7e38..d92b2be378c2b5 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -199,8 +199,9 @@ async def test_TC_SU_2_8(self):
         await asyncio.sleep(2)
 
         command = {"Name": "Snapshot", "Cluster": "OtaSoftwareUpdateProvider", "Endpoint": 0}
+        fifo_in = "/tmp/su_2_8_fifo"
         fifo_out = "/tmp/su_2_8_fifo_out"
-        self.write_to_app_pipe(command)
+        self.write_to_app_pipe(command, fifo_in)
         response_data = self.read_from_app_pipe(fifo_out)
 
         logging.info(f"Response data: {response_data}")
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
index 9d2e37fd935b67..2f91f770f6bbb4 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
@@ -982,13 +982,17 @@ def read_from_app_pipe(self, app_pipe_out: Optional[str] = None):
         if not isinstance(app_pipe_out, str):
             raise TypeError("The named pipe must be provided as a string value")
 
-        data = ""
+        line = ""
+        f = self.open_fifo_nonblocking(app_pipe_out)
+        LOGGER.info(f"Reading out-of-band command response to file: {app_pipe_out}")
+        line = f.readline()
+        f.close()
 
-        with open(app_pipe_out, "r") as app_pipe_out_fp:
-            LOGGER.info(f"Reading out-of-band command response to file: {app_pipe_out}")
-            data = json.load(app_pipe_out_fp)
+        return line
 
-        return data
+    def open_fifo_nonblocking(self, app_pipe_out):
+        fd = os.open(app_pipe_out, os.O_RDONLY | os.O_NONBLOCK)
+        return os.fdopen(fd, "r", buffering=1)
 
     def write_to_app_pipe(self, command_dict: dict, app_pipe: Optional[str] = None):
         """

From e530f03531b177676dc98891f057ffe4736724aa Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 5 Nov 2025 20:02:55 +0000
Subject: [PATCH 16/18] Getting real data from device

---
 .../OTAProviderExample.cpp                    | 24 +++++++++++
 .../ota-provider-common/OTAProviderExample.h  | 41 ++++++++++++-------
 .../OtaProviderAppCommandDelegate.cpp         |  9 +++-
 .../OtaProviderAppCommandDelegate.h           |  2 +
 examples/platform/linux/NamedPipeCommands.cpp |  5 +--
 src/python_testing/TC_SU_2_8.py               |  2 +-
 .../matter/testing/matter_testing.py          | 20 ++++-----
 7 files changed, 73 insertions(+), 30 deletions(-)

diff --git a/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp b/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp
index 556c64162664d7..e3c627d31f889d 100644
--- a/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp
+++ b/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp
@@ -322,11 +322,35 @@ void OTAProviderExample::SendQueryImageResponse(app::CommandHandler * commandObj
     commandObj->AddResponse(commandPath, response);
 }
 
+void OTAProviderExample::SaveCommandSnapshot(const QueryImage::DecodableType & commandData)
+{
+    mVendorId            = commandData.vendorID;
+    mProductId           = commandData.productID;
+    mHardwareVersion     = commandData.hardwareVersion.ValueOr(0);
+    mSoftwareVersion     = commandData.softwareVersion;
+    mRequestorCanConsent = commandData.requestorCanConsent.ValueOr(false);
+
+    mLocation.clear();
+    if (commandData.location.HasValue())
+    {
+        mLocation = NullTerminated(commandData.location.Value()).c_str();
+    }
+
+    mProtocolsSupported.clear();
+    auto iter = commandData.protocolsSupported.begin();
+    while (iter.Next())
+    {
+        mProtocolsSupported.push_back(iter.GetValue());
+    }
+}
+
 void OTAProviderExample::HandleQueryImage(app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
                                           const QueryImage::DecodableType & commandData)
 {
     bool requestorCanConsent = commandData.requestorCanConsent.ValueOr(false);
 
+    SaveCommandSnapshot(commandData);
+
     if (mIgnoreQueryImageCount > 0)
     {
         ChipLogDetail(SoftwareUpdate, "Skip sending QueryImageResponse, ignore count: %" PRIu32, mIgnoreQueryImageCount);
diff --git a/examples/ota-provider-app/ota-provider-common/OTAProviderExample.h b/examples/ota-provider-app/ota-provider-common/OTAProviderExample.h
index 55880151270eb7..feabb695a85b5b 100644
--- a/examples/ota-provider-app/ota-provider-common/OTAProviderExample.h
+++ b/examples/ota-provider-app/ota-provider-common/OTAProviderExample.h
@@ -29,21 +29,19 @@
 /**
  * A reference implementation for an OTA Provider. Includes a method for providing a path to a local OTA file to serve.
  */
-class OTAProviderExample : public chip::app::Clusters::OTAProviderDelegate
-{
+class OTAProviderExample : public chip::app::Clusters::OTAProviderDelegate {
 public:
     OTAProviderExample();
 
-    using OTAQueryStatus       = chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus;
+    using OTAQueryStatus = chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus;
     using OTAApplyUpdateAction = chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction;
 
     static constexpr uint16_t SW_VER_STR_MAX_LEN = 64;
-    static constexpr uint16_t OTA_URL_MAX_LEN    = 512;
-    static constexpr size_t kFilepathBufLen      = 256;
-    static constexpr size_t kUriMaxLen           = 256;
+    static constexpr uint16_t OTA_URL_MAX_LEN = 512;
+    static constexpr size_t kFilepathBufLen = 256;
+    static constexpr size_t kUriMaxLen = 256;
 
-    typedef struct DeviceSoftwareVersionModel
-    {
+    typedef struct DeviceSoftwareVersionModel {
         chip::VendorId vendorId;
         uint16_t productId;
         uint32_t softwareVersion;
@@ -91,15 +89,23 @@ class OTAProviderExample : public chip::app::Clusters::OTAProviderDelegate
 
     void SetMaxBDXBlockSize(uint16_t blockSize) { mMaxBDXBlockSize = blockSize; }
 
+    uint32_t GetVendorId() { return mVendorId; }
+    uint32_t GetProductId() { return mProductId; }
+    short unsigned int GetHardwareVersion() { return mHardwareVersion; }
+    uint32_t GetSoftwareVersion() { return mSoftwareVersion; }
+    std::vector<chip::app::Clusters::OtaSoftwareUpdateProvider::DownloadProtocolEnum> GetProtocolsSupported() { return mProtocolsSupported; }
+    bool GetRequestorCanConsent() { return mRequestorCanConsent; }
+    std::string GetLocation() { return mLocation; }
+
 private:
     bool SelectOTACandidate(const uint16_t requestorVendorID, const uint16_t requestorProductID,
-                            const uint32_t requestorSoftwareVersion,
-                            OTAProviderExample::DeviceSoftwareVersionModel & finalCandidate);
+        const uint32_t requestorSoftwareVersion,
+        OTAProviderExample::DeviceSoftwareVersionModel & finalCandidate);
 
     chip::ota::UserConsentSubject
     GetUserConsentSubject(const chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
-                          const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::DecodableType & commandData,
-                          uint32_t targetVersion);
+        const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::DecodableType & commandData,
+        uint32_t targetVersion);
 
     bool ParseOTAHeader(chip::OTAImageHeaderParser & parser, const char * otaFilePath, chip::OTAImageHeader & header);
 
@@ -108,7 +114,8 @@ class OTAProviderExample : public chip::app::Clusters::OTAProviderDelegate
      */
     void
     SendQueryImageResponse(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
-                           const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::DecodableType & commandData);
+        const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::DecodableType & commandData);
+    void SaveCommandSnapshot(const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::DecodableType & commandData);
 
     BdxOtaSender mBdxOtaSender;
     std::vector<DeviceSoftwareVersionModel> mCandidates;
@@ -122,8 +129,14 @@ class OTAProviderExample : public chip::app::Clusters::OTAProviderDelegate
     uint32_t mDelayedApplyActionTimeSec;
     chip::ota::OTAProviderUserConsentDelegate * mUserConsentDelegate;
     bool mUserConsentNeeded;
-    uint32_t mSoftwareVersion;
     char mSoftwareVersionString[SW_VER_STR_MAX_LEN];
     uint32_t mPollInterval;
     uint16_t mMaxBDXBlockSize;
+    uint32_t mVendorId;
+    uint32_t mProductId;
+    short unsigned int mHardwareVersion;
+    uint32_t mSoftwareVersion;
+    std::vector<chip::app::Clusters::OtaSoftwareUpdateProvider::DownloadProtocolEnum> mProtocolsSupported;
+    bool mRequestorCanConsent;
+    std::string mLocation;
 };
diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
index 7553ae1bb2a232..0878730a37dedb 100644
--- a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
@@ -62,7 +62,14 @@ Json::Value OtaProviderAppCommandHandler::BuildOtaProviderSnapshot(uint16_t endp
 {
     Json::Value payload(Json::objectValue);
 
-    payload["QueryImageStatus"] = "Test"; // static_cast<uint32_t>(gQueryImageStatus);
+    // payload["QueryImageStatus"]    = static_cast<uint32_t>(gOtaProvider.GetQueryImageStatus());
+    payload["VendorID"]        = gOtaProvider.GetVendorId();
+    payload["ProductID"]       = gOtaProvider.GetProductId();
+    payload["SoftwareVersion"] = gOtaProvider.GetSoftwareVersion();
+    payload["HardwareVersion"] = gOtaProvider.GetHardwareVersion();
+    // payload["ProtocolsSupported"]  = gOtaProvider.GetProtocolsSupported();
+    payload["Location"]            = gOtaProvider.GetLocation();
+    payload["RequestorCanConsent"] = gOtaProvider.GetRequestorCanConsent();
 
     return payload;
 }
diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
index c3c1f432cd6b33..1d477d8870f2f5 100644
--- a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.h
@@ -21,11 +21,13 @@
 #include "NamedPipeCommands.h"
 
 #include <json/json.h>
+#include <ota-provider-common/OTAProviderExample.h>
 #include <platform/DiagnosticDataProvider.h>
 
 #include <string>
 
 class OtaProviderAppCommandDelegate;
+extern OTAProviderExample gOtaProvider;
 
 class OtaProviderAppCommandHandler {
 public:
diff --git a/examples/platform/linux/NamedPipeCommands.cpp b/examples/platform/linux/NamedPipeCommands.cpp
index b4106351350ff8..4e527217692797 100644
--- a/examples/platform/linux/NamedPipeCommands.cpp
+++ b/examples/platform/linux/NamedPipeCommands.cpp
@@ -67,9 +67,6 @@ CHIP_ERROR NamedPipeCommands::Start(std::string & path, std::string & path_out,
 
     VerifyOrReturnError((mkfifo(path_out.c_str(), 0666) == 0) || (errno == EEXIST), CHIP_ERROR_OPEN_FAILED);
 
-    mOutFd = open(path_out.c_str(), O_RDWR | O_NONBLOCK);
-    VerifyOrReturnError(mOutFd != -1, CHIP_ERROR_OPEN_FAILED);
-
     return CHIP_NO_ERROR;
 }
 
@@ -105,6 +102,8 @@ CHIP_ERROR NamedPipeCommands::Stop()
 
 void NamedPipeCommands::WriteToOutPipe(const std::string & json)
 {
+    mOutFd = open(mChipEventFifoPathOut.c_str(), O_WRONLY);
+
     if (mOutFd == -1 || json.empty())
         return;
 
diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index d92b2be378c2b5..20a5586cb0698b 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -204,7 +204,7 @@ async def test_TC_SU_2_8(self):
         self.write_to_app_pipe(command, fifo_in)
         response_data = self.read_from_app_pipe(fifo_out)
 
-        logging.info(f"Response data: {response_data}")
+        # logging.info(f"Response data: {response_data}")
 
         # # Check VendorID
         # vendor_id_basic_information = await self.read_single_attribute_check_success(
diff --git a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
index 2f91f770f6bbb4..24bfd722b1ee79 100644
--- a/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
+++ b/src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py
@@ -971,6 +971,8 @@ async def write_single_attribute(self, attribute_value: ClusterObjects.ClusterAt
         return write_result[0].Status
 
     def read_from_app_pipe(self, app_pipe_out: Optional[str] = None):
+        BUFFER_SIZE = 1024
+
         # If is not empty from the args, verify if the fifo file exists.
         if app_pipe_out is not None and not os.path.exists(app_pipe_out):
             LOGGER.error("Named pipe %r does NOT exist" % app_pipe_out)
@@ -982,17 +984,13 @@ def read_from_app_pipe(self, app_pipe_out: Optional[str] = None):
         if not isinstance(app_pipe_out, str):
             raise TypeError("The named pipe must be provided as a string value")
 
-        line = ""
-        f = self.open_fifo_nonblocking(app_pipe_out)
-        LOGGER.info(f"Reading out-of-band command response to file: {app_pipe_out}")
-        line = f.readline()
-        f.close()
-
-        return line
-
-    def open_fifo_nonblocking(self, app_pipe_out):
-        fd = os.open(app_pipe_out, os.O_RDONLY | os.O_NONBLOCK)
-        return os.fdopen(fd, "r", buffering=1)
+        data = ""
+        with open(app_pipe_out, "r") as app_pipe_out_fp:
+            LOGGER.info(f"Reading out-of-band command response to file: {app_pipe_out}")
+            data = app_pipe_out_fp.read(BUFFER_SIZE)
+        LOGGER.info(data)
+        data = json.loads(data)
+        return data
 
     def write_to_app_pipe(self, command_dict: dict, app_pipe: Optional[str] = None):
         """

From ad22e29e7b674595967e229a93bc85996d1d9496 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Wed, 5 Nov 2025 20:12:32 +0000
Subject: [PATCH 17/18] Adding protocols supported}

---
 .../OtaProviderAppCommandDelegate.cpp          | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
index 0878730a37dedb..50f3ac58091cc6 100644
--- a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
@@ -63,14 +63,22 @@ Json::Value OtaProviderAppCommandHandler::BuildOtaProviderSnapshot(uint16_t endp
     Json::Value payload(Json::objectValue);
 
     // payload["QueryImageStatus"]    = static_cast<uint32_t>(gOtaProvider.GetQueryImageStatus());
-    payload["VendorID"]        = gOtaProvider.GetVendorId();
-    payload["ProductID"]       = gOtaProvider.GetProductId();
-    payload["SoftwareVersion"] = gOtaProvider.GetSoftwareVersion();
-    payload["HardwareVersion"] = gOtaProvider.GetHardwareVersion();
-    // payload["ProtocolsSupported"]  = gOtaProvider.GetProtocolsSupported();
+    payload["VendorID"]            = gOtaProvider.GetVendorId();
+    payload["ProductID"]           = gOtaProvider.GetProductId();
+    payload["SoftwareVersion"]     = gOtaProvider.GetSoftwareVersion();
+    payload["HardwareVersion"]     = gOtaProvider.GetHardwareVersion();
     payload["Location"]            = gOtaProvider.GetLocation();
     payload["RequestorCanConsent"] = gOtaProvider.GetRequestorCanConsent();
 
+    const auto & protos = gOtaProvider.GetProtocolsSupported();
+
+    Json::Value arr(Json::arrayValue);
+    for (chip::app::Clusters::OtaSoftwareUpdateProvider::DownloadProtocolEnum p : protos)
+    {
+        arr.append(Json::UInt(p));
+    }
+    payload["ProtocolsSupported"] = arr;
+
     return payload;
 }
 

From d8119af00fee3549e365bf4c994c61775f852372 Mon Sep 17 00:00:00 2001
From: Ramiro Recchia <rrecchia@google.com>
Date: Thu, 6 Nov 2025 19:47:44 +0000
Subject: [PATCH 18/18] Uncommenting test steps

---
 .../OtaProviderAppCommandDelegate.cpp         |   3 +-
 src/python_testing/TC_SU_2_8.py               | 426 +++++++++---------
 2 files changed, 207 insertions(+), 222 deletions(-)

diff --git a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
index 50f3ac58091cc6..55b903733bd579 100644
--- a/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
+++ b/examples/ota-provider-app/ota-provider-common/OtaProviderAppCommandDelegate.cpp
@@ -62,7 +62,6 @@ Json::Value OtaProviderAppCommandHandler::BuildOtaProviderSnapshot(uint16_t endp
 {
     Json::Value payload(Json::objectValue);
 
-    // payload["QueryImageStatus"]    = static_cast<uint32_t>(gOtaProvider.GetQueryImageStatus());
     payload["VendorID"]            = gOtaProvider.GetVendorId();
     payload["ProductID"]           = gOtaProvider.GetProductId();
     payload["SoftwareVersion"]     = gOtaProvider.GetSoftwareVersion();
@@ -97,7 +96,7 @@ void OtaProviderAppCommandHandler::HandleCommand(intptr_t context)
     endpoint = static_cast<uint16_t>(self->mJsonValue.get("Endpoint", 0).asUInt());
     delegate = self->mDelegate;
 
-    if (name == "Snapshot")
+    if (name == "QueryImageSnapshot")
     {
         Json::Value out(Json::objectValue);
         out["Name"]     = "SnapshotResponse";
diff --git a/src/python_testing/TC_SU_2_8.py b/src/python_testing/TC_SU_2_8.py
index 20a5586cb0698b..d7abcc8c1e3df0 100644
--- a/src/python_testing/TC_SU_2_8.py
+++ b/src/python_testing/TC_SU_2_8.py
@@ -55,25 +55,6 @@
 from matter.testing.event_attribute_reporting import EventSubscriptionHandler
 from matter.testing.matter_testing import MatterBaseTest, TestStep, async_test_body, default_matter_test_main
 
-ANSI_RE = re.compile(r"\x1B\[[0-?]*[-/]*[@-~]]")
-HEX_OR_DEC = re.compile(r"(0x[0-9a-fA-F]+|\d+)")
-VENDOR_RE = re.compile(r"VendorID:\s*(0x[0-9a-fA-F]+|\d+)")
-PRODUCT_RE = re.compile(r"ProductID:\s*(0x[0-9a-fA-F]+|\d+)")
-SWVER_RE = re.compile(r"SoftwareVersion:\s*(0x[0-9a-fA-F]+|\d+)")
-PROTO_RE = re.compile(r"ProtocolsSupported:\s*\[(.*?)\]", re.DOTALL)
-HWVER_RE = re.compile(r"HardwareVersion:\s*(0x[0-9a-fA-F]+|\d+)")
-LOC_RE = re.compile(r"Location:\s*([A-Za-z0.9]+)")
-RCC_RE = re.compile(r"RequestorCanConsent:\s*(0x[0-9a-fA-F]+|\d+)")
-
-FIELDS = {
-    "vendor_id": VENDOR_RE,
-    "product_id": PRODUCT_RE,
-    "software_version": SWVER_RE,
-    "hardware_version": HWVER_RE,
-    "location": LOC_RE,
-    "requestor_can_consent": RCC_RE
-}
-
 
 class TC_SU_2_8(SoftwareUpdateBaseTest, MatterBaseTest):
     """
@@ -102,10 +83,10 @@ def steps_TC_SU_2_8(self) -> list[TestStep]:
                      "Verify the field ProtocolsSupported lists the BDX Synchronous protocol."
                      "If (MCORE.OTA.HTTPS_Supported) HTTPS protocol should be listed."
                      "Verify the default value of RequestorCanConsent is set to False unless DUT sets it to True."
-                     "If the Location field is present, verify that the value is same as Basic Information Cluster Location Attribute of the DUT.")  # ,
-            # TestStep(2, "Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P.",
-            #          "TH1/OTA-P does not respond with QueryImage response command. StateTransition goes from idle to querying, then a download error happens and finally it goes back to idle."
-            #          "Subscribe to events for OtaSoftwareUpdateRequestor cluster and verify StateTransition reaches downloading state. Also check if the targetSoftwareVersion is 3."),
+                     "If the Location field is present, verify that the value is same as Basic Information Cluster Location Attribute of the DUT."),
+            TestStep(2, "Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P.",
+                     "TH1/OTA-P does not respond with QueryImage response command. StateTransition goes from idle to querying, then a download error happens and finally it goes back to idle."
+                     "Subscribe to events for OtaSoftwareUpdateRequestor cluster and verify StateTransition reaches downloading state. Also check if the targetSoftwareVersion is 2."),
         ]
         return steps
 
@@ -126,14 +107,14 @@ async def test_TC_SU_2_8(self):
         provider_port = 5540
 
         app_path = "./out/debug/chip-ota-provider-app"
-        provider_ota_file = OtaImagePath(path="firmware_v3.ota")
+        provider_ota_file = OtaImagePath(path="firmware_v1.ota")
 
         # States
         idle = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kIdle
         querying = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kQuerying
         downloading = Clusters.Objects.OtaSoftwareUpdateRequestor.Enums.UpdateStateEnum.kDownloading
 
-        target_version = 3
+        target_version = 2
 
         endpoint = self.get_endpoint(default=0)
         dut_node_id = self.dut_node_id
@@ -198,225 +179,230 @@ async def test_TC_SU_2_8(self):
 
         await asyncio.sleep(2)
 
-        command = {"Name": "Snapshot", "Cluster": "OtaSoftwareUpdateProvider", "Endpoint": 0}
+        command = {"Name": "QueryImageSnapshot", "Cluster": "OtaSoftwareUpdateProvider", "Endpoint": 0}
         fifo_in = "/tmp/su_2_8_fifo"
         fifo_out = "/tmp/su_2_8_fifo_out"
         self.write_to_app_pipe(command, fifo_in)
         response_data = self.read_from_app_pipe(fifo_out)
 
-        # logging.info(f"Response data: {response_data}")
-
-        # # Check VendorID
-        # vendor_id_basic_information = await self.read_single_attribute_check_success(
-        #     dev_ctrl=th1,
-        #     cluster=Clusters.BasicInformation,
-        #     attribute=Clusters.BasicInformation.Attributes.VendorID
-        # )
-
-        # asserts.assert_equal(vendor_id_basic_information,
-        #                      parsed['vendor_id'], f"Vendor ID is {parsed['vendor_id']} and it should be {vendor_id_basic_information}")
-
-        # # Check ProductID
-        # product_id_basic_information = await self.read_single_attribute_check_success(
-        #     dev_ctrl=th1,
-        #     cluster=Clusters.BasicInformation,
-        #     attribute=Clusters.BasicInformation.Attributes.ProductID
-        # )
-
-        # asserts.assert_equal(product_id_basic_information,
-        #                      parsed['product_id'], f"Product ID is {parsed['product_id']} and it should be {product_id_basic_information}")
-
-        # # Check HardwareVersion
-        # hardware_version_basic_information = await self.read_single_attribute_check_success(
-        #     dev_ctrl=th1,
-        #     cluster=Clusters.BasicInformation,
-        #     attribute=Clusters.BasicInformation.Attributes.HardwareVersion
-        # )
-
-        # asserts.assert_equal(hardware_version_basic_information,
-        #                      parsed['hardware_version'], f"Hardware Version is {parsed['hardware_version']} and it should be {hardware_version_basic_information}")
-
-        # # Check SoftwareVersion
-        # software_version_basic_information = await self.read_single_attribute_check_success(
-        #     dev_ctrl=th1,
-        #     cluster=Clusters.BasicInformation,
-        #     attribute=Clusters.BasicInformation.Attributes.SoftwareVersion
-        # )
-
-        # asserts.assert_equal(software_version_basic_information,
-        #                      parsed['software_version'], f"Software Version is {parsed['software_version']} and it should be {software_version_basic_information}")
-
-        # # Check ProtocolsSupported protocols_supported
-        # asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous in parsed['protocols_supported'],
-        #                     f"kBDXSynchronous: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
-
-        # # Check MCORE.OTA.HTTPS
-        # if self.check_pics("MCORE.OTA.HTTPS"):
-        #     asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps in parsed['protocols_supported'],
-        #                         f"kHttps: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps} is not part of ProtocolsSupporter: {parsed['protocols_supported']}")
-
-        # # Check RequestorCanConsent
-        # asserts.assert_equal(parsed['requestor_can_consent'], 0,
-        #                      f"Requestor Can Consent is {parsed['requestor_can_consent']} instead of 0")
-
-        # # Check Location
-        # if parsed['location']:
-        #     location_basic_information = await self.read_single_attribute_check_success(
-        #         dev_ctrl=th1,
-        #         cluster=Clusters.BasicInformation,
-        #         attribute=Clusters.BasicInformation.Attributes.Location
-        #     )
-
-        #     asserts.assert_equal(location_basic_information,
-        #                          parsed['location'], f"Location is {parsed['location']} and it should be {location_basic_information}")
+        # Check VendorID
+        vid = response_data["Payload"]["VendorID"]
+        vendor_id_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.VendorID
+        )
+
+        asserts.assert_equal(vendor_id_basic_information, vid, f"Vendor ID is {vid} and it should be {vendor_id_basic_information}")
+
+        # Check ProductID
+        pid = response_data["Payload"]["ProductID"]
+        product_id_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.ProductID
+        )
+
+        asserts.assert_equal(product_id_basic_information, pid,
+                             f"Product ID is {pid} and it should be {product_id_basic_information}")
+
+        # Check HardwareVersion
+        hwv = response_data["Payload"]["HardwareVersion"]
+        hardware_version_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.HardwareVersion
+        )
+
+        asserts.assert_equal(hardware_version_basic_information, hwv,
+                             f"Hardware Version is {hwv} and it should be {hardware_version_basic_information}")
+
+        # Check SoftwareVersion
+        swv = response_data["Payload"]["SoftwareVersion"]
+        software_version_basic_information = await self.read_single_attribute_check_success(
+            dev_ctrl=th1,
+            cluster=Clusters.BasicInformation,
+            attribute=Clusters.BasicInformation.Attributes.SoftwareVersion
+        )
+
+        asserts.assert_equal(software_version_basic_information, swv,
+                             f"Software Version is {swv} and it should be {software_version_basic_information}")
+
+        # Check ProtocolsSupported protocols_supported
+        protocols_supported = response_data["Payload"]["ProtocolsSupported"]
+        asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous in protocols_supported,
+                            f"kBDXSynchronous: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kBDXSynchronous} is not part of ProtocolsSupporter: {protocols_supported}")
+
+        # Check MCORE.OTA.HTTPS
+        if self.check_pics("MCORE.OTA.HTTPS"):
+            asserts.assert_true(Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps in protocols_supported,
+                                f"kHttps: {Clusters.OtaSoftwareUpdateProvider.Enums.DownloadProtocolEnum.kHttps} is not part of ProtocolsSupporter: {protocols_supported}")
+
+        # Check RequestorCanConsent
+        requestor_can_consent = response_data["Payload"]["RequestorCanConsent"]
+        expected_requestor_can_consent = 0
+        asserts.assert_equal(requestor_can_consent, expected_requestor_can_consent,
+                             f"Requestor Can Consent is {requestor_can_consent} instead of {expected_requestor_can_consent}")
+
+        # Check Location
+        location = response_data["Payload"]["Location"]
+        if location:
+            location_basic_information = await self.read_single_attribute_check_success(
+                dev_ctrl=th1,
+                cluster=Clusters.BasicInformation,
+                attribute=Clusters.BasicInformation.Attributes.Location
+            )
+
+            asserts.assert_equal(location_basic_information, location,
+                                 f"Location is {location} and it should be {location_basic_information}")
 
         # Event Handler
-        # event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
-        # await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
-        #                      fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
+                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
 
         # Stop provider
-        # await asyncio.sleep(2)
-        # try:
-        #     provider_1.terminate()
-        # except Exception as e:
-        #     logging.warning(f"Provider termination raised: {e}")
-#
-        # th1.ExpireSessions(nodeid=p1_node)
-        # await asyncio.sleep(2)
-#
-        # event_cb.reset()
-        # await event_cb.cancel()
+        await asyncio.sleep(2)
+        try:
+            provider_1.terminate()
+        except Exception as e:
+            logging.warning(f"Provider termination raised: {e}")
+
+        th1.ExpireSessions(nodeid=p1_node)
+        await asyncio.sleep(2)
+
+        event_cb.reset()
+        await event_cb.cancel()
 
         # Configure DefaultOTAProviders with invalid node ID. DUT tries to send a QueryImage command to TH1/OTA-P. DUT sends QueryImage command to TH2/OTA-P
-        # self.step(2)
+        self.step(2)
+
+        provider_ota_file = OtaImagePath(path="firmware_v2.ota")
+
+        logging.info("Starting OTA Provider 2")
+        provider_2 = OTAProviderSubprocess(
+            app=app_path,
+            storage_dir='/tmp',
+            port=provider_port,
+            discriminator=p2_disc,
+            passcode=p_pass,
+            ota_source=provider_ota_file,
+            kvs_path='/tmp/chip_kvs_provider_2',
+            log_file='/tmp/provider_2.log',
+            err_log_file='/tmp/provider_2.log'
+        )
+
+        provider_2.start()
 
-        # provider_ota_file = OtaImagePath(path="firmware_v3.ota")
-#
-        # logging.info("Starting OTA Provider 2")
-        # provider_2 = OTAProviderSubprocess(
-        #    app=app_path,
-        #    storage_dir='/tmp',
-        #    port=provider_port,
-        #    discriminator=p2_disc,
-        #    passcode=p_pass,
-        #    ota_source=provider_ota_file,
-        #    kvs_path='/tmp/chip_kvs_provider_2',
-        #    log_file='/tmp/provider_2.log',
-        #    err_log_file='/tmp/provider_2.log'
-        # )
-#
-        # provider_2.start()
-#
         # Create TH2
-        # logging.info("Setting up TH2.")
-        # th2_certificate_auth = self.certificate_authority_manager.NewCertificateAuthority()
-        # th2_fabric_admin = th2_certificate_auth.NewFabricAdmin(vendorId=vendor_id, fabricId=fabric_id_th2)
-        # th2 = th2_fabric_admin.NewController(nodeId=2, useTestCommissioner=True)
-#
-        # logging.info("Opening commissioning window on DUT.")
-        # params = await self.open_commissioning_window(th1, dut_node_id)
-#
+        logging.info("Setting up TH2.")
+        th2_certificate_auth = self.certificate_authority_manager.NewCertificateAuthority()
+        th2_fabric_admin = th2_certificate_auth.NewFabricAdmin(vendorId=vendor_id, fabricId=fabric_id_th2)
+        th2 = th2_fabric_admin.NewController(nodeId=2, useTestCommissioner=True)
+
+        logging.info("Opening commissioning window on DUT.")
+        params = await self.open_commissioning_window(th1, dut_node_id)
+
         # Commission TH2/DUT (requestor)
-        # resp = await th2.CommissionOnNetwork(
-        #    nodeId=requestor_node_id,
-        #    setupPinCode=params.commissioningParameters.setupPinCode,
-        #    filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
-        #    filter=params.randomDiscriminator
-        # )
-#
-        # logging.info(f"TH2 commissioned: {resp}.")
-#
+        resp = await th2.CommissionOnNetwork(
+            nodeId=requestor_node_id,
+            setupPinCode=params.commissioningParameters.setupPinCode,
+            filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
+            filter=params.randomDiscriminator
+        )
+
+        logging.info(f"TH2 commissioned: {resp}.")
+
         # Commissioning Provider-TH2
-        # logging.info("Commissioning OTA Provider to TH2")
-#
-        # resp = await th2.CommissionOnNetwork(
-        #    nodeId=p2_node,
-        #    setupPinCode=p_pass,
-        #    filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
-        #    filter=p2_disc
-        # )
-#
-        # logging.info(f"Commissioning response: {resp}.")
-#
+        logging.info("Commissioning OTA Provider to TH2")
+
+        resp = await th2.CommissionOnNetwork(
+            nodeId=p2_node,
+            setupPinCode=p_pass,
+            filterType=ChipDeviceCtrl.DiscoveryFilterType.LONG_DISCRIMINATOR,
+            filter=p2_disc
+        )
+
+        logging.info(f"Commissioning response: {resp}.")
+
         # ACL permissions are not required
-#
-        # if fabric_id_th2 == th1.fabricId:
-        #    raise AssertionError(f"Fabric IDs are the same for TH1: {th1.fabricId} and TH2: {fabric_id_th2}.")
-#
+
+        if fabric_id_th2 == th1.fabricId:
+            raise AssertionError(f"Fabric IDs are the same for TH1: {th1.fabricId} and TH2: {fabric_id_th2}.")
+
         # Event Handler
-        # event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
-        # await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
-        #                     fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
-#
+        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        await event_cb.start(dev_ctrl=th1, node_id=requestor_node_id, endpoint=endpoint,
+                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+
         # Write default OTA providers TH1 with p1_node which does not exist
-        # await self.write_ota_providers(th1, p1_node_invalid, endpoint)
-#
+        await self.write_ota_providers(th1, p1_node_invalid, endpoint)
+
         # Announce TH1-OTA Provider
-        # await self.announce_ota_provider(controller=th1, provider_node_id=p1_node_invalid, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
-#
+        await self.announce_ota_provider(controller=th1, provider_node_id=p1_node_invalid, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
+
         # Expect events idle to querying, downloadError and then back to idle
-        # querying_event = event_cb.wait_for_event_report(
-        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
-        # asserts.assert_equal(querying, querying_event.newState,
-        #                     f"New state is {querying_event.newState} and it should be {querying}")
-#
-        # download_error = event_cb.wait_for_event_report(
-        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.DownloadError, 50000)
-#
-        # logging.info(f"Download Error: {download_error}")
-#
-        # idle_event = event_cb.wait_for_event_report(
-        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 50000)
-        # asserts.assert_equal(idle, idle_event.newState,
-        #                     f"New state is {idle_event.newState} and it should be {idle}")
-#
-        # event_cb.reset()
-        # await event_cb.cancel()
-        # await asyncio.sleep(2)
-#
+        querying_event = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+        asserts.assert_equal(querying, querying_event.newState,
+                             f"New state is {querying_event.newState} and it should be {querying}")
+
+        download_error = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.DownloadError, 50000)
+
+        logging.info(f"Download Error: {download_error}")
+
+        idle_event = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 50000)
+        asserts.assert_equal(idle, idle_event.newState,
+                             f"New state is {idle_event.newState} and it should be {idle}")
+
+        event_cb.reset()
+        await event_cb.cancel()
+        await asyncio.sleep(2)
+
         # Subscribe to events
-        # event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
-        # await event_cb.start(dev_ctrl=th2, node_id=requestor_node_id, endpoint=endpoint,
-        #                     fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
-#
+        event_cb = EventSubscriptionHandler(expected_cluster=Clusters.Objects.OtaSoftwareUpdateRequestor)
+        await event_cb.start(dev_ctrl=th2, node_id=requestor_node_id, endpoint=endpoint,
+                             fabric_filtered=False, min_interval_sec=0, max_interval_sec=5)
+
         # Define ACL entry
-        # await self.create_acl_entry(dev_ctrl=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id)
-#
+        await self.create_acl_entry(dev_ctrl=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id)
+
         # Write default OTA providers TH2
-        # await self.write_ota_providers(th2, p2_node, endpoint)
-#
+        await self.write_ota_providers(th2, p2_node, endpoint)
+
         # Announce after subscription
-        # await self.announce_ota_provider(controller=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
-#
-        # event_idle_to_querying = event_cb.wait_for_event_report(
-        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
-#
-        # self.verify_state_transition_event(event_report=event_idle_to_querying, previous_state=idle, new_state=querying)
-#
-        # event_querying_to_downloading = event_cb.wait_for_event_report(
-        #    Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
-#
-        # self.verify_state_transition_event(event_report=event_querying_to_downloading,
-        #                                   previous_state=querying, new_state=downloading, target_version=target_version)
-#
-        # event_cb.reset()
-        # await event_cb.cancel()
-#
-        # logging.info("Cleaning DefaultOTAProviders.")
-        # resp = await th2.WriteAttribute(
-        #    dut_node_id,
-        #    [(endpoint, Clusters.Objects.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders([]))]
-        # )
-        # asserts.assert_equal(resp[0].Status, Status.Success, "Clean DefaultOTAProviders failed.")
-#
-        # await asyncio.sleep(2)
-        # try:
-        #    provider_2.terminate()
-        # except Exception as e:
-        #    logging.warning(f"Provider termination raised: {e}")
-#
-        # th2.ExpireSessions(nodeid=p2_node)
+        await self.announce_ota_provider(controller=th2, provider_node_id=p2_node, requestor_node_id=requestor_node_id, vendor_id=vendor_id, endpoint=endpoint)
+
+        event_idle_to_querying = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+
+        self.verify_state_transition_event(event_report=event_idle_to_querying, previous_state=idle, new_state=querying)
+
+        event_querying_to_downloading = event_cb.wait_for_event_report(
+            Clusters.Objects.OtaSoftwareUpdateRequestor.Events.StateTransition, 5000)
+
+        self.verify_state_transition_event(event_report=event_querying_to_downloading,
+                                           previous_state=querying, new_state=downloading, target_version=target_version)
+
+        event_cb.reset()
+        await event_cb.cancel()
+
+        logging.info("Cleaning DefaultOTAProviders.")
+        resp = await th2.WriteAttribute(
+            dut_node_id,
+            [(endpoint, Clusters.Objects.OtaSoftwareUpdateRequestor.Attributes.DefaultOTAProviders([]))]
+        )
+        asserts.assert_equal(resp[0].Status, Status.Success, "Clean DefaultOTAProviders failed.")
+
+        await asyncio.sleep(2)
+        try:
+            provider_2.terminate()
+        except Exception as e:
+            logging.warning(f"Provider termination raised: {e}")
+
+        th2.ExpireSessions(nodeid=p2_node)
 
 
 if __name__ == "__main__":