Improved ManagedContainer classes

3 files changed, 265 insertions, 1 deletions

diff --git a/test/core/managed/ManagedContainerTest.cpp b/test/core/managed/ManagedContainerTest.cpp
index db72295..a2f7aa6 100644
--- a/test/core/managed/ManagedContainerTest.cpp
+++ b/test/core/managed/ManagedContainerTest.cpp
@@ -47,7 +47,7 @@ TEST(ManagedVector, managedVector)
 			ASSERT_TRUE(v);
 		}
 
-		ManagedVector<TestManaged> v(root, elems);
+		ManagedVector<TestManaged> v(root, elems.begin(), elems.end());
 
 		// Remove the last element from the list. It should be garbage collected.
 		v.pop_back();
@@ -69,6 +69,200 @@ TEST(ManagedVector, managedVector)
 		v.erase(v.find(elems[3]), v.find(elems[5]));
 		ASSERT_FALSE(a[3] || a[4]);
 		ASSERT_TRUE(a[5]);
+
+		{
+			// Copy the managed vector to another managed vector
+			ManagedVector<TestManaged> v2(v);
+			v2.push_back(new TestManaged{mgr, a[3]});
+			ASSERT_TRUE(a[3]);
+		}
+		ASSERT_FALSE(a[3]);
+		ASSERT_TRUE(a[5]);
+	}
+
+	for (bool v : a) {
+		ASSERT_FALSE(v);
+	}
+}
+
+
+TEST(ManagedVector, moveAssignment)
+{
+	constexpr int nElem = 16;
+	std::array<bool, nElem> a;
+
+	Manager mgr(1);
+	{
+		Rooted<Managed> root{new Managed{mgr}};
+		ManagedVector<TestManaged> v1(root);
+		{
+			ManagedVector<TestManaged> v2(root);
+
+			for (int i = 0; i < nElem; i++) {
+				v2.push_back(new TestManaged{mgr, a[i]});
+			}
+			for (bool v : a) {
+				ASSERT_TRUE(v);
+			}
+
+			v1 = std::move(v2);
+			ASSERT_EQ(nullptr, v2.getOwner());
+		}
+		for (bool v : a) {
+			ASSERT_TRUE(v);
+		}
+	}
+
+	for (bool v : a) {
+		ASSERT_FALSE(v);
+	}
+}
+
+TEST(ManagedVector, copyAssignment)
+{
+	constexpr int nElem = 16;
+	std::array<bool, nElem> a;
+
+	Manager mgr(1);
+	{
+		Rooted<Managed> root{new Managed{mgr}};
+		ManagedVector<TestManaged> v1(root);
+		{
+			ManagedVector<TestManaged> v2(root);
+
+			for (int i = 0; i < nElem; i++) {
+				v2.push_back(new TestManaged{mgr, a[i]});
+			}
+			for (bool v : a) {
+				ASSERT_TRUE(v);
+			}
+
+			v1 = v2;
+			ASSERT_TRUE(v1 == v2);
+		}
+		for (bool v : a) {
+			ASSERT_TRUE(v);
+		}
+	}
+
+	for (bool v : a) {
+		ASSERT_FALSE(v);
+	}
+}
+
+TEST(ManagedVector, copyWithNewOwner)
+{
+	constexpr int nElem = 16;
+	std::array<bool, nElem> a;
+
+	Manager mgr(1);
+	{
+		Rooted<Managed> root{new Managed{mgr}};
+		ManagedVector<TestManaged> v1(root);
+		{
+			Rooted<Managed> root2{new Managed{mgr}};
+			ManagedVector<TestManaged> v2(root2);
+
+			for (int i = 0; i < nElem; i++) {
+				v2.push_back(new TestManaged{mgr, a[i]});
+			}
+			for (bool v : a) {
+				ASSERT_TRUE(v);
+			}
+
+			ManagedVector<TestManaged> v3{root, v2};
+			v1 = std::move(v3);
+			ASSERT_EQ(nullptr, v3.getOwner());
+			ASSERT_TRUE(v1 != v2);
+		}
+		for (bool v : a) {
+			ASSERT_TRUE(v);
+		}
+	}
+
+	for (bool v : a) {
+		ASSERT_FALSE(v);
+	}
+}
+
+TEST(ManagedVector, moveWithNewOwner)
+{
+	constexpr int nElem = 16;
+	std::array<bool, nElem> a;
+
+	Manager mgr(1);
+	{
+		Rooted<Managed> root{new Managed{mgr}};
+		ManagedVector<TestManaged> v1(root);
+		{
+			Rooted<Managed> root2{new Managed{mgr}};
+			ManagedVector<TestManaged> v2(root2);
+
+			for (int i = 0; i < nElem; i++) {
+				v2.push_back(new TestManaged{mgr, a[i]});
+			}
+			for (bool v : a) {
+				ASSERT_TRUE(v);
+			}
+
+			ManagedVector<TestManaged> v3{root, std::move(v2)};
+			v1 = std::move(v3);
+			ASSERT_EQ(nullptr, v2.getOwner());
+			ASSERT_EQ(nullptr, v3.getOwner());
+		}
+		for (bool v : a) {
+			ASSERT_TRUE(v);
+		}
+	}
+
+	for (bool v : a) {
+		ASSERT_FALSE(v);
+	}
+}
+
+TEST(ManagedMap, managedMap)
+{
+	// TODO: This test is highly incomplete
+
+	constexpr int nElem = 16;
+	std::array<bool, nElem> a;
+
+	Manager mgr(1);
+	{
+		Rooted<Managed> root{new Managed{mgr}};
+
+		std::map<int, TestManaged*> elems;
+		for (int i = 0; i < nElem; i++) {
+			elems.insert(std::make_pair(i, new TestManaged{mgr, a[i]}));
+		}
+
+		for (bool v : a) {
+			ASSERT_TRUE(v);
+		}
+
+		ManagedMap<int, TestManaged> m(root, elems.begin(), elems.end());
+
+		// Remove the entry with the number 4
+		m.erase(m.find(10));
+		ASSERT_FALSE(a[10]);
+
+		// Insert a new element
+		m.insert(std::make_pair(nElem + 1, new TestManaged{mgr, a[10]}));
+		ASSERT_TRUE(a[10]);
+
+		// Erase element 3 - 5
+		m.erase(m.find(3), m.find(5));
+		ASSERT_FALSE(a[3] || a[4]);
+		ASSERT_TRUE(a[5]);
+
+		{
+			// Copy the managed map to another managed map vector
+			ManagedMap<int, TestManaged> m2(m);
+			m2.insert(std::make_pair(3, new TestManaged{mgr, a[3]}));
+			ASSERT_TRUE(a[3]);
+		}
+		ASSERT_FALSE(a[3]);
+		ASSERT_TRUE(a[5]);
 	}
 
 	for (bool v : a) {
@@ -76,5 +270,6 @@ TEST(ManagedVector, managedVector)
 	}
 }
 
+
 }
 
diff --git a/test/core/managed/ManagedTest.cpp b/test/core/managed/ManagedTest.cpp
index e8a24f2..707aeb9 100644
--- a/test/core/managed/ManagedTest.cpp
+++ b/test/core/managed/ManagedTest.cpp
@@ -16,7 +16,35 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <gtest/gtest.h>
+
+#include <core/managed/Managed.hpp>
+
+#include "TestManaged.hpp"
+
 namespace ousia {
 
+TEST(Managed, data)
+{
+	Manager mgr{1};
+
+	Rooted<Managed> n{new Managed{mgr}};
+
+	Managed *m1 = new Managed{mgr};
+	n->storeData("info", m1);
+	ASSERT_TRUE(n->hasDataKey("info"));
+	ASSERT_FALSE(n->hasDataKey("test"));
+
+	Managed *m2 = new Managed{mgr};
+	n->storeData("test", m2);
+	ASSERT_TRUE(n->hasDataKey("info"));
+	ASSERT_TRUE(n->hasDataKey("test"));
+
+	ASSERT_TRUE(n->deleteData("info"));
+	ASSERT_FALSE(n->deleteData("info"));
+	ASSERT_FALSE(n->hasDataKey("info"));
+	ASSERT_TRUE(n->hasDataKey("test"));
+}
+
 }
 
diff --git a/test/core/managed/ManagerTest.cpp b/test/core/managed/ManagerTest.cpp
index da42f0a..f597af7 100644
--- a/test/core/managed/ManagerTest.cpp
+++ b/test/core/managed/ManagerTest.cpp
@@ -548,5 +548,46 @@ TEST(Manager, hiddenRootedGraph)
 		ASSERT_FALSE(v);
 	}
 }
+
+TEST(Manager, storeData)
+{
+	Manager mgr(1);
+
+	std::array<bool, 5> a;
+
+	{
+		Rooted<TestManaged> n{new TestManaged{mgr, a[0]}};
+
+		mgr.storeData(n.get(), "key1", new TestManaged{mgr, a[1]});
+
+		Managed *m2 = new TestManaged{mgr, a[2]};
+		mgr.storeData(n.get(), "key2", m2);
+
+		ASSERT_TRUE(a[0] && a[1] && a[2]);
+
+		ASSERT_TRUE(mgr.deleteData(n.get(), "key1"));
+		ASSERT_FALSE(a[1]);
+		ASSERT_FALSE(mgr.deleteData(n.get(), "key1"));
+
+		mgr.storeData(n.get(), "key1", new TestManaged{mgr, a[3]});
+		ASSERT_TRUE(a[3]);
+
+		Managed *m = new TestManaged{mgr, a[4]};
+		mgr.storeData(n.get(), "key1", m);
+		ASSERT_FALSE(a[3]);
+		ASSERT_TRUE(a[4]);
+
+		ASSERT_EQ(m, mgr.readData(n.get(), "key1"));
+		ASSERT_EQ(m2, mgr.readData(n.get(), "key2"));
+
+		auto map = mgr.readData(n.get());
+		ASSERT_EQ(2U, map.size());
+		ASSERT_TRUE(map.find("key1") != map.end());
+		ASSERT_TRUE(map.find("key2") != map.end());
+	}
+
+	ASSERT_FALSE(a[0] || a[1] || a[2] || a[3] || a[4]);
+}
+
 }