src/app/tests/TestEcosystemInformationCluster.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *    Copyright (c) 2024 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 "lib/support/CHIPMem.h"

 #include <app/clusters/ecosystem-information-server/ecosystem-information-server.h>
 #include <app/data-model-provider/tests/ReadTesting.h>
 #include <pw_unit_test/framework.h>

 namespace chip {
 namespace app {
 namespace {

 using namespace Clusters;
 using namespace Clusters::EcosystemInformation;

 const EndpointId kValidEndpointId                      = 1;
 const Structs::DeviceTypeStruct::Type kValidDeviceType = { .deviceType = 0, .revision = 1 };
 constexpr Access::SubjectDescriptor kSubjectDescriptor = Testing::kAdminSubjectDescriptor;
 const FabricIndex kValidFabricIndex                    = kSubjectDescriptor.fabricIndex;

 struct RequiredEcosystemDeviceParams
 {
     EndpointId originalEndpointId              = kValidEndpointId;
     Structs::DeviceTypeStruct::Type deviceType = kValidDeviceType;
     FabricIndex fabicIndex                     = kValidFabricIndex;
 };

 const RequiredEcosystemDeviceParams kDefaultRequiredDeviceParams;

 const EndpointId kAnotherValidEndpointId = 2;
 static_assert(kValidEndpointId != kAnotherValidEndpointId);
 const char * kValidLocationName                 = "AValidLocationName";
 const ClusterId kEcosystemInfoClusterId         = EcosystemInformation::Id;
 const AttributeId kDeviceDirectoryAttributeId   = EcosystemInformation::Attributes::DeviceDirectory::Id;
 const AttributeId kLocationDirectoryAttributeId = EcosystemInformation::Attributes::LocationDirectory::Id;

 class MockMatterContext : public MatterContext
 {
 public:
     virtual void MarkDirty(EndpointId endpointId, AttributeId attributeId) override
     {
         ConcreteAttributePath path(endpointId, kEcosystemInfoClusterId, attributeId);
         mDirtyMarkedList.push_back(path);
     }

     std::vector<ConcreteAttributePath> & GetDirtyList() { return mDirtyMarkedList; }

 private:
     std::vector<ConcreteAttributePath> mDirtyMarkedList;
 };

 } // namespace

 class TestEcosystemInformationCluster : public ::testing::Test
 {
 public:
     TestEcosystemInformationCluster() : mClusterServer(TestOnlyParameter(), mMockMatterContext) {}

     static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
     static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }

     Clusters::EcosystemInformation::EcosystemInformationServer & EcoInfoCluster() { return mClusterServer; }

     std::unique_ptr<EcosystemDeviceStruct>
     CreateSimplestValidDeviceStruct(const RequiredEcosystemDeviceParams & requiredParams = kDefaultRequiredDeviceParams)
     {
         std::unique_ptr<EcosystemDeviceStruct> deviceInfo = EcosystemDeviceStruct::Builder()
                                                                 .SetOriginalEndpoint(requiredParams.originalEndpointId)
                                                                 .AddDeviceType(requiredParams.deviceType)
                                                                 .SetFabricIndex(requiredParams.fabicIndex)
                                                                 .Build();
         VerifyOrDie(deviceInfo);
         return deviceInfo;
     }

     std::unique_ptr<EcosystemLocationStruct> CreateValidLocationStruct(const char * requiredLocationName = kValidLocationName)
     {
         std::string locationName(requiredLocationName);
         std::unique_ptr<EcosystemLocationStruct> locationInfo =
             EcosystemLocationStruct::Builder().SetLocationName(locationName).Build();
         VerifyOrDie(locationInfo);
         return locationInfo;
     }

     MockMatterContext & GetMockMatterContext() { return mMockMatterContext; }

 private:
     MockMatterContext mMockMatterContext;
     Clusters::EcosystemInformation::EcosystemInformationServer mClusterServer;
 };

 TEST_F(TestEcosystemInformationCluster, UnsupportedClusterWhenReadingDeviceDirectoryOnNewClusterServer)
 {
     ConcreteAttributePath path(kValidEndpointId, kEcosystemInfoClusterId, kDeviceDirectoryAttributeId);

     Testing::ReadOperation testRequest(path);
     std::unique_ptr<AttributeValueEncoder> encoder = testRequest.StartEncoding();

     ASSERT_EQ(EcoInfoCluster().ReadAttribute(path, *encoder), CHIP_IM_GLOBAL_STATUS(UnsupportedCluster));
 }

 TEST_F(TestEcosystemInformationCluster, UnsupportedClusterWhenReadingLocationDirectoryOnNewClusterServer)
 {
     ConcreteAttributePath path(kValidEndpointId, kEcosystemInfoClusterId, kLocationDirectoryAttributeId);

     Testing::ReadOperation testRequest(path);
     std::unique_ptr<AttributeValueEncoder> encoder = testRequest.StartEncoding();

     ASSERT_EQ(EcoInfoCluster().ReadAttribute(path, *encoder), CHIP_IM_GLOBAL_STATUS(UnsupportedCluster));
 }

 TEST_F(TestEcosystemInformationCluster, EmptyReadAfterAddEcosystemInformationClusterToEndpoint)
 {
     ConcreteAttributePath deviceDirectoryPath(kValidEndpointId, kEcosystemInfoClusterId, kDeviceDirectoryAttributeId);
     ConcreteAttributePath locationDirectoryPath(kValidEndpointId, kEcosystemInfoClusterId, kLocationDirectoryAttributeId);

     ASSERT_EQ(EcoInfoCluster().AddEcosystemInformationClusterToEndpoint(kValidEndpointId), CHIP_NO_ERROR);

     Testing::ReadOperation testDeviceDirectoryRequest(deviceDirectoryPath);
     std::unique_ptr<AttributeValueEncoder> deviceDirectoryEncoder = testDeviceDirectoryRequest.StartEncoding();
     ASSERT_EQ(EcoInfoCluster().ReadAttribute(deviceDirectoryPath, *deviceDirectoryEncoder), CHIP_NO_ERROR);
     ASSERT_EQ(testDeviceDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);
     std::vector<Testing::DecodedAttributeData> deviceDirectoryAttributeData;
     ASSERT_EQ(testDeviceDirectoryRequest.GetEncodedIBs().Decode(deviceDirectoryAttributeData), CHIP_NO_ERROR);
     ASSERT_EQ(deviceDirectoryAttributeData.size(), 1u);
     Testing::DecodedAttributeData & deviceDirectoryEncodedData = deviceDirectoryAttributeData[0];
     ASSERT_EQ(deviceDirectoryEncodedData.attributePath, testDeviceDirectoryRequest.GetRequest().path);
     EcosystemInformation::Attributes::DeviceDirectory::TypeInfo::DecodableType decodableDeviceDirectory;
     ASSERT_EQ(decodableDeviceDirectory.Decode(deviceDirectoryEncodedData.dataReader), CHIP_NO_ERROR);
     size_t deviceDirectorySize = 0;
     ASSERT_EQ(decodableDeviceDirectory.ComputeSize(&deviceDirectorySize), CHIP_NO_ERROR);
     ASSERT_EQ(deviceDirectorySize, 0u);

     Testing::ReadOperation testLocationDirectoryRequest(locationDirectoryPath);
     std::unique_ptr<AttributeValueEncoder> locationDirectoryEncoder = testLocationDirectoryRequest.StartEncoding();
     ASSERT_EQ(EcoInfoCluster().ReadAttribute(locationDirectoryPath, *locationDirectoryEncoder), CHIP_NO_ERROR);
     ASSERT_EQ(testLocationDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);
     std::vector<Testing::DecodedAttributeData> locationDirectoryAttributeData;
     ASSERT_EQ(testLocationDirectoryRequest.GetEncodedIBs().Decode(locationDirectoryAttributeData), CHIP_NO_ERROR);
     ASSERT_EQ(locationDirectoryAttributeData.size(), 1u);
     Testing::DecodedAttributeData & locationDirectoryEncodedData = locationDirectoryAttributeData[0];
     ASSERT_EQ(locationDirectoryEncodedData.attributePath, testLocationDirectoryRequest.GetRequest().path);
     EcosystemInformation::Attributes::LocationDirectory::TypeInfo::DecodableType decodableLocationDirectory;
     ASSERT_EQ(decodableLocationDirectory.Decode(locationDirectoryEncodedData.dataReader), CHIP_NO_ERROR);
     size_t locationDirectorySize = 0;
     ASSERT_EQ(decodableLocationDirectory.ComputeSize(&locationDirectorySize), CHIP_NO_ERROR);
     ASSERT_EQ(locationDirectorySize, 0u);
 }

 TEST_F(TestEcosystemInformationCluster, BuildingEcosystemDeviceStruct)
 {
     EcosystemDeviceStruct::Builder deviceInfoBuilder;
     std::unique_ptr<EcosystemDeviceStruct> deviceInfo = deviceInfoBuilder.Build();
     ASSERT_FALSE(deviceInfo);

     deviceInfoBuilder.SetOriginalEndpoint(1);
     deviceInfo = deviceInfoBuilder.Build();
     ASSERT_FALSE(deviceInfo);

     auto deviceType     = Structs::DeviceTypeStruct::Type();
     deviceType.revision = 1;
     deviceInfoBuilder.AddDeviceType(deviceType);
     deviceInfo = deviceInfoBuilder.Build();
     ASSERT_FALSE(deviceInfo);

     deviceInfoBuilder.SetFabricIndex(1);
     deviceInfo = deviceInfoBuilder.Build();
     ASSERT_TRUE(deviceInfo);

     // Building a second device info with previously successfully built deviceInfoBuilder
     // is expected to fail.
     std::unique_ptr<EcosystemDeviceStruct> secondDeviceInfo = deviceInfoBuilder.Build();
     ASSERT_FALSE(secondDeviceInfo);
 }

 TEST_F(TestEcosystemInformationCluster, BuildingInvalidEcosystemDeviceStruct)
 {
     auto deviceType                       = Structs::DeviceTypeStruct::Type();
     deviceType.revision                   = 1;
     const FabricIndex kFabricIndexTooLow  = 0;
     const FabricIndex kFabricIndexTooHigh = kMaxValidFabricIndex + 1;

     EcosystemDeviceStruct::Builder deviceInfoBuilder;
     deviceInfoBuilder.SetOriginalEndpoint(1);
     deviceInfoBuilder.AddDeviceType(deviceType);
     deviceInfoBuilder.SetFabricIndex(kFabricIndexTooLow);
     std::unique_ptr<EcosystemDeviceStruct> deviceInfo = deviceInfoBuilder.Build();
     ASSERT_FALSE(deviceInfo);

     deviceInfoBuilder.SetFabricIndex(kFabricIndexTooHigh);
     deviceInfo = deviceInfoBuilder.Build();
     ASSERT_FALSE(deviceInfo);

     deviceInfoBuilder.SetFabricIndex(1);
     // At this point deviceInfoBuilder would be able to be built successfully.

     std::string nameThatsTooLong(65, 'x');
     uint64_t nameEpochValueUs = 0; // This values doesn't matter.
     deviceInfoBuilder.SetDeviceName(std::move(nameThatsTooLong), nameEpochValueUs);
     deviceInfo = deviceInfoBuilder.Build();
     ASSERT_FALSE(deviceInfo);

     // Ending unit test by building something that should work just to make sure
     // Builder isn't silently failing on building for some other reason.
     std::string nameThatsMaxLength(64, 'x');
     deviceInfoBuilder.SetDeviceName(std::move(nameThatsMaxLength), nameEpochValueUs);
     deviceInfo = deviceInfoBuilder.Build();
     ASSERT_TRUE(deviceInfo);
 }

 TEST_F(TestEcosystemInformationCluster, AddDeviceInfoInvalidArguments)
 {
     ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kValidEndpointId, nullptr), CHIP_ERROR_INVALID_ARGUMENT);

     std::unique_ptr<EcosystemDeviceStruct> deviceInfo = CreateSimplestValidDeviceStruct();
     ASSERT_TRUE(deviceInfo);
     ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kRootEndpointId, std::move(deviceInfo)), CHIP_ERROR_INVALID_ARGUMENT);

     deviceInfo = CreateSimplestValidDeviceStruct();
     ASSERT_TRUE(deviceInfo);
     ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kInvalidEndpointId, std::move(deviceInfo)), CHIP_ERROR_INVALID_ARGUMENT);
 }

 TEST_F(TestEcosystemInformationCluster, AddDeviceInfo)
 {
     std::unique_ptr<EcosystemDeviceStruct> deviceInfo = CreateSimplestValidDeviceStruct();
     // originalEndpoint and path endpoint do not need to be the same, for that reason we use a different value for
     // path endpoint
     static_assert(kAnotherValidEndpointId != kValidEndpointId);
     ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kAnotherValidEndpointId, std::move(deviceInfo)), CHIP_NO_ERROR);
     ConcreteAttributePath deviceDirectoryPath(kAnotherValidEndpointId, kEcosystemInfoClusterId, kDeviceDirectoryAttributeId);
     Testing::ReadOperation testDeviceDirectoryRequest(deviceDirectoryPath);
     testDeviceDirectoryRequest.SetSubjectDescriptor(kSubjectDescriptor);
     std::unique_ptr<AttributeValueEncoder> deviceDirectoryEncoder = testDeviceDirectoryRequest.StartEncoding();

     ASSERT_EQ(EcoInfoCluster().ReadAttribute(deviceDirectoryPath, *deviceDirectoryEncoder), CHIP_NO_ERROR);
     ASSERT_EQ(testDeviceDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);

     std::vector<Testing::DecodedAttributeData> attributeData;
     ASSERT_EQ(testDeviceDirectoryRequest.GetEncodedIBs().Decode(attributeData), CHIP_NO_ERROR);
     ASSERT_EQ(attributeData.size(), 1u);
     Testing::DecodedAttributeData & encodedData = attributeData[0];
     ASSERT_EQ(encodedData.attributePath, testDeviceDirectoryRequest.GetRequest().path);
     EcosystemInformation::Attributes::DeviceDirectory::TypeInfo::DecodableType decodableDeviceDirectory;
     ASSERT_EQ(decodableDeviceDirectory.Decode(encodedData.dataReader), CHIP_NO_ERROR);
     size_t size = 0;
     ASSERT_EQ(decodableDeviceDirectory.ComputeSize(&size), CHIP_NO_ERROR);
     ASSERT_EQ(size, 1u);
     auto iterator = decodableDeviceDirectory.begin();
     ASSERT_TRUE(iterator.Next());
     auto deviceDirectoryEntry = iterator.GetValue();
     ASSERT_FALSE(deviceDirectoryEntry.deviceName.HasValue());
     ASSERT_FALSE(deviceDirectoryEntry.deviceNameLastEdit.HasValue());
     ASSERT_EQ(deviceDirectoryEntry.bridgedEndpoint, kInvalidEndpointId);
     ASSERT_EQ(deviceDirectoryEntry.originalEndpoint, kValidEndpointId);
     size_t deviceTypeListSize = 0;
     ASSERT_EQ(deviceDirectoryEntry.deviceTypes.ComputeSize(&deviceTypeListSize), CHIP_NO_ERROR);
     ASSERT_EQ(deviceTypeListSize, 1u);
     auto deviceTypeIterator = deviceDirectoryEntry.deviceTypes.begin();
     ASSERT_TRUE(deviceTypeIterator.Next());
     auto deviceTypeEntry = deviceTypeIterator.GetValue();
     ASSERT_EQ(deviceTypeEntry.deviceType, 0u);
     ASSERT_EQ(deviceTypeEntry.revision, 1);
     ASSERT_FALSE(deviceTypeIterator.Next());
     size_t uniqueLocationIdListSize = 0;
     ASSERT_EQ(deviceDirectoryEntry.uniqueLocationIDs.ComputeSize(&uniqueLocationIdListSize), CHIP_NO_ERROR);
     ASSERT_EQ(uniqueLocationIdListSize, 0u);
     ASSERT_EQ(deviceDirectoryEntry.uniqueLocationIDsLastEdit, 0u);
     ASSERT_EQ(deviceDirectoryEntry.fabricIndex, kSubjectDescriptor.fabricIndex);
     ASSERT_FALSE(iterator.Next());
 }

 TEST_F(TestEcosystemInformationCluster, AddDeviceInfoResultInMarkDirty)
 {
     std::unique_ptr<EcosystemDeviceStruct> deviceInfo = CreateSimplestValidDeviceStruct();
     ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kValidEndpointId, std::move(deviceInfo)), CHIP_NO_ERROR);

     auto markedDirtyList = GetMockMatterContext().GetDirtyList();
     ASSERT_EQ(markedDirtyList.size(), 1u);
     ConcreteAttributePath path = markedDirtyList[0];
     ASSERT_EQ(path.mEndpointId, kValidEndpointId);
     ASSERT_EQ(path.mClusterId, kEcosystemInfoClusterId);
     ASSERT_EQ(path.mAttributeId, kDeviceDirectoryAttributeId);
 }

 TEST_F(TestEcosystemInformationCluster, BuildingEcosystemLocationStruct)
 {
     EcosystemLocationStruct::Builder locationInfoBuilder;

     std::string validLocationName = "validName";
     locationInfoBuilder.SetLocationName(validLocationName);

     std::unique_ptr<EcosystemLocationStruct> locationInfo = locationInfoBuilder.Build();
     ASSERT_TRUE(locationInfo);

     // Building a second device info with previously successfully built deviceInfoBuilder
     // is expected to fail.
     locationInfo = locationInfoBuilder.Build();
     ASSERT_FALSE(locationInfo);
 }

 TEST_F(TestEcosystemInformationCluster, BuildingInvalidEcosystemLocationStruct)
 {
     EcosystemLocationStruct::Builder locationInfoBuilder;

     std::string nameThatsTooLong(129, 'x');
     locationInfoBuilder.SetLocationName(nameThatsTooLong);

     std::unique_ptr<EcosystemLocationStruct> locationInfo = locationInfoBuilder.Build();
     ASSERT_FALSE(locationInfo);

     // Ending unit test by building something that should work just to make sure
     // Builder isn't silently failing on building for some other reason.
     std::string nameThatsMaxLength(128, 'x');
     locationInfoBuilder.SetLocationName(nameThatsMaxLength);
     locationInfo = locationInfoBuilder.Build();
     ASSERT_TRUE(locationInfo);
 }

 TEST_F(TestEcosystemInformationCluster, AddLocationInfoInvalidArguments)
 {
     const FabricIndex kFabricIndexTooLow  = 0;
     const FabricIndex kFabricIndexTooHigh = kMaxValidFabricIndex + 1;
     const std::string kEmptyLocationIdStr;
     const std::string kValidLocationIdStr = "SomeLocationString";
     const std::string kInvalidLocationIdTooLongStr(65, 'x');

     std::unique_ptr<EcosystemLocationStruct> locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kInvalidEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
               CHIP_ERROR_INVALID_ARGUMENT);

     locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kRootEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
               CHIP_ERROR_INVALID_ARGUMENT);

     locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kEmptyLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
               CHIP_ERROR_INVALID_ARGUMENT);

     locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kInvalidLocationIdTooLongStr, kValidFabricIndex,
                                                std::move(locationInfo)),
               CHIP_ERROR_INVALID_ARGUMENT);

     locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kFabricIndexTooLow, std::move(locationInfo)),
               CHIP_ERROR_INVALID_ARGUMENT);

     locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kFabricIndexTooHigh, std::move(locationInfo)),
               CHIP_ERROR_INVALID_ARGUMENT);

     // Sanity check that we can successfully add something after all the previously failed attempts
     locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
               CHIP_NO_ERROR);

     // Adding a second identical entry is expected to fail
     locationInfo = CreateValidLocationStruct();
     ASSERT_TRUE(locationInfo);
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
               CHIP_ERROR_INVALID_ARGUMENT);
 }

 TEST_F(TestEcosystemInformationCluster, AddLocationInfo)
 {
     std::unique_ptr<EcosystemLocationStruct> locationInfo = CreateValidLocationStruct();
     const char * kValidLocationIdStr                      = "SomeLocationIdString";
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, Testing::kAdminSubjectDescriptor.fabricIndex,
                                                std::move(locationInfo)),
               CHIP_NO_ERROR);

     ConcreteAttributePath locationDirectoryPath(kValidEndpointId, kEcosystemInfoClusterId, kLocationDirectoryAttributeId);
     Testing::ReadOperation testLocationDirectoryRequest(locationDirectoryPath);
     testLocationDirectoryRequest.SetSubjectDescriptor(Testing::kAdminSubjectDescriptor);
     std::unique_ptr<AttributeValueEncoder> locationDirectoryEncoder = testLocationDirectoryRequest.StartEncoding();
     ASSERT_EQ(EcoInfoCluster().ReadAttribute(locationDirectoryPath, *locationDirectoryEncoder), CHIP_NO_ERROR);
     ASSERT_EQ(testLocationDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);

     std::vector<Testing::DecodedAttributeData> locationDirectoryAttributeData;
     ASSERT_EQ(testLocationDirectoryRequest.GetEncodedIBs().Decode(locationDirectoryAttributeData), CHIP_NO_ERROR);
     ASSERT_EQ(locationDirectoryAttributeData.size(), 1u);
     Testing::DecodedAttributeData & locationDirectoryEncodedData = locationDirectoryAttributeData[0];
     ASSERT_EQ(locationDirectoryEncodedData.attributePath, testLocationDirectoryRequest.GetRequest().path);
     EcosystemInformation::Attributes::LocationDirectory::TypeInfo::DecodableType decodableLocationDirectory;
     ASSERT_EQ(decodableLocationDirectory.Decode(locationDirectoryEncodedData.dataReader), CHIP_NO_ERROR);
     size_t locationDirectorySize = 0;
     ASSERT_EQ(decodableLocationDirectory.ComputeSize(&locationDirectorySize), CHIP_NO_ERROR);
     ASSERT_EQ(locationDirectorySize, 1u);
     auto iterator = decodableLocationDirectory.begin();
     ASSERT_TRUE(iterator.Next());
     auto locationDirectoryEntry = iterator.GetValue();
     ASSERT_TRUE(locationDirectoryEntry.uniqueLocationID.data_equal(CharSpan::fromCharString(kValidLocationIdStr)));
     ASSERT_TRUE(locationDirectoryEntry.locationDescriptor.locationName.data_equal(CharSpan::fromCharString(kValidLocationName)));
     ASSERT_TRUE(locationDirectoryEntry.locationDescriptor.floorNumber.IsNull());
     ASSERT_TRUE(locationDirectoryEntry.locationDescriptor.areaType.IsNull());
     ASSERT_EQ(locationDirectoryEntry.locationDescriptorLastEdit, 0u);
     ASSERT_EQ(locationDirectoryEntry.fabricIndex, Testing::kAdminSubjectDescriptor.fabricIndex);
     ASSERT_FALSE(iterator.Next());
 }

 TEST_F(TestEcosystemInformationCluster, AddLocationInfoResultInMarkDirty)
 {
     std::unique_ptr<EcosystemLocationStruct> locationInfo = CreateValidLocationStruct();
     const char * kValidLocationIdStr                      = "SomeLocationIdString";
     ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, Testing::kAdminSubjectDescriptor.fabricIndex,
                                                std::move(locationInfo)),
               CHIP_NO_ERROR);

     auto markedDirtyList = GetMockMatterContext().GetDirtyList();
     ASSERT_EQ(markedDirtyList.size(), 1u);
     ConcreteAttributePath path = markedDirtyList[0];
     ASSERT_EQ(path.mEndpointId, kValidEndpointId);
     ASSERT_EQ(path.mClusterId, kEcosystemInfoClusterId);
     ASSERT_EQ(path.mAttributeId, kLocationDirectoryAttributeId);
 }

 } // namespace app
 } // namespace chip
	/*
	* Copyright (c) 2024 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 "lib/support/CHIPMem.h"

	#include <app/clusters/ecosystem-information-server/ecosystem-information-server.h>
	#include <app/data-model-provider/tests/ReadTesting.h>
	#include <pw_unit_test/framework.h>

	namespace chip {
	namespace app {
	namespace {

	using namespace Clusters;
	using namespace Clusters::EcosystemInformation;

	const EndpointId kValidEndpointId = 1;
	const Structs::DeviceTypeStruct::Type kValidDeviceType = { .deviceType = 0, .revision = 1 };
	constexpr Access::SubjectDescriptor kSubjectDescriptor = Testing::kAdminSubjectDescriptor;
	const FabricIndex kValidFabricIndex = kSubjectDescriptor.fabricIndex;

	struct RequiredEcosystemDeviceParams
	{
	EndpointId originalEndpointId = kValidEndpointId;
	Structs::DeviceTypeStruct::Type deviceType = kValidDeviceType;
	FabricIndex fabicIndex = kValidFabricIndex;
	};

	const RequiredEcosystemDeviceParams kDefaultRequiredDeviceParams;

	const EndpointId kAnotherValidEndpointId = 2;
	static_assert(kValidEndpointId != kAnotherValidEndpointId);
	const char * kValidLocationName = "AValidLocationName";
	const ClusterId kEcosystemInfoClusterId = EcosystemInformation::Id;
	const AttributeId kDeviceDirectoryAttributeId = EcosystemInformation::Attributes::DeviceDirectory::Id;
	const AttributeId kLocationDirectoryAttributeId = EcosystemInformation::Attributes::LocationDirectory::Id;

	class MockMatterContext : public MatterContext
	{
	public:
	virtual void MarkDirty(EndpointId endpointId, AttributeId attributeId) override
	{
	ConcreteAttributePath path(endpointId, kEcosystemInfoClusterId, attributeId);
	mDirtyMarkedList.push_back(path);
	}

	std::vector<ConcreteAttributePath> & GetDirtyList() { return mDirtyMarkedList; }

	private:
	std::vector<ConcreteAttributePath> mDirtyMarkedList;
	};

	} // namespace

	class TestEcosystemInformationCluster : public ::testing::Test
	{
	public:
	TestEcosystemInformationCluster() : mClusterServer(TestOnlyParameter(), mMockMatterContext) {}

	static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
	static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }

	Clusters::EcosystemInformation::EcosystemInformationServer & EcoInfoCluster() { return mClusterServer; }

	std::unique_ptr<EcosystemDeviceStruct>
	CreateSimplestValidDeviceStruct(const RequiredEcosystemDeviceParams & requiredParams = kDefaultRequiredDeviceParams)
	{
	std::unique_ptr<EcosystemDeviceStruct> deviceInfo = EcosystemDeviceStruct::Builder()
	.SetOriginalEndpoint(requiredParams.originalEndpointId)
	.AddDeviceType(requiredParams.deviceType)
	.SetFabricIndex(requiredParams.fabicIndex)
	.Build();
	VerifyOrDie(deviceInfo);
	return deviceInfo;
	}

	std::unique_ptr<EcosystemLocationStruct> CreateValidLocationStruct(const char * requiredLocationName = kValidLocationName)
	{
	std::string locationName(requiredLocationName);
	std::unique_ptr<EcosystemLocationStruct> locationInfo =
	EcosystemLocationStruct::Builder().SetLocationName(locationName).Build();
	VerifyOrDie(locationInfo);
	return locationInfo;
	}

	MockMatterContext & GetMockMatterContext() { return mMockMatterContext; }

	private:
	MockMatterContext mMockMatterContext;
	Clusters::EcosystemInformation::EcosystemInformationServer mClusterServer;
	};

	TEST_F(TestEcosystemInformationCluster, UnsupportedClusterWhenReadingDeviceDirectoryOnNewClusterServer)
	{
	ConcreteAttributePath path(kValidEndpointId, kEcosystemInfoClusterId, kDeviceDirectoryAttributeId);

	Testing::ReadOperation testRequest(path);
	std::unique_ptr<AttributeValueEncoder> encoder = testRequest.StartEncoding();

	ASSERT_EQ(EcoInfoCluster().ReadAttribute(path, *encoder), CHIP_IM_GLOBAL_STATUS(UnsupportedCluster));
	}

	TEST_F(TestEcosystemInformationCluster, UnsupportedClusterWhenReadingLocationDirectoryOnNewClusterServer)
	{
	ConcreteAttributePath path(kValidEndpointId, kEcosystemInfoClusterId, kLocationDirectoryAttributeId);

	Testing::ReadOperation testRequest(path);
	std::unique_ptr<AttributeValueEncoder> encoder = testRequest.StartEncoding();

	ASSERT_EQ(EcoInfoCluster().ReadAttribute(path, *encoder), CHIP_IM_GLOBAL_STATUS(UnsupportedCluster));
	}

	TEST_F(TestEcosystemInformationCluster, EmptyReadAfterAddEcosystemInformationClusterToEndpoint)
	{
	ConcreteAttributePath deviceDirectoryPath(kValidEndpointId, kEcosystemInfoClusterId, kDeviceDirectoryAttributeId);
	ConcreteAttributePath locationDirectoryPath(kValidEndpointId, kEcosystemInfoClusterId, kLocationDirectoryAttributeId);

	ASSERT_EQ(EcoInfoCluster().AddEcosystemInformationClusterToEndpoint(kValidEndpointId), CHIP_NO_ERROR);

	Testing::ReadOperation testDeviceDirectoryRequest(deviceDirectoryPath);
	std::unique_ptr<AttributeValueEncoder> deviceDirectoryEncoder = testDeviceDirectoryRequest.StartEncoding();
	ASSERT_EQ(EcoInfoCluster().ReadAttribute(deviceDirectoryPath, *deviceDirectoryEncoder), CHIP_NO_ERROR);
	ASSERT_EQ(testDeviceDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);
	std::vector<Testing::DecodedAttributeData> deviceDirectoryAttributeData;
	ASSERT_EQ(testDeviceDirectoryRequest.GetEncodedIBs().Decode(deviceDirectoryAttributeData), CHIP_NO_ERROR);
	ASSERT_EQ(deviceDirectoryAttributeData.size(), 1u);
	Testing::DecodedAttributeData & deviceDirectoryEncodedData = deviceDirectoryAttributeData[0];
	ASSERT_EQ(deviceDirectoryEncodedData.attributePath, testDeviceDirectoryRequest.GetRequest().path);
	EcosystemInformation::Attributes::DeviceDirectory::TypeInfo::DecodableType decodableDeviceDirectory;
	ASSERT_EQ(decodableDeviceDirectory.Decode(deviceDirectoryEncodedData.dataReader), CHIP_NO_ERROR);
	size_t deviceDirectorySize = 0;
	ASSERT_EQ(decodableDeviceDirectory.ComputeSize(&deviceDirectorySize), CHIP_NO_ERROR);
	ASSERT_EQ(deviceDirectorySize, 0u);

	Testing::ReadOperation testLocationDirectoryRequest(locationDirectoryPath);
	std::unique_ptr<AttributeValueEncoder> locationDirectoryEncoder = testLocationDirectoryRequest.StartEncoding();
	ASSERT_EQ(EcoInfoCluster().ReadAttribute(locationDirectoryPath, *locationDirectoryEncoder), CHIP_NO_ERROR);
	ASSERT_EQ(testLocationDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);
	std::vector<Testing::DecodedAttributeData> locationDirectoryAttributeData;
	ASSERT_EQ(testLocationDirectoryRequest.GetEncodedIBs().Decode(locationDirectoryAttributeData), CHIP_NO_ERROR);
	ASSERT_EQ(locationDirectoryAttributeData.size(), 1u);
	Testing::DecodedAttributeData & locationDirectoryEncodedData = locationDirectoryAttributeData[0];
	ASSERT_EQ(locationDirectoryEncodedData.attributePath, testLocationDirectoryRequest.GetRequest().path);
	EcosystemInformation::Attributes::LocationDirectory::TypeInfo::DecodableType decodableLocationDirectory;
	ASSERT_EQ(decodableLocationDirectory.Decode(locationDirectoryEncodedData.dataReader), CHIP_NO_ERROR);
	size_t locationDirectorySize = 0;
	ASSERT_EQ(decodableLocationDirectory.ComputeSize(&locationDirectorySize), CHIP_NO_ERROR);
	ASSERT_EQ(locationDirectorySize, 0u);
	}

	TEST_F(TestEcosystemInformationCluster, BuildingEcosystemDeviceStruct)
	{
	EcosystemDeviceStruct::Builder deviceInfoBuilder;
	std::unique_ptr<EcosystemDeviceStruct> deviceInfo = deviceInfoBuilder.Build();
	ASSERT_FALSE(deviceInfo);

	deviceInfoBuilder.SetOriginalEndpoint(1);
	deviceInfo = deviceInfoBuilder.Build();
	ASSERT_FALSE(deviceInfo);

	auto deviceType = Structs::DeviceTypeStruct::Type();
	deviceType.revision = 1;
	deviceInfoBuilder.AddDeviceType(deviceType);
	deviceInfo = deviceInfoBuilder.Build();
	ASSERT_FALSE(deviceInfo);

	deviceInfoBuilder.SetFabricIndex(1);
	deviceInfo = deviceInfoBuilder.Build();
	ASSERT_TRUE(deviceInfo);

	// Building a second device info with previously successfully built deviceInfoBuilder
	// is expected to fail.
	std::unique_ptr<EcosystemDeviceStruct> secondDeviceInfo = deviceInfoBuilder.Build();
	ASSERT_FALSE(secondDeviceInfo);
	}

	TEST_F(TestEcosystemInformationCluster, BuildingInvalidEcosystemDeviceStruct)
	{
	auto deviceType = Structs::DeviceTypeStruct::Type();
	deviceType.revision = 1;
	const FabricIndex kFabricIndexTooLow = 0;
	const FabricIndex kFabricIndexTooHigh = kMaxValidFabricIndex + 1;

	EcosystemDeviceStruct::Builder deviceInfoBuilder;
	deviceInfoBuilder.SetOriginalEndpoint(1);
	deviceInfoBuilder.AddDeviceType(deviceType);
	deviceInfoBuilder.SetFabricIndex(kFabricIndexTooLow);
	std::unique_ptr<EcosystemDeviceStruct> deviceInfo = deviceInfoBuilder.Build();
	ASSERT_FALSE(deviceInfo);

	deviceInfoBuilder.SetFabricIndex(kFabricIndexTooHigh);
	deviceInfo = deviceInfoBuilder.Build();
	ASSERT_FALSE(deviceInfo);

	deviceInfoBuilder.SetFabricIndex(1);
	// At this point deviceInfoBuilder would be able to be built successfully.

	std::string nameThatsTooLong(65, 'x');
	uint64_t nameEpochValueUs = 0; // This values doesn't matter.
	deviceInfoBuilder.SetDeviceName(std::move(nameThatsTooLong), nameEpochValueUs);
	deviceInfo = deviceInfoBuilder.Build();
	ASSERT_FALSE(deviceInfo);

	// Ending unit test by building something that should work just to make sure
	// Builder isn't silently failing on building for some other reason.
	std::string nameThatsMaxLength(64, 'x');
	deviceInfoBuilder.SetDeviceName(std::move(nameThatsMaxLength), nameEpochValueUs);
	deviceInfo = deviceInfoBuilder.Build();
	ASSERT_TRUE(deviceInfo);
	}

	TEST_F(TestEcosystemInformationCluster, AddDeviceInfoInvalidArguments)
	{
	ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kValidEndpointId, nullptr), CHIP_ERROR_INVALID_ARGUMENT);

	std::unique_ptr<EcosystemDeviceStruct> deviceInfo = CreateSimplestValidDeviceStruct();
	ASSERT_TRUE(deviceInfo);
	ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kRootEndpointId, std::move(deviceInfo)), CHIP_ERROR_INVALID_ARGUMENT);

	deviceInfo = CreateSimplestValidDeviceStruct();
	ASSERT_TRUE(deviceInfo);
	ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kInvalidEndpointId, std::move(deviceInfo)), CHIP_ERROR_INVALID_ARGUMENT);
	}

	TEST_F(TestEcosystemInformationCluster, AddDeviceInfo)
	{
	std::unique_ptr<EcosystemDeviceStruct> deviceInfo = CreateSimplestValidDeviceStruct();
	// originalEndpoint and path endpoint do not need to be the same, for that reason we use a different value for
	// path endpoint
	static_assert(kAnotherValidEndpointId != kValidEndpointId);
	ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kAnotherValidEndpointId, std::move(deviceInfo)), CHIP_NO_ERROR);
	ConcreteAttributePath deviceDirectoryPath(kAnotherValidEndpointId, kEcosystemInfoClusterId, kDeviceDirectoryAttributeId);
	Testing::ReadOperation testDeviceDirectoryRequest(deviceDirectoryPath);
	testDeviceDirectoryRequest.SetSubjectDescriptor(kSubjectDescriptor);
	std::unique_ptr<AttributeValueEncoder> deviceDirectoryEncoder = testDeviceDirectoryRequest.StartEncoding();

	ASSERT_EQ(EcoInfoCluster().ReadAttribute(deviceDirectoryPath, *deviceDirectoryEncoder), CHIP_NO_ERROR);
	ASSERT_EQ(testDeviceDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);

	std::vector<Testing::DecodedAttributeData> attributeData;
	ASSERT_EQ(testDeviceDirectoryRequest.GetEncodedIBs().Decode(attributeData), CHIP_NO_ERROR);
	ASSERT_EQ(attributeData.size(), 1u);
	Testing::DecodedAttributeData & encodedData = attributeData[0];
	ASSERT_EQ(encodedData.attributePath, testDeviceDirectoryRequest.GetRequest().path);
	EcosystemInformation::Attributes::DeviceDirectory::TypeInfo::DecodableType decodableDeviceDirectory;
	ASSERT_EQ(decodableDeviceDirectory.Decode(encodedData.dataReader), CHIP_NO_ERROR);
	size_t size = 0;
	ASSERT_EQ(decodableDeviceDirectory.ComputeSize(&size), CHIP_NO_ERROR);
	ASSERT_EQ(size, 1u);
	auto iterator = decodableDeviceDirectory.begin();
	ASSERT_TRUE(iterator.Next());
	auto deviceDirectoryEntry = iterator.GetValue();
	ASSERT_FALSE(deviceDirectoryEntry.deviceName.HasValue());
	ASSERT_FALSE(deviceDirectoryEntry.deviceNameLastEdit.HasValue());
	ASSERT_EQ(deviceDirectoryEntry.bridgedEndpoint, kInvalidEndpointId);
	ASSERT_EQ(deviceDirectoryEntry.originalEndpoint, kValidEndpointId);
	size_t deviceTypeListSize = 0;
	ASSERT_EQ(deviceDirectoryEntry.deviceTypes.ComputeSize(&deviceTypeListSize), CHIP_NO_ERROR);
	ASSERT_EQ(deviceTypeListSize, 1u);
	auto deviceTypeIterator = deviceDirectoryEntry.deviceTypes.begin();
	ASSERT_TRUE(deviceTypeIterator.Next());
	auto deviceTypeEntry = deviceTypeIterator.GetValue();
	ASSERT_EQ(deviceTypeEntry.deviceType, 0u);
	ASSERT_EQ(deviceTypeEntry.revision, 1);
	ASSERT_FALSE(deviceTypeIterator.Next());
	size_t uniqueLocationIdListSize = 0;
	ASSERT_EQ(deviceDirectoryEntry.uniqueLocationIDs.ComputeSize(&uniqueLocationIdListSize), CHIP_NO_ERROR);
	ASSERT_EQ(uniqueLocationIdListSize, 0u);
	ASSERT_EQ(deviceDirectoryEntry.uniqueLocationIDsLastEdit, 0u);
	ASSERT_EQ(deviceDirectoryEntry.fabricIndex, kSubjectDescriptor.fabricIndex);
	ASSERT_FALSE(iterator.Next());
	}

	TEST_F(TestEcosystemInformationCluster, AddDeviceInfoResultInMarkDirty)
	{
	std::unique_ptr<EcosystemDeviceStruct> deviceInfo = CreateSimplestValidDeviceStruct();
	ASSERT_EQ(EcoInfoCluster().AddDeviceInfo(kValidEndpointId, std::move(deviceInfo)), CHIP_NO_ERROR);

	auto markedDirtyList = GetMockMatterContext().GetDirtyList();
	ASSERT_EQ(markedDirtyList.size(), 1u);
	ConcreteAttributePath path = markedDirtyList[0];
	ASSERT_EQ(path.mEndpointId, kValidEndpointId);
	ASSERT_EQ(path.mClusterId, kEcosystemInfoClusterId);
	ASSERT_EQ(path.mAttributeId, kDeviceDirectoryAttributeId);
	}

	TEST_F(TestEcosystemInformationCluster, BuildingEcosystemLocationStruct)
	{
	EcosystemLocationStruct::Builder locationInfoBuilder;

	std::string validLocationName = "validName";
	locationInfoBuilder.SetLocationName(validLocationName);

	std::unique_ptr<EcosystemLocationStruct> locationInfo = locationInfoBuilder.Build();
	ASSERT_TRUE(locationInfo);

	// Building a second device info with previously successfully built deviceInfoBuilder
	// is expected to fail.
	locationInfo = locationInfoBuilder.Build();
	ASSERT_FALSE(locationInfo);
	}

	TEST_F(TestEcosystemInformationCluster, BuildingInvalidEcosystemLocationStruct)
	{
	EcosystemLocationStruct::Builder locationInfoBuilder;

	std::string nameThatsTooLong(129, 'x');
	locationInfoBuilder.SetLocationName(nameThatsTooLong);

	std::unique_ptr<EcosystemLocationStruct> locationInfo = locationInfoBuilder.Build();
	ASSERT_FALSE(locationInfo);

	// Ending unit test by building something that should work just to make sure
	// Builder isn't silently failing on building for some other reason.
	std::string nameThatsMaxLength(128, 'x');
	locationInfoBuilder.SetLocationName(nameThatsMaxLength);
	locationInfo = locationInfoBuilder.Build();
	ASSERT_TRUE(locationInfo);
	}

	TEST_F(TestEcosystemInformationCluster, AddLocationInfoInvalidArguments)
	{
	const FabricIndex kFabricIndexTooLow = 0;
	const FabricIndex kFabricIndexTooHigh = kMaxValidFabricIndex + 1;
	const std::string kEmptyLocationIdStr;
	const std::string kValidLocationIdStr = "SomeLocationString";
	const std::string kInvalidLocationIdTooLongStr(65, 'x');

	std::unique_ptr<EcosystemLocationStruct> locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kInvalidEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
	CHIP_ERROR_INVALID_ARGUMENT);

	locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kRootEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
	CHIP_ERROR_INVALID_ARGUMENT);

	locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kEmptyLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
	CHIP_ERROR_INVALID_ARGUMENT);

	locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kInvalidLocationIdTooLongStr, kValidFabricIndex,
	std::move(locationInfo)),
	CHIP_ERROR_INVALID_ARGUMENT);

	locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kFabricIndexTooLow, std::move(locationInfo)),
	CHIP_ERROR_INVALID_ARGUMENT);

	locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kFabricIndexTooHigh, std::move(locationInfo)),
	CHIP_ERROR_INVALID_ARGUMENT);

	// Sanity check that we can successfully add something after all the previously failed attempts
	locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
	CHIP_NO_ERROR);

	// Adding a second identical entry is expected to fail
	locationInfo = CreateValidLocationStruct();
	ASSERT_TRUE(locationInfo);
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, kValidFabricIndex, std::move(locationInfo)),
	CHIP_ERROR_INVALID_ARGUMENT);
	}

	TEST_F(TestEcosystemInformationCluster, AddLocationInfo)
	{
	std::unique_ptr<EcosystemLocationStruct> locationInfo = CreateValidLocationStruct();
	const char * kValidLocationIdStr = "SomeLocationIdString";
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, Testing::kAdminSubjectDescriptor.fabricIndex,
	std::move(locationInfo)),
	CHIP_NO_ERROR);

	ConcreteAttributePath locationDirectoryPath(kValidEndpointId, kEcosystemInfoClusterId, kLocationDirectoryAttributeId);
	Testing::ReadOperation testLocationDirectoryRequest(locationDirectoryPath);
	testLocationDirectoryRequest.SetSubjectDescriptor(Testing::kAdminSubjectDescriptor);
	std::unique_ptr<AttributeValueEncoder> locationDirectoryEncoder = testLocationDirectoryRequest.StartEncoding();
	ASSERT_EQ(EcoInfoCluster().ReadAttribute(locationDirectoryPath, *locationDirectoryEncoder), CHIP_NO_ERROR);
	ASSERT_EQ(testLocationDirectoryRequest.FinishEncoding(), CHIP_NO_ERROR);

	std::vector<Testing::DecodedAttributeData> locationDirectoryAttributeData;
	ASSERT_EQ(testLocationDirectoryRequest.GetEncodedIBs().Decode(locationDirectoryAttributeData), CHIP_NO_ERROR);
	ASSERT_EQ(locationDirectoryAttributeData.size(), 1u);
	Testing::DecodedAttributeData & locationDirectoryEncodedData = locationDirectoryAttributeData[0];
	ASSERT_EQ(locationDirectoryEncodedData.attributePath, testLocationDirectoryRequest.GetRequest().path);
	EcosystemInformation::Attributes::LocationDirectory::TypeInfo::DecodableType decodableLocationDirectory;
	ASSERT_EQ(decodableLocationDirectory.Decode(locationDirectoryEncodedData.dataReader), CHIP_NO_ERROR);
	size_t locationDirectorySize = 0;
	ASSERT_EQ(decodableLocationDirectory.ComputeSize(&locationDirectorySize), CHIP_NO_ERROR);
	ASSERT_EQ(locationDirectorySize, 1u);
	auto iterator = decodableLocationDirectory.begin();
	ASSERT_TRUE(iterator.Next());
	auto locationDirectoryEntry = iterator.GetValue();
	ASSERT_TRUE(locationDirectoryEntry.uniqueLocationID.data_equal(CharSpan::fromCharString(kValidLocationIdStr)));
	ASSERT_TRUE(locationDirectoryEntry.locationDescriptor.locationName.data_equal(CharSpan::fromCharString(kValidLocationName)));
	ASSERT_TRUE(locationDirectoryEntry.locationDescriptor.floorNumber.IsNull());
	ASSERT_TRUE(locationDirectoryEntry.locationDescriptor.areaType.IsNull());
	ASSERT_EQ(locationDirectoryEntry.locationDescriptorLastEdit, 0u);
	ASSERT_EQ(locationDirectoryEntry.fabricIndex, Testing::kAdminSubjectDescriptor.fabricIndex);
	ASSERT_FALSE(iterator.Next());
	}

	TEST_F(TestEcosystemInformationCluster, AddLocationInfoResultInMarkDirty)
	{
	std::unique_ptr<EcosystemLocationStruct> locationInfo = CreateValidLocationStruct();
	const char * kValidLocationIdStr = "SomeLocationIdString";
	ASSERT_EQ(EcoInfoCluster().AddLocationInfo(kValidEndpointId, kValidLocationIdStr, Testing::kAdminSubjectDescriptor.fabricIndex,
	std::move(locationInfo)),
	CHIP_NO_ERROR);

	auto markedDirtyList = GetMockMatterContext().GetDirtyList();
	ASSERT_EQ(markedDirtyList.size(), 1u);
	ConcreteAttributePath path = markedDirtyList[0];
	ASSERT_EQ(path.mEndpointId, kValidEndpointId);
	ASSERT_EQ(path.mClusterId, kEcosystemInfoClusterId);
	ASSERT_EQ(path.mAttributeId, kLocationDirectoryAttributeId);
	}

	} // namespace app
	} // namespace chip