src/controller/tests/TestEventCaching.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 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-common/zap-generated/ids/Attributes.h"
 #include "app-common/zap-generated/ids/Clusters.h"
 #include "app/ClusterStateCache.h"
 #include "app/ConcreteAttributePath.h"
 #include "protocols/interaction_model/Constants.h"
 #include <app-common/zap-generated/cluster-objects.h>
 #include <app/BufferedReadCallback.h>
 #include <app/CommandHandlerInterface.h>
 #include <app/EventLogging.h>
 #include <app/InteractionModelEngine.h>
 #include <app/data-model/Decode.h>
 #include <app/tests/AppTestContext.h>
 #include <app/util/DataModelHandler.h>
 #include <app/util/attribute-storage.h>
 #include <controller/InvokeInteraction.h>
 #include <lib/core/ErrorStr.h>
 #include <lib/support/TimeUtils.h>
 #include <lib/support/UnitTestContext.h>
 #include <lib/support/UnitTestRegistration.h>
 #include <lib/support/UnitTestUtils.h>
 #include <lib/support/logging/CHIPLogging.h>
 #include <messaging/tests/MessagingContext.h>
 #include <nlunit-test.h>

 using namespace chip;
 using namespace chip::app;
 using namespace chip::app::Clusters;

 namespace {

 static uint8_t gDebugEventBuffer[4096];
 static uint8_t gInfoEventBuffer[4096];
 static uint8_t gCritEventBuffer[4096];
 static chip::app::CircularEventBuffer gCircularEventBuffer[3];

 class TestContext : public chip::Test::AppContext
 {
 public:
     // Performs setup for each individual test in the test suite
     void SetUp() override
     {
         const chip::app::LogStorageResources logStorageResources[] = {
             { &gDebugEventBuffer[0], sizeof(gDebugEventBuffer), chip::app::PriorityLevel::Debug },
             { &gInfoEventBuffer[0], sizeof(gInfoEventBuffer), chip::app::PriorityLevel::Info },
             { &gCritEventBuffer[0], sizeof(gCritEventBuffer), chip::app::PriorityLevel::Critical },
         };

         chip::Test::AppContext::SetUp();

         CHIP_ERROR err = CHIP_NO_ERROR;
         // TODO: use ASSERT_EQ, once transition to pw_unit_test is complete
         VerifyOrDieWithMsg((err = mEventCounter.Init(0)) == CHIP_NO_ERROR, AppServer,
                            "Init EventCounter failed: %" CHIP_ERROR_FORMAT, err.Format());
         chip::app::EventManagement::CreateEventManagement(&GetExchangeManager(), ArraySize(logStorageResources),
                                                           gCircularEventBuffer, logStorageResources, &mEventCounter);
     }

     // Performs teardown for each individual test in the test suite
     void TearDown() override
     {
         chip::app::EventManagement::DestroyEventManagement();
         chip::Test::AppContext::TearDown();
     }

 private:
     MonotonicallyIncreasingCounter<EventNumber> mEventCounter;
 };

 nlTestSuite * gSuite = nullptr;

 //
 // The generated endpoint_config for the controller app has Endpoint 1
 // already used in the fixed endpoint set of size 1. Consequently, let's use the next
 // number higher than that for our dynamic test endpoint.
 //
 constexpr EndpointId kTestEndpointId = 2;

 class TestReadEvents
 {
 public:
     TestReadEvents() {}
     static void TestBasicCaching(nlTestSuite * apSuite, void * apContext);

 private:
 };

 //clang-format off
 DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(testClusterAttrs)
 DECLARE_DYNAMIC_ATTRIBUTE_LIST_END();

 DECLARE_DYNAMIC_CLUSTER_LIST_BEGIN(testEndpointClusters)
 DECLARE_DYNAMIC_CLUSTER(Clusters::UnitTesting::Id, testClusterAttrs, ZAP_CLUSTER_MASK(SERVER), nullptr, nullptr),
     DECLARE_DYNAMIC_CLUSTER_LIST_END;

 DECLARE_DYNAMIC_ENDPOINT(testEndpoint, testEndpointClusters);

 //clang-format on

 class TestReadCallback : public app::ClusterStateCache::Callback
 {
 public:
     TestReadCallback() : mClusterCacheAdapter(*this) {}
     void OnDone(app::ReadClient *) override {}

     void OnEventData(const EventHeader & aEventHeader, TLV::TLVReader * apData, const StatusIB * apStatus) override
     {
         ++mEventsSeen;
     }

     app::ClusterStateCache mClusterCacheAdapter;

     size_t mEventsSeen = 0;
 };

 namespace {

 void GenerateEvents(nlTestSuite * apSuite, chip::EventNumber & firstEventNumber, chip::EventNumber & lastEventNumber)
 {
     CHIP_ERROR err                 = CHIP_NO_ERROR;
     static uint8_t generationCount = 0;

     Clusters::UnitTesting::Events::TestEvent::Type content;

     for (int i = 0; i < 5; i++)
     {
         content.arg1 = static_cast<uint8_t>(generationCount++);
         NL_TEST_ASSERT(apSuite, (err = app::LogEvent(content, kTestEndpointId, lastEventNumber)) == CHIP_NO_ERROR);
         if (i == 0)
         {
             firstEventNumber = lastEventNumber;
         }
     }
 }

 } // namespace

 /*
  * This validates event caching by forcing a bunch of events to get generated, then reading them back
  * and upon completion of that operation, iterating over any events that have accumulated in the cache
  * and validating their contents.
  *
  * It then proceeds to do another round of generation and re-do the read, validating that the old and new
  * events are present in the cache.
  *
  */
 void TestReadEvents::TestBasicCaching(nlTestSuite * apSuite, void * apContext)
 {
     TestContext & ctx                    = *static_cast<TestContext *>(apContext);
     auto sessionHandle                   = ctx.GetSessionBobToAlice();
     app::InteractionModelEngine * engine = app::InteractionModelEngine::GetInstance();

     // Initialize the ember side server logic
     InitDataModelHandler();

     // Register our fake dynamic endpoint.
     DataVersion dataVersionStorage[ArraySize(testEndpointClusters)];
     emberAfSetDynamicEndpoint(0, kTestEndpointId, &testEndpoint, Span<DataVersion>(dataVersionStorage));

     chip::EventNumber firstEventNumber;
     chip::EventNumber lastEventNumber;

     GenerateEvents(apSuite, firstEventNumber, lastEventNumber);
     NL_TEST_ASSERT(apSuite, lastEventNumber > firstEventNumber);

     app::EventPathParams eventPath;
     eventPath.mEndpointId = kTestEndpointId;
     eventPath.mClusterId  = app::Clusters::UnitTesting::Id;
     app::ReadPrepareParams readParams(sessionHandle);

     readParams.mpEventPathParamsList    = &eventPath;
     readParams.mEventPathParamsListSize = 1;
     readParams.mEventNumber.SetValue(firstEventNumber);

     TestReadCallback readCallback;

     {
         app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
                                    app::ReadClient::InteractionType::Read);

         NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

         ctx.DrainAndServiceIO();

         uint8_t generationCount = 0;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;
                 return CHIP_NO_ERROR;
             });

         NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

         Optional<EventNumber> highestEventNumber;
         readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
         NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == lastEventNumber);

         //
         // Re-run the iterator but pass in a path filter: EP*/TestCluster/EID*
         //
         generationCount = 0;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;
                 return CHIP_NO_ERROR;
             },
             app::EventPathParams(kInvalidEndpointId, Clusters::UnitTesting::Id, kInvalidEventId));

         NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

         //
         // Re-run the iterator but pass in a path filter: EP*/TestCluster/TestEvent
         //
         generationCount = 0;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;
                 return CHIP_NO_ERROR;
             },
             app::EventPathParams(kInvalidEndpointId, Clusters::UnitTesting::Id, Clusters::UnitTesting::Events::TestEvent::Id));

         NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

         //
         // Re-run the iterator but pass in a min event number filter
         // (EventNumber = firstEventNumber + 1). We should only receive 4 events.
         //
         generationCount = 1;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber + 1);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;
                 return CHIP_NO_ERROR;
             },
             app::EventPathParams(), firstEventNumber + 1);

         NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

         //
         // Re-run the iterator but pass in a min event number filter
         // (EventNumber = firstEventNumber + 1) AND a path filter. We should only receive 4
         // events.
         //
         generationCount = 1;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber + 1);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;
                 return CHIP_NO_ERROR;
             },
             app::EventPathParams(kInvalidEndpointId, Clusters::UnitTesting::Id, kInvalidEventId), firstEventNumber + 1);

         NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);
     }

     //
     // Generate more events.
     //
     const EventNumber oldFirstEventNumber = firstEventNumber;
     GenerateEvents(apSuite, firstEventNumber, lastEventNumber);

     {
         app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
                                    app::ReadClient::InteractionType::Read);

         NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

         ctx.DrainAndServiceIO();

         //
         // Validate that we still have all 5 of the old events we received, as well as the new ones that just got generated.
         // This also ensures that we don't receive duplicate events in the `ForEachEventData` call below.
         //
         uint8_t generationCount = 0;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount, oldFirstEventNumber, lastEventNumber](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber >= oldFirstEventNumber);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;

                 return CHIP_NO_ERROR;
             });

         NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - oldFirstEventNumber + 1);

         Optional<EventNumber> highestEventNumber;
         readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
         NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == 9);

         readCallback.mClusterCacheAdapter.ClearEventCache();
         generationCount = 0;
         readCallback.mClusterCacheAdapter.ForEachEventData([&generationCount](const app::EventHeader & header) {
             generationCount++;
             return CHIP_NO_ERROR;
         });

         NL_TEST_ASSERT(apSuite, generationCount == 0);
         readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
         NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == 9);
     }

     //
     // Clear out the event cache and set its highest received event number to a non zero value. Validate that
     // we don't receive events lower than that value.
     //
     {
         app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
                                    app::ReadClient::InteractionType::Read);

         readCallback.mClusterCacheAdapter.ClearEventCache();
         constexpr EventNumber kLastSeenEventNumber = 3;
         NL_TEST_ASSERT(apSuite, kLastSeenEventNumber < lastEventNumber);
         readCallback.mClusterCacheAdapter.SetHighestReceivedEventNumber(kLastSeenEventNumber);
         readParams.mEventNumber.ClearValue();

         readCallback.mEventsSeen = 0;

         NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

         ctx.DrainAndServiceIO();

         // We should only get events with event numbers larger than kHighestEventNumberSeen.
         NL_TEST_ASSERT(apSuite, readCallback.mEventsSeen == lastEventNumber - kLastSeenEventNumber);

         uint8_t generationCount = kLastSeenEventNumber + 1;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount, lastEventNumber](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber > kLastSeenEventNumber);
                 NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;

                 return CHIP_NO_ERROR;
             });

         NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - oldFirstEventNumber + 1);
         Optional<EventNumber> highestEventNumber;
         readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
         NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == lastEventNumber);
     }

     //
     // Set user-provided event number, then read client would use user-provided event number and not use the cached one in read
     // client
     //

     {
         readParams.mEventNumber.SetValue(5);
         app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
                                    app::ReadClient::InteractionType::Read);
         readCallback.mClusterCacheAdapter.ClearEventCache(true);
         NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

         ctx.DrainAndServiceIO();

         //
         // Validate that we would receive 5 events
         //

         uint8_t generationCount = 5;
         readCallback.mClusterCacheAdapter.ForEachEventData(
             [&apSuite, &readCallback, &generationCount](const app::EventHeader & header) {
                 NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
                 NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);

                 Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
                 NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

                 NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
                 generationCount++;

                 return CHIP_NO_ERROR;
             });

         NL_TEST_ASSERT(apSuite, generationCount == 10);

         Optional<EventNumber> highestEventNumber;
         readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
         NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == 9);
     }

     NL_TEST_ASSERT(apSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0);

     emberAfClearDynamicEndpoint(0);
 }

 const nlTest sTests[] = {
     NL_TEST_DEF("TestBasicCaching", TestReadEvents::TestBasicCaching),
     NL_TEST_SENTINEL(),
 };

 nlTestSuite sSuite = {
     "TestEventCaching",
     &sTests[0],
     TestContext::nlTestSetUpTestSuite,
     TestContext::nlTestTearDownTestSuite,
     TestContext::nlTestSetUp,
     TestContext::nlTestTearDown,
 };

 } // namespace

 int TestEventCaching()
 {
     gSuite = &sSuite;
     return chip::ExecuteTestsWithContext<TestContext>(&sSuite);
 }

 CHIP_REGISTER_TEST_SUITE(TestEventCaching)
	/*
	*
	* Copyright (c) 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-common/zap-generated/ids/Attributes.h"
	#include "app-common/zap-generated/ids/Clusters.h"
	#include "app/ClusterStateCache.h"
	#include "app/ConcreteAttributePath.h"
	#include "protocols/interaction_model/Constants.h"
	#include <app-common/zap-generated/cluster-objects.h>
	#include <app/BufferedReadCallback.h>
	#include <app/CommandHandlerInterface.h>
	#include <app/EventLogging.h>
	#include <app/InteractionModelEngine.h>
	#include <app/data-model/Decode.h>
	#include <app/tests/AppTestContext.h>
	#include <app/util/DataModelHandler.h>
	#include <app/util/attribute-storage.h>
	#include <controller/InvokeInteraction.h>
	#include <lib/core/ErrorStr.h>
	#include <lib/support/TimeUtils.h>
	#include <lib/support/UnitTestContext.h>
	#include <lib/support/UnitTestRegistration.h>
	#include <lib/support/UnitTestUtils.h>
	#include <lib/support/logging/CHIPLogging.h>
	#include <messaging/tests/MessagingContext.h>
	#include <nlunit-test.h>

	using namespace chip;
	using namespace chip::app;
	using namespace chip::app::Clusters;

	namespace {

	static uint8_t gDebugEventBuffer[4096];
	static uint8_t gInfoEventBuffer[4096];
	static uint8_t gCritEventBuffer[4096];
	static chip::app::CircularEventBuffer gCircularEventBuffer[3];

	class TestContext : public chip::Test::AppContext
	{
	public:
	// Performs setup for each individual test in the test suite
	void SetUp() override
	{
	const chip::app::LogStorageResources logStorageResources[] = {
	{ &gDebugEventBuffer[0], sizeof(gDebugEventBuffer), chip::app::PriorityLevel::Debug },
	{ &gInfoEventBuffer[0], sizeof(gInfoEventBuffer), chip::app::PriorityLevel::Info },
	{ &gCritEventBuffer[0], sizeof(gCritEventBuffer), chip::app::PriorityLevel::Critical },
	};

	chip::Test::AppContext::SetUp();

	CHIP_ERROR err = CHIP_NO_ERROR;
	// TODO: use ASSERT_EQ, once transition to pw_unit_test is complete
	VerifyOrDieWithMsg((err = mEventCounter.Init(0)) == CHIP_NO_ERROR, AppServer,
	"Init EventCounter failed: %" CHIP_ERROR_FORMAT, err.Format());
	chip::app::EventManagement::CreateEventManagement(&GetExchangeManager(), ArraySize(logStorageResources),
	gCircularEventBuffer, logStorageResources, &mEventCounter);
	}

	// Performs teardown for each individual test in the test suite
	void TearDown() override
	{
	chip::app::EventManagement::DestroyEventManagement();
	chip::Test::AppContext::TearDown();
	}

	private:
	MonotonicallyIncreasingCounter<EventNumber> mEventCounter;
	};

	nlTestSuite * gSuite = nullptr;

	//
	// The generated endpoint_config for the controller app has Endpoint 1
	// already used in the fixed endpoint set of size 1. Consequently, let's use the next
	// number higher than that for our dynamic test endpoint.
	//
	constexpr EndpointId kTestEndpointId = 2;

	class TestReadEvents
	{
	public:
	TestReadEvents() {}
	static void TestBasicCaching(nlTestSuite * apSuite, void * apContext);

	private:
	};

	//clang-format off
	DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(testClusterAttrs)
	DECLARE_DYNAMIC_ATTRIBUTE_LIST_END();

	DECLARE_DYNAMIC_CLUSTER_LIST_BEGIN(testEndpointClusters)
	DECLARE_DYNAMIC_CLUSTER(Clusters::UnitTesting::Id, testClusterAttrs, ZAP_CLUSTER_MASK(SERVER), nullptr, nullptr),
	DECLARE_DYNAMIC_CLUSTER_LIST_END;

	DECLARE_DYNAMIC_ENDPOINT(testEndpoint, testEndpointClusters);

	//clang-format on

	class TestReadCallback : public app::ClusterStateCache::Callback
	{
	public:
	TestReadCallback() : mClusterCacheAdapter(*this) {}
	void OnDone(app::ReadClient *) override {}

	void OnEventData(const EventHeader & aEventHeader, TLV::TLVReader * apData, const StatusIB * apStatus) override
	{
	++mEventsSeen;
	}

	app::ClusterStateCache mClusterCacheAdapter;

	size_t mEventsSeen = 0;
	};

	namespace {

	void GenerateEvents(nlTestSuite * apSuite, chip::EventNumber & firstEventNumber, chip::EventNumber & lastEventNumber)
	{
	CHIP_ERROR err = CHIP_NO_ERROR;
	static uint8_t generationCount = 0;

	Clusters::UnitTesting::Events::TestEvent::Type content;

	for (int i = 0; i < 5; i++)
	{
	content.arg1 = static_cast<uint8_t>(generationCount++);
	NL_TEST_ASSERT(apSuite, (err = app::LogEvent(content, kTestEndpointId, lastEventNumber)) == CHIP_NO_ERROR);
	if (i == 0)
	{
	firstEventNumber = lastEventNumber;
	}
	}
	}

	} // namespace

	/*
	* This validates event caching by forcing a bunch of events to get generated, then reading them back
	* and upon completion of that operation, iterating over any events that have accumulated in the cache
	* and validating their contents.
	*
	* It then proceeds to do another round of generation and re-do the read, validating that the old and new
	* events are present in the cache.
	*
	*/
	void TestReadEvents::TestBasicCaching(nlTestSuite * apSuite, void * apContext)
	{
	TestContext & ctx = static_cast<TestContext >(apContext);
	auto sessionHandle = ctx.GetSessionBobToAlice();
	app::InteractionModelEngine * engine = app::InteractionModelEngine::GetInstance();

	// Initialize the ember side server logic
	InitDataModelHandler();

	// Register our fake dynamic endpoint.
	DataVersion dataVersionStorage[ArraySize(testEndpointClusters)];
	emberAfSetDynamicEndpoint(0, kTestEndpointId, &testEndpoint, Span<DataVersion>(dataVersionStorage));

	chip::EventNumber firstEventNumber;
	chip::EventNumber lastEventNumber;

	GenerateEvents(apSuite, firstEventNumber, lastEventNumber);
	NL_TEST_ASSERT(apSuite, lastEventNumber > firstEventNumber);

	app::EventPathParams eventPath;
	eventPath.mEndpointId = kTestEndpointId;
	eventPath.mClusterId = app::Clusters::UnitTesting::Id;
	app::ReadPrepareParams readParams(sessionHandle);

	readParams.mpEventPathParamsList = &eventPath;
	readParams.mEventPathParamsListSize = 1;
	readParams.mEventNumber.SetValue(firstEventNumber);

	TestReadCallback readCallback;

	{
	app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
	app::ReadClient::InteractionType::Read);

	NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

	ctx.DrainAndServiceIO();

	uint8_t generationCount = 0;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
	NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber);
	NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;
	return CHIP_NO_ERROR;
	});

	NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

	Optional<EventNumber> highestEventNumber;
	readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
	NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == lastEventNumber);

	//
	// Re-run the iterator but pass in a path filter: EP/TestCluster/EID
	//
	generationCount = 0;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
	NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber);
	NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;
	return CHIP_NO_ERROR;
	},
	app::EventPathParams(kInvalidEndpointId, Clusters::UnitTesting::Id, kInvalidEventId));

	NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

	//
	// Re-run the iterator but pass in a path filter: EP*/TestCluster/TestEvent
	//
	generationCount = 0;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
	NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber);
	NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;
	return CHIP_NO_ERROR;
	},
	app::EventPathParams(kInvalidEndpointId, Clusters::UnitTesting::Id, Clusters::UnitTesting::Events::TestEvent::Id));

	NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

	//
	// Re-run the iterator but pass in a min event number filter
	// (EventNumber = firstEventNumber + 1). We should only receive 4 events.
	//
	generationCount = 1;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
	NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber + 1);
	NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;
	return CHIP_NO_ERROR;
	},
	app::EventPathParams(), firstEventNumber + 1);

	NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);

	//
	// Re-run the iterator but pass in a min event number filter
	// (EventNumber = firstEventNumber + 1) AND a path filter. We should only receive 4
	// events.
	//
	generationCount = 1;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount, firstEventNumber, lastEventNumber](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
	NL_TEST_ASSERT(apSuite, header.mEventNumber >= firstEventNumber + 1);
	NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;
	return CHIP_NO_ERROR;
	},
	app::EventPathParams(kInvalidEndpointId, Clusters::UnitTesting::Id, kInvalidEventId), firstEventNumber + 1);

	NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - firstEventNumber + 1);
	}

	//
	// Generate more events.
	//
	const EventNumber oldFirstEventNumber = firstEventNumber;
	GenerateEvents(apSuite, firstEventNumber, lastEventNumber);

	{
	app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
	app::ReadClient::InteractionType::Read);

	NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

	ctx.DrainAndServiceIO();

	//
	// Validate that we still have all 5 of the old events we received, as well as the new ones that just got generated.
	// This also ensures that we don't receive duplicate events in the `ForEachEventData` call below.
	//
	uint8_t generationCount = 0;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount, oldFirstEventNumber, lastEventNumber](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
	NL_TEST_ASSERT(apSuite, header.mEventNumber >= oldFirstEventNumber);
	NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;

	return CHIP_NO_ERROR;
	});

	NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - oldFirstEventNumber + 1);

	Optional<EventNumber> highestEventNumber;
	readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
	NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == 9);

	readCallback.mClusterCacheAdapter.ClearEventCache();
	generationCount = 0;
	readCallback.mClusterCacheAdapter.ForEachEventData([&generationCount](const app::EventHeader & header) {
	generationCount++;
	return CHIP_NO_ERROR;
	});

	NL_TEST_ASSERT(apSuite, generationCount == 0);
	readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
	NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == 9);
	}

	//
	// Clear out the event cache and set its highest received event number to a non zero value. Validate that
	// we don't receive events lower than that value.
	//
	{
	app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
	app::ReadClient::InteractionType::Read);

	readCallback.mClusterCacheAdapter.ClearEventCache();
	constexpr EventNumber kLastSeenEventNumber = 3;
	NL_TEST_ASSERT(apSuite, kLastSeenEventNumber < lastEventNumber);
	readCallback.mClusterCacheAdapter.SetHighestReceivedEventNumber(kLastSeenEventNumber);
	readParams.mEventNumber.ClearValue();

	readCallback.mEventsSeen = 0;

	NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

	ctx.DrainAndServiceIO();

	// We should only get events with event numbers larger than kHighestEventNumberSeen.
	NL_TEST_ASSERT(apSuite, readCallback.mEventsSeen == lastEventNumber - kLastSeenEventNumber);

	uint8_t generationCount = kLastSeenEventNumber + 1;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount, lastEventNumber](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);
	NL_TEST_ASSERT(apSuite, header.mEventNumber > kLastSeenEventNumber);
	NL_TEST_ASSERT(apSuite, header.mEventNumber <= lastEventNumber);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;

	return CHIP_NO_ERROR;
	});

	NL_TEST_ASSERT(apSuite, generationCount == lastEventNumber - oldFirstEventNumber + 1);
	Optional<EventNumber> highestEventNumber;
	readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
	NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == lastEventNumber);
	}

	//
	// Set user-provided event number, then read client would use user-provided event number and not use the cached one in read
	// client
	//

	{
	readParams.mEventNumber.SetValue(5);
	app::ReadClient readClient(engine, &ctx.GetExchangeManager(), readCallback.mClusterCacheAdapter.GetBufferedCallback(),
	app::ReadClient::InteractionType::Read);
	readCallback.mClusterCacheAdapter.ClearEventCache(true);
	NL_TEST_ASSERT(apSuite, readClient.SendRequest(readParams) == CHIP_NO_ERROR);

	ctx.DrainAndServiceIO();

	//
	// Validate that we would receive 5 events
	//

	uint8_t generationCount = 5;
	readCallback.mClusterCacheAdapter.ForEachEventData(
	[&apSuite, &readCallback, &generationCount](const app::EventHeader & header) {
	NL_TEST_ASSERT(apSuite, header.mPath.mClusterId == Clusters::UnitTesting::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEventId == Clusters::UnitTesting::Events::TestEvent::Id);
	NL_TEST_ASSERT(apSuite, header.mPath.mEndpointId == kTestEndpointId);

	Clusters::UnitTesting::Events::TestEvent::DecodableType eventData;
	NL_TEST_ASSERT(apSuite, readCallback.mClusterCacheAdapter.Get(header.mEventNumber, eventData) == CHIP_NO_ERROR);

	NL_TEST_ASSERT(apSuite, eventData.arg1 == generationCount);
	generationCount++;

	return CHIP_NO_ERROR;
	});

	NL_TEST_ASSERT(apSuite, generationCount == 10);

	Optional<EventNumber> highestEventNumber;
	readCallback.mClusterCacheAdapter.GetHighestReceivedEventNumber(highestEventNumber);
	NL_TEST_ASSERT(apSuite, highestEventNumber.HasValue() && highestEventNumber.Value() == 9);
	}

	NL_TEST_ASSERT(apSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0);

	emberAfClearDynamicEndpoint(0);
	}

	const nlTest sTests[] = {
	NL_TEST_DEF("TestBasicCaching", TestReadEvents::TestBasicCaching),
	NL_TEST_SENTINEL(),
	};

	nlTestSuite sSuite = {
	"TestEventCaching",
	&sTests[0],
	TestContext::nlTestSetUpTestSuite,
	TestContext::nlTestTearDownTestSuite,
	TestContext::nlTestSetUp,
	TestContext::nlTestTearDown,
	};

	} // namespace

	int TestEventCaching()
	{
	gSuite = &sSuite;
	return chip::ExecuteTestsWithContext<TestContext>(&sSuite);
	}

	CHIP_REGISTER_TEST_SUITE(TestEventCaching)