Addition of a new helper class to deal with WDL maps.
diff --git a/src/lib/profiles/data-management/Current/WdmDictionary.h b/src/lib/profiles/data-management/Current/WdmDictionary.h
new file mode 100644
index 0000000..5685465
--- /dev/null
+++ b/src/lib/profiles/data-management/Current/WdmDictionary.h
@@ -0,0 +1,230 @@
+/*
+ *
+ * Copyright (c) 2018 Google LLC.
+ * Copyright (c) 2013-2017 Nest Labs, Inc.
+ * 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 provides a more logical container representation of a WDM dictionary
+ * that permits both indexing against the dictionary key as well as a more logical primary
+ * key
+ */
+
+#ifndef _WEAVE_DATA_MANAGEMENT_WDM_DICTIONARY_H
+#define _WEAVE_DATA_MANAGEMENT_WDM_DICTIONARY_H
+
+#include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h>
+
+#include <Weave/Core/WeaveCore.h>
+#include <Weave/Core/WeaveMessageLayer.h>
+#include <Weave/Profiles/ProfileCommon.h>
+#include <Weave/Support/CodeUtils.h>
+#include <Weave/Profiles/data-management/MessageDef.h>
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+
+using namespace boost::multi_index;
+
+namespace nl {
+namespace Weave {
+namespace Profiles {
+namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {
+
+//
+// This templated class provides a more user-friendly type when interacting with WDL maps.
+// WDL maps are constrained in their keys to having 16-bit numerical keys. As such, these maps
+// cannot be thought of as traditional maps that have the key being the logical/primary key used to
+// index the data in the collection. Rather, the key is merely a unique number assigned to each item,
+// lacking any semantic or logical meaning. The actual logical key is embedded in the item itself, and
+// be any WDL type. In this sense, WDL maps can be thought of as spare arrays.
+//
+// Applications will typically want to interact with the collection locally on devices more naturally as a keyed collection,
+// with the data index using the logical key. This requires them to maintain a two-map solution:
+// one to store the original data in the trait, and another to translate from the logical key to the map key.
+//
+// This templated class utilizes boost's multi_index_container, which permits indexing the data against multiple keys
+// while still retaining efficient storage and look-up of the data. The class wraps the provided boost type and
+// provides helper methods to interact with each key's sub-table.
+//
+// Specializing the template requires passing in both the logical key type as well as the value type as well.
+//
+// Requirements on the types include:
+// Logical Key Type: Has both '<' and '==' operators implemented.
+// Value Type: Has the '==' operator implemented.
+//
+// The class also provides methods to compare against another instance of the collection to easily figure out the
+// set of items added, removed or modified against the logical key. This allows for comparisons
+//
+template <class KeyT, class ValueT>
+class WdmDictionary {
+public:
+ //
+ // This is the Item that is used in the collection, housing both the 16-bit dictionary
+ // key as well as the logical KeyT typed key.
+ // It also contains the value as well.
+ //
+ struct Item {
+ Item(uint16_t dictKey) { _dict_key = dictKey; _logical_key = 0; }
+ Item() { _dict_key = 0; _logical_key = 0; }
+
+ bool operator<(const Item& i1) const {
+ return (_logical_key < i1._logical_key);
+ }
+
+ bool operator ==(const Item& i) const {
+ return (_logical_key == i._logical_key && _dict_key == i._dict_key && _data == i._data);
+ }
+
+ ValueT _data;
+ uint16_t _dict_key;
+ KeyT _logical_key;
+ };
+
+ struct map_key{};
+ struct logical_key{};
+
+ typedef multi_index_container<
+ Item,
+ indexed_by<
+ // Both indexes are of type 'ordered_unique' since it's expected there will and should
+ // not be collisions in either of the key-spaces.
+ ordered_unique<tag<map_key>, member<Item, uint16_t, &Item::_dict_key> >,
+ ordered_unique<tag<logical_key>, member<Item, KeyT, &Item::_logical_key> >
+ >
+ > Container;
+
+ typedef typename Container::template index<map_key>::type DictKeyTableType;
+ typedef typename Container::template index<map_key>::type::iterator DictKeyTableTypeIterator;
+ typedef typename Container::template index<logical_key>::type LogicalKeyTableType;
+ typedef typename Container::template index<logical_key>::type::iterator LogicalKeyTableTypeIterator;
+
+ DictKeyTableType& GetDictKeyTable() { return _container.template get<map_key>(); }
+ LogicalKeyTableType& GetLogicalKeyTable() { return _container.template get<logical_key>(); }
+
+ //
+ // This is a convenience method that automatically creates an element in the collection with a particular
+ // dictionary key, or accesses an existing element that already exists, and allows the caller to mutate a member
+ // through a provided closure.
+ //
+ void ModifyItem(uint16_t dictKey, std::function<void(Item&)> func);
+
+ //
+ // The following methods compare against a provided container and enumerates items that have been added, deleted or modified.
+ // This is specifically done against the logical key table and *not* against the dictionary keys. This is necessary since certain
+ // implementations of dictionaries (like the Nest cloud service) do not provide key stability for the dictionary keys, occasionally
+ // re-key'ing them while retaining the logical key + value content.
+ //
+ void ItemsAdded(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func, bool updateStore=false);
+ void ItemsRemoved(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func, bool updateStore=false);
+ void ItemsModified(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&, LogicalKeyTableTypeIterator&)> func, bool updateStore=false);
+ bool IsEqual(WdmDictionary &dictionary);
+
+private:
+ Container _container;
+};
+
+template <typename KeyT, typename ValueT>
+bool WdmDictionary<KeyT, ValueT>::IsEqual(WdmDictionary &dictionary)
+{
+ return (dictionary._container.size() == _container.size())
+ && std::equal(_container.begin(), _container.end(), dictionary._container.begin());
+}
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ModifyItem(uint16_t dictKey, std::function<void(Item &)> func)
+{
+ Item item = Item(dictKey);
+ DictKeyTableType& mapkey_tbl = _container.template get<map_key>();
+ mapkey_tbl.modify(mapkey_tbl.insert(item).first, [&func](Item &d) {
+ func(d);
+ });
+}
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ItemsAdded(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func, bool updateStore)
+{
+ Container addedItems;
+ LogicalKeyTableType &addedItemsLogicalTbl = addedItems.template get<logical_key>();
+
+ std::set_difference(stagedContainer.GetLogicalKeyTable().begin(), stagedContainer.GetLogicalKeyTable().end(),
+ GetLogicalKeyTable().begin(), GetLogicalKeyTable().end(),
+ std::inserter(addedItemsLogicalTbl, addedItemsLogicalTbl.begin()));
+
+ for (auto it = addedItemsLogicalTbl.begin(); it != addedItemsLogicalTbl.end(); it++) {
+ func(it);
+
+ if (updateStore) {
+ GetLogicalKeyTable().insert(*it);
+ }
+ }
+}
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ItemsRemoved(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func, bool updateStore)
+{
+ Container removedItems;
+ LogicalKeyTableType &removedItemsLogicalTbl = removedItems.template get<logical_key>();
+
+ std::set_difference(GetLogicalKeyTable().begin(), GetLogicalKeyTable().end(),
+ stagedContainer.GetLogicalKeyTable().begin(), stagedContainer.GetLogicalKeyTable().end(),
+ std::inserter(removedItemsLogicalTbl, removedItemsLogicalTbl.begin()));
+
+ for (auto it = removedItemsLogicalTbl.begin(); it != removedItemsLogicalTbl.end(); it++) {
+ func(it);
+
+ if (updateStore) {
+ GetLogicalKeyTable().erase(it->_logical_key);
+ }
+ }
+}
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ItemsModified(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&, LogicalKeyTableTypeIterator&)> func, bool updateStore)
+{
+ Container modifiedItems;
+ LogicalKeyTableType &modifiedItemsTbl = modifiedItems.template get<logical_key>();
+
+ std::set_intersection(stagedContainer.GetLogicalKeyTable().begin(), stagedContainer.GetLogicalKeyTable().end(),
+ GetLogicalKeyTable().begin(), GetLogicalKeyTable().end(),
+ std::inserter(modifiedItemsTbl, modifiedItemsTbl.begin()));
+
+ for (auto it = modifiedItemsTbl.begin(); it != modifiedItemsTbl.end(); it++) {
+ auto it1 = GetLogicalKeyTable().find(it->_logical_key);
+ auto it2 = stagedContainer.GetLogicalKeyTable().find(it->_logical_key);
+
+ if (!(it1->_data == it2->_data)) {
+ func(it1, it2);
+ }
+
+ if (updateStore) {
+ GetLogicalKeyTable().modify(it1, [it2](auto &d) {
+ d = *it2;
+ });
+ }
+ }
+}
+
+}; // namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
+}; // namespace Profiles
+}; // namespace Weave
+}; // namespace nl
+
+#endif
diff --git a/src/test-apps/Makefile.am b/src/test-apps/Makefile.am
index 801e077..f1a7719 100644
--- a/src/test-apps/Makefile.am
+++ b/src/test-apps/Makefile.am
@@ -356,11 +356,13 @@
if HAVE_CXX11
check_PROGRAMS += \
TestTDM \
+ TestTDMDictionary \
$(NULL)
endif
check_PROGRAMS += \
TestTDM \
+ TestTDMDictionary \
TestPathStore \
TestWdmUpdateEncoder \
TestWdmUpdateResponse \
@@ -469,6 +471,7 @@
if HAVE_CXX11
local_test_programs += \
TestTDM \
+ TestTDMDictionary \
TestWDM \
$(NULL)
endif
@@ -1220,6 +1223,20 @@
TestTDM_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/src/test-apps/schema
TestTDM_LDFLAGS = $(AM_CPPFLAGS)
TestTDM_LDADD = libWeaveTestCommon.a $(COMMON_LDADD)
+
+TestTDMDictionary_SOURCES = TestTDMDictionary.cpp \
+ schema/nest/test/trait/TestHTrait.cpp \
+ schema/nest/test/trait/TestCTrait.cpp \
+ schema/nest/test/trait/TestBTrait.cpp \
+ schema/nest/test/trait/TestMismatchedCTrait.cpp \
+ schema/nest/test/trait/TestCommon.cpp \
+ MockMismatchedSchemaSinkAndSource.cpp \
+ TestPersistedStorageImplementation.cpp \
+ MockTestBTrait.cpp
+
+TestTDMDictionary_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/src/test-apps/schema
+TestTDMDictionary_LDFLAGS = $(AM_CPPFLAGS)
+TestTDMDictionary_LDADD = libWeaveTestCommon.a $(COMMON_LDADD)
endif
TestWDM_SOURCES = TestWdm.cpp
diff --git a/src/test-apps/TestTDM.cpp b/src/test-apps/TestTDM.cpp
index fd00d05..0170916 100644
--- a/src/test-apps/TestTDM.cpp
+++ b/src/test-apps/TestTDM.cpp
@@ -65,6 +65,116 @@
using namespace nl::Weave::TLV;
using namespace nl::Weave::Profiles::DataManagement;
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+
+using namespace boost::multi_index;
+
+template <class KeyT, class ValueT>
+class WdmDictionary {
+public:
+ struct Item {
+ Item(uint16_t dictKey) { _dict_key = dictKey; }
+
+ bool operator<(const Item& i1) const {
+ return (_logical_key < i1._logical_key);
+ }
+
+ ValueT _data;
+ uint16_t _dict_key;
+ KeyT _logical_key;
+ };
+
+ struct map_key{};
+ struct logical_key{};
+
+ typedef multi_index_container<
+ Item,
+ indexed_by<
+ ordered_unique<tag<map_key>, member<Item, uint16_t, &Item::_dict_key> >,
+ ordered_unique<tag<logical_key>, member<Item, KeyT, &Item::_logical_key> >
+ >
+ > Container;
+
+ typedef typename Container::template index<map_key>::type DictKeyTableType;
+ typedef typename Container::template index<logical_key>::type LogicalKeyTableType;
+ typedef typename Container::template index<logical_key>::type::iterator LogicalKeyTableTypeIterator;
+
+ void ModifyItem(uint16_t dictKey, std::function<void(Item&)> func);
+ DictKeyTableType& GetDictKeyTable() { return _container.template get<map_key>(); }
+ LogicalKeyTableType& GetLogicalKeyTable() { return _container.template get<logical_key>(); }
+
+ void ItemsAdded(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func);
+ void ItemsRemoved(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func);
+ void ItemsModified(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&, LogicalKeyTableTypeIterator&)> func);
+
+private:
+ Container _container;
+};
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ModifyItem(uint16_t dictKey, std::function<void(Item &)> func)
+{
+ Item item = Item(dictKey);
+ DictKeyTableType& mapkey_tbl = _container.template get<map_key>();
+ mapkey_tbl.modify(mapkey_tbl.insert(item).first, [&func](Item &d) {
+ func(d);
+ });
+}
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ItemsAdded(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func)
+{
+ Container addedItems;
+ LogicalKeyTableType &addedItemsLogicalTbl = addedItems.template get<logical_key>();
+
+ std::set_difference(stagedContainer.GetLogicalKeyTable().begin(), stagedContainer.GetLogicalKeyTable().end(),
+ GetLogicalKeyTable().begin(), GetLogicalKeyTable().end(),
+ std::inserter(addedItemsLogicalTbl, addedItemsLogicalTbl.begin()));
+
+ for (auto it = addedItemsLogicalTbl.begin(); it != addedItemsLogicalTbl.end(); it++) {
+ func(it);
+ }
+}
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ItemsRemoved(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&)> func)
+{
+ Container removedItems;
+ LogicalKeyTableType &removedItemsLogicalTbl = removedItems.template get<logical_key>();
+
+ std::set_difference(GetLogicalKeyTable().begin(), GetLogicalKeyTable().end(),
+ stagedContainer.GetLogicalKeyTable().begin(), stagedContainer.GetLogicalKeyTable().end(),
+ std::inserter(removedItemsLogicalTbl, removedItemsLogicalTbl.begin()));
+
+ for (auto it = removedItemsLogicalTbl.begin(); it != removedItemsLogicalTbl.end(); it++) {
+ func(it);
+ }
+}
+
+template <typename KeyT, typename ValueT>
+void WdmDictionary<KeyT, ValueT>::ItemsModified(WdmDictionary& stagedContainer, std::function<void(LogicalKeyTableTypeIterator&, LogicalKeyTableTypeIterator&)> func)
+{
+ Container modifiedItems;
+ LogicalKeyTableType &modifiedItemsTbl = modifiedItems.template get<logical_key>();
+
+ std::set_intersection(stagedContainer.GetLogicalKeyTable().begin(), stagedContainer.GetLogicalKeyTable().end(),
+ GetLogicalKeyTable().begin(), GetLogicalKeyTable().end(),
+ std::inserter(modifiedItemsTbl, modifiedItemsTbl.begin()));
+
+ for (auto it = modifiedItemsTbl.begin(); it != modifiedItemsTbl.end(); it++) {
+ auto it1 = GetLogicalKeyTable().find(it->_logical_key);
+ auto it2 = stagedContainer.GetLogicalKeyTable().find(it->_logical_key);
+
+ if (!(it1->_data == it2->_data)) {
+ func(it1, it2);
+ }
+ }
+}
+
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// System/Platform definitions
diff --git a/src/test-apps/TestTDMDictionary.cpp b/src/test-apps/TestTDMDictionary.cpp
new file mode 100644
index 0000000..ccf0e85
--- /dev/null
+++ b/src/test-apps/TestTDMDictionary.cpp
@@ -0,0 +1,765 @@
+/*
+ *
+ * Copyright (c) 2018 Google LLC.
+ * Copyright (c) 2013-2017 Nest Labs, Inc.
+ * 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 the Weave TLV implementation.
+ *
+ */
+
+#include "ToolCommon.h"
+
+#include <nlbyteorder.h>
+#include <nlunit-test.h>
+
+#include <Weave/Core/WeaveCore.h>
+#include <Weave/Core/WeaveTLV.h>
+#include <Weave/Core/WeaveTLVDebug.hpp>
+#include <Weave/Core/WeaveTLVUtilities.hpp>
+#include <Weave/Core/WeaveTLVData.hpp>
+#include <Weave/Core/WeaveCircularTLVBuffer.h>
+#include <Weave/Support/RandUtils.h>
+
+#include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h>
+#include <Weave/Profiles/data-management/DataManagement.h>
+
+#include <Weave/Profiles/data-management/WdmDictionary.h>
+
+#include <nest/test/trait/TestHTrait.h>
+#include <nest/test/trait/TestCTrait.h>
+#include <nest/test/trait/TestMismatchedCTrait.h>
+
+#include "MockMismatchedSchemaSinkAndSource.h"
+
+#include "MockTestBTrait.h"
+
+#include "MockPlatformClocks.h"
+
+#include <new>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <set>
+#include <string>
+#include <iterator>
+
+#if WEAVE_SYSTEM_CONFIG_USE_LWIP
+#include <lwip/init.h>
+#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP
+
+using namespace nl;
+using namespace nl::Weave::TLV;
+using namespace nl::Weave::Profiles::DataManagement;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// System/Platform definitions
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+namespace Private {
+
+System::Error SetClock_RealTime(uint64_t newCurTime)
+{
+ return WEAVE_SYSTEM_NO_ERROR;
+}
+
+static System::Error GetClock_RealTime(uint64_t & curTime)
+{
+ curTime = 0x42; // arbitrary non-zero value.
+ return WEAVE_SYSTEM_NO_ERROR;
+}
+
+} // namespace Private
+
+
+namespace nl {
+namespace Weave {
+namespace Profiles {
+namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {
+namespace Platform {
+ // for unit tests, the dummy critical section is sufficient.
+ void CriticalSectionEnter()
+ {
+ return;
+ }
+
+ void CriticalSectionExit()
+ {
+ return;
+ }
+} // Platform
+} // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
+}
+}
+}
+
+static SubscriptionEngine *gSubscriptionEngine;
+
+SubscriptionEngine * SubscriptionEngine::GetInstance()
+{
+ return gSubscriptionEngine;
+}
+
+static void TestTdmStatic_SingleLeafHandle(nlTestSuite *inSuite, void *inContext);
+
+// Test Suite
+
+/**
+ * Test Suite that lists all the test functions.
+ */
+static const nlTest sTests[] = {
+ // Tests the static schema portions of TDM
+ NL_TEST_DEF("Test Tdm (Static schema): Single leaf handle", TestTdmStatic_SingleLeafHandle),
+ NL_TEST_SENTINEL()
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Testing NotificationEngine + TraitData
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace nl {
+namespace Weave {
+namespace Profiles {
+namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {
+
+using namespace Schema::Nest::Test::Trait;
+
+class TestTdmSource : public TraitDataSource {
+public:
+ TestTdmSource();
+ void Reset();
+
+private:
+ WEAVE_ERROR GetLeafData(PropertyPathHandle aLeafHandle, uint64_t aTagToWrite, TLVWriter &aWriter);
+ WEAVE_ERROR GetNextDictionaryItemKey(PropertyPathHandle aDictionaryHandle, uintptr_t &aContext, PropertyDictionaryKey &aKey);
+
+public:
+ //
+ // The logical key here is the field 'da', which is of type uint32.
+ //
+ WdmDictionary<uint32_t, TestHTrait::StructDictionary> _dict;
+};
+
+TestTdmSource::TestTdmSource()
+ : TraitDataSource(&TestHTrait::TraitSchema)
+{
+ // Using the Modify method to insert and modify.
+ _dict.ModifyItem(1, [](auto &item) {
+ item._logical_key = 10;
+ item._data.da = 10;
+ item._data.db = 1;
+ item._data.dc = 2;
+ });
+
+ _dict.ModifyItem(2, [](auto &item) {
+ item._logical_key = 20;
+ item._data.da = 20;
+ item._data.db = 3;
+ item._data.dc = 4;
+ });
+}
+
+void TestTdmSource::Reset()
+{
+}
+
+WEAVE_ERROR TestTdmSource::GetNextDictionaryItemKey(PropertyPathHandle aDictionaryHandle, uintptr_t &aContext, PropertyDictionaryKey &aKey)
+{
+ static WdmDictionary<uint32_t, TestHTrait::StructDictionary>::DictKeyTableTypeIterator it;
+
+ if (aContext == 0) {
+ it = _dict.GetDictKeyTable().begin();
+ }
+ else {
+ it++;
+ }
+
+ aContext = (uintptr_t)⁢
+
+ if (it == _dict.GetDictKeyTable().end()) {
+ return WEAVE_END_OF_INPUT;
+ }
+ else {
+ aKey = it->_dict_key;
+ }
+
+ return WEAVE_NO_ERROR;
+}
+
+WEAVE_ERROR TestTdmSource::GetLeafData(PropertyPathHandle aLeafHandle, uint64_t aTagToWrite, TLVWriter &aWriter)
+{
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+ PropertyPathHandle dictionaryItemHandle = kNullPropertyPathHandle;
+
+ if (GetSchemaEngine()->IsInDictionary(aLeafHandle, dictionaryItemHandle)) {
+ PropertyPathHandle dictionaryHandle = GetSchemaEngine()->GetParent(dictionaryItemHandle);
+ PropertyDictionaryKey key = GetPropertyDictionaryKey(dictionaryItemHandle);
+
+ if (dictionaryHandle == TestHTrait::kPropertyHandle_L) {
+ auto it = _dict.GetDictKeyTable().find(key);
+
+ if (it != _dict.GetDictKeyTable().end()) {
+ TestHTrait::StructDictionary item = it->_data;
+ uint32_t val;
+
+ switch (GetPropertySchemaHandle(aLeafHandle)) {
+ case TestHTrait::kPropertyHandle_L_Value_Da:
+ WeaveLogDetail(DataManagement, "[TestTdmSource::GetLeafData] >> l[%u].da = %u", key, item.da);
+ val = item.da;
+ break;
+
+ case TestHTrait::kPropertyHandle_L_Value_Db:
+ WeaveLogDetail(DataManagement, "[TestTdmSource::GetLeafData] >> l[%u].db = %u", key, item.da);
+ val = item.db;
+ break;
+
+ case TestHTrait::kPropertyHandle_L_Value_Dc:
+ WeaveLogDetail(DataManagement, "[TestTdmSource::GetLeafData] >> l[%u].dc = %u", key, item.da);
+ val = item.dc;
+ break;
+
+ default:
+ WeaveLogError(DataManagement, "Unknown handle passed in!");
+ return WEAVE_ERROR_INVALID_ARGUMENT;
+ break;
+ }
+
+ err = aWriter.Put(aTagToWrite, val);
+ SuccessOrExit(err);
+ }
+ else {
+ WeaveLogError(DataManagement, "Requested key %u for dictionary handle %u that doesn't exist!", key, dictionaryHandle);
+ return WEAVE_ERROR_INVALID_ARGUMENT;
+ }
+ }
+ }
+
+exit:
+ return err;
+}
+
+
+class TestTdmSink : public TraitDataSink {
+public:
+ TestTdmSink();
+ void Reset();
+ void DumpChangeSets();
+
+private:
+ WEAVE_ERROR OnEvent(uint16_t aType, void *aInParam);
+ WEAVE_ERROR SetLeafData(PropertyPathHandle aLeafHandle, nl::Weave::TLV::TLVReader &aReader);
+
+public:
+ //
+ // Main canonical store of truth
+ //
+ WdmDictionary<uint32_t, TestHTrait::StructDictionary> _dict;
+
+ //
+ // Staged changes that are accrued and applied at the end
+ // of a logical change
+ //
+ WdmDictionary<uint32_t, TestHTrait::StructDictionary> _stagedDict;
+
+ //
+ // Staged set of deleted path handles
+ //
+ std::set<PropertyPathHandle> _deletedDictItems;
+
+ //
+ // Staged item that gets appended to the staged dictionary on completion
+ // of the modification.
+ WdmDictionary<uint32_t, TestHTrait::StructDictionary>::Item _stagedDictItem;
+
+ bool _isReplaceOperation;
+};
+
+TestTdmSink::TestTdmSink()
+ : TraitDataSink(&TestHTrait::TraitSchema)
+{
+}
+
+void TestTdmSink::Reset()
+{
+ ClearVersion();
+ _stagedDict.GetDictKeyTable().clear();
+ _deletedDictItems.clear();
+}
+
+WEAVE_ERROR TestTdmSink::OnEvent(uint16_t aType, void *aInParam)
+{
+ InEventParam *inParam = static_cast<InEventParam *>(aInParam);
+
+ switch (aType) {
+ case kEventChangeBegin:
+ _stagedDict.GetDictKeyTable().clear();
+ _deletedDictItems.clear();
+ _isReplaceOperation = false;
+ break;
+
+ case kEventDictionaryItemDelete:
+ WeaveLogError(DataManagement, "[TestTdmSink::OnEvent] Deleting %u:%u",
+ GetPropertyDictionaryKey(inParam->mDictionaryItemDelete.mTargetHandle), GetPropertySchemaHandle(inParam->mDictionaryItemDelete.mTargetHandle));
+
+
+ if (GetPropertySchemaHandle(inParam->mDictionaryItemDelete.mTargetHandle) == TestHTrait::kPropertyHandle_L) {
+ _deletedDictItems.insert(GetPropertyDictionaryKey(inParam->mDictionaryItemDelete.mTargetHandle));
+ }
+
+ break;
+
+ case kEventDictionaryItemModifyBegin:
+ {
+ auto it = _dict.GetDictKeyTable().find(GetPropertyDictionaryKey(inParam->mDictionaryItemModifyBegin.mTargetHandle));
+
+ WeaveLogError(DataManagement, "[TestTdmSink::OnEvent] Adding/Modifying %u:%u", GetPropertyDictionaryKey(inParam->mDictionaryItemModifyBegin.mTargetHandle), GetPropertySchemaHandle(inParam->mDictionaryItemModifyBegin.mTargetHandle));
+
+ _stagedDictItem._dict_key = GetPropertyDictionaryKey(inParam->mDictionaryItemModifyBegin.mTargetHandle);
+ if (it != _dict.GetDictKeyTable().end()) {
+ _stagedDictItem = *it;
+ }
+
+ break;
+ }
+
+ case kEventDictionaryItemModifyEnd:
+ _stagedDict.GetDictKeyTable().insert(_stagedDictItem);
+ break;
+
+ case kEventDictionaryReplaceBegin:
+ WeaveLogError(DataManagement, "[TestTdmSink::OnEvent] Replacing %u:%u", GetPropertyDictionaryKey(inParam->mDictionaryReplaceBegin.mTargetHandle), GetPropertySchemaHandle(inParam->mDictionaryReplaceBegin.mTargetHandle));
+
+ _isReplaceOperation = true;
+ _stagedDict.GetDictKeyTable().clear();
+ break;
+
+
+ case kEventChangeEnd:
+ WeaveLogError(DataManagement, "[TestTdmSink::OnEvent] Change End");
+
+ //
+ // Delete items
+ //
+ for (auto it = _deletedDictItems.begin(); it != _deletedDictItems.end(); it++) {
+ _dict.GetDictKeyTable().erase(*it);
+ }
+
+ _dict.ItemsAdded(_stagedDict, [](auto &i) {
+ printf("A %u: %u\n", i->_logical_key, i->_data.db);
+ }, true);
+
+ //
+ // Only do the negative intersection if we're doing a full replace on the dictionary. Otherwise, we'll
+ // unintentionally remove elements.
+ //
+ if (_isReplaceOperation) {
+ _dict.ItemsRemoved(_stagedDict, [](auto &i) {
+ printf("R %u: %u\n", i->_logical_key, i->_data.db);
+ }, true);
+ }
+
+ _dict.ItemsModified(_stagedDict, [](auto &oldd, auto &newd) {
+ printf("M %u: %u %u\n", oldd->_logical_key, oldd->_data.db, newd->_data.db);
+ }, true);
+
+ break;
+ }
+
+ return WEAVE_NO_ERROR;
+}
+
+WEAVE_ERROR TestTdmSink::SetLeafData(PropertyPathHandle aHandle, TLVReader &aReader)
+{
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+ PropertySchemaHandle schemaHandle = GetPropertySchemaHandle(aHandle);
+
+ WeaveLogError(DataManagement, "[TestTdmSink::SetLeafData] << %u:%u", GetPropertyDictionaryKey(aHandle), GetPropertySchemaHandle(aHandle));
+
+ switch (schemaHandle) {
+ case TestHTrait::kPropertyHandle_L_Value_Da:
+ {
+ err = aReader.Get(_stagedDictItem._data.da);
+ SuccessOrExit(err);
+
+ _stagedDictItem._logical_key = _stagedDictItem._data.da;
+ break;
+ }
+
+ case TestHTrait::kPropertyHandle_L_Value_Db:
+ {
+ err = aReader.Get(_stagedDictItem._data.db);
+ SuccessOrExit(err);
+ break;
+ }
+
+ case TestHTrait::kPropertyHandle_L_Value_Dc:
+ {
+ err = aReader.Get(_stagedDictItem._data.dc);
+ SuccessOrExit(err);
+ break;
+ }
+ }
+
+exit:
+ return err;
+}
+
+class TestTdm {
+public:
+ TestTdm();
+
+ int Setup();
+ int Teardown();
+ int Reset();
+ int BuildAndProcessNotify();
+
+ void TestTdmStatic_SingleLeafHandle(nlTestSuite *inSuite);
+
+private:
+ SubscriptionHandler *mSubHandler;
+ SubscriptionClient *mSubClient;
+ NotificationEngine *mNotificationEngine;
+
+ SubscriptionEngine mSubscriptionEngine;
+ WeaveExchangeManager mExchangeMgr;
+ SingleResourceSourceTraitCatalog::CatalogItem mSourceCatalogStore[5];
+ SingleResourceSourceTraitCatalog mSourceCatalog;
+ SingleResourceSinkTraitCatalog::CatalogItem mSinkCatalogStore[5];
+ SingleResourceSinkTraitCatalog mSinkCatalog;
+ TestTdmSource mTestTdmSource;
+ TestTdmSink mTestTdmSink;
+ Binding *mClientBinding;
+ uint32_t mTestCase;
+ WEAVE_ERROR AllocateBuffer(uint32_t desiredSize, uint32_t minSize);
+};
+
+TestTdm::TestTdm()
+ : mSourceCatalog(ResourceIdentifier(ResourceIdentifier::SELF_NODE_ID), mSourceCatalogStore, 5),
+ mSinkCatalog(ResourceIdentifier(ResourceIdentifier::SELF_NODE_ID), mSinkCatalogStore, 5),
+ mClientBinding(NULL)
+{
+ mTestCase = 0;
+}
+
+int TestTdm::Setup()
+{
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+ TraitDataHandle testTdmSourceHandle;
+ TraitDataHandle testTdmSinkHandle;
+ SubscriptionHandler::TraitInstanceInfo *traitInstance = NULL;
+
+ gSubscriptionEngine = &mSubscriptionEngine;
+
+ // Initialize SubEngine and set it up
+ err = mSubscriptionEngine.Init(&ExchangeMgr, NULL, NULL);
+ SuccessOrExit(err);
+
+ err = mSubscriptionEngine.EnablePublisher(NULL, &mSourceCatalog);
+ SuccessOrExit(err);
+
+ // Get a sub handler and prime it to the right state
+ err = mSubscriptionEngine.NewSubscriptionHandler(&mSubHandler);
+ SuccessOrExit(err);
+
+ mSubHandler->mBinding = ExchangeMgr.NewBinding();
+ mSubHandler->mBinding->BeginConfiguration().Transport_UDP();
+
+ mClientBinding = ExchangeMgr.NewBinding();
+
+ err = mSubscriptionEngine.NewClient(&mSubClient, mClientBinding, NULL, NULL, &mSinkCatalog, 0);
+ SuccessOrExit(err);
+
+ mNotificationEngine = &mSubscriptionEngine.mNotificationEngine;
+
+ mSourceCatalog.Add(0, &mTestTdmSource, testTdmSourceHandle);
+ mSinkCatalog.Add(0, &mTestTdmSink, testTdmSinkHandle);
+
+ traitInstance = mSubscriptionEngine.mTraitInfoPool;
+ mSubHandler->mTraitInstanceList = traitInstance;
+ mSubHandler->mNumTraitInstances++;
+ ++(SubscriptionEngine::GetInstance()->mNumTraitInfosInPool);
+
+ traitInstance->Init();
+ traitInstance->mTraitDataHandle = testTdmSourceHandle;
+ traitInstance->mRequestedVersion = 1;
+
+exit:
+ if (err != WEAVE_NO_ERROR) {
+ WeaveLogError(DataManagement, "Error setting up test: %d", err);
+ }
+
+ return err;
+}
+
+void TestTdm::TestTdmStatic_SingleLeafHandle(nlTestSuite *inSuite)
+{
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+ bool testPass = false;
+
+ Reset();
+
+ //
+ // Replace
+ //
+ mTestTdmSource.Lock();
+ mTestTdmSource.SetDirty(TestHTrait::kPropertyHandle_L);
+ mTestTdmSource.Unlock();
+
+ err = BuildAndProcessNotify();
+ SuccessOrExit(err);
+
+ printf("Equal: %d\n", mTestTdmSource._dict.IsEqual(mTestTdmSink._dict));
+
+ //
+ // Delete Item
+ //
+ mTestTdmSource.Lock();
+ mTestTdmSource._dict.GetDictKeyTable().erase(0);
+ mTestTdmSource.DeleteKey(CreatePropertyPathHandle(TestHTrait::kPropertyHandle_L_Value, 0));
+ mTestTdmSource.Unlock();
+
+ err = BuildAndProcessNotify();
+ SuccessOrExit(err);
+
+ printf("Equal: %d\n", mTestTdmSource._dict.IsEqual(mTestTdmSink._dict));
+
+ //
+ // Add Item
+ //
+ mTestTdmSource.Lock();
+ mTestTdmSource._dict.ModifyItem(10, [](auto &i) {
+ i._logical_key = 300;
+ i._data.da = 300;
+ i._data.db = 30;
+ i._data.dc = 30;
+ });
+
+ mTestTdmSource.Lock();
+ mTestTdmSource.SetDirty(CreatePropertyPathHandle(TestHTrait::kPropertyHandle_L_Value, 10));
+ mTestTdmSource.Unlock();
+
+ err = BuildAndProcessNotify();
+ SuccessOrExit(err);
+
+ printf("Equal: %d\n", mTestTdmSource._dict.IsEqual(mTestTdmSink._dict));
+
+ //
+ // Change dictionary keys, but keep logical keys + data stable.
+ //
+ mTestTdmSource.Lock();
+ mTestTdmSource._dict.ModifyItem(10, [](auto &i) {
+ i._dict_key = 100;
+ });
+
+ mTestTdmSource._dict.ModifyItem(1, [](auto &i) {
+ i._dict_key = 1000;
+ });
+
+ mTestTdmSource.SetDirty(TestHTrait::kPropertyHandle_L);
+ mTestTdmSource.Unlock();
+
+ err = BuildAndProcessNotify();
+ SuccessOrExit(err);
+
+ printf("Equal: %d\n", mTestTdmSource._dict.IsEqual(mTestTdmSink._dict));
+
+
+exit:
+ NL_TEST_ASSERT(inSuite, testPass);
+}
+
+int TestTdm::Teardown()
+{
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+
+ if (mClientBinding != NULL)
+ {
+ mClientBinding->Release();
+ mClientBinding = NULL;
+ }
+
+ return err;
+}
+
+int TestTdm::Reset()
+{
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+
+ mSubHandler->MoveToState(SubscriptionHandler::kState_SubscriptionEstablished_Idle);
+
+ mTestTdmSink.Reset();
+ mTestTdmSource.Reset();
+
+ mNotificationEngine->mGraphSolver.ClearDirty();
+
+ return err;
+}
+
+int TestTdm::BuildAndProcessNotify()
+{
+ bool isSubscriptionClean;
+ NotificationEngine::NotifyRequestBuilder notifyRequest;
+ NotificationRequest::Parser notify;
+ PacketBuffer *buf = NULL;
+ TLVWriter writer;
+ TLVReader reader;
+ TLVType dummyType1, dummyType2;
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+ bool neWriteInProgress = false;
+ uint32_t maxNotificationSize = 0;
+ uint32_t maxPayloadSize = 0;
+
+ maxNotificationSize = mSubHandler->GetMaxNotificationSize();
+
+ err = mSubHandler->mBinding->AllocateRightSizedBuffer(buf, maxNotificationSize, WDM_MIN_NOTIFICATION_SIZE, maxPayloadSize);
+ SuccessOrExit(err);
+
+ err = notifyRequest.Init(buf, &writer, mSubHandler, maxPayloadSize);
+ SuccessOrExit(err);
+
+ err = mNotificationEngine->BuildSingleNotifyRequestDataList(mSubHandler, notifyRequest, isSubscriptionClean, neWriteInProgress);
+ SuccessOrExit(err);
+
+ if (neWriteInProgress)
+ {
+ err = notifyRequest.MoveToState(NotificationEngine::kNotifyRequestBuilder_Idle);
+ SuccessOrExit(err);
+
+ reader.Init(buf);
+
+ err = reader.Next();
+ SuccessOrExit(err);
+
+ notify.Init(reader);
+
+ err = notify.CheckSchemaValidity();
+ SuccessOrExit(err);
+
+ // Enter the struct
+ err = reader.EnterContainer(dummyType1);
+ SuccessOrExit(err);
+
+ // SubscriptionId
+ err = reader.Next();
+ SuccessOrExit(err);
+
+ err = reader.Next();
+ SuccessOrExit(err);
+
+ VerifyOrExit(nl::Weave::TLV::kTLVType_Array == reader.GetType(), err = WEAVE_ERROR_WRONG_TLV_TYPE);
+
+ err = reader.EnterContainer(dummyType2);
+ SuccessOrExit(err);
+
+ err = mSubClient->ProcessDataList(reader);
+ SuccessOrExit(err);
+ }
+ else
+ {
+ WeaveLogDetail(DataManagement, "nothing has been written");
+ }
+
+exit:
+ if (buf) {
+ PacketBuffer::Free(buf);
+ }
+
+ return err;
+}
+
+WEAVE_ERROR TestTdm::AllocateBuffer(uint32_t desiredSize, uint32_t minSize)
+{
+ WEAVE_ERROR err = WEAVE_NO_ERROR;
+ uint32_t maxPayloadSize = 0;
+ PacketBuffer *buf = NULL;
+
+
+ err = mSubHandler->mBinding->AllocateRightSizedBuffer(buf, desiredSize, minSize, maxPayloadSize);
+ SuccessOrExit(err);
+
+exit:
+
+ if (buf)
+ {
+ PacketBuffer::Free(buf);
+ }
+
+ return err;
+}
+
+} // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
+}
+}
+}
+
+TestTdm *gTestTdm;
+
+/**
+ * Set up the test suite.
+ */
+static int TestSetup(void *inContext)
+{
+ static TestTdm testTdm;
+ gTestTdm = &testTdm;
+
+ return testTdm.Setup();
+}
+
+/**
+ * Tear down the test suite.
+ */
+static int TestTeardown(void *inContext)
+{
+ return gTestTdm->Teardown();
+}
+
+static void TestTdmStatic_SingleLeafHandle(nlTestSuite *inSuite, void *inContext)
+{
+ gTestTdm->TestTdmStatic_SingleLeafHandle(inSuite);
+}
+
+/**
+ * Main
+ */
+int main(int argc, char *argv[])
+{
+#if WEAVE_SYSTEM_CONFIG_USE_LWIP
+ tcpip_init(NULL, NULL);
+#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP
+
+ MockPlatform::gMockPlatformClocks.GetClock_RealTime = Private::GetClock_RealTime;
+ MockPlatform::gMockPlatformClocks.SetClock_RealTime = Private::SetClock_RealTime;
+
+ nlTestSuite theSuite = {
+ "weave-tdm",
+ &sTests[0],
+ TestSetup,
+ TestTeardown
+ };
+
+ // Generate machine-readable, comma-separated value (CSV) output.
+ nl_test_set_output_style(OUTPUT_CSV);
+
+ // Run test suit against one context
+ nlTestRunner(&theSuite, NULL);
+
+ return nlTestRunnerStats(&theSuite);
+}
diff --git a/src/test-apps/schema/nest/test/trait/TestHTrait.h b/src/test-apps/schema/nest/test/trait/TestHTrait.h
index c3badd4..d7a1d75 100644
--- a/src/test-apps/schema/nest/test/trait/TestHTrait.h
+++ b/src/test-apps/schema/nest/test/trait/TestHTrait.h
@@ -186,6 +186,10 @@
uint32_t db;
uint32_t dc;
+ bool operator ==(const StructDictionary& a) const {
+ return (memcmp(&a, this, sizeof(StructDictionary)) == 0);
+ }
+
static const nl::SchemaFieldDescriptor FieldSchema;
};
