diff --git a/src/app/tests/BUILD.gn b/src/app/tests/BUILD.gn index e8413b92026d9a..41f083e1735924 100644 --- a/src/app/tests/BUILD.gn +++ b/src/app/tests/BUILD.gn @@ -143,11 +143,18 @@ chip_test_suite("tests") { test_sources = [ "TestAttributeAccessInterfaceCache.cpp", "TestAttributePathExpandIterator.cpp", + "TestAttributePathParams.cpp", "TestAttributePersistenceProvider.cpp", "TestAttributeValueDecoder.cpp", "TestAttributeValueEncoder.cpp", + "TestBasicCommandPathRegistry.cpp", "TestBindingTable.cpp", "TestBuilderParser.cpp", + "TestCommandPathParams.cpp", + "TestConcreteAttributePath.cpp", + "TestDataModelSerialization.cpp", + "TestDefaultOTARequestorStorage.cpp", + "TestEventPathParams.cpp", "TestMessageDef.cpp", "TestNullable.cpp", "TestNumericAttributeTraits.cpp", @@ -193,6 +200,17 @@ chip_test_suite("tests") { "${chip_root}/src/lib/support:test_utils", "${chip_root}/src/lib/support:testing", ] + + if (chip_device_platform != "android") { + test_sources += [ + "TestExtensionFieldSets.cpp", + "TestSceneTable.cpp", + ] + public_deps += [ + ":power-cluster-test-srcs", + ":scenes-table-test-srcs", + ] + } } chip_test_suite_using_nltest("tests_nltest") { @@ -201,16 +219,9 @@ chip_test_suite_using_nltest("tests_nltest") { test_sources = [ "TestAclAttribute.cpp", "TestAclEvent.cpp", - "TestBasicCommandPathRegistry.cpp", - "TestClusterInfo.cpp", "TestCommandInteraction.cpp", - "TestCommandPathParams.cpp", - "TestConcreteAttributePath.cpp", - "TestDataModelSerialization.cpp", - "TestDefaultOTARequestorStorage.cpp", "TestEventLoggingNoUTCTime.cpp", "TestEventOverflow.cpp", - "TestEventPathParams.cpp", "TestFabricScopedEventLogging.cpp", "TestInteractionModelEngine.cpp", "TestReadInteraction.cpp", @@ -258,17 +269,6 @@ chip_test_suite_using_nltest("tests_nltest") { "${nlunit_test_root}:nlunit-test", ] - if (chip_device_platform != "android") { - test_sources += [ - "TestExtensionFieldSets.cpp", - "TestSceneTable.cpp", - ] - public_deps += [ - ":power-cluster-test-srcs", - ":scenes-table-test-srcs", - ] - } - if (chip_config_network_layer_ble && (chip_device_platform == "linux" || chip_device_platform == "darwin")) { test_sources += [ "TestCommissionManager.cpp" ] diff --git a/src/app/tests/TestAttributePathParams.cpp b/src/app/tests/TestAttributePathParams.cpp new file mode 100644 index 00000000000000..19745e20f027a0 --- /dev/null +++ b/src/app/tests/TestAttributePathParams.cpp @@ -0,0 +1,156 @@ +/* + * + * Copyright (c) 2021 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 +#include + +#include +#include + +namespace chip { +namespace app { +namespace TestPath { + +TEST(TestAttributePathParams, TestAttributePathIntersect) +{ + EndpointId endpointIdArray[2] = { 1, kInvalidEndpointId }; + ClusterId clusterIdArray[2] = { 2, kInvalidClusterId }; + AttributeId attributeIdArray[2] = { 3, kInvalidAttributeId }; + + for (auto endpointId1 : endpointIdArray) + { + for (auto clusterId1 : clusterIdArray) + { + for (auto attributeId1 : attributeIdArray) + { + for (auto endpointId2 : endpointIdArray) + { + for (auto clusterId2 : clusterIdArray) + { + for (auto attributeId2 : attributeIdArray) + { + AttributePathParams path1; + path1.mEndpointId = endpointId1; + path1.mClusterId = clusterId1; + path1.mAttributeId = attributeId1; + AttributePathParams path2; + path2.mEndpointId = endpointId2; + path2.mClusterId = clusterId2; + path2.mAttributeId = attributeId2; + EXPECT_TRUE(path1.Intersects(path2)); + } + } + } + } + } + } + + { + AttributePathParams path1; + path1.mEndpointId = 1; + AttributePathParams path2; + path2.mEndpointId = 2; + EXPECT_FALSE(path1.Intersects(path2)); + } + + { + AttributePathParams path1; + path1.mClusterId = 1; + AttributePathParams path2; + path2.mClusterId = 2; + EXPECT_FALSE(path1.Intersects(path2)); + } + + { + AttributePathParams path1; + path1.mAttributeId = 1; + AttributePathParams path2; + path2.mAttributeId = 2; + EXPECT_FALSE(path1.Intersects(path2)); + } +} + +TEST(TestAttributePathParams, TestAttributePathIncludedSameFieldId) +{ + AttributePathParams path1; + AttributePathParams path2; + AttributePathParams path3; + path1.mAttributeId = 1; + path2.mAttributeId = 1; + path3.mAttributeId = 1; + EXPECT_TRUE(path1.IsAttributePathSupersetOf(path2)); + path2.mListIndex = 1; + EXPECT_TRUE(path1.IsAttributePathSupersetOf(path2)); + path1.mListIndex = 0; + EXPECT_FALSE(path1.IsAttributePathSupersetOf(path3)); + path3.mListIndex = 0; + EXPECT_TRUE(path1.IsAttributePathSupersetOf(path3)); + path3.mListIndex = 1; + EXPECT_FALSE(path1.IsAttributePathSupersetOf(path3)); +} + +TEST(TestAttributePathParams, TestAttributePathIncludedDifferentFieldId) +{ + { + AttributePathParams path1; + AttributePathParams path2; + path1.mAttributeId = 1; + path2.mAttributeId = 2; + EXPECT_FALSE(path1.IsAttributePathSupersetOf(path2)); + } + { + AttributePathParams path1; + AttributePathParams path2; + path2.mAttributeId = 2; + EXPECT_TRUE(path1.IsAttributePathSupersetOf(path2)); + } + { + AttributePathParams path1; + AttributePathParams path2; + EXPECT_TRUE(path1.IsAttributePathSupersetOf(path2)); + } + { + AttributePathParams path1; + AttributePathParams path2; + + path1.mAttributeId = 1; + EXPECT_FALSE(path1.IsAttributePathSupersetOf(path2)); + } +} + +TEST(TestAttributePathParams, TestAttributePathIncludedDifferentEndpointId) +{ + AttributePathParams path1; + AttributePathParams path2; + path1.mEndpointId = 1; + path2.mEndpointId = 2; + EXPECT_FALSE(path1.IsAttributePathSupersetOf(path2)); +} + +TEST(TestAttributePathParams, TestAttributePathIncludedDifferentClusterId) +{ + AttributePathParams path1; + AttributePathParams path2; + path1.mClusterId = 1; + path2.mClusterId = 2; + EXPECT_FALSE(path1.IsAttributePathSupersetOf(path2)); +} + +} // namespace TestPath +} // namespace app +} // namespace chip diff --git a/src/app/tests/TestBasicCommandPathRegistry.cpp b/src/app/tests/TestBasicCommandPathRegistry.cpp index 28d7621ccbe7d1..cc003cfc1581c3 100644 --- a/src/app/tests/TestBasicCommandPathRegistry.cpp +++ b/src/app/tests/TestBasicCommandPathRegistry.cpp @@ -17,9 +17,9 @@ */ #include -#include -#include +#include +#include namespace chip { namespace app { @@ -30,7 +30,7 @@ size_t constexpr kQuickTestSize = 10; } // namespace -void TestAddingSameConcretePath(nlTestSuite * apSuite, void * apContext) +TEST(TestBasicCommandPathRegistry, TestAddingSameConcretePath) { CHIP_ERROR err = CHIP_NO_ERROR; BasicCommandPathRegistry basicCommandPathRegistry; @@ -47,11 +47,11 @@ void TestAddingSameConcretePath(nlTestSuite * apSuite, void * apContext) err = basicCommandPathRegistry.Add(concretePath, commandRef); } - NL_TEST_ASSERT(apSuite, err == CHIP_ERROR_DUPLICATE_KEY_ID); - NL_TEST_ASSERT(apSuite, basicCommandPathRegistry.Count() == 1); + EXPECT_EQ(err, CHIP_ERROR_DUPLICATE_KEY_ID); + EXPECT_EQ(basicCommandPathRegistry.Count(), 1u); } -void TestAddingSameCommandRef(nlTestSuite * apSuite, void * apContext) +TEST(TestBasicCommandPathRegistry, TestAddingSameCommandRef) { CHIP_ERROR err = CHIP_NO_ERROR; BasicCommandPathRegistry basicCommandPathRegistry; @@ -69,32 +69,30 @@ void TestAddingSameCommandRef(nlTestSuite * apSuite, void * apContext) err = basicCommandPathRegistry.Add(concretePath, commandRef); } - NL_TEST_ASSERT(apSuite, err == CHIP_ERROR_DUPLICATE_KEY_ID); - NL_TEST_ASSERT(apSuite, basicCommandPathRegistry.Count() == 1); + EXPECT_EQ(err, CHIP_ERROR_DUPLICATE_KEY_ID); + EXPECT_EQ(basicCommandPathRegistry.Count(), 1u); } -void TestAddingMaxNumberOfEntries(nlTestSuite * apSuite, void * apContext) +TEST(TestBasicCommandPathRegistry, TestAddingMaxNumberOfEntries) { - CHIP_ERROR err = CHIP_NO_ERROR; BasicCommandPathRegistry basicCommandPathRegistry; std::optional commandRef; uint16_t commandRefAndEndpointValue = 0; size_t idx = 0; - for (idx = 0; idx < kQuickTestSize && err == CHIP_NO_ERROR; idx++) + for (idx = 0; idx < kQuickTestSize; idx++) { ConcreteCommandPath concretePath(commandRefAndEndpointValue, 0, 0); commandRef.emplace(commandRefAndEndpointValue); commandRefAndEndpointValue++; - err = basicCommandPathRegistry.Add(concretePath, commandRef); + ASSERT_EQ(basicCommandPathRegistry.Add(concretePath, commandRef), CHIP_NO_ERROR); } - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, basicCommandPathRegistry.Count() == kQuickTestSize); + EXPECT_EQ(basicCommandPathRegistry.Count(), kQuickTestSize); } -void TestAddingTooManyEntries(nlTestSuite * apSuite, void * apContext) +TEST(TestBasicCommandPathRegistry, TestAddingTooManyEntries) { CHIP_ERROR err = CHIP_NO_ERROR; BasicCommandPathRegistry basicCommandPathRegistry; @@ -112,36 +110,10 @@ void TestAddingTooManyEntries(nlTestSuite * apSuite, void * apContext) err = basicCommandPathRegistry.Add(concretePath, commandRef); } - NL_TEST_ASSERT(apSuite, err == CHIP_ERROR_NO_MEMORY); - NL_TEST_ASSERT(apSuite, basicCommandPathRegistry.Count() == kQuickTestSize); + EXPECT_EQ(err, CHIP_ERROR_NO_MEMORY); + EXPECT_EQ(basicCommandPathRegistry.Count(), kQuickTestSize); } } // namespace TestBasicCommandPathRegistry } // namespace app } // namespace chip - -namespace { -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("TestAddingSameConcretePath", chip::app::TestBasicCommandPathRegistry::TestAddingSameConcretePath), - NL_TEST_DEF("TestAddingSameCommandRef", chip::app::TestBasicCommandPathRegistry::TestAddingSameCommandRef), - NL_TEST_DEF("TestAddingMaxNumberOfEntries", chip::app::TestBasicCommandPathRegistry::TestAddingMaxNumberOfEntries), - NL_TEST_DEF("TestAddingTooManyEntries", chip::app::TestBasicCommandPathRegistry::TestAddingTooManyEntries), - - NL_TEST_SENTINEL() -}; -// clang-format on - -} // namespace - -int TestBasicCommandPathRegistry() -{ - nlTestSuite theSuite = { "CommandPathRegistry", &sTests[0], nullptr, nullptr }; - - nlTestRunner(&theSuite, nullptr); - - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestBasicCommandPathRegistry) diff --git a/src/app/tests/TestClusterInfo.cpp b/src/app/tests/TestClusterInfo.cpp deleted file mode 100644 index bfbefc7af693e8..00000000000000 --- a/src/app/tests/TestClusterInfo.cpp +++ /dev/null @@ -1,255 +0,0 @@ -/* - * - * Copyright (c) 2021 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. - */ - -/** - * @file - * This file implements unit tests for CommandPathParams - * - */ - -#include -#include -#include -#include -#include -#include - -using namespace chip::Test; - -namespace chip { -namespace app { -namespace TestPath { -void TestAttributePathIntersect(nlTestSuite * apSuite, void * apContext) -{ - EndpointId endpointIdArray[2] = { 1, kInvalidEndpointId }; - ClusterId clusterIdArray[2] = { 2, kInvalidClusterId }; - AttributeId attributeIdArray[2] = { 3, kInvalidAttributeId }; - - for (auto endpointId1 : endpointIdArray) - { - for (auto clusterId1 : clusterIdArray) - { - for (auto attributeId1 : attributeIdArray) - { - for (auto endpointId2 : endpointIdArray) - { - for (auto clusterId2 : clusterIdArray) - { - for (auto attributeId2 : attributeIdArray) - { - AttributePathParams path1; - path1.mEndpointId = endpointId1; - path1.mClusterId = clusterId1; - path1.mAttributeId = attributeId1; - AttributePathParams path2; - path2.mEndpointId = endpointId2; - path2.mClusterId = clusterId2; - path2.mAttributeId = attributeId2; - NL_TEST_ASSERT(apSuite, path1.Intersects(path2)); - } - } - } - } - } - } - - { - AttributePathParams path1; - path1.mEndpointId = 1; - AttributePathParams path2; - path2.mEndpointId = 2; - NL_TEST_ASSERT(apSuite, !path1.Intersects(path2)); - } - - { - AttributePathParams path1; - path1.mClusterId = 1; - AttributePathParams path2; - path2.mClusterId = 2; - NL_TEST_ASSERT(apSuite, !path1.Intersects(path2)); - } - - { - AttributePathParams path1; - path1.mAttributeId = 1; - AttributePathParams path2; - path2.mAttributeId = 2; - NL_TEST_ASSERT(apSuite, !path1.Intersects(path2)); - } -} - -void TestAttributePathIncludedSameFieldId(nlTestSuite * apSuite, void * apContext) -{ - AttributePathParams clusterInfo1; - AttributePathParams clusterInfo2; - AttributePathParams clusterInfo3; - clusterInfo1.mAttributeId = 1; - clusterInfo2.mAttributeId = 1; - clusterInfo3.mAttributeId = 1; - NL_TEST_ASSERT(apSuite, clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); - clusterInfo2.mListIndex = 1; - NL_TEST_ASSERT(apSuite, clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); - clusterInfo1.mListIndex = 0; - NL_TEST_ASSERT(apSuite, !clusterInfo1.IsAttributePathSupersetOf(clusterInfo3)); - clusterInfo3.mListIndex = 0; - NL_TEST_ASSERT(apSuite, clusterInfo1.IsAttributePathSupersetOf(clusterInfo3)); - clusterInfo3.mListIndex = 1; - NL_TEST_ASSERT(apSuite, !clusterInfo1.IsAttributePathSupersetOf(clusterInfo3)); -} - -void TestAttributePathIncludedDifferentFieldId(nlTestSuite * apSuite, void * apContext) -{ - { - AttributePathParams clusterInfo1; - AttributePathParams clusterInfo2; - clusterInfo1.mAttributeId = 1; - clusterInfo2.mAttributeId = 2; - NL_TEST_ASSERT(apSuite, !clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); - } - { - AttributePathParams clusterInfo1; - AttributePathParams clusterInfo2; - clusterInfo2.mAttributeId = 2; - NL_TEST_ASSERT(apSuite, clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); - } - { - AttributePathParams clusterInfo1; - AttributePathParams clusterInfo2; - NL_TEST_ASSERT(apSuite, clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); - } - { - AttributePathParams clusterInfo1; - AttributePathParams clusterInfo2; - - clusterInfo1.mAttributeId = 1; - NL_TEST_ASSERT(apSuite, !clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); - } -} - -void TestAttributePathIncludedDifferentEndpointId(nlTestSuite * apSuite, void * apContext) -{ - AttributePathParams clusterInfo1; - AttributePathParams clusterInfo2; - clusterInfo1.mEndpointId = 1; - clusterInfo2.mEndpointId = 2; - NL_TEST_ASSERT(apSuite, !clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); -} - -void TestAttributePathIncludedDifferentClusterId(nlTestSuite * apSuite, void * apContext) -{ - AttributePathParams clusterInfo1; - AttributePathParams clusterInfo2; - clusterInfo1.mClusterId = 1; - clusterInfo2.mClusterId = 2; - NL_TEST_ASSERT(apSuite, !clusterInfo1.IsAttributePathSupersetOf(clusterInfo2)); -} - -/* -{kInvalidEndpointId, kInvalidClusterId, kInvalidEventId}, -{kInvalidEndpointId, MockClusterId(1), kInvalidEventId}, -{kInvalidEndpointId, MockClusterId(1), MockEventId(1)}, -{kMockEndpoint1, kInvalidClusterId, kInvalidEventId}, -{kMockEndpoint1, MockClusterId(1), kInvalidEventId}, -{kMockEndpoint1, MockClusterId(1), MockEventId(1)}, -*/ -chip::app::EventPathParams validEventpaths[6]; -void InitEventPaths() -{ - validEventpaths[1].mClusterId = MockClusterId(1); - validEventpaths[2].mClusterId = MockClusterId(1); - validEventpaths[2].mEventId = MockEventId(1); - validEventpaths[3].mEndpointId = kMockEndpoint1; - validEventpaths[4].mEndpointId = kMockEndpoint1; - validEventpaths[4].mClusterId = MockClusterId(1); - validEventpaths[5].mEndpointId = kMockEndpoint1; - validEventpaths[5].mClusterId = MockClusterId(1); - validEventpaths[5].mEventId = MockEventId(1); -} - -void TestEventPathSameEventId(nlTestSuite * apSuite, void * apContext) -{ - ConcreteEventPath testPath(kMockEndpoint1, MockClusterId(1), MockEventId(1)); - for (auto & path : validEventpaths) - { - NL_TEST_ASSERT(apSuite, path.IsValidEventPath()); - NL_TEST_ASSERT(apSuite, path.IsEventPathSupersetOf(testPath)); - } -} - -void TestEventPathDifferentEventId(nlTestSuite * apSuite, void * apContext) -{ - ConcreteEventPath testPath(kMockEndpoint1, MockClusterId(1), MockEventId(2)); - NL_TEST_ASSERT(apSuite, validEventpaths[0].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, validEventpaths[1].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[2].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, validEventpaths[3].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, validEventpaths[4].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[5].IsEventPathSupersetOf(testPath)); -} - -void TestEventPathDifferentClusterId(nlTestSuite * apSuite, void * apContext) -{ - ConcreteEventPath testPath(kMockEndpoint1, MockClusterId(2), MockEventId(1)); - NL_TEST_ASSERT(apSuite, validEventpaths[0].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[1].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[2].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, validEventpaths[3].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[4].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[5].IsEventPathSupersetOf(testPath)); -} - -void TestEventPathDifferentEndpointId(nlTestSuite * apSuite, void * apContext) -{ - ConcreteEventPath testPath(kMockEndpoint2, MockClusterId(1), MockEventId(1)); - NL_TEST_ASSERT(apSuite, validEventpaths[0].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, validEventpaths[1].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, validEventpaths[2].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[3].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[4].IsEventPathSupersetOf(testPath)); - NL_TEST_ASSERT(apSuite, !validEventpaths[5].IsEventPathSupersetOf(testPath)); -} - -} // namespace TestPath -} // namespace app -} // namespace chip - -namespace { -const nlTest sTests[] = { - NL_TEST_DEF("TestAttributePathIncludedSameFieldId", chip::app::TestPath::TestAttributePathIncludedSameFieldId), - NL_TEST_DEF("TestAttributePathIncludedDifferentFieldId", chip::app::TestPath::TestAttributePathIncludedDifferentFieldId), - NL_TEST_DEF("TestAttributePathIncludedDifferentEndpointId", chip::app::TestPath::TestAttributePathIncludedDifferentEndpointId), - NL_TEST_DEF("TestAttributePathIncludedDifferentClusterId", chip::app::TestPath::TestAttributePathIncludedDifferentClusterId), - NL_TEST_DEF("TestEventPathSameEventId", chip::app::TestPath::TestEventPathSameEventId), - NL_TEST_DEF("TestEventPathDifferentEventId", chip::app::TestPath::TestEventPathDifferentEventId), - NL_TEST_DEF("TestEventPathDifferentClusterId", chip::app::TestPath::TestEventPathDifferentClusterId), - NL_TEST_DEF("TestEventPathDifferentEndpointId", chip::app::TestPath::TestEventPathDifferentEndpointId), - NL_TEST_DEF("TestAttributePathIntersect", chip::app::TestPath::TestAttributePathIntersect), - NL_TEST_SENTINEL() -}; -} - -int TestPath() -{ - nlTestSuite theSuite = { "TestPath", &sTests[0], nullptr, nullptr }; - chip::app::TestPath::InitEventPaths(); - nlTestRunner(&theSuite, nullptr); - - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestPath) diff --git a/src/app/tests/TestCommandPathParams.cpp b/src/app/tests/TestCommandPathParams.cpp index 62b0b295b5b362..83a34cbc922537 100644 --- a/src/app/tests/TestCommandPathParams.cpp +++ b/src/app/tests/TestCommandPathParams.cpp @@ -23,74 +23,54 @@ */ #include -#include -#include + +#include +#include namespace chip { namespace app { namespace TestCommandPathParams { -void TestSamePath(nlTestSuite * apSuite, void * apContext) +TEST(TestCommandPathParams, TestSamePath) { CommandPathParams commandPathParams1(1, 2, 3, 4, CommandPathFlags::kEndpointIdValid); CommandPathParams commandPathParams2(1, 2, 3, 4, CommandPathFlags::kEndpointIdValid); - NL_TEST_ASSERT(apSuite, commandPathParams1.IsSamePath(commandPathParams2)); + EXPECT_TRUE(commandPathParams1.IsSamePath(commandPathParams2)); } -void TestDifferentEndpointId(nlTestSuite * apSuite, void * apContext) +TEST(TestCommandPathParams, TestDifferentEndpointId) { CommandPathParams commandPathParams1(1, 2, 3, 4, CommandPathFlags::kEndpointIdValid); CommandPathParams commandPathParams2(6, 2, 3, 4, CommandPathFlags::kEndpointIdValid); - NL_TEST_ASSERT(apSuite, !commandPathParams1.IsSamePath(commandPathParams2)); + EXPECT_FALSE(commandPathParams1.IsSamePath(commandPathParams2)); } -void TestDifferentGroupId(nlTestSuite * apSuite, void * apContext) +TEST(TestCommandPathParams, TestDifferentGroupId) { CommandPathParams commandPathParams1(1, 2, 3, 4, CommandPathFlags::kGroupIdValid); CommandPathParams commandPathParams2(1, 6, 3, 4, CommandPathFlags::kGroupIdValid); - NL_TEST_ASSERT(apSuite, !commandPathParams1.IsSamePath(commandPathParams2)); + EXPECT_FALSE(commandPathParams1.IsSamePath(commandPathParams2)); } -void TestDifferentClusterId(nlTestSuite * apSuite, void * apContext) +TEST(TestCommandPathParams, TestDifferentClusterId) { CommandPathParams commandPathParams1(1, 2, 3, 4, CommandPathFlags::kEndpointIdValid); CommandPathParams commandPathParams2(1, 2, 6, 4, CommandPathFlags::kEndpointIdValid); - NL_TEST_ASSERT(apSuite, !commandPathParams1.IsSamePath(commandPathParams2)); + EXPECT_FALSE(commandPathParams1.IsSamePath(commandPathParams2)); } -void TestDifferentCommandId(nlTestSuite * apSuite, void * apContext) +TEST(TestCommandPathParams, TestDifferentCommandId) { CommandPathParams commandPathParams1(1, 2, 3, 4, CommandPathFlags::kEndpointIdValid); CommandPathParams commandPathParams2(1, 2, 3, 6, CommandPathFlags::kEndpointIdValid); - NL_TEST_ASSERT(apSuite, !commandPathParams1.IsSamePath(commandPathParams2)); + EXPECT_FALSE(commandPathParams1.IsSamePath(commandPathParams2)); } -void TestDifferentPathFlag(nlTestSuite * apSuite, void * apContext) +TEST(TestCommandPathParams, TestDifferentPathFlag) { CommandPathParams commandPathParams1(1, 2, 3, 4, CommandPathFlags::kEndpointIdValid); CommandPathParams commandPathParams2(1, 2, 3, 4, CommandPathFlags::kGroupIdValid); - NL_TEST_ASSERT(apSuite, !commandPathParams1.IsSamePath(commandPathParams2)); + EXPECT_FALSE(commandPathParams1.IsSamePath(commandPathParams2)); } } // namespace TestCommandPathParams } // namespace app } // namespace chip - -namespace { -const nlTest sTests[] = { NL_TEST_DEF("TestSamePath", chip::app::TestCommandPathParams::TestSamePath), - NL_TEST_DEF("TestDifferentEndpointId", chip::app::TestCommandPathParams::TestDifferentEndpointId), - NL_TEST_DEF("TestDifferentGroupId", chip::app::TestCommandPathParams::TestDifferentGroupId), - NL_TEST_DEF("TestDifferentClusterId", chip::app::TestCommandPathParams::TestDifferentClusterId), - NL_TEST_DEF("TestDifferentCommandId", chip::app::TestCommandPathParams::TestDifferentCommandId), - NL_TEST_DEF("TestDifferentPathFlag", chip::app::TestCommandPathParams::TestDifferentPathFlag), - NL_TEST_SENTINEL() }; -} - -int TestCommandPathParams() -{ - nlTestSuite theSuite = { "CommandPathParams", &sTests[0], nullptr, nullptr }; - - nlTestRunner(&theSuite, nullptr); - - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestCommandPathParams) diff --git a/src/app/tests/TestConcreteAttributePath.cpp b/src/app/tests/TestConcreteAttributePath.cpp index a598c2f23c121f..d9f50ab799f487 100644 --- a/src/app/tests/TestConcreteAttributePath.cpp +++ b/src/app/tests/TestConcreteAttributePath.cpp @@ -17,36 +17,37 @@ */ #include -#include -#include + +#include +#include using namespace chip; using namespace chip::app; namespace { -void TestConcreteAttributePathEqualityDefaultConstructor(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteAttributePathEqualityDefaultConstructor) { ConcreteAttributePath path_one; ConcreteAttributePath path_two; - NL_TEST_ASSERT(aSuite, path_one == path_two); + EXPECT_EQ(path_one, path_two); } -void TestConcreteAttributePathEquality(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteAttributePathEquality) { ConcreteAttributePath path_one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteAttributePath path_two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); - NL_TEST_ASSERT(aSuite, path_one == path_two); + EXPECT_EQ(path_one, path_two); } -void TestConcreteAttributePathInequalityDifferentAttributeId(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteAttributePathInequalityDifferentAttributeId) { ConcreteAttributePath path_one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteAttributePath path_two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/4); - NL_TEST_ASSERT(aSuite, path_one != path_two); + EXPECT_NE(path_one, path_two); } -void TestConcreteDataAttributePathMatchesConcreteAttributePathEquality(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathMatchesConcreteAttributePathEquality) { ConcreteAttributePath path(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteDataAttributePath data_path(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); @@ -56,138 +57,96 @@ void TestConcreteDataAttributePathMatchesConcreteAttributePathEquality(nlTestSui /*aListOp=*/ConcreteDataAttributePath::ListOperation::ReplaceAll, /*aListIndex=*/5U); - NL_TEST_ASSERT(aSuite, data_path.MatchesConcreteAttributePath(path)); - NL_TEST_ASSERT(aSuite, data_path_with_version.MatchesConcreteAttributePath(path)); - NL_TEST_ASSERT(aSuite, data_path_with_list.MatchesConcreteAttributePath(path)); + EXPECT_TRUE(data_path.MatchesConcreteAttributePath(path)); + EXPECT_TRUE(data_path_with_version.MatchesConcreteAttributePath(path)); + EXPECT_TRUE(data_path_with_list.MatchesConcreteAttributePath(path)); } -void TestConcreteDataAttributePathMatchesConcreteAttributePathInequality(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathMatchesConcreteAttributePathInequality) { ConcreteAttributePath path(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteDataAttributePath data_path(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/4); - NL_TEST_ASSERT(aSuite, !data_path.MatchesConcreteAttributePath(path)); + EXPECT_FALSE(data_path.MatchesConcreteAttributePath(path)); } -void TestConcreteDataAttributePathEqualityDefaultConstructor(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathEqualityDefaultConstructor) { ConcreteDataAttributePath one; ConcreteDataAttributePath two; - NL_TEST_ASSERT(aSuite, one == two); + EXPECT_EQ(one, two); } -void TestConcreteDataAttributePathEqualityConcreteAttributePathConstructor(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathEqualityConcreteAttributePathConstructor) { ConcreteAttributePath path(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteDataAttributePath one(path); ConcreteDataAttributePath two(path); - NL_TEST_ASSERT(aSuite, one == two); + EXPECT_EQ(one, two); } -void TestConcreteDataAttributePathInequalityConcreteAttributePathConstructorDifferentAttributeId(nlTestSuite * aSuite, - void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathInequalityConcreteAttributePathConstructorDifferentAttributeId) { ConcreteAttributePath path_one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteAttributePath path_two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/4); ConcreteDataAttributePath one(path_one); ConcreteDataAttributePath two(path_two); - NL_TEST_ASSERT(aSuite, one != two); + EXPECT_NE(one, two); } -void TestConcreteDataAttributePathEqualityConcreteAttributePathArgsConstructor(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathEqualityConcreteAttributePathArgsConstructor) { ConcreteDataAttributePath one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteDataAttributePath two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); - NL_TEST_ASSERT(aSuite, one == two); + EXPECT_EQ(one, two); } -void TestConcreteDataAttributePathInequalityConcreteAttributePathArgsConstructorDifferentAttributeId(nlTestSuite * aSuite, - void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathInequalityConcreteAttributePathArgsConstructorDifferentAttributeId) { ConcreteDataAttributePath one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3); ConcreteDataAttributePath two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/4); - NL_TEST_ASSERT(aSuite, one != two); + EXPECT_NE(one, two); } -void TestConcreteDataAttributePathEqualityDataVersionConstructor(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathEqualityDataVersionConstructor) { ConcreteDataAttributePath one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, /*aDataVersion=*/MakeOptional(4U)); ConcreteDataAttributePath two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, /*aDataVersion=*/MakeOptional(4U)); - NL_TEST_ASSERT(aSuite, one == two); + EXPECT_EQ(one, two); } -void TestConcreteDataAttributePathInequalityDataVersionConstructorDifferentDataVersion(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathInequalityDataVersionConstructorDifferentDataVersion) { ConcreteDataAttributePath one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, /*aDataVersion=*/MakeOptional(4U)); ConcreteDataAttributePath two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, /*aDataVersion=*/MakeOptional(5U)); - NL_TEST_ASSERT(aSuite, one != two); + EXPECT_NE(one, two); } -void TestConcreteDataAttributePathEqualityListConstructor(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathEqualityListConstructor) { ConcreteDataAttributePath one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, ConcreteDataAttributePath::ListOperation::ReplaceAll, /*aListIndex=*/5); ConcreteDataAttributePath two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, ConcreteDataAttributePath::ListOperation::ReplaceAll, /*aListIndex=*/5); - NL_TEST_ASSERT(aSuite, one == two); + EXPECT_EQ(one, two); } -void TestConcreteDataAttributePathInequalityListConstructorDifferentListOp(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathInequalityListConstructorDifferentListOp) { ConcreteDataAttributePath one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, ConcreteDataAttributePath::ListOperation::ReplaceAll, /*aListIndex=*/5); ConcreteDataAttributePath two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, ConcreteDataAttributePath::ListOperation::ReplaceItem, /*aListIndex=*/5); - NL_TEST_ASSERT(aSuite, one != two); + EXPECT_NE(one, two); } -void TestConcreteDataAttributePathInequalityListConstructorDifferentListIndex(nlTestSuite * aSuite, void * aContext) +TEST(TestConcreteAttributePath, TestConcreteDataAttributePathInequalityListConstructorDifferentListIndex) { ConcreteDataAttributePath one(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, ConcreteDataAttributePath::ListOperation::ReplaceAll, /*aListIndex=*/5); ConcreteDataAttributePath two(/*aEndpointId=*/1, /*aClusterId=*/2, /*aAttributeId=*/3, ConcreteDataAttributePath::ListOperation::ReplaceAll, /*aListIndex=*/6); - NL_TEST_ASSERT(aSuite, one != two); + EXPECT_NE(one, two); } -const nlTest sTests[] = { - NL_TEST_DEF("TestConcreteAttributePathEqualityDefaultConstructor", TestConcreteAttributePathEqualityDefaultConstructor), - NL_TEST_DEF("TestConcreteAttributePathEquality", TestConcreteAttributePathEquality), - NL_TEST_DEF("TestConcreteAttributePathInequalityDifferentAttributeId", TestConcreteAttributePathInequalityDifferentAttributeId), - NL_TEST_DEF("TestConcreteDataAttributePathMatchesConcreteAttributePathEquality", - TestConcreteDataAttributePathMatchesConcreteAttributePathEquality), - NL_TEST_DEF("TestConcreteDataAttributePathMatchesConcreteAttributePathInequality", - TestConcreteDataAttributePathMatchesConcreteAttributePathInequality), - NL_TEST_DEF("TestConcreteDataAttributePathEqualityDefaultConstructor", TestConcreteDataAttributePathEqualityDefaultConstructor), - NL_TEST_DEF("TestConcreteDataAttributePathEqualityConcreteAttributePathConstructor", - TestConcreteDataAttributePathEqualityConcreteAttributePathConstructor), - NL_TEST_DEF("TestConcreteDataAttributePathInequalityConcreteAttributePathConstructorDifferentAttributeId", - TestConcreteDataAttributePathInequalityConcreteAttributePathConstructorDifferentAttributeId), - NL_TEST_DEF("TestConcreteDataAttributePathEqualityConcreteAttributePathArgsConstructor", - TestConcreteDataAttributePathEqualityConcreteAttributePathArgsConstructor), - NL_TEST_DEF("TestConcreteDataAttributePathInequalityConcreteAttributePathArgsConstructorDifferentAttributeId", - TestConcreteDataAttributePathInequalityConcreteAttributePathArgsConstructorDifferentAttributeId), - NL_TEST_DEF("TestConcreteDataAttributePathEqualityDataVersionConstructor", - TestConcreteDataAttributePathEqualityDataVersionConstructor), - NL_TEST_DEF("TestConcreteDataAttributePathInequalityDataVersionConstructorDifferentDataVersion", - TestConcreteDataAttributePathInequalityDataVersionConstructorDifferentDataVersion), - NL_TEST_DEF("TestConcreteDataAttributePathEqualityListConstructor", TestConcreteDataAttributePathEqualityListConstructor), - NL_TEST_DEF("TestConcreteDataAttributePathInequalityListConstructorDifferentListOp", - TestConcreteDataAttributePathInequalityListConstructorDifferentListOp), - NL_TEST_DEF("TestConcreteDataAttributePathInequalityListConstructorDifferentListIndex", - TestConcreteDataAttributePathInequalityListConstructorDifferentListIndex), - NL_TEST_SENTINEL() -}; - } // anonymous namespace - -int TestConcreteAttributePath() -{ - nlTestSuite theSuite = { "ConcreteAttributePath", &sTests[0], nullptr, nullptr }; - - nlTestRunner(&theSuite, nullptr); - - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestConcreteAttributePath) diff --git a/src/app/tests/TestDataModelSerialization.cpp b/src/app/tests/TestDataModelSerialization.cpp index cdfa6560d70150..4c4a54e2e5ab74 100644 --- a/src/app/tests/TestDataModelSerialization.cpp +++ b/src/app/tests/TestDataModelSerialization.cpp @@ -16,57 +16,37 @@ * limitations under the License. */ -/** - * @file - * This file implements unit tests for CHIP Interaction Model Command Interaction - * - */ - #include #include #include #include #include -#include -#include #include #include +#include +#include + namespace { using namespace chip; using namespace chip::app; using namespace chip::app::Clusters; -class TestDataModelSerialization +class TestDataModelSerialization : public ::testing::Test { public: - static void TestDataModelSerialization_EncAndDecSimpleStruct(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_EncAndDecNestedStruct(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_EncAndDecNestedStructList(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_EncAndDecDecodableNestedStructList(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_EncAndDecDecodableDoubleNestedStructList(nlTestSuite * apSuite, void * apContext); - - static void TestDataModelSerialization_OptionalFields(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_ExtraField(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_InvalidSimpleFieldTypes(nlTestSuite * apSuite, void * apContext); - static void TestDataModelSerialization_InvalidListType(nlTestSuite * apSuite, void * apContext); - - static void NullablesOptionalsStruct(nlTestSuite * apSuite, void * apContext); - static void NullablesOptionalsCommand(nlTestSuite * apSuite, void * apContext); + static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } + static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); } + void TearDown() override { System::PacketBufferHandle buf = mStore.Release(); } - void Shutdown(); - -protected: // Helper functions template - static void NullablesOptionalsEncodeDecodeCheck(nlTestSuite * apSuite, void * apContext, bool encodeNulls, bool encodeValues); + void NullablesOptionalsEncodeDecodeCheck(bool encodeNulls, bool encodeValues); template - static void NullablesOptionalsEncodeDecodeCheck(nlTestSuite * apSuite, void * apContext); + void NullablesOptionalsEncodeDecodeCheck(); -private: void SetupBuf(); void DumpBuf(); void SetupReader(); @@ -74,13 +54,10 @@ class TestDataModelSerialization System::TLVPacketBufferBackingStore mStore; TLV::TLVWriter mWriter; TLV::TLVReader mReader; - nlTestSuite * mpSuite; }; using namespace TLV; -TestDataModelSerialization gTestDataModelSerialization; - void TestDataModelSerialization::SetupBuf() { System::PacketBufferHandle buf; @@ -92,11 +69,6 @@ void TestDataModelSerialization::SetupBuf() mReader.Init(mStore); } -void TestDataModelSerialization::Shutdown() -{ - System::PacketBufferHandle buf = mStore.Release(); -} - void TestDataModelSerialization::DumpBuf() { TLV::TLVReader reader; @@ -112,12 +84,9 @@ void TestDataModelSerialization::DumpBuf() void TestDataModelSerialization::SetupReader() { - CHIP_ERROR err; mReader.Init(mStore); - err = mReader.Next(); - - NL_TEST_ASSERT(mpSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(mReader.Next(), CHIP_NO_ERROR); } template @@ -161,13 +130,9 @@ bool StringMatches(Span str1, const char * str2) return (strncmp(str1.data(), str2, str1.size()) == 0); } -void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruct(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, EncAndDecSimpleStruct) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -186,13 +151,11 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruc t.f.Set(Clusters::UnitTesting::SimpleBitmap::kValueC); - err = DataModel::Encode(_this->mWriter, TLV::AnonymousTag(), t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Encode(mWriter, TLV::AnonymousTag(), t), CHIP_NO_ERROR); - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - _this->DumpBuf(); + DumpBuf(); } // @@ -201,35 +164,31 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruc { Clusters::UnitTesting::Structs::SimpleStruct::Type t; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, t.a == 20); - NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c == Clusters::UnitTesting::SimpleEnum::kValueA); + EXPECT_EQ(t.a, 20); + EXPECT_TRUE(t.b); + EXPECT_EQ(t.c, Clusters::UnitTesting::SimpleEnum::kValueA); - NL_TEST_ASSERT(apSuite, t.d.size() == 4); + EXPECT_EQ(t.d.size(), 4u); for (uint32_t i = 0; i < t.d.size(); i++) { - NL_TEST_ASSERT(apSuite, t.d.data()[i] == i); + EXPECT_EQ(t.d.data()[i], i); } - NL_TEST_ASSERT(apSuite, StringMatches(t.e, "chip")); - NL_TEST_ASSERT(apSuite, t.f.HasOnly(Clusters::UnitTesting::SimpleBitmap::kValueC)); + EXPECT_TRUE(StringMatches(t.e, "chip")); + EXPECT_TRUE(t.f.HasOnly(Clusters::UnitTesting::SimpleBitmap::kValueC)); } } -void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum(nlTestSuite * apSuite, - void * apContext) +TEST_F(TestDataModelSerialization, EncAndDecSimpleStructNegativeEnum) + { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -248,13 +207,11 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruc t.f.Set(Clusters::UnitTesting::SimpleBitmap::kValueC); - err = DataModel::Encode(_this->mWriter, TLV::AnonymousTag(), t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Encode(mWriter, TLV::AnonymousTag(), t), CHIP_NO_ERROR); - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - _this->DumpBuf(); + DumpBuf(); } // @@ -263,21 +220,17 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruc { Clusters::UnitTesting::Structs::SimpleStruct::Type t; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, to_underlying(t.c) == 4); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); + EXPECT_EQ(to_underlying(t.c), 4); } } -void TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruct(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, EncAndDecNestedStruct) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -296,13 +249,10 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruc t.c.e = Span{ strbuf, strlen(strbuf) }; - err = DataModel::Encode(_this->mWriter, TLV::AnonymousTag(), t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Encode(mWriter, TLV::AnonymousTag(), t), CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - _this->DumpBuf(); + DumpBuf(); } // @@ -311,36 +261,30 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruc { Clusters::UnitTesting::Structs::NestedStruct::DecodableType t; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, t.a == 20); - NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c.a == 11); - NL_TEST_ASSERT(apSuite, t.c.b == true); - NL_TEST_ASSERT(apSuite, t.c.c == Clusters::UnitTesting::SimpleEnum::kValueB); + EXPECT_EQ(t.a, 20); + EXPECT_TRUE(t.b); + EXPECT_EQ(t.c.a, 11); + EXPECT_TRUE(t.c.b); + EXPECT_EQ(t.c.c, Clusters::UnitTesting::SimpleEnum::kValueB); - NL_TEST_ASSERT(apSuite, t.c.d.size() == 4); + EXPECT_EQ(t.c.d.size(), 4u); for (uint32_t i = 0; i < t.c.d.size(); i++) { - NL_TEST_ASSERT(apSuite, t.c.d.data()[i] == i); + EXPECT_EQ(t.c.d.data()[i], i); } - NL_TEST_ASSERT(apSuite, StringMatches(t.c.e, "chip")); + EXPECT_TRUE(StringMatches(t.c.e, "chip")); } } - -void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNestedStructList(nlTestSuite * apSuite, - void * apContext) +TEST_F(TestDataModelSerialization, EncAndDecDecodableNestedStructList) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -381,13 +325,10 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe t.c.e = Span{ strbuf, strlen(strbuf) }; t.d = structList; - err = DataModel::Encode(_this->mWriter, TLV::AnonymousTag(), t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Encode(mWriter, TLV::AnonymousTag(), t), CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - _this->DumpBuf(); + DumpBuf(); } // @@ -397,18 +338,17 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe Clusters::UnitTesting::Structs::NestedStructList::DecodableType t; int i; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, t.a == 20); - NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c.a == 11); - NL_TEST_ASSERT(apSuite, t.c.b == true); - NL_TEST_ASSERT(apSuite, t.c.c == Clusters::UnitTesting::SimpleEnum::kValueB); + EXPECT_EQ(t.a, 20); + EXPECT_TRUE(t.b); + EXPECT_EQ(t.c.a, 11); + EXPECT_TRUE(t.c.b); + EXPECT_EQ(t.c.c, Clusters::UnitTesting::SimpleEnum::kValueB); - NL_TEST_ASSERT(apSuite, StringMatches(t.c.e, "chip")); + EXPECT_TRUE(StringMatches(t.c.e, "chip")); { i = 0; @@ -416,13 +356,13 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe while (iter.Next()) { auto & item = iter.GetValue(); - NL_TEST_ASSERT(apSuite, item.a == static_cast(i)); - NL_TEST_ASSERT(apSuite, item.b == true); + EXPECT_EQ(item.a, static_cast(i)); + EXPECT_TRUE(item.b); i++; } - NL_TEST_ASSERT(apSuite, iter.GetStatus() == CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, i == 4); + EXPECT_EQ(iter.GetStatus(), CHIP_NO_ERROR); + EXPECT_EQ(i, 4); } { @@ -431,12 +371,12 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe while (iter.Next()) { auto & item = iter.GetValue(); - NL_TEST_ASSERT(apSuite, item == static_cast(i + 10000)); + EXPECT_EQ(item, static_cast(i + 10000)); i++; } - NL_TEST_ASSERT(apSuite, iter.GetStatus() == CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, i == 4); + EXPECT_EQ(iter.GetStatus(), CHIP_NO_ERROR); + EXPECT_EQ(i, 4); } { @@ -450,15 +390,15 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe unsigned int j = 0; for (; j < item.size(); j++) { - NL_TEST_ASSERT(apSuite, item.data()[j] == j); + EXPECT_EQ(item.data()[j], j); } - NL_TEST_ASSERT(apSuite, j == 4); + EXPECT_EQ(j, 4u); i++; } - NL_TEST_ASSERT(apSuite, iter.GetStatus() == CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, i == 4); + EXPECT_EQ(iter.GetStatus(), CHIP_NO_ERROR); + EXPECT_EQ(i, 4); } { @@ -468,24 +408,19 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe while (iter.Next()) { auto & item = iter.GetValue(); - NL_TEST_ASSERT(apSuite, item == i); + EXPECT_EQ(item, i); i++; } - NL_TEST_ASSERT(apSuite, iter.GetStatus() == CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, i == 4); + EXPECT_EQ(iter.GetStatus(), CHIP_NO_ERROR); + EXPECT_EQ(i, 4); } } } - -void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableDoubleNestedStructList(nlTestSuite * apSuite, - void * apContext) +TEST_F(TestDataModelSerialization, EncAndDecDecodableDoubleNestedStructList) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -510,13 +445,10 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableDo item.d = structList; } - err = DataModel::Encode(_this->mWriter, TLV::AnonymousTag(), t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Encode(mWriter, TLV::AnonymousTag(), t), CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - _this->DumpBuf(); + DumpBuf(); } // @@ -525,10 +457,9 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableDo { Clusters::UnitTesting::Structs::DoubleNestedStructList::DecodableType t; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); uint8_t i = 0; @@ -543,26 +474,23 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableDo { auto & nestedItem = nestedIter.GetValue(); - NL_TEST_ASSERT(apSuite, nestedItem.a == (static_cast(35) + j)); + EXPECT_EQ(nestedItem.a, (static_cast(35) + j)); j++; } - NL_TEST_ASSERT(apSuite, j == 4); + EXPECT_EQ(j, 4u); i++; } - NL_TEST_ASSERT(apSuite, iter.GetStatus() == CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, i == 4); + EXPECT_EQ(iter.GetStatus(), CHIP_NO_ERROR); + EXPECT_EQ(i, 4u); } } -void TestDataModelSerialization::TestDataModelSerialization_OptionalFields(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, OptionalFields) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -581,18 +509,18 @@ void TestDataModelSerialization::TestDataModelSerialization_OptionalFields(nlTes // Encode every field manually except a. { - err = EncodeStruct(_this->mWriter, TLV::AnonymousTag(), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kB), t.b), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kC), t.c), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kD), t.d), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e)); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ( + EncodeStruct(mWriter, TLV::AnonymousTag(), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kB), t.b), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kC), t.c), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kD), t.d), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e)), + CHIP_NO_ERROR); } - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - _this->DumpBuf(); + DumpBuf(); } // @@ -601,38 +529,33 @@ void TestDataModelSerialization::TestDataModelSerialization_OptionalFields(nlTes { Clusters::UnitTesting::Structs::SimpleStruct::DecodableType t; - _this->SetupReader(); + SetupReader(); // Set the value of a to a specific value, and ensure it is not over-written after decode. t.a = 150; - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); // Ensure that the decoder did not over-write the value set in the generated object - NL_TEST_ASSERT(apSuite, t.a == 150); + EXPECT_EQ(t.a, 150); - NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c == Clusters::UnitTesting::SimpleEnum::kValueA); + EXPECT_TRUE(t.b); + EXPECT_EQ(t.c, Clusters::UnitTesting::SimpleEnum::kValueA); - NL_TEST_ASSERT(apSuite, t.d.size() == 4); + EXPECT_EQ(t.d.size(), 4u); for (uint32_t i = 0; i < t.d.size(); i++) { - NL_TEST_ASSERT(apSuite, t.d.data()[i] == i); + EXPECT_EQ(t.d.data()[i], i); } - NL_TEST_ASSERT(apSuite, StringMatches(t.e, "chip")); + EXPECT_TRUE(StringMatches(t.e, "chip")); } } -void TestDataModelSerialization::TestDataModelSerialization_ExtraField(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, ExtraField) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -651,22 +574,21 @@ void TestDataModelSerialization::TestDataModelSerialization_ExtraField(nlTestSui // Encode every field + an extra field. { - err = EncodeStruct( - _this->mWriter, TLV::AnonymousTag(), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kA), t.a), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kB), t.b), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kC), t.c), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kD), t.d), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e), - MakeTagValuePair(TLV::ContextTag(to_underlying(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE) + 1), - t.a)); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(EncodeStruct( + mWriter, TLV::AnonymousTag(), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kA), t.a), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kB), t.b), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kC), t.c), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kD), t.d), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e), + MakeTagValuePair( + TLV::ContextTag(to_underlying(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE) + 1), t.a)), + CHIP_NO_ERROR); } - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - _this->DumpBuf(); + DumpBuf(); } // @@ -675,35 +597,29 @@ void TestDataModelSerialization::TestDataModelSerialization_ExtraField(nlTestSui { Clusters::UnitTesting::Structs::SimpleStruct::DecodableType t; - _this->SetupReader(); + SetupReader(); // Ensure successful decode despite the extra field. - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, t.a == 20); - NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c == Clusters::UnitTesting::SimpleEnum::kValueA); + EXPECT_EQ(t.a, 20); + EXPECT_TRUE(t.b); + EXPECT_EQ(t.c, Clusters::UnitTesting::SimpleEnum::kValueA); - NL_TEST_ASSERT(apSuite, t.d.size() == 4); + EXPECT_EQ(t.d.size(), 4u); for (uint32_t i = 0; i < t.d.size(); i++) { - NL_TEST_ASSERT(apSuite, t.d.data()[i] == i); + EXPECT_EQ(t.d.data()[i], i); } - NL_TEST_ASSERT(apSuite, StringMatches(t.e, "chip")); + EXPECT_TRUE(StringMatches(t.e, "chip")); } } -void TestDataModelSerialization::TestDataModelSerialization_InvalidSimpleFieldTypes(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, InvalidSimpleFieldTypes) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - - _this->mpSuite = apSuite; - _this->SetupBuf(); - + SetupBuf(); // // Case #1: Swap out field a (an integer) with a boolean. // @@ -725,37 +641,32 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidSimpleFieldTy // Encode every field manually except a. { - err = - EncodeStruct(_this->mWriter, TLV::AnonymousTag(), + EXPECT_EQ( + EncodeStruct(mWriter, TLV::AnonymousTag(), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kA), t.b), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kB), t.b), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kC), t.c), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kD), t.d), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e)); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e)), + CHIP_NO_ERROR); } - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - _this->DumpBuf(); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); + DumpBuf(); } - // // Decode // { Clusters::UnitTesting::Structs::SimpleStruct::DecodableType t; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err != CHIP_NO_ERROR); + EXPECT_NE(DataModel::Decode(mReader, t), CHIP_NO_ERROR); } } - _this->SetupBuf(); - + SetupBuf(); // // Case #2: Swap out an octet string with a UTF-8 string. // @@ -777,20 +688,19 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidSimpleFieldTy // Encode every field manually except a. { - err = - EncodeStruct(_this->mWriter, TLV::AnonymousTag(), + EXPECT_EQ( + EncodeStruct(mWriter, TLV::AnonymousTag(), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kA), t.a), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kB), t.b), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kC), t.c), MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kD), t.e), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e)); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::SimpleStruct::Fields::kE), t.e)), + CHIP_NO_ERROR); } - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); - _this->DumpBuf(); + DumpBuf(); } // @@ -799,21 +709,16 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidSimpleFieldTy { Clusters::UnitTesting::Structs::SimpleStruct::DecodableType t; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err != CHIP_NO_ERROR); + EXPECT_NE(DataModel::Decode(mReader, t), CHIP_NO_ERROR); } } } -void TestDataModelSerialization::TestDataModelSerialization_InvalidListType(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, InvalidListType) { - CHIP_ERROR err; - auto * _this = static_cast(apContext); - - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); // // Encode @@ -826,16 +731,14 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidListType(nlTe // Encode a list of integers for field d instead of a list of structs. { - err = - EncodeStruct(_this->mWriter, TLV::AnonymousTag(), - MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::NestedStructList::Fields::kD), t.e)); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ( + EncodeStruct(mWriter, TLV::AnonymousTag(), + MakeTagValuePair(TLV::ContextTag(Clusters::UnitTesting::Structs::NestedStructList::Fields::kD), t.e)), + CHIP_NO_ERROR); } - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - _this->DumpBuf(); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); + DumpBuf(); } // @@ -844,10 +747,9 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidListType(nlTe { Clusters::UnitTesting::Structs::NestedStructList::DecodableType t; - _this->SetupReader(); + SetupReader(); - err = DataModel::Decode(_this->mReader, t); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, t), CHIP_NO_ERROR); auto iter = t.d.begin(); bool hadItems = false; @@ -857,8 +759,8 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidListType(nlTe hadItems = true; } - NL_TEST_ASSERT(apSuite, iter.GetStatus() != CHIP_NO_ERROR); - NL_TEST_ASSERT(apSuite, !hadItems); + EXPECT_NE(iter.GetStatus(), CHIP_NO_ERROR); + EXPECT_FALSE(hadItems); } } @@ -905,13 +807,10 @@ bool ListsEqual(const DataModel::DecodableList & list1, const DataModel::List } // anonymous namespace template -void TestDataModelSerialization::NullablesOptionalsEncodeDecodeCheck(nlTestSuite * apSuite, void * apContext, bool encodeNulls, - bool encodeValues) +void TestDataModelSerialization::NullablesOptionalsEncodeDecodeCheck(bool encodeNulls, bool encodeValues) { - auto * _this = static_cast(apContext); - _this->mpSuite = apSuite; - _this->SetupBuf(); + SetupBuf(); static const char structStr[] = "something"; const uint8_t structBytes[] = { 1, 8, 17 }; @@ -974,161 +873,117 @@ void TestDataModelSerialization::NullablesOptionalsEncodeDecodeCheck(nlTestSuite encodable.nullableList.SetNull(); } - CHIP_ERROR err = DataModel::Encode(_this->mWriter, TLV::AnonymousTag(), encodable); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - err = _this->mWriter.Finalize(); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Encode(mWriter, TLV::AnonymousTag(), encodable), CHIP_NO_ERROR); + EXPECT_EQ(mWriter.Finalize(), CHIP_NO_ERROR); } // Decode { - _this->SetupReader(); + SetupReader(); Decodable decodable; - CHIP_ERROR err = DataModel::Decode(_this->mReader, decodable); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(DataModel::Decode(mReader, decodable), CHIP_NO_ERROR); if (encodeNulls) { - NL_TEST_ASSERT(apSuite, decodable.nullableInt.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalInt.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalInt.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalInt.Value().IsNull()); - - NL_TEST_ASSERT(apSuite, decodable.nullableString.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalString.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalString.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalString.Value().IsNull()); - - NL_TEST_ASSERT(apSuite, decodable.nullableStruct.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalStruct.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalStruct.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalStruct.Value().IsNull()); - - NL_TEST_ASSERT(apSuite, decodable.nullableList.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalList.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalList.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalList.Value().IsNull()); + EXPECT_TRUE(decodable.nullableInt.IsNull()); + EXPECT_FALSE(decodable.optionalInt.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalInt.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalInt.Value().IsNull()); + + EXPECT_TRUE(decodable.nullableString.IsNull()); + EXPECT_FALSE(decodable.optionalString.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalString.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalString.Value().IsNull()); + + EXPECT_TRUE(decodable.nullableStruct.IsNull()); + EXPECT_FALSE(decodable.optionalStruct.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalStruct.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalStruct.Value().IsNull()); + + EXPECT_TRUE(decodable.nullableList.IsNull()); + EXPECT_FALSE(decodable.optionalList.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalList.HasValue()); + EXPECT_TRUE(decodable.nullableOptionalList.Value().IsNull()); } else if (encodeValues) { static const char str[] = "abc"; CharSpan strSpan = CharSpan::fromCharString(str); - NL_TEST_ASSERT(apSuite, !decodable.nullableInt.IsNull()); - NL_TEST_ASSERT(apSuite, decodable.nullableInt.Value() == 5); - NL_TEST_ASSERT(apSuite, decodable.optionalInt.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.optionalInt.Value() == 6); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalInt.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalInt.Value().IsNull()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalInt.Value().Value() == 7); - - NL_TEST_ASSERT(apSuite, !decodable.nullableString.IsNull()); - NL_TEST_ASSERT(apSuite, decodable.nullableString.Value().data_equal(strSpan)); - NL_TEST_ASSERT(apSuite, decodable.optionalString.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.optionalString.Value().data_equal(strSpan)); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalString.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalString.Value().IsNull()); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalString.Value().Value().data_equal(strSpan)); - - NL_TEST_ASSERT(apSuite, !decodable.nullableStruct.IsNull()); - NL_TEST_ASSERT(apSuite, SimpleStructsEqual(decodable.nullableStruct.Value(), myStruct)); - NL_TEST_ASSERT(apSuite, decodable.optionalStruct.HasValue()); - NL_TEST_ASSERT(apSuite, SimpleStructsEqual(decodable.optionalStruct.Value(), myStruct)); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalStruct.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalStruct.Value().IsNull()); - NL_TEST_ASSERT(apSuite, SimpleStructsEqual(decodable.nullableOptionalStruct.Value().Value(), myStruct)); - - NL_TEST_ASSERT(apSuite, !decodable.nullableList.IsNull()); - NL_TEST_ASSERT(apSuite, ListsEqual(decodable.nullableList.Value(), enumList)); - NL_TEST_ASSERT(apSuite, decodable.optionalList.HasValue()); - NL_TEST_ASSERT(apSuite, ListsEqual(decodable.optionalList.Value(), enumList)); - NL_TEST_ASSERT(apSuite, decodable.nullableOptionalList.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalList.Value().IsNull()); - NL_TEST_ASSERT(apSuite, ListsEqual(decodable.nullableOptionalList.Value().Value(), enumList)); + EXPECT_FALSE(decodable.nullableInt.IsNull()); + EXPECT_EQ(decodable.nullableInt.Value(), 5); + EXPECT_TRUE(decodable.optionalInt.HasValue()); + EXPECT_EQ(decodable.optionalInt.Value(), 6); + EXPECT_TRUE(decodable.nullableOptionalInt.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalInt.Value().IsNull()); + EXPECT_EQ(decodable.nullableOptionalInt.Value().Value(), 7); + + EXPECT_FALSE(decodable.nullableString.IsNull()); + EXPECT_TRUE(decodable.nullableString.Value().data_equal(strSpan)); + EXPECT_TRUE(decodable.optionalString.HasValue()); + EXPECT_TRUE(decodable.optionalString.Value().data_equal(strSpan)); + EXPECT_TRUE(decodable.nullableOptionalString.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalString.Value().IsNull()); + EXPECT_TRUE(decodable.nullableOptionalString.Value().Value().data_equal(strSpan)); + + EXPECT_FALSE(decodable.nullableStruct.IsNull()); + EXPECT_TRUE(SimpleStructsEqual(decodable.nullableStruct.Value(), myStruct)); + EXPECT_TRUE(decodable.optionalStruct.HasValue()); + EXPECT_TRUE(SimpleStructsEqual(decodable.optionalStruct.Value(), myStruct)); + EXPECT_TRUE(decodable.nullableOptionalStruct.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalStruct.Value().IsNull()); + EXPECT_TRUE(SimpleStructsEqual(decodable.nullableOptionalStruct.Value().Value(), myStruct)); + + EXPECT_FALSE(decodable.nullableList.IsNull()); + EXPECT_TRUE(ListsEqual(decodable.nullableList.Value(), enumList)); + EXPECT_TRUE(decodable.optionalList.HasValue()); + EXPECT_TRUE(ListsEqual(decodable.optionalList.Value(), enumList)); + EXPECT_TRUE(decodable.nullableOptionalList.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalList.Value().IsNull()); + EXPECT_TRUE(ListsEqual(decodable.nullableOptionalList.Value().Value(), enumList)); } else { - NL_TEST_ASSERT(apSuite, decodable.nullableInt.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalInt.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalInt.HasValue()); + EXPECT_TRUE(decodable.nullableInt.IsNull()); + EXPECT_FALSE(decodable.optionalInt.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalInt.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableString.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalString.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalString.HasValue()); + EXPECT_TRUE(decodable.nullableString.IsNull()); + EXPECT_FALSE(decodable.optionalString.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalString.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableStruct.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalStruct.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalStruct.HasValue()); + EXPECT_TRUE(decodable.nullableStruct.IsNull()); + EXPECT_FALSE(decodable.optionalStruct.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalStruct.HasValue()); - NL_TEST_ASSERT(apSuite, decodable.nullableList.IsNull()); - NL_TEST_ASSERT(apSuite, !decodable.optionalList.HasValue()); - NL_TEST_ASSERT(apSuite, !decodable.nullableOptionalList.HasValue()); + EXPECT_TRUE(decodable.nullableList.IsNull()); + EXPECT_FALSE(decodable.optionalList.HasValue()); + EXPECT_FALSE(decodable.nullableOptionalList.HasValue()); } } } template -void TestDataModelSerialization::NullablesOptionalsEncodeDecodeCheck(nlTestSuite * apSuite, void * apContext) +void TestDataModelSerialization::NullablesOptionalsEncodeDecodeCheck() { - NullablesOptionalsEncodeDecodeCheck(apSuite, apContext, false, false); - NullablesOptionalsEncodeDecodeCheck(apSuite, apContext, true, false); - NullablesOptionalsEncodeDecodeCheck(apSuite, apContext, false, true); + NullablesOptionalsEncodeDecodeCheck(false, false); + NullablesOptionalsEncodeDecodeCheck(true, false); + NullablesOptionalsEncodeDecodeCheck(false, true); } -void TestDataModelSerialization::NullablesOptionalsStruct(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, NullablesOptionalsStruct) { using EncType = Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::Type; using DecType = Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType; - NullablesOptionalsEncodeDecodeCheck(apSuite, apContext); + NullablesOptionalsEncodeDecodeCheck(); } -void TestDataModelSerialization::NullablesOptionalsCommand(nlTestSuite * apSuite, void * apContext) +TEST_F(TestDataModelSerialization, NullablesOptionalsCommand) { using EncType = Clusters::UnitTesting::Commands::TestComplexNullableOptionalRequest::Type; using DecType = Clusters::UnitTesting::Commands::TestComplexNullableOptionalRequest::DecodableType; - NullablesOptionalsEncodeDecodeCheck(apSuite, apContext); -} - -int Initialize(void * apSuite) -{ - VerifyOrReturnError(chip::Platform::MemoryInit() == CHIP_NO_ERROR, FAILURE); - return SUCCESS; -} - -int Finalize(void * aContext) -{ - gTestDataModelSerialization.Shutdown(); - chip::Platform::MemoryShutdown(); - return SUCCESS; + NullablesOptionalsEncodeDecodeCheck(); } } // namespace - -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("TestDataModelSerialization_EncAndDecSimple", TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruct), - NL_TEST_DEF("TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum", TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum), - NL_TEST_DEF("TestDataModelSerialization_EncAndDecNestedStruct", TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruct), - NL_TEST_DEF("TestDataModelSerialization_EncAndDecDecodableNestedStructList", TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNestedStructList), - NL_TEST_DEF("TestDataModelSerialization_EncAndDecDecodableDoubleNestedStructList", TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableDoubleNestedStructList), - NL_TEST_DEF("TestDataModelSerialization_OptionalFields", TestDataModelSerialization::TestDataModelSerialization_OptionalFields), - NL_TEST_DEF("TestDataModelSerialization_ExtraField", TestDataModelSerialization::TestDataModelSerialization_ExtraField), - NL_TEST_DEF("TestDataModelSerialization_InvalidSimpleFieldTypes", TestDataModelSerialization::TestDataModelSerialization_InvalidSimpleFieldTypes), - NL_TEST_DEF("TestDataModelSerialization_InvalidListType", TestDataModelSerialization::TestDataModelSerialization_InvalidListType), - NL_TEST_DEF("TestDataModelSerialization_NullablesOptionalsStruct", TestDataModelSerialization::NullablesOptionalsStruct), - NL_TEST_DEF("TestDataModelSerialization_NullablesOptionalsCommand", TestDataModelSerialization::NullablesOptionalsCommand), - NL_TEST_SENTINEL() -}; -// clang-format on - -nlTestSuite theSuite = { "TestDataModelSerialization", &sTests[0], Initialize, Finalize }; - -int DataModelSerializationTest() -{ - nlTestRunner(&theSuite, &gTestDataModelSerialization); - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(DataModelSerializationTest) diff --git a/src/app/tests/TestDefaultOTARequestorStorage.cpp b/src/app/tests/TestDefaultOTARequestorStorage.cpp index 1b4e9b0a3bc5ed..53ee108e73f8b6 100644 --- a/src/app/tests/TestDefaultOTARequestorStorage.cpp +++ b/src/app/tests/TestDefaultOTARequestorStorage.cpp @@ -19,16 +19,16 @@ #include #include #include -#include -#include +#include +#include using namespace chip; using namespace chip::DeviceLayer; namespace { -void TestDefaultProviders(nlTestSuite * inSuite, void * inContext) +TEST(TestDefaultOTARequestorStorage, TestDefaultProviders) { TestPersistentStorageDelegate persistentStorage; DefaultOTARequestorStorage otaStorage; @@ -43,49 +43,49 @@ void TestDefaultProviders(nlTestSuite * inSuite, void * inContext) }; ProviderLocationList providers = {}; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == providers.Add(makeProvider(FabricIndex(1), NodeId(0x11111111), EndpointId(1)))); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == providers.Add(makeProvider(FabricIndex(2), NodeId(0x22222222), EndpointId(2)))); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == providers.Add(makeProvider(FabricIndex(3), NodeId(0x33333333), EndpointId(3)))); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.StoreDefaultProviders(providers)); + EXPECT_EQ(CHIP_NO_ERROR, providers.Add(makeProvider(FabricIndex(1), NodeId(0x11111111), EndpointId(1)))); + EXPECT_EQ(CHIP_NO_ERROR, providers.Add(makeProvider(FabricIndex(2), NodeId(0x22222222), EndpointId(2)))); + EXPECT_EQ(CHIP_NO_ERROR, providers.Add(makeProvider(FabricIndex(3), NodeId(0x33333333), EndpointId(3)))); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.StoreDefaultProviders(providers)); providers = {}; - NL_TEST_ASSERT(inSuite, !providers.Begin().Next()); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.LoadDefaultProviders(providers)); + EXPECT_FALSE(providers.Begin().Next()); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.LoadDefaultProviders(providers)); auto provider = providers.Begin(); bool hasNext; - NL_TEST_ASSERT(inSuite, hasNext = provider.Next()); + EXPECT_TRUE(hasNext = provider.Next()); if (hasNext) { - NL_TEST_ASSERT(inSuite, provider.GetValue().fabricIndex == 1); - NL_TEST_ASSERT(inSuite, provider.GetValue().providerNodeID == 0x11111111); - NL_TEST_ASSERT(inSuite, provider.GetValue().endpoint == 1); + EXPECT_EQ(provider.GetValue().fabricIndex, 1); + EXPECT_EQ(provider.GetValue().providerNodeID, 0x11111111u); + EXPECT_EQ(provider.GetValue().endpoint, 1); } - NL_TEST_ASSERT(inSuite, hasNext = provider.Next()); + EXPECT_TRUE(hasNext = provider.Next()); if (hasNext) { - NL_TEST_ASSERT(inSuite, provider.GetValue().fabricIndex == 2); - NL_TEST_ASSERT(inSuite, provider.GetValue().providerNodeID == 0x22222222); - NL_TEST_ASSERT(inSuite, provider.GetValue().endpoint == 2); + EXPECT_EQ(provider.GetValue().fabricIndex, 2); + EXPECT_EQ(provider.GetValue().providerNodeID, 0x22222222u); + EXPECT_EQ(provider.GetValue().endpoint, 2); } - NL_TEST_ASSERT(inSuite, hasNext = provider.Next()); + EXPECT_TRUE(hasNext = provider.Next()); if (hasNext) { - NL_TEST_ASSERT(inSuite, provider.GetValue().fabricIndex == 3); - NL_TEST_ASSERT(inSuite, provider.GetValue().providerNodeID == 0x33333333); - NL_TEST_ASSERT(inSuite, provider.GetValue().endpoint == 3); + EXPECT_EQ(provider.GetValue().fabricIndex, 3); + EXPECT_EQ(provider.GetValue().providerNodeID, 0x33333333u); + EXPECT_EQ(provider.GetValue().endpoint, 3); } - NL_TEST_ASSERT(inSuite, !provider.Next()); + EXPECT_FALSE(provider.Next()); } -void TestDefaultProvidersEmpty(nlTestSuite * inSuite, void * inContext) +TEST(TestDefaultOTARequestorStorage, TestDefaultProvidersEmpty) { TestPersistentStorageDelegate persistentStorage; DefaultOTARequestorStorage otaStorage; @@ -93,11 +93,11 @@ void TestDefaultProvidersEmpty(nlTestSuite * inSuite, void * inContext) ProviderLocationList providers = {}; - NL_TEST_ASSERT(inSuite, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND == otaStorage.LoadDefaultProviders(providers)); - NL_TEST_ASSERT(inSuite, !providers.Begin().Next()); + EXPECT_EQ(CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND, otaStorage.LoadDefaultProviders(providers)); + EXPECT_FALSE(providers.Begin().Next()); } -void TestCurrentProviderLocation(nlTestSuite * inSuite, void * inContext) +TEST(TestDefaultOTARequestorStorage, TestCurrentProviderLocation) { TestPersistentStorageDelegate persistentStorage; DefaultOTARequestorStorage otaStorage; @@ -108,19 +108,19 @@ void TestCurrentProviderLocation(nlTestSuite * inSuite, void * inContext) provider.providerNodeID = 0x12344321; provider.endpoint = 10; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.StoreCurrentProviderLocation(provider)); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.StoreCurrentProviderLocation(provider)); provider = {}; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.LoadCurrentProviderLocation(provider)); - NL_TEST_ASSERT(inSuite, provider.fabricIndex == 1); - NL_TEST_ASSERT(inSuite, provider.providerNodeID == 0x12344321); - NL_TEST_ASSERT(inSuite, provider.endpoint == 10); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.ClearCurrentProviderLocation()); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR != otaStorage.LoadCurrentProviderLocation(provider)); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.LoadCurrentProviderLocation(provider)); + EXPECT_EQ(provider.fabricIndex, 1); + EXPECT_EQ(provider.providerNodeID, 0x12344321u); + EXPECT_EQ(provider.endpoint, 10); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.ClearCurrentProviderLocation()); + EXPECT_NE(CHIP_NO_ERROR, otaStorage.LoadCurrentProviderLocation(provider)); } -void TestUpdateToken(nlTestSuite * inSuite, void * inContext) +TEST(TestDefaultOTARequestorStorage, TestUpdateToken) { TestPersistentStorageDelegate persistentStorage; DefaultOTARequestorStorage otaStorage; @@ -133,21 +133,21 @@ void TestUpdateToken(nlTestSuite * inSuite, void * inContext) for (uint8_t i = 0; i < updateTokenLength; ++i) updateTokenBuffer[i] = i; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.StoreUpdateToken(updateToken)); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.StoreUpdateToken(updateToken)); uint8_t readBuffer[updateTokenLength + 10]; MutableByteSpan readUpdateToken(readBuffer); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.LoadUpdateToken(readUpdateToken)); - NL_TEST_ASSERT(inSuite, readUpdateToken.size() == updateTokenLength); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.LoadUpdateToken(readUpdateToken)); + EXPECT_EQ(readUpdateToken.size(), updateTokenLength); for (uint8_t i = 0; i < updateTokenLength; ++i) - NL_TEST_ASSERT(inSuite, readBuffer[i] == i); + EXPECT_EQ(readBuffer[i], i); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.ClearUpdateToken()); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR != otaStorage.LoadUpdateToken(readUpdateToken)); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.ClearUpdateToken()); + EXPECT_NE(CHIP_NO_ERROR, otaStorage.LoadUpdateToken(readUpdateToken)); } -void TestCurrentUpdateState(nlTestSuite * inSuite, void * inContext) +TEST(TestDefaultOTARequestorStorage, TestCurrentUpdateState) { TestPersistentStorageDelegate persistentStorage; DefaultOTARequestorStorage otaStorage; @@ -155,17 +155,17 @@ void TestCurrentUpdateState(nlTestSuite * inSuite, void * inContext) OTARequestorStorage::OTAUpdateStateEnum updateState = OTARequestorStorage::OTAUpdateStateEnum::kApplying; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.StoreCurrentUpdateState(updateState)); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.StoreCurrentUpdateState(updateState)); updateState = OTARequestorStorage::OTAUpdateStateEnum::kUnknown; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.LoadCurrentUpdateState(updateState)); - NL_TEST_ASSERT(inSuite, updateState == OTARequestorStorage::OTAUpdateStateEnum::kApplying); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.ClearCurrentUpdateState()); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR != otaStorage.LoadCurrentUpdateState(updateState)); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.LoadCurrentUpdateState(updateState)); + EXPECT_EQ(updateState, OTARequestorStorage::OTAUpdateStateEnum::kApplying); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.ClearCurrentUpdateState()); + EXPECT_NE(CHIP_NO_ERROR, otaStorage.LoadCurrentUpdateState(updateState)); } -void TestTargetVersion(nlTestSuite * inSuite, void * inContext) +TEST(TestDefaultOTARequestorStorage, TestTargetVersion) { TestPersistentStorageDelegate persistentStorage; DefaultOTARequestorStorage otaStorage; @@ -173,43 +173,14 @@ void TestTargetVersion(nlTestSuite * inSuite, void * inContext) uint32_t targetVersion = 2; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.StoreTargetVersion(targetVersion)); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.StoreTargetVersion(targetVersion)); targetVersion = 0; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.LoadTargetVersion(targetVersion)); - NL_TEST_ASSERT(inSuite, targetVersion == 2); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == otaStorage.ClearTargetVersion()); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR != otaStorage.LoadTargetVersion(targetVersion)); -} - -const nlTest sTests[] = { NL_TEST_DEF("Test default providers", TestDefaultProviders), - NL_TEST_DEF("Test default providers (empty list)", TestDefaultProvidersEmpty), - NL_TEST_DEF("Test current provider location", TestCurrentProviderLocation), - NL_TEST_DEF("Test update token", TestUpdateToken), - NL_TEST_DEF("Test current update state", TestCurrentUpdateState), - NL_TEST_DEF("Test target version", TestTargetVersion), - NL_TEST_SENTINEL() }; - -int TestSetup(void * inContext) -{ - return SUCCESS; -} - -int TestTearDown(void * inContext) -{ - return SUCCESS; + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.LoadTargetVersion(targetVersion)); + EXPECT_EQ(targetVersion, 2u); + EXPECT_EQ(CHIP_NO_ERROR, otaStorage.ClearTargetVersion()); + EXPECT_NE(CHIP_NO_ERROR, otaStorage.LoadTargetVersion(targetVersion)); } } // namespace - -int TestDefaultOTARequestorStorage() -{ - nlTestSuite theSuite = { "OTA Storage tests", &sTests[0], TestSetup, TestTearDown }; - - // Run test suite against one context. - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestDefaultOTARequestorStorage) diff --git a/src/app/tests/TestEventPathParams.cpp b/src/app/tests/TestEventPathParams.cpp index da0b3315290815..a962a6b7e43d75 100644 --- a/src/app/tests/TestEventPathParams.cpp +++ b/src/app/tests/TestEventPathParams.cpp @@ -16,65 +16,120 @@ * limitations under the License. */ -/** - * @file - * This file implements unit tests for EventPathParams - * - */ - #include -#include -#include +#include +#include +#include + +using namespace chip::Test; namespace chip { namespace app { namespace TestEventPathParams { -void TestSamePath(nlTestSuite * apSuite, void * apContext) + +class TestEventPathParams : public ::testing::Test +{ +public: + static void SetUpTestSuite() { InitEventPaths(); } + + static void InitEventPaths(); + + static chip::app::EventPathParams validEventpaths[6]; +}; + +chip::app::EventPathParams TestEventPathParams::validEventpaths[6]; + +TEST_F(TestEventPathParams, SamePath) { EventPathParams eventPathParams1(2, 3, 4); EventPathParams eventPathParams2(2, 3, 4); - NL_TEST_ASSERT(apSuite, eventPathParams1.IsSamePath(eventPathParams2)); + EXPECT_TRUE(eventPathParams1.IsSamePath(eventPathParams2)); } -void TestDifferentEndpointId(nlTestSuite * apSuite, void * apContext) +TEST_F(TestEventPathParams, DifferentEndpointId) { EventPathParams eventPathParams1(2, 3, 4); EventPathParams eventPathParams2(6, 3, 4); - NL_TEST_ASSERT(apSuite, !eventPathParams1.IsSamePath(eventPathParams2)); + EXPECT_FALSE(eventPathParams1.IsSamePath(eventPathParams2)); } -void TestDifferentClusterId(nlTestSuite * apSuite, void * apContext) +TEST_F(TestEventPathParams, DifferentClusterId) { EventPathParams eventPathParams1(2, 3, 4); EventPathParams eventPathParams2(2, 6, 4); - NL_TEST_ASSERT(apSuite, !eventPathParams1.IsSamePath(eventPathParams2)); + EXPECT_FALSE(eventPathParams1.IsSamePath(eventPathParams2)); } -void TestDifferentEventId(nlTestSuite * apSuite, void * apContext) +TEST_F(TestEventPathParams, DifferentEventId) { EventPathParams eventPathParams1(2, 3, 4); EventPathParams eventPathParams2(2, 3, 6); - NL_TEST_ASSERT(apSuite, !eventPathParams1.IsSamePath(eventPathParams2)); + EXPECT_FALSE(eventPathParams1.IsSamePath(eventPathParams2)); } -} // namespace TestEventPathParams -} // namespace app -} // namespace chip -namespace { -const nlTest sTests[] = { NL_TEST_DEF("TestSamePath", chip::app::TestEventPathParams::TestSamePath), - NL_TEST_DEF("TestDifferentEndpointId", chip::app::TestEventPathParams::TestDifferentEndpointId), - NL_TEST_DEF("TestDifferentClusterId", chip::app::TestEventPathParams::TestDifferentClusterId), - NL_TEST_DEF("TestDifferentEventId", chip::app::TestEventPathParams::TestDifferentEventId), - NL_TEST_SENTINEL() }; +/* after Init, validEventpaths array will have the following values: +{kInvalidEndpointId, kInvalidClusterId, kInvalidEventId}, +{kInvalidEndpointId, MockClusterId(1), kInvalidEventId}, +{kInvalidEndpointId, MockClusterId(1), MockEventId(1)}, +{kMockEndpoint1, kInvalidClusterId, kInvalidEventId}, +{kMockEndpoint1, MockClusterId(1), kInvalidEventId}, +{kMockEndpoint1, MockClusterId(1), MockEventId(1)}, +*/ +void TestEventPathParams::InitEventPaths() +{ + validEventpaths[1].mClusterId = MockClusterId(1); + validEventpaths[2].mClusterId = MockClusterId(1); + validEventpaths[2].mEventId = MockEventId(1); + validEventpaths[3].mEndpointId = kMockEndpoint1; + validEventpaths[4].mEndpointId = kMockEndpoint1; + validEventpaths[4].mClusterId = MockClusterId(1); + validEventpaths[5].mEndpointId = kMockEndpoint1; + validEventpaths[5].mClusterId = MockClusterId(1); + validEventpaths[5].mEventId = MockEventId(1); } -int TestEventPathParams() +TEST_F(TestEventPathParams, ConcreteEventPathSameEventId) +{ + ConcreteEventPath testPath(kMockEndpoint1, MockClusterId(1), MockEventId(1)); + for (auto & path : validEventpaths) + { + EXPECT_TRUE(path.IsValidEventPath()); + EXPECT_TRUE(path.IsEventPathSupersetOf(testPath)); + } +} +TEST_F(TestEventPathParams, ConcreteEventPathDifferentEndpointId) { - nlTestSuite theSuite = { "EventPathParams", &sTests[0], nullptr, nullptr }; + ConcreteEventPath testPath(kMockEndpoint2, MockClusterId(1), MockEventId(1)); + EXPECT_TRUE(validEventpaths[0].IsEventPathSupersetOf(testPath)); + EXPECT_TRUE(validEventpaths[1].IsEventPathSupersetOf(testPath)); + EXPECT_TRUE(validEventpaths[2].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[3].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[4].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[5].IsEventPathSupersetOf(testPath)); +} - nlTestRunner(&theSuite, nullptr); +TEST_F(TestEventPathParams, ConcreteEventPathDifferentClusterId) +{ + ConcreteEventPath testPath(kMockEndpoint1, MockClusterId(2), MockEventId(1)); + EXPECT_TRUE(validEventpaths[0].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[1].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[2].IsEventPathSupersetOf(testPath)); + EXPECT_TRUE(validEventpaths[3].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[4].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[5].IsEventPathSupersetOf(testPath)); +} - return (nlTestRunnerStats(&theSuite)); +TEST_F(TestEventPathParams, ConcreteEventPathDifferentEventId) +{ + ConcreteEventPath testPath(kMockEndpoint1, MockClusterId(1), MockEventId(2)); + EXPECT_TRUE(validEventpaths[0].IsEventPathSupersetOf(testPath)); + EXPECT_TRUE(validEventpaths[1].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[2].IsEventPathSupersetOf(testPath)); + EXPECT_TRUE(validEventpaths[3].IsEventPathSupersetOf(testPath)); + EXPECT_TRUE(validEventpaths[4].IsEventPathSupersetOf(testPath)); + EXPECT_FALSE(validEventpaths[5].IsEventPathSupersetOf(testPath)); } -CHIP_REGISTER_TEST_SUITE(TestEventPathParams) +} // namespace TestEventPathParams +} // namespace app +} // namespace chip diff --git a/src/app/tests/TestExtensionFieldSets.cpp b/src/app/tests/TestExtensionFieldSets.cpp index 2c7fb4e37a2929..66b4e9e72ad891 100644 --- a/src/app/tests/TestExtensionFieldSets.cpp +++ b/src/app/tests/TestExtensionFieldSets.cpp @@ -19,8 +19,9 @@ #include #include #include -#include -#include + +#include +#include using namespace chip; @@ -53,7 +54,14 @@ static const scenes::ExtensionFieldSet EFS3(kColorControlClusterId, colorControl static scenes::ExtensionFieldSetsImpl sEFSets; -void TestInsertExtensionFieldSet(nlTestSuite * aSuite, void * aContext) +class TestExtensionFieldSets : public ::testing::Test +{ +public: + static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } + static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); } +}; + +TEST_F(TestExtensionFieldSets, TestInsertExtensionFieldSet) { scenes::ExtensionFieldSetsImpl * EFS = &sEFSets; scenes::ExtensionFieldSetsImpl testEFS1; @@ -68,118 +76,118 @@ void TestInsertExtensionFieldSet(nlTestSuite * aSuite, void * aContext) memset(double_size_buffer, static_cast(1), sizeof(double_size_buffer)); - NL_TEST_ASSERT(aSuite, true == EFS->IsEmpty()); + EXPECT_TRUE(EFS->IsEmpty()); // Test creators of single ExtensionFieldSet - NL_TEST_ASSERT(aSuite, EFS1.mID == kOnOffClusterId); - NL_TEST_ASSERT(aSuite, EFS1.mUsedBytes == kOnOffSize); - NL_TEST_ASSERT(aSuite, !memcmp(onOffBuffer, EFS1.mBytesBuffer, EFS1.mUsedBytes)); + EXPECT_EQ(EFS1.mID, kOnOffClusterId); + EXPECT_EQ(EFS1.mUsedBytes, kOnOffSize); + EXPECT_EQ(memcmp(onOffBuffer, EFS1.mBytesBuffer, EFS1.mUsedBytes), 0); - NL_TEST_ASSERT(aSuite, EFS2.mID == kLevelControlClusterId); - NL_TEST_ASSERT(aSuite, EFS2.mUsedBytes == kLevelControlSize); - NL_TEST_ASSERT(aSuite, !memcmp(levelControlBuffer, EFS2.mBytesBuffer, EFS2.mUsedBytes)); + EXPECT_EQ(EFS2.mID, kLevelControlClusterId); + EXPECT_EQ(EFS2.mUsedBytes, kLevelControlSize); + EXPECT_EQ(memcmp(levelControlBuffer, EFS2.mBytesBuffer, EFS2.mUsedBytes), 0); - NL_TEST_ASSERT(aSuite, EFS3.mID == kColorControlClusterId); - NL_TEST_ASSERT(aSuite, EFS3.mUsedBytes == kColorControlSize); - NL_TEST_ASSERT(aSuite, !memcmp(colorControlBuffer, EFS3.mBytesBuffer, EFS3.mUsedBytes)); + EXPECT_EQ(EFS3.mID, kColorControlClusterId); + EXPECT_EQ(EFS3.mUsedBytes, kColorControlSize); + EXPECT_EQ(memcmp(colorControlBuffer, EFS3.mBytesBuffer, EFS3.mUsedBytes), 0); // operator tests single EFS tempEFS = EFS1; - NL_TEST_ASSERT(aSuite, tempEFS == EFS1); + EXPECT_EQ(tempEFS, EFS1); tempEFS = EFS2; - NL_TEST_ASSERT(aSuite, tempEFS == EFS2); + EXPECT_EQ(tempEFS, EFS2); tempEFS = EFS3; - NL_TEST_ASSERT(aSuite, tempEFS == EFS3); + EXPECT_EQ(tempEFS, EFS3); // Test clear EFS tempEFS.Clear(); - NL_TEST_ASSERT(aSuite, tempEFS.IsEmpty()); - NL_TEST_ASSERT(aSuite, tempEFS.mID == kInvalidClusterId); - NL_TEST_ASSERT(aSuite, tempEFS.mUsedBytes == 0); - NL_TEST_ASSERT(aSuite, !memcmp(empty_buffer, tempEFS.mBytesBuffer, sizeof(tempEFS.mBytesBuffer))); + EXPECT_TRUE(tempEFS.IsEmpty()); + EXPECT_EQ(tempEFS.mID, kInvalidClusterId); + EXPECT_EQ(tempEFS.mUsedBytes, 0); + EXPECT_EQ(memcmp(empty_buffer, tempEFS.mBytesBuffer, sizeof(tempEFS.mBytesBuffer)), 0); // Test creation of EFS from Array and ByteSpan that are to big tempEFS = scenes::ExtensionFieldSet(kOnOffClusterId, double_size_buffer, sizeof(double_size_buffer)); - NL_TEST_ASSERT(aSuite, tempEFS.mID == kOnOffClusterId); + EXPECT_EQ(tempEFS.mID, kOnOffClusterId); // Confirm EFS empty - NL_TEST_ASSERT(aSuite, tempEFS.mUsedBytes == 0); - NL_TEST_ASSERT(aSuite, !memcmp(empty_buffer, tempEFS.mBytesBuffer, sizeof(empty_buffer))); + EXPECT_EQ(tempEFS.mUsedBytes, 0); + EXPECT_EQ(memcmp(empty_buffer, tempEFS.mBytesBuffer, sizeof(empty_buffer)), 0); tempEFS = scenes::ExtensionFieldSet(kLevelControlClusterId, bufferSpan); - NL_TEST_ASSERT(aSuite, tempEFS.mID == kLevelControlClusterId); + EXPECT_EQ(tempEFS.mID, kLevelControlClusterId); // Confirm EFS empty - NL_TEST_ASSERT(aSuite, tempEFS.mUsedBytes == 0); - NL_TEST_ASSERT(aSuite, !memcmp(empty_buffer, tempEFS.mBytesBuffer, sizeof(empty_buffer))); + EXPECT_EQ(tempEFS.mUsedBytes, 0); + EXPECT_EQ(memcmp(empty_buffer, tempEFS.mBytesBuffer, sizeof(empty_buffer)), 0); // Test creation of EFS from truncating an Array tempEFS = scenes::ExtensionFieldSet(kColorControlClusterId, double_size_buffer, sizeof(tempEFS.mBytesBuffer)); - NL_TEST_ASSERT(aSuite, tempEFS.mID == kColorControlClusterId); + EXPECT_EQ(tempEFS.mID, kColorControlClusterId); // Confirm EFS was written - NL_TEST_ASSERT(aSuite, tempEFS.mUsedBytes == static_cast(sizeof(tempEFS.mBytesBuffer))); - NL_TEST_ASSERT(aSuite, !memcmp(double_size_buffer, tempEFS.mBytesBuffer, sizeof(tempEFS.mBytesBuffer))); + EXPECT_EQ(tempEFS.mUsedBytes, static_cast(sizeof(tempEFS.mBytesBuffer))); + EXPECT_EQ(memcmp(double_size_buffer, tempEFS.mBytesBuffer, sizeof(tempEFS.mBytesBuffer)), 0); tempEFS.Clear(); - NL_TEST_ASSERT(aSuite, tempEFS.IsEmpty()); + EXPECT_TRUE(tempEFS.IsEmpty()); // Test insertion of uninitialized EFS - NL_TEST_ASSERT(aSuite, CHIP_ERROR_INVALID_ARGUMENT == EFS->InsertFieldSet(tempEFS)); - NL_TEST_ASSERT(aSuite, 0 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_ERROR_INVALID_ARGUMENT, EFS->InsertFieldSet(tempEFS)); + EXPECT_EQ(0, EFS->GetFieldSetCount()); // Test insertion of empty EFS tempEFS.mID = kOnOffClusterId; - NL_TEST_ASSERT(aSuite, CHIP_ERROR_INVALID_ARGUMENT == EFS->InsertFieldSet(tempEFS)); - NL_TEST_ASSERT(aSuite, 0 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_ERROR_INVALID_ARGUMENT, EFS->InsertFieldSet(tempEFS)); + EXPECT_EQ(0, EFS->GetFieldSetCount()); // test operators on multiple EFS struct - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == testEFS1.InsertFieldSet(EFS1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == testEFS1.InsertFieldSet(EFS2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == testEFS1.InsertFieldSet(EFS3)); + EXPECT_EQ(CHIP_NO_ERROR, testEFS1.InsertFieldSet(EFS1)); + EXPECT_EQ(CHIP_NO_ERROR, testEFS1.InsertFieldSet(EFS2)); + EXPECT_EQ(CHIP_NO_ERROR, testEFS1.InsertFieldSet(EFS3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == testEFS2.InsertFieldSet(EFS3)); + EXPECT_EQ(CHIP_NO_ERROR, testEFS2.InsertFieldSet(EFS3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == testEFS3.InsertFieldSet(EFS1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == testEFS3.InsertFieldSet(EFS2)); + EXPECT_EQ(CHIP_NO_ERROR, testEFS3.InsertFieldSet(EFS1)); + EXPECT_EQ(CHIP_NO_ERROR, testEFS3.InsertFieldSet(EFS2)); tempTestEFS = testEFS1; - NL_TEST_ASSERT(aSuite, tempTestEFS == testEFS1); - NL_TEST_ASSERT(aSuite, !(tempTestEFS == testEFS2)); - NL_TEST_ASSERT(aSuite, !(tempTestEFS == testEFS3)); + EXPECT_EQ(tempTestEFS, testEFS1); + EXPECT_FALSE(tempTestEFS == testEFS2); + EXPECT_FALSE(tempTestEFS == testEFS3); tempTestEFS = testEFS2; - NL_TEST_ASSERT(aSuite, tempTestEFS == testEFS2); - NL_TEST_ASSERT(aSuite, !(tempTestEFS == testEFS1)); - NL_TEST_ASSERT(aSuite, !(tempTestEFS == testEFS3)); + EXPECT_EQ(tempTestEFS, testEFS2); + EXPECT_FALSE(tempTestEFS == testEFS1); + EXPECT_FALSE(tempTestEFS == testEFS3); tempTestEFS = testEFS3; - NL_TEST_ASSERT(aSuite, tempTestEFS == testEFS3); - NL_TEST_ASSERT(aSuite, !(tempTestEFS == testEFS1)); - NL_TEST_ASSERT(aSuite, !(tempTestEFS == testEFS2)); + EXPECT_EQ(tempTestEFS, testEFS3); + EXPECT_FALSE(tempTestEFS == testEFS1); + EXPECT_FALSE(tempTestEFS == testEFS2); // test clear multipler efs struct tempTestEFS.Clear(); - NL_TEST_ASSERT(aSuite, tempTestEFS.IsEmpty()); - NL_TEST_ASSERT(aSuite, 0 == tempTestEFS.GetFieldSetCount()); + EXPECT_TRUE(tempTestEFS.IsEmpty()); + EXPECT_EQ(0, tempTestEFS.GetFieldSetCount()); // Test insert - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->InsertFieldSet(EFS1)); - NL_TEST_ASSERT(aSuite, 1 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->InsertFieldSet(EFS1)); + EXPECT_EQ(1, EFS->GetFieldSetCount()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->InsertFieldSet(EFS2)); - NL_TEST_ASSERT(aSuite, 2 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->InsertFieldSet(EFS2)); + EXPECT_EQ(2, EFS->GetFieldSetCount()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->InsertFieldSet(EFS3)); - NL_TEST_ASSERT(aSuite, 3 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->InsertFieldSet(EFS3)); + EXPECT_EQ(3, EFS->GetFieldSetCount()); // Test get - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 0)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS1); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 0)); + EXPECT_EQ(tempEFS, EFS1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 1)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS2); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 1)); + EXPECT_EQ(tempEFS, EFS2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 2)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS3); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 2)); + EXPECT_EQ(tempEFS, EFS3); } -void TestSerializeDerializeExtensionFieldSet(nlTestSuite * aSuite, void * aContext) +TEST_F(TestExtensionFieldSets, TestSerializeDerializeExtensionFieldSet) { scenes::ExtensionFieldSetsImpl * EFS = &sEFSets; scenes::ExtensionFieldSetsImpl testSceneEFS; @@ -203,148 +211,105 @@ void TestSerializeDerializeExtensionFieldSet(nlTestSuite * aSuite, void * aConte // Individual Field Sets serialize / deserialize writer.Init(EFS1Buffer); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS1.Serialize(writer)); + EXPECT_EQ(CHIP_NO_ERROR, EFS1.Serialize(writer)); EFS1_serialized_length = writer.GetLengthWritten(); - NL_TEST_ASSERT(aSuite, EFS1_serialized_length <= scenes::kMaxFieldBytesPerCluster); + EXPECT_LE(EFS1_serialized_length, scenes::kMaxFieldBytesPerCluster); writer.Init(EFS2Buffer); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS2.Serialize(writer)); + EXPECT_EQ(CHIP_NO_ERROR, EFS2.Serialize(writer)); EFS2_serialized_length = writer.GetLengthWritten(); - NL_TEST_ASSERT(aSuite, EFS2_serialized_length <= scenes::kMaxFieldBytesPerCluster); + EXPECT_LE(EFS2_serialized_length, scenes::kMaxFieldBytesPerCluster); writer.Init(EFS3Buffer); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS3.Serialize(writer)); + EXPECT_EQ(CHIP_NO_ERROR, EFS3.Serialize(writer)); EFS3_serialized_length = writer.GetLengthWritten(); - NL_TEST_ASSERT(aSuite, EFS3_serialized_length <= scenes::kMaxFieldBytesPerCluster); + EXPECT_LE(EFS3_serialized_length, scenes::kMaxFieldBytesPerCluster); reader.Init(EFS1Buffer); reader.Next(TLV::AnonymousTag()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == tempEFS.Deserialize(reader)); - NL_TEST_ASSERT(aSuite, EFS1 == tempEFS); + EXPECT_EQ(CHIP_NO_ERROR, tempEFS.Deserialize(reader)); + EXPECT_EQ(EFS1, tempEFS); reader.Init(EFS2Buffer); reader.Next(TLV::AnonymousTag()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == tempEFS.Deserialize(reader)); - NL_TEST_ASSERT(aSuite, EFS2 == tempEFS); + EXPECT_EQ(CHIP_NO_ERROR, tempEFS.Deserialize(reader)); + EXPECT_EQ(EFS2, tempEFS); reader.Init(EFS3Buffer); reader.Next(TLV::AnonymousTag()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == tempEFS.Deserialize(reader)); - NL_TEST_ASSERT(aSuite, EFS3 == tempEFS); + EXPECT_EQ(CHIP_NO_ERROR, tempEFS.Deserialize(reader)); + EXPECT_EQ(EFS3, tempEFS); // All ExtensionFieldSets serialize / deserialize writer.Init(sceneEFSBuffer); writer.StartContainer(TLV::AnonymousTag(), TLV::kTLVType_Structure, outer); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->Serialize(writer)); + EXPECT_EQ(CHIP_NO_ERROR, EFS->Serialize(writer)); writer.EndContainer(outer); sceneEFS_serialized_length = writer.GetLengthWritten(); - NL_TEST_ASSERT(aSuite, sceneEFS_serialized_length <= kPersistentSceneBufferMax); + EXPECT_LE(sceneEFS_serialized_length, kPersistentSceneBufferMax); reader.Init(sceneEFSBuffer); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == reader.Next()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == reader.EnterContainer(outerRead)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == testSceneEFS.Deserialize(reader)); + EXPECT_EQ(CHIP_NO_ERROR, reader.Next()); + EXPECT_EQ(CHIP_NO_ERROR, reader.EnterContainer(outerRead)); + EXPECT_EQ(CHIP_NO_ERROR, testSceneEFS.Deserialize(reader)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == reader.ExitContainer(outerRead)); - NL_TEST_ASSERT(aSuite, *EFS == testSceneEFS); + EXPECT_EQ(CHIP_NO_ERROR, reader.ExitContainer(outerRead)); + EXPECT_EQ(*EFS, testSceneEFS); } -void TestRemoveExtensionFieldSet(nlTestSuite * aSuite, void * aContext) +TEST_F(TestExtensionFieldSets, TestRemoveExtensionFieldSet) { scenes::ExtensionFieldSetsImpl * EFS = &sEFSets; scenes::ExtensionFieldSet tempEFS; // Order in EFS at this point: [EFS1, EFS2, EFS3] // Removal at beginning - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->RemoveFieldAtPosition(0)); - NL_TEST_ASSERT(aSuite, 2 == EFS->GetFieldSetCount()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->InsertFieldSet(EFS1)); - NL_TEST_ASSERT(aSuite, 3 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->RemoveFieldAtPosition(0)); + EXPECT_EQ(2, EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->InsertFieldSet(EFS1)); + EXPECT_EQ(3, EFS->GetFieldSetCount()); // Verify order - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 0)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 1)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 2)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS1); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 0)); + EXPECT_EQ(tempEFS, EFS2); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 1)); + EXPECT_EQ(tempEFS, EFS3); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 2)); + EXPECT_EQ(tempEFS, EFS1); // Order in EFS at this point: [EFS2, EFS3, EFS1] // Removal at middle - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->RemoveFieldAtPosition(1)); - NL_TEST_ASSERT(aSuite, 2 == EFS->GetFieldSetCount()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->InsertFieldSet(EFS3)); - NL_TEST_ASSERT(aSuite, 3 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->RemoveFieldAtPosition(1)); + EXPECT_EQ(2, EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->InsertFieldSet(EFS3)); + EXPECT_EQ(3, EFS->GetFieldSetCount()); // Verify order - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 0)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 1)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 2)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS3); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 0)); + EXPECT_EQ(tempEFS, EFS2); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 1)); + EXPECT_EQ(tempEFS, EFS1); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 2)); + EXPECT_EQ(tempEFS, EFS3); // Order in EFS at this point: [EFS2, EFS1, EFS3] // Removal at end - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->RemoveFieldAtPosition(2)); - NL_TEST_ASSERT(aSuite, 2 == EFS->GetFieldSetCount()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->InsertFieldSet(EFS3)); - NL_TEST_ASSERT(aSuite, 3 == EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->RemoveFieldAtPosition(2)); + EXPECT_EQ(2, EFS->GetFieldSetCount()); + EXPECT_EQ(CHIP_NO_ERROR, EFS->InsertFieldSet(EFS3)); + EXPECT_EQ(3, EFS->GetFieldSetCount()); // Verify order - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 0)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 1)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == EFS->GetFieldSetAtPosition(tempEFS, 2)); - NL_TEST_ASSERT(aSuite, tempEFS == EFS3); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 0)); + EXPECT_EQ(tempEFS, EFS2); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 1)); + EXPECT_EQ(tempEFS, EFS1); + EXPECT_EQ(CHIP_NO_ERROR, EFS->GetFieldSetAtPosition(tempEFS, 2)); + EXPECT_EQ(tempEFS, EFS3); // Emptying the table EFS->Clear(); - NL_TEST_ASSERT(aSuite, true == EFS->IsEmpty()); + EXPECT_TRUE(EFS->IsEmpty()); } } // namespace TestEFS -/** - * Tear down the test suite. - */ -int TestSetup(void * inContext) -{ - VerifyOrReturnError(CHIP_NO_ERROR == chip::Platform::MemoryInit(), FAILURE); - - return SUCCESS; -} - -namespace { -/** - * Setup the test suite. - */ -int TestTeardown(void * inContext) -{ - chip::Platform::MemoryShutdown(); - - return SUCCESS; -} -} // namespace - -int TestExtensionFieldSets() -{ - static nlTest sTests[] = { NL_TEST_DEF("TestInsertExtensionFieldSet", TestEFS::TestInsertExtensionFieldSet), - NL_TEST_DEF("TestSerializeDerializeExtensionFieldSet", - TestEFS::TestSerializeDerializeExtensionFieldSet), - NL_TEST_DEF("TestRemoveExtensionFieldSet", TestEFS::TestRemoveExtensionFieldSet), - - NL_TEST_SENTINEL() }; - - nlTestSuite theSuite = { - "SceneTable", - &sTests[0], - TestSetup, - TestTeardown, - }; - - nlTestRunner(&theSuite, nullptr); - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestExtensionFieldSets) diff --git a/src/app/tests/TestSceneTable.cpp b/src/app/tests/TestSceneTable.cpp index 1ce2583c28ab27..1563c286ac3e16 100644 --- a/src/app/tests/TestSceneTable.cpp +++ b/src/app/tests/TestSceneTable.cpp @@ -22,9 +22,9 @@ #include #include #include -#include -#include +#include +#include using namespace chip; using SceneTable = scenes::SceneTable; @@ -425,10 +425,42 @@ class TestSceneTableImpl : public SceneTableImpl uint8_t GetClusterCountFromEndpoint() override { return 3; } }; -// Storage -static chip::TestPersistentStorageDelegate testStorage; -// Scene -static TestSceneHandler sHandler; +// Test Fixture Class +class TestSceneTable : public ::testing::Test +{ +public: + static void SetUpTestSuite() + { + mpTestStorage = new chip::TestPersistentStorageDelegate; + mpSceneHandler = new TestSceneHandler; + + ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); + + // Initialize Scene Table + SceneTable * sceneTable = scenes::GetSceneTableImpl(); + ASSERT_NE(sceneTable, nullptr); + ASSERT_EQ(sceneTable->Init(mpTestStorage), CHIP_NO_ERROR); + } + + static void TearDownTestSuite() + { + // Terminate Scene Table + SceneTable * sceneTable = scenes::GetSceneTableImpl(); + ASSERT_NE(sceneTable, nullptr); + sceneTable->Finish(); + delete mpTestStorage; + delete mpSceneHandler; + chip::Platform::MemoryShutdown(); + } + + // Storage + static chip::TestPersistentStorageDelegate * mpTestStorage; + // Scene + static TestSceneHandler * mpSceneHandler; +}; + +chip::TestPersistentStorageDelegate * TestSceneTable::mpTestStorage = nullptr; +TestSceneHandler * TestSceneTable::mpSceneHandler = nullptr; void ResetSceneTable(SceneTable * sceneTable) { @@ -437,11 +469,10 @@ void ResetSceneTable(SceneTable * sceneTable) sceneTable->RemoveFabric(kFabric3); } -void TestHandlerRegistration(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestHandlerRegistration) { SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); TestSceneHandler tmpHandler[scenes::kMaxClustersPerScene]; for (uint8_t i = 0; i < scenes::kMaxClustersPerScene; i++) @@ -453,7 +484,7 @@ void TestHandlerRegistration(nlTestSuite * aSuite, void * aContext) sceneTable->UnregisterAllHandlers(); // Verify the handler num has been updated properly - NL_TEST_ASSERT(aSuite, sceneTable->HandlerListEmpty()); + EXPECT_TRUE(sceneTable->HandlerListEmpty()); for (uint8_t i = 0; i < scenes::kMaxClustersPerScene; i++) { @@ -462,40 +493,38 @@ void TestHandlerRegistration(nlTestSuite * aSuite, void * aContext) // Hanlder order in table : [H0, H1, H2] - NL_TEST_ASSERT(aSuite, !sceneTable->HandlerListEmpty()); + EXPECT_FALSE(sceneTable->HandlerListEmpty()); // Removal at beginning sceneTable->UnregisterHandler(&tmpHandler[0]); - NL_TEST_ASSERT(aSuite, !sceneTable->HandlerListEmpty()); + EXPECT_FALSE(sceneTable->HandlerListEmpty()); // Re-insert sceneTable->RegisterHandler(&tmpHandler[0]); - NL_TEST_ASSERT(aSuite, !sceneTable->HandlerListEmpty()); + EXPECT_FALSE(sceneTable->HandlerListEmpty()); // Hanlder order in table : [H0, H1, H2] // Removal at the middle sceneTable->UnregisterHandler(&tmpHandler[2]); - NL_TEST_ASSERT(aSuite, !sceneTable->HandlerListEmpty()); + EXPECT_FALSE(sceneTable->HandlerListEmpty()); // Re-insert sceneTable->RegisterHandler(&tmpHandler[2]); - NL_TEST_ASSERT(aSuite, !sceneTable->HandlerListEmpty()); + EXPECT_FALSE(sceneTable->HandlerListEmpty()); // Hanlder order in table : [H1, H0, H2] // Removal at the end sceneTable->UnregisterHandler(&tmpHandler[2]); - NL_TEST_ASSERT(aSuite, !sceneTable->HandlerListEmpty()); + EXPECT_FALSE(sceneTable->HandlerListEmpty()); // Emptying Handler array sceneTable->UnregisterAllHandlers(); // Verify the handler num has been updated properly - NL_TEST_ASSERT(aSuite, sceneTable->HandlerListEmpty()); + EXPECT_TRUE(sceneTable->HandlerListEmpty()); } -void TestHandlerFunctions(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestHandlerFunctions) { SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - + ASSERT_NE(nullptr, sceneTable); app::Clusters::ScenesManagement::Structs::ExtensionFieldSet::Type extensionFieldSetOut; app::Clusters::ScenesManagement::Structs::ExtensionFieldSet::DecodableType extensionFieldSetIn; @@ -548,99 +577,91 @@ void TestHandlerFunctions(nlTestSuite * aSuite, void * aContext) // Serialize Extension Field sets as if they were recovered from memory writer.Init(OO_buffer); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == app::DataModel::Encode(writer, TLV::AnonymousTag(), OOextensionFieldSet.attributeValueList)); + EXPECT_EQ(CHIP_NO_ERROR, app::DataModel::Encode(writer, TLV::AnonymousTag(), OOextensionFieldSet.attributeValueList)); OO_buffer_serialized_length = writer.GetLengthWritten(); writer.Init(LC_buffer); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == app::DataModel::Encode(writer, TLV::AnonymousTag(), LCextensionFieldSet.attributeValueList)); + EXPECT_EQ(CHIP_NO_ERROR, app::DataModel::Encode(writer, TLV::AnonymousTag(), LCextensionFieldSet.attributeValueList)); LC_buffer_serialized_length = writer.GetLengthWritten(); writer.Init(CC_buffer); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == app::DataModel::Encode(writer, TLV::AnonymousTag(), CCextensionFieldSet.attributeValueList)); + EXPECT_EQ(CHIP_NO_ERROR, app::DataModel::Encode(writer, TLV::AnonymousTag(), CCextensionFieldSet.attributeValueList)); CC_buffer_serialized_length = writer.GetLengthWritten(); // Test Registering SceneHandler - sceneTable->RegisterHandler(&sHandler); - NL_TEST_ASSERT(aSuite, !sceneTable->HandlerListEmpty()); + sceneTable->RegisterHandler(mpSceneHandler); + EXPECT_FALSE(sceneTable->HandlerListEmpty()); // Setup the On Off Extension field set in the expected state from a command reader.Init(OO_list); extensionFieldSetIn.clusterID = kOnOffClusterId; - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == reader.Next()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == extensionFieldSetIn.attributeValueList.Decode(reader)); + EXPECT_EQ(CHIP_NO_ERROR, reader.Next()); + EXPECT_EQ(CHIP_NO_ERROR, extensionFieldSetIn.attributeValueList.Decode(reader)); - NL_TEST_ASSERT(aSuite, sHandler.SupportsCluster(kTestEndpoint1, extensionFieldSetIn.clusterID)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sHandler.SerializeAdd(kTestEndpoint1, extensionFieldSetIn, buff_span)); + EXPECT_TRUE(mpSceneHandler->SupportsCluster(kTestEndpoint1, extensionFieldSetIn.clusterID)); + EXPECT_EQ(CHIP_NO_ERROR, mpSceneHandler->SerializeAdd(kTestEndpoint1, extensionFieldSetIn, buff_span)); // Verify the handler extracted buffer matches the initial field sets - NL_TEST_ASSERT(aSuite, 0 == memcmp(OO_list.data(), buff_span.data(), buff_span.size())); + EXPECT_EQ(0, memcmp(OO_list.data(), buff_span.data(), buff_span.size())); memset(buffer, 0, buff_span.size()); buff_span = MutableByteSpan(buffer); // Setup the Level Control Extension field set in the expected state from a command reader.Init(LC_list); extensionFieldSetIn.clusterID = kLevelControlClusterId; - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == reader.Next()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == extensionFieldSetIn.attributeValueList.Decode(reader)); + EXPECT_EQ(CHIP_NO_ERROR, reader.Next()); + EXPECT_EQ(CHIP_NO_ERROR, extensionFieldSetIn.attributeValueList.Decode(reader)); - NL_TEST_ASSERT(aSuite, sHandler.SupportsCluster(kTestEndpoint1, extensionFieldSetIn.clusterID)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sHandler.SerializeAdd(kTestEndpoint1, extensionFieldSetIn, buff_span)); + EXPECT_TRUE(mpSceneHandler->SupportsCluster(kTestEndpoint1, extensionFieldSetIn.clusterID)); + EXPECT_EQ(CHIP_NO_ERROR, mpSceneHandler->SerializeAdd(kTestEndpoint1, extensionFieldSetIn, buff_span)); // Verify the handler extracted buffer matches the initial field sets - NL_TEST_ASSERT(aSuite, 0 == memcmp(LC_list.data(), buff_span.data(), buff_span.size())); + EXPECT_EQ(0, memcmp(LC_list.data(), buff_span.data(), buff_span.size())); memset(buffer, 0, buff_span.size()); buff_span = MutableByteSpan(buffer); // Setup the Color control Extension field set in the expected state from a command reader.Init(CC_list); extensionFieldSetIn.clusterID = kColorControlClusterId; - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == reader.Next()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == extensionFieldSetIn.attributeValueList.Decode(reader)); + EXPECT_EQ(CHIP_NO_ERROR, reader.Next()); + EXPECT_EQ(CHIP_NO_ERROR, extensionFieldSetIn.attributeValueList.Decode(reader)); - NL_TEST_ASSERT(aSuite, sHandler.SupportsCluster(kTestEndpoint1, extensionFieldSetIn.clusterID)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sHandler.SerializeAdd(kTestEndpoint1, extensionFieldSetIn, buff_span)); + EXPECT_TRUE(mpSceneHandler->SupportsCluster(kTestEndpoint1, extensionFieldSetIn.clusterID)); + EXPECT_EQ(CHIP_NO_ERROR, mpSceneHandler->SerializeAdd(kTestEndpoint1, extensionFieldSetIn, buff_span)); // Verify the handler extracted buffer matches the initial field sets - NL_TEST_ASSERT(aSuite, 0 == memcmp(CC_list.data(), buff_span.data(), buff_span.size())); + EXPECT_EQ(0, memcmp(CC_list.data(), buff_span.data(), buff_span.size())); memset(buffer, 0, buff_span.size()); buff_span = MutableByteSpan(buffer); // Verify Deserializing is properly filling out output extension field set for on off - NL_TEST_ASSERT(aSuite, sHandler.SupportsCluster(kTestEndpoint1, kOnOffClusterId)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sHandler.Deserialize(kTestEndpoint1, kOnOffClusterId, OO_list, extensionFieldSetOut)); + EXPECT_TRUE(mpSceneHandler->SupportsCluster(kTestEndpoint1, kOnOffClusterId)); + EXPECT_EQ(CHIP_NO_ERROR, mpSceneHandler->Deserialize(kTestEndpoint1, kOnOffClusterId, OO_list, extensionFieldSetOut)); // Verify Encoding the Extension field set returns the same data as the one serialized for on off previously writer.Init(buff_span); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldSetOut.attributeValueList)); - NL_TEST_ASSERT(aSuite, 0 == memcmp(OO_list.data(), buff_span.data(), buff_span.size())); + EXPECT_EQ(CHIP_NO_ERROR, app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldSetOut.attributeValueList)); + EXPECT_EQ(0, memcmp(OO_list.data(), buff_span.data(), buff_span.size())); memset(buffer, 0, buff_span.size()); // Verify Deserializing is properly filling out output extension field set for level control - NL_TEST_ASSERT(aSuite, sHandler.SupportsCluster(kTestEndpoint1, kLevelControlClusterId)); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == sHandler.Deserialize(kTestEndpoint1, kLevelControlClusterId, LC_list, extensionFieldSetOut)); + EXPECT_TRUE(mpSceneHandler->SupportsCluster(kTestEndpoint1, kLevelControlClusterId)); + EXPECT_EQ(CHIP_NO_ERROR, mpSceneHandler->Deserialize(kTestEndpoint1, kLevelControlClusterId, LC_list, extensionFieldSetOut)); // Verify Encoding the Extension field set returns the same data as the one serialized for level control previously writer.Init(buff_span); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldSetOut.attributeValueList)); - NL_TEST_ASSERT(aSuite, 0 == memcmp(LC_list.data(), buff_span.data(), buff_span.size())); + EXPECT_EQ(CHIP_NO_ERROR, app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldSetOut.attributeValueList)); + EXPECT_EQ(0, memcmp(LC_list.data(), buff_span.data(), buff_span.size())); memset(buffer, 0, buff_span.size()); // Verify Deserializing is properly filling out output extension field set for color control - NL_TEST_ASSERT(aSuite, sHandler.SupportsCluster(kTestEndpoint1, kColorControlClusterId)); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == sHandler.Deserialize(kTestEndpoint1, kColorControlClusterId, CC_list, extensionFieldSetOut)); + EXPECT_TRUE(mpSceneHandler->SupportsCluster(kTestEndpoint1, kColorControlClusterId)); + EXPECT_EQ(CHIP_NO_ERROR, mpSceneHandler->Deserialize(kTestEndpoint1, kColorControlClusterId, CC_list, extensionFieldSetOut)); // Verify Encoding the Extension field set returns the same data as the one serialized for color control previously writer.Init(buff_span); - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldSetOut.attributeValueList)); - NL_TEST_ASSERT(aSuite, 0 == memcmp(CC_list.data(), buff_span.data(), buff_span.size())); + EXPECT_EQ(CHIP_NO_ERROR, app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldSetOut.attributeValueList)); + EXPECT_EQ(0, memcmp(CC_list.data(), buff_span.data(), buff_span.size())); memset(buffer, 0, buff_span.size()); // To test failure on serialize and deserialize when too many pairs are in the field sets @@ -663,52 +684,46 @@ void TestHandlerFunctions(nlTestSuite * aSuite, void * aContext) // Serialize Extension Field sets as if they were recovered from memory writer.Init(failBuffer); - NL_TEST_ASSERT( - aSuite, CHIP_NO_ERROR == app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldFailTestOut.attributeValueList)); + EXPECT_EQ(CHIP_NO_ERROR, app::DataModel::Encode(writer, TLV::AnonymousTag(), extensionFieldFailTestOut.attributeValueList)); // Setup the On Off Extension field set in the expected state from a command reader.Init(fail_list); extensionFieldFailTestIn.clusterID = kColorControlClusterId; - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == reader.Next()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == extensionFieldFailTestIn.attributeValueList.Decode(reader)); + EXPECT_EQ(CHIP_NO_ERROR, reader.Next()); + EXPECT_EQ(CHIP_NO_ERROR, extensionFieldFailTestIn.attributeValueList.Decode(reader)); // Verify failure on both serialize and deserialize - NL_TEST_ASSERT(aSuite, - CHIP_ERROR_BUFFER_TOO_SMALL == sHandler.SerializeAdd(kTestEndpoint1, extensionFieldFailTestIn, buff_span)); - NL_TEST_ASSERT(aSuite, - CHIP_ERROR_BUFFER_TOO_SMALL == - sHandler.Deserialize(kTestEndpoint1, kColorControlClusterId, fail_list, extensionFieldFailTestOut)); + EXPECT_EQ(CHIP_ERROR_BUFFER_TOO_SMALL, mpSceneHandler->SerializeAdd(kTestEndpoint1, extensionFieldFailTestIn, buff_span)); + EXPECT_EQ(CHIP_ERROR_BUFFER_TOO_SMALL, + mpSceneHandler->Deserialize(kTestEndpoint1, kColorControlClusterId, fail_list, extensionFieldFailTestOut)); memset(failBuffer, 0, fail_list.size()); memset(buffer, 0, buff_span.size()); }; -void TestHandlerHelpers(nlTestSuite * aSuite, void * aContext) {} - -void TestStoreScenes(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestStoreScenes) { SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); SceneId sceneList[defaultTestFabricCapacity]; // Reset test ResetSceneTable(sceneTable); // Populate scene1's EFS (Endpoint1) - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneSaveEFS(scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneSaveEFS(scene1)); // Populate scene2's EFS (Endpoint1) - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneSaveEFS(scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneSaveEFS(scene2)); // Populate scene3's EFS (Endpoint2) - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneSaveEFS(scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneSaveEFS(scene3)); // Populate scene4's EFS (Endpoint2) - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneSaveEFS(scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneSaveEFS(scene4)); // Populate scene8's EFS (Endpoint3) - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneSaveEFS(scene8)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneSaveEFS(scene8)); SceneTableEntry scene; Span sceneListSpan = Span(sceneList); @@ -716,272 +731,266 @@ void TestStoreScenes(nlTestSuite * aSuite, void * aContext) Span smallListSpan = Span(sceneList, 1); // Test Get All scenes in Group in empty scene table - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); - NL_TEST_ASSERT(aSuite, 0 == emptyListSpan.size()); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); + EXPECT_EQ(0u, emptyListSpan.size()); // Set test - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); // Test single scene in table with 0 size span - NL_TEST_ASSERT(aSuite, CHIP_ERROR_BUFFER_TOO_SMALL == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, smallListSpan)); - NL_TEST_ASSERT(aSuite, 1 == smallListSpan.size()); + EXPECT_EQ(CHIP_ERROR_BUFFER_TOO_SMALL, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, smallListSpan)); + EXPECT_EQ(1u, smallListSpan.size()); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene7)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene7)); // Too many scenes for 1 fabric - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NO_MEMORY == sceneTable->SetSceneTableEntry(kFabric1, scene9)); + EXPECT_EQ(CHIP_ERROR_NO_MEMORY, sceneTable->SetSceneTableEntry(kFabric1, scene9)); // Not Found - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId9, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_BUFFER_TOO_SMALL == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId9, scene)); + EXPECT_EQ(CHIP_ERROR_BUFFER_TOO_SMALL, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); // Get test - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneApplyEFS(scene)); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneApplyEFS(scene)); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneApplyEFS(scene)); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneApplyEFS(scene)); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, scene == scene5); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, scene == scene6); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); - NL_TEST_ASSERT(aSuite, scene == scene7); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SceneApplyEFS(scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneApplyEFS(scene)); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(scene, scene2); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneApplyEFS(scene)); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(scene, scene3); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneApplyEFS(scene)); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(scene, scene4); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneApplyEFS(scene)); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(scene, scene5); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(scene, scene6); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + EXPECT_EQ(scene, scene7); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SceneApplyEFS(scene)); // Test error when list too small in a full table // Test failure for 3 spaces in 4 scenes list - NL_TEST_ASSERT(aSuite, CHIP_ERROR_BUFFER_TOO_SMALL == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, smallListSpan)); + EXPECT_EQ(CHIP_ERROR_BUFFER_TOO_SMALL, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, smallListSpan)); // Test failure for no space in a 4 scenes list - NL_TEST_ASSERT(aSuite, CHIP_ERROR_BUFFER_TOO_SMALL == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); + EXPECT_EQ(CHIP_ERROR_BUFFER_TOO_SMALL, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, emptyListSpan)); // Test failure for no space in a 1 scene list - NL_TEST_ASSERT(aSuite, CHIP_ERROR_BUFFER_TOO_SMALL == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup3, emptyListSpan)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup3, smallListSpan)); - NL_TEST_ASSERT(aSuite, 1 == smallListSpan.size()); + EXPECT_EQ(CHIP_ERROR_BUFFER_TOO_SMALL, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup3, emptyListSpan)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup3, smallListSpan)); + EXPECT_EQ(1u, smallListSpan.size()); // Test successfully getting Ids from various groups - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, sceneListSpan)); - NL_TEST_ASSERT(aSuite, 4 == sceneListSpan.size()); - NL_TEST_ASSERT(aSuite, kScene1 == sceneList[0]); - NL_TEST_ASSERT(aSuite, kScene2 == sceneList[1]); - NL_TEST_ASSERT(aSuite, kScene3 == sceneList[2]); - NL_TEST_ASSERT(aSuite, kScene4 == sceneList[3]); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup2, sceneListSpan)); - NL_TEST_ASSERT(aSuite, 2 == sceneListSpan.size()); - NL_TEST_ASSERT(aSuite, kScene5 == sceneList[0]); - NL_TEST_ASSERT(aSuite, kScene6 == sceneList[1]); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup3, sceneListSpan)); - NL_TEST_ASSERT(aSuite, 1 == sceneListSpan.size()); - NL_TEST_ASSERT(aSuite, kScene7 == sceneList[0]); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup1, sceneListSpan)); + EXPECT_EQ(4u, sceneListSpan.size()); + EXPECT_EQ(kScene1, sceneList[0]); + EXPECT_EQ(kScene2, sceneList[1]); + EXPECT_EQ(kScene3, sceneList[2]); + EXPECT_EQ(kScene4, sceneList[3]); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup2, sceneListSpan)); + EXPECT_EQ(2u, sceneListSpan.size()); + EXPECT_EQ(kScene5, sceneList[0]); + EXPECT_EQ(kScene6, sceneList[1]); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetAllSceneIdsInGroup(kFabric1, kGroup3, sceneListSpan)); + EXPECT_EQ(1u, sceneListSpan.size()); + EXPECT_EQ(kScene7, sceneList[0]); uint8_t sceneCount = 0; sceneTable->GetEndpointSceneCount(sceneCount); sceneTable->GetFabricSceneCount(kFabric1, sceneCount); } -void TestOverwriteScenes(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestOverwriteScenes) { SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); uint8_t sceneCount = 0; sceneTable->GetEndpointSceneCount(sceneCount); sceneTable->GetFabricSceneCount(kFabric1, sceneCount); SceneTableEntry scene; // Overwriting the first entry - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene10)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene10)); // Overwriting in the middle - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene11)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene11)); // Overwriting the last entry - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene12)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene12)); // Scene 10 has the same sceneId as scene 1, Get->sceneId1 should thus return scene 10, etc. - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene10); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(scene, scene10); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, scene == scene11); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(scene, scene11); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); - NL_TEST_ASSERT(aSuite, scene == scene12); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + EXPECT_EQ(scene, scene12); } -void TestIterateScenes(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestIterateScenes) { SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); SceneTableEntry scene; auto * iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator != nullptr); + ASSERT_NE(iterator, nullptr); if (iterator) { - NL_TEST_ASSERT(aSuite, iterator->Count() == 7); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene10); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene11); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene6); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene12); - - NL_TEST_ASSERT(aSuite, iterator->Next(scene) == false); + EXPECT_EQ(iterator->Count(), 7u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene10); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene2); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene3); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene4); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene11); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene6); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene12); + + EXPECT_FALSE(iterator->Next(scene)); iterator->Release(); } } -void TestRemoveScenes(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestRemoveScenes) { SceneTableImpl * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); SceneTableEntry scene; // Removing non-existing entry should not return errors - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene9.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene9.mStorageId)); // Remove middle - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene5.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene5.mStorageId)); auto * iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 6); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene10); + EXPECT_EQ(iterator->Count(), 6u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene10); iterator->Release(); // Add scene in middle, a spot should have been freed - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene9)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene9)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 7); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId9, scene)); - NL_TEST_ASSERT(aSuite, scene == scene9); + EXPECT_EQ(iterator->Count(), 7u); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId9, scene)); + EXPECT_EQ(scene, scene9); iterator->Release(); // Remove the recently added scene 9 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene9.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene9.mStorageId)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 6); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene10); + EXPECT_EQ(iterator->Count(), 6u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene10); iterator->Release(); // Remove first - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntryAtPosition(kTestEndpoint1, kFabric1, 0)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntryAtPosition(kTestEndpoint1, kFabric1, 0)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 5); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); + EXPECT_EQ(iterator->Count(), 5u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene2); iterator->Release(); // Remove Next - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene3.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene3.mStorageId)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 4); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); + EXPECT_EQ(iterator->Count(), 4u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene2); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene4); iterator->Release(); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene2.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene2.mStorageId)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 3); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); + EXPECT_EQ(iterator->Count(), 3u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene4); iterator->Release(); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene4.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene4.mStorageId)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 2); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene6); + EXPECT_EQ(iterator->Count(), 2u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene6); iterator->Release(); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene6.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene6.mStorageId)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 1); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene12); + EXPECT_EQ(iterator->Count(), 1u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene12); iterator->Release(); // Remove last - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, scene7.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, scene7.mStorageId)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 0); - NL_TEST_ASSERT(aSuite, iterator->Next(scene) == false); + EXPECT_EQ(iterator->Count(), 0u); + EXPECT_FALSE(iterator->Next(scene)); iterator->Release(); // Remove at empty position, shouldn't trigger error - NL_TEST_ASSERT(aSuite, - CHIP_NO_ERROR == - sceneTable->RemoveSceneTableEntryAtPosition(kTestEndpoint1, kFabric1, defaultTestFabricCapacity - 1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntryAtPosition(kTestEndpoint1, kFabric1, defaultTestFabricCapacity - 1)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 0); + EXPECT_EQ(iterator->Count(), 0u); iterator->Release(); // Test Remove all scenes in Group - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene6)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 6); + EXPECT_EQ(iterator->Count(), 6u); iterator->Release(); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->DeleteAllScenesInGroup(kFabric1, kGroup1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->DeleteAllScenesInGroup(kFabric1, kGroup1)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 2); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene5); - NL_TEST_ASSERT(aSuite, iterator->Next(scene)); - NL_TEST_ASSERT(aSuite, scene == scene6); + EXPECT_EQ(iterator->Count(), 2u); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene5); + EXPECT_TRUE(iterator->Next(scene)); + EXPECT_EQ(scene, scene6); iterator->Release(); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->DeleteAllScenesInGroup(kFabric1, kGroup2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->DeleteAllScenesInGroup(kFabric1, kGroup2)); iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, iterator->Count() == 0); + EXPECT_EQ(iterator->Count(), 0u); iterator->Release(); } -void TestFabricScenes(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestFabricScenes) { SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); // Reset test ResetSceneTable(sceneTable); @@ -990,234 +999,233 @@ void TestFabricScenes(nlTestSuite * aSuite, void * aContext) uint8_t fabric_capacity = 0; // Verify capacities are at max - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); // Fabric 1 inserts - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene7)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene7)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); uint8_t scene_count = 0; - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric1, scene_count)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric1, scene_count)); + EXPECT_EQ(defaultTestFabricCapacity, scene_count); // Fabric 2 inserts - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, (defaultTestFabricCapacity - 4) == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric2, scene_count)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, 11 == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ((defaultTestFabricCapacity - 4), fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric2, scene_count)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(scene_count)); + EXPECT_EQ(11, scene_count); // Fabric 3 inserts, should only be 4 spaces left at this point since 12 got taken - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestTableSize - 11 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric3, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric3, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric3, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric3, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric3, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric3, scene_count)); - NL_TEST_ASSERT(aSuite, 5 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, defaultTestTableSize == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); + EXPECT_EQ(defaultTestTableSize - 11, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric3, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric3, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric3, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric3, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric3, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric3, scene_count)); + EXPECT_EQ(5, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(scene_count)); + EXPECT_EQ(defaultTestTableSize, scene_count); // Checks capacity is now 0 accross all fabrics - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); // To many scenes accross fabrics (Max scenes accross fabrics == 16) - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NO_MEMORY == sceneTable->SetSceneTableEntry(kFabric3, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NO_MEMORY == sceneTable->SetSceneTableEntry(kFabric2, scene5)); + EXPECT_EQ(CHIP_ERROR_NO_MEMORY, sceneTable->SetSceneTableEntry(kFabric3, scene6)); + EXPECT_EQ(CHIP_ERROR_NO_MEMORY, sceneTable->SetSceneTableEntry(kFabric2, scene5)); // Verifying all inserted scenes are accessible - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, scene == scene5); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, scene == scene6); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); - NL_TEST_ASSERT(aSuite, scene == scene7); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, scene == scene5); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(scene, scene2); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(scene, scene3); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(scene, scene4); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(scene, scene5); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(scene, scene6); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + EXPECT_EQ(scene, scene7); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); + EXPECT_EQ(scene, scene2); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); + EXPECT_EQ(scene, scene3); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); + EXPECT_EQ(scene, scene4); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); + EXPECT_EQ(scene, scene2); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); + EXPECT_EQ(scene, scene3); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); + EXPECT_EQ(scene, scene4); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); + EXPECT_EQ(scene, scene5); // Remove Fabric 1 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveFabric(kFabric1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveFabric(kFabric1)); // Verify Fabric 1 removed - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric1, scene_count)); - NL_TEST_ASSERT(aSuite, 0 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, 9 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId8, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric1, scene_count)); + EXPECT_EQ(0, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(scene_count)); + EXPECT_EQ(9, scene_count); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId8, scene)); // Verify Fabric 2 still there - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric2, scene_count)); - NL_TEST_ASSERT(aSuite, 4 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric2, scene_count)); + EXPECT_EQ(4, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); + EXPECT_EQ(scene, scene2); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); + EXPECT_EQ(scene, scene3); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); + EXPECT_EQ(scene, scene4); // Verify capacity updated for all fabrics - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 4 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 5 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 4, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 5, fabric_capacity); // Verify we can now write more scenes in scene fabric 2 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene7)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, scene == scene5); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, scene == scene6); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); - NL_TEST_ASSERT(aSuite, scene == scene7); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric2, scene_count)); - NL_TEST_ASSERT(aSuite, 7 == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene7)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); + EXPECT_EQ(scene, scene5); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); + EXPECT_EQ(scene, scene6); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); + EXPECT_EQ(scene, scene7); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric2, scene_count)); + EXPECT_EQ(7, scene_count); // Verify capacity updated properly - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 4 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 5 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(4, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 5, fabric_capacity); // Verify Fabric 3 still there - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, scene == scene5); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); + EXPECT_EQ(scene, scene2); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); + EXPECT_EQ(scene, scene3); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); + EXPECT_EQ(scene, scene4); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); + EXPECT_EQ(scene, scene5); // Remove Fabric 2 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveFabric(kFabric2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveFabric(kFabric2)); // Verify Fabric 2 removed - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric2, scene_count)); - NL_TEST_ASSERT(aSuite, 0 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, 5 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric2, scene_count)); + EXPECT_EQ(0, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(scene_count)); + EXPECT_EQ(5, scene_count); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); // Verify Fabric 3 still there - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric3, scene_count)); - NL_TEST_ASSERT(aSuite, 5 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, scene == scene2); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, scene == scene3); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, scene == scene4); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, scene == scene5); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric3, scene_count)); + EXPECT_EQ(5, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); + EXPECT_EQ(scene, scene2); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); + EXPECT_EQ(scene, scene3); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); + EXPECT_EQ(scene, scene4); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); + EXPECT_EQ(scene, scene5); // Remove Fabric 3 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveFabric(kFabric3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveFabric(kFabric3)); // Verify Fabric 3 removed - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric2, scene_count)); - NL_TEST_ASSERT(aSuite, 0 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, 0 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric2, scene_count)); + EXPECT_EQ(0, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(scene_count)); + EXPECT_EQ(0, scene_count); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric3, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric3, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric3, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric3, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric3, sceneId5, scene)); // Confirm all counts are at 0 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric1, scene_count)); - NL_TEST_ASSERT(aSuite, 0 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric2, scene_count)); - NL_TEST_ASSERT(aSuite, 0 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetFabricSceneCount(kFabric3, scene_count)); - NL_TEST_ASSERT(aSuite, 0 == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric1, scene_count)); + EXPECT_EQ(0, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric2, scene_count)); + EXPECT_EQ(0, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetFabricSceneCount(kFabric3, scene_count)); + EXPECT_EQ(0, scene_count); // Verify capacity updated for all fabrics - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric3, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); } -void TestEndpointScenes(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestEndpointScenes) { // Get Count for Endpoint 1 SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); // Reset test ResetSceneTable(sceneTable); @@ -1228,401 +1236,360 @@ void TestEndpointScenes(nlTestSuite * aSuite, void * aContext) // Get Count for Endpoint 1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Get Count for Endpoint 2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Get Count for Endpoint 3 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Test Scenes insertion not accessible accross all endpoints sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 2 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(2, endpoint_scene_count); uint8_t fabric_capacity = 0; - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 1 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 1 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 1, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 1, fabric_capacity); // Endpoint2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Endpoint3 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Check if scene present in Endpoint 1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(scene, scene1); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + EXPECT_EQ(scene, scene1); // Check if scene present in Endpoint 2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); // Check if scene present in Endpoint 3 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); // Test removal on different endpoints do not affect each endpoints // Insertion on Endpoint2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(scene, scene1); // Removal on Endpoint1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, sceneId1)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, sceneId1)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); // Scene present on Endpoint2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(scene, scene1); // Removal on Endpoint 2 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric1, sceneId1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric1, sceneId1)); // Removal on Endpoint 1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveSceneTableEntry(kFabric2, sceneId1)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveSceneTableEntry(kFabric2, sceneId1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Endpoint 2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Endpoint 3 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Test the fabric capacity accross endpoint // Fill fabric 1 endpoint 1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene7)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene7)); // Fill fabric 2 endpoint 1 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene7)); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene7)); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); // Endpoints 2 and 3 should be unaffected sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); // Verify filling Fabric on endpoint 2 does not affect on endpoint 3 despite Max per fabric being reached by adding Endpoint1 // and Endpoint2 // Fill fabric 1 endpoint 2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene7)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene7)); // Fill fabric 2 endpoint 2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene7)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene7)); // scene count to Endpoint // Endpoint 3 still unafected sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); // Fill fabric 1 endpoint 3 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene7)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene7)); // Test removal of Endpoint clears scene on all fabrics for that endpoint sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->RemoveEndpoint()); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->RemoveEndpoint()); // Check Fabric1 on Endpoint 2 - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); // Check Fabric 1 and 2 on Endpoint 1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); - - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId1, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId2, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId3, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId4, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId5, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId6, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric2, sceneId7, scene)); // Check Fabric 1 on Endpoint 3 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); // Test removal of fabric clears scene fabric on all endpoints sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); sceneTable->RemoveFabric(kFabric1); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId2, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId3, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId4, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId5, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId6, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId7, scene)); sceneTable->RemoveFabric(kFabric2); // Validate endpoints are empty sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(endpoint_scene_count)); - NL_TEST_ASSERT(aSuite, 0 == endpoint_scene_count); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(endpoint_scene_count)); + EXPECT_EQ(0, endpoint_scene_count); // Validate Fabric capacities at maximum accross all endpoints // Endpoint 1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); // Endpoint 2 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); // Endpoint 3 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint3, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); // Test of Get with changes to Endpoint capacity // Endpoint 1 sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize - 2); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 1 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 1 == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 1, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 1, fabric_capacity); // Test Endpoint 2's capacity remains unaffected sceneTable = scenes::GetSceneTableImpl(kTestEndpoint2, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == fabric_capacity); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity, fabric_capacity); + ASSERT_NE(nullptr, sceneTable); // Test Insertion then change of capacity sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 4 == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 4, fabric_capacity); sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestFabricCapacity - 2); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 6 == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(defaultTestFabricCapacity - 6, fabric_capacity); sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestFabricCapacity - 4); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); // Test making the endpoint scene table smaller than the actual number of scenes on it sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestFabricCapacity - 5); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + ASSERT_NE(nullptr, sceneTable); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); } -void TestOTAChanges(nlTestSuite * aSuite, void * aContext) +TEST_F(TestSceneTable, TestOTAChanges) { SceneTable * sceneTable = scenes::GetSceneTableImpl(kTestEndpoint1, defaultTestTableSize); - NL_TEST_ASSERT(aSuite, nullptr != sceneTable); - VerifyOrReturn(nullptr != sceneTable); + ASSERT_NE(nullptr, sceneTable); // Reset test ResetSceneTable(sceneTable); @@ -1633,88 +1600,85 @@ void TestOTAChanges(nlTestSuite * aSuite, void * aContext) // Fill scene table // Fill fabric 1 to capacity - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric1, scene7)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric1, scene7)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); uint8_t scene_table_fabric1_capacity = fabric_capacity; auto * iterator = sceneTable->IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == iterator->Count()); + EXPECT_EQ(defaultTestFabricCapacity, iterator->Count()); iterator->Release(); // Fill fabric 2 to capacity - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene1)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene2)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene3)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene4)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene5)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene6)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->SetSceneTableEntry(kFabric2, scene7)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene1)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene2)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene3)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene4)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene5)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene6)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->SetSceneTableEntry(kFabric2, scene7)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); uint8_t scene_table_fabric2_capacity = fabric_capacity; iterator = sceneTable->IterateSceneEntries(kFabric2); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity == iterator->Count()); + EXPECT_EQ(defaultTestFabricCapacity, iterator->Count()); iterator->Release(); // SceneTable should be full at this point uint8_t scene_count; - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetEndpointSceneCount(scene_count)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetEndpointSceneCount(scene_count)); // Global count should not have been modified - NL_TEST_ASSERT(aSuite, fabricsFullCount == scene_count); + EXPECT_EQ(fabricsFullCount, scene_count); // Create a scene table with a greater capacity than the original one (Max allowed capacity from gen_config.h) TestSceneTableImpl ExpandedSceneTable(scenes::kMaxScenesPerFabric, scenes::kMaxScenesPerEndpoint); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.Init(&testStorage)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.Init(mpTestStorage)); ExpandedSceneTable.SetEndpoint(kTestEndpoint1); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, - scene_table_fabric1_capacity + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity) == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, - scene_table_fabric2_capacity + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity) == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(scene_table_fabric1_capacity + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity), fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(scene_table_fabric2_capacity + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity), fabric_capacity); // We should be able to insert 4 scenes into fabric 2 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene9)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene13)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene14)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene15)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene9)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene13)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene14)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric2, scene15)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); // Fabric 1's capacity should have remain unchanged - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, - scene_table_fabric1_capacity + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity) == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(scene_table_fabric1_capacity + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity), fabric_capacity); // Global count should have increased by (scenes::kMaxScenesPerFarbic - defaultTestFabricCapacity) - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, fabricsFullCount + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity) == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.GetEndpointSceneCount(scene_count)); + EXPECT_EQ(fabricsFullCount + (scenes::kMaxScenesPerFabric - defaultTestFabricCapacity), scene_count); // Same test for 4 insertion in fabric 1 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene9)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene13)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene14)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene15)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene9)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene13)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene14)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.SetSceneTableEntry(kFabric1, scene15)); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); // Global count should be at defaultTestTableSize + (scenes::kMaxScenesPerEndpoint - defaultTestTableSize) - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ExpandedSceneTable.GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, fabricsFullCount + (scenes::kMaxScenesPerEndpoint - defaultTestTableSize) == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, ExpandedSceneTable.GetEndpointSceneCount(scene_count)); + EXPECT_EQ(fabricsFullCount + (scenes::kMaxScenesPerEndpoint - defaultTestTableSize), scene_count); // Test failure to init a SceneTable with sizes above the defined max scenes per fabric or globaly TestSceneTableImpl SceneTableTooManyPerFabric(scenes::kMaxScenesPerFabric + 1, scenes::kMaxScenesPerEndpoint); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_INVALID_INTEGER_VALUE == SceneTableTooManyPerFabric.Init(&testStorage)); + EXPECT_EQ(CHIP_ERROR_INVALID_INTEGER_VALUE, SceneTableTooManyPerFabric.Init(mpTestStorage)); SceneTableTooManyPerFabric.Finish(); TestSceneTableImpl SceneTableTooManyGlobal(scenes::kMaxScenesPerFabric, scenes::kMaxScenesPerEndpoint + 1); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_INVALID_INTEGER_VALUE == SceneTableTooManyGlobal.Init(&testStorage)); + EXPECT_EQ(CHIP_ERROR_INVALID_INTEGER_VALUE, SceneTableTooManyGlobal.Init(mpTestStorage)); SceneTableTooManyGlobal.Finish(); // Create a new table with a lower limit of scenes per fabric @@ -1722,148 +1686,90 @@ void TestOTAChanges(nlTestSuite * aSuite, void * aContext) uint8_t newTableSize = defaultTestTableSize - 2; uint8_t capacityDifference = static_cast(scenes::kMaxScenesPerFabric - newCapacity); TestSceneTableImpl ReducedSceneTable(newCapacity, newTableSize); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.Init(&testStorage)); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.Init(mpTestStorage)); ReducedSceneTable.SetEndpoint(kTestEndpoint1); // Global count should not have been modified - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, scenes::kMaxScenesPerEndpoint - 2 == scene_count); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetEndpointSceneCount(scene_count)); + EXPECT_EQ(scenes::kMaxScenesPerEndpoint - 2, scene_count); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); // Load a scene from fabric 1, this should adjust fabric 1 scene count in flash - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetSceneTableEntry(kFabric1, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetSceneTableEntry(kFabric1, sceneId1, scene)); + EXPECT_EQ(scene, scene1); // The number count of scenes in Fabric 1 should have been adjusted here iterator = ReducedSceneTable.IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, newCapacity == iterator->Count()); + EXPECT_EQ(newCapacity, iterator->Count()); iterator->Release(); // Capacity should still be 0 in fabric 1 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetEndpointSceneCount(scene_count)); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetEndpointSceneCount(scene_count)); // Global count should have been reduced by the difference between the max fabric capacity of a fabric and the // new fabric capacity since we haven't loaded from fabric 2 yet - NL_TEST_ASSERT(aSuite, scenes::kMaxScenesPerEndpoint - 2 - capacityDifference == scene_count); + EXPECT_EQ(scenes::kMaxScenesPerEndpoint - 2 - capacityDifference, scene_count); // Remove a Scene from the Fabric 1 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene1.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene1.mStorageId)); // Check count updated for fabric iterator = ReducedSceneTable.IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, static_cast(newCapacity - 1) == iterator->Count()); + EXPECT_EQ(static_cast(newCapacity - 1), iterator->Count()); iterator->Release(); // Check fabric still doesn't have capacity because fabric 2 still have a higher number of scene than allowed - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); // Remove another scene from fabric 1 - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene2.mStorageId)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene3.mStorageId)); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene4.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene2.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene3.mStorageId)); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.RemoveSceneTableEntry(kFabric1, scene4.mStorageId)); // Check count updated for fabric iterator = ReducedSceneTable.IterateSceneEntries(kFabric1); - NL_TEST_ASSERT(aSuite, 2 == iterator->Count()); + EXPECT_EQ(2u, iterator->Count()); iterator->Release(); // Confirm global count has been updated - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetEndpointSceneCount(scene_count)); - NL_TEST_ASSERT(aSuite, 13 == scene_count); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetEndpointSceneCount(scene_count)); + EXPECT_EQ(13, scene_count); // Confirm we now have capacity in fabric one - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 1 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(1, fabric_capacity); // Load a scene from fabric 2, this should adjust fabric 2 scene count in flash - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetSceneTableEntry(kFabric2, sceneId1, scene)); - NL_TEST_ASSERT(aSuite, scene == scene1); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetSceneTableEntry(kFabric2, sceneId1, scene)); + EXPECT_EQ(scene, scene1); // The number count of scenes in Fabric 2 should have been adjusted here iterator = ReducedSceneTable.IterateSceneEntries(kFabric2); - NL_TEST_ASSERT(aSuite, defaultTestFabricCapacity - 1 == iterator->Count()); + EXPECT_EQ(defaultTestFabricCapacity - 1u, iterator->Count()); iterator->Release(); // Global count should also have been adjusted - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetEndpointSceneCount(scene_count)); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetEndpointSceneCount(scene_count)); // had 22 scenes, truncated 5 from both (10) and deleted 4 from fabric 1: 8 scenes left - NL_TEST_ASSERT(aSuite, 8 == scene_count); + EXPECT_EQ(8, scene_count); // Confirm we now have capacity of 6 in the first fabric since we previously removed 6 scenes form there - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 4 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(4, fabric_capacity); // Fabric 2 should still be at capacity - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == ReducedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 0 == fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, ReducedSceneTable.GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(0, fabric_capacity); ReducedSceneTable.Finish(); // The Scene 8 should now have been truncated from the memory and thus not be accessible from both fabrics in the // original scene table - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric1, sceneId8, scene)); - NL_TEST_ASSERT(aSuite, CHIP_ERROR_NOT_FOUND == sceneTable->GetSceneTableEntry(kFabric2, sceneId8, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric1, sceneId8, scene)); + EXPECT_EQ(CHIP_ERROR_NOT_FOUND, sceneTable->GetSceneTableEntry(kFabric2, sceneId8, scene)); // The Remaining capacity in the original scene table therefore have been modified as well // Fabric 2 should still be almost at capacity - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 5 == fabric_capacity); - NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric1, fabric_capacity)); + EXPECT_EQ(5, fabric_capacity); + EXPECT_EQ(CHIP_NO_ERROR, sceneTable->GetRemainingCapacity(kFabric2, fabric_capacity)); - NL_TEST_ASSERT(aSuite, 1 == fabric_capacity); + EXPECT_EQ(1, fabric_capacity); } } // namespace TestScenes - -namespace { -/** - * Setup the test suite. - */ -int TestSetup(void * inContext) -{ - VerifyOrReturnError(CHIP_NO_ERROR == chip::Platform::MemoryInit(), FAILURE); - - // Initialize Scene Table - SceneTable * sceneTable = scenes::GetSceneTableImpl(); - VerifyOrReturnError(nullptr != sceneTable, FAILURE); - VerifyOrReturnError(CHIP_NO_ERROR == sceneTable->Init(&TestScenes::testStorage), FAILURE); - - return SUCCESS; -} - -/** - * Tear down the test suite. - */ -int TestTeardown(void * inContext) -{ - // Terminate Scene Table - SceneTable * sceneTable = scenes::GetSceneTableImpl(); - VerifyOrReturnError(nullptr != sceneTable, FAILURE); - sceneTable->Finish(); - chip::Platform::MemoryShutdown(); - - return SUCCESS; -} -} // namespace - -int TestSceneTable() -{ - static nlTest sTests[] = { NL_TEST_DEF("TestHandlerRegistration", TestScenes::TestHandlerRegistration), - NL_TEST_DEF("TestHandlerFunctions", TestScenes::TestHandlerFunctions), - NL_TEST_DEF("TestStoreScenes", TestScenes::TestStoreScenes), - NL_TEST_DEF("TestOverwriteScenes", TestScenes::TestOverwriteScenes), - NL_TEST_DEF("TestIterateScenes", TestScenes::TestIterateScenes), - NL_TEST_DEF("TestRemoveScenes", TestScenes::TestRemoveScenes), - NL_TEST_DEF("TestFabricScenes", TestScenes::TestFabricScenes), - NL_TEST_DEF("TestEndpointScenes", TestScenes::TestEndpointScenes), - NL_TEST_DEF("TestOTAChanges", TestScenes::TestOTAChanges), - - NL_TEST_SENTINEL() }; - - nlTestSuite theSuite = { - "SceneTable", - &sTests[0], - TestSetup, - TestTeardown, - }; - - nlTestRunner(&theSuite, nullptr); - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestSceneTable)