From 6ab808852ce5f13fa86a6717659492c7c31a4381 Mon Sep 17 00:00:00 2001
From: mlangkabel <malte.langkabel@gmail.com>
Date: Mon, 22 Feb 2021 18:22:51 +0100
Subject: [PATCH] test: make HierarchyCache tests independent of edge order

---
 src/test/HierarchyCacheTestSuite.cpp | 104 ++++++++++++++-------------
 1 file changed, 54 insertions(+), 50 deletions(-)

diff --git a/src/test/HierarchyCacheTestSuite.cpp b/src/test/HierarchyCacheTestSuite.cpp
index f0903971..6fb02642 100644
--- a/src/test/HierarchyCacheTestSuite.cpp
+++ b/src/test/HierarchyCacheTestSuite.cpp
@@ -1,13 +1,58 @@
 #include "catch.hpp"
 
 #include "HierarchyCache.h"
+#include "utility.h"
+
+class TestEdge
+{
+public:
+	TestEdge(Id sourceId, Id targetId, const std::vector<Id>& edgeIds)
+		: m_sourceId(sourceId), m_targetId(targetId), m_edgeIds(edgeIds)
+	{
+		std::sort(m_edgeIds.begin(), m_edgeIds.end());
+	}
+
+	TestEdge(std::tuple<Id, Id, std::vector<size_t>> tuple)
+		: m_sourceId(std::get<0>(tuple))
+		, m_targetId(std::get<1>(tuple))
+		, m_edgeIds(std::get<2>(tuple))
+	{
+		std::sort(m_edgeIds.begin(), m_edgeIds.end());
+	}
+
+	std::string toString() const
+	{
+		std::string ret = "s:" + std::to_string(m_sourceId) + ";";
+		ret += "t:" + std::to_string(m_targetId) + ";";
+		for (Id edgeId: m_edgeIds)
+		{
+			ret += "e:" + std::to_string(edgeId) + ";";
+		}
+		return ret;
+	}
+
+	const Id m_sourceId;
+	const Id m_targetId;
+	std::vector<Id> m_edgeIds;
+};
+
+std::vector<std::string> getSerializedInheritanceEdges(
+	HierarchyCache& cache, Id nodeId, std::set<Id> nodeIds)
+{
+	std::vector<std::string> inheritanceEdges;
+	for (const std::tuple<Id, Id, std::vector<size_t>>& edge:
+		 cache.getInheritanceEdgesForNodeId(nodeId, nodeIds))
+	{
+		inheritanceEdges.push_back(TestEdge(edge).toString());
+	}
+	return inheritanceEdges;
+}
 
 TEST_CASE("HierarchyCache returns no inheritance edges for empty node set")
 {
 	HierarchyCache cache;
 	cache.createInheritance(1, 1, 2);
-	std::vector<std::tuple<Id, Id, std::vector<size_t>>> inheritanceEdges =
-		cache.getInheritanceEdgesForNodeId(1, {});
+	std::vector<std::string> inheritanceEdges = getSerializedInheritanceEdges(cache, 1, {});
 	REQUIRE(inheritanceEdges.size() == 0);
 }
 
@@ -15,19 +60,9 @@ TEST_CASE("HierarchyCache returns inheritance edge for non-empty node set")
 {
 	HierarchyCache cache;
 	cache.createInheritance(1, 1, 2);
-	std::vector<std::tuple<Id, Id, std::vector<size_t>>> inheritanceEdges =
-		cache.getInheritanceEdgesForNodeId(1, {2});
+	std::vector<std::string> inheritanceEdges = getSerializedInheritanceEdges(cache, 1, {2});
 	REQUIRE(inheritanceEdges.size() == 1);
-	{
-		const std::tuple<Id, Id, std::vector<Id>>& edge = inheritanceEdges[0];
-		const Id sourceId = std::get<0>(edge);
-		const Id targetId = std::get<1>(edge);
-		const std::vector<Id> edgeIds = std::get<2>(edge);
-		REQUIRE(sourceId == 1);
-		REQUIRE(targetId == 2);
-		REQUIRE(edgeIds.size() == 1);
-		REQUIRE(edgeIds[0] == 1);
-	}
+	REQUIRE(utility::containsElement(inheritanceEdges, TestEdge(1, 2, {1}).toString()));
 }
 
 TEST_CASE("HierarchyCache skips inheritance for nodes not in set")
@@ -35,20 +70,9 @@ TEST_CASE("HierarchyCache skips inheritance for nodes not in set")
 	HierarchyCache cache;
 	cache.createInheritance(1, 1, 2);
 	cache.createInheritance(2, 2, 3);
-	std::vector<std::tuple<Id, Id, std::vector<size_t>>> inheritanceEdges =
-		cache.getInheritanceEdgesForNodeId(1, {3});
+	std::vector<std::string> inheritanceEdges = getSerializedInheritanceEdges(cache, 1, {3});
 	REQUIRE(inheritanceEdges.size() == 1);
-	{
-		const std::tuple<Id, Id, std::vector<Id>>& edge = inheritanceEdges[0];
-		const Id sourceId = std::get<0>(edge);
-		const Id targetId = std::get<1>(edge);
-		const std::vector<Id> edgeIds = std::get<2>(edge);
-		REQUIRE(sourceId == 1);
-		REQUIRE(targetId == 3);
-		REQUIRE(edgeIds.size() == 2);
-		REQUIRE(edgeIds[0] == 1);
-		REQUIRE(edgeIds[1] == 2);
-	}
+	REQUIRE(utility::containsElement(inheritanceEdges, TestEdge(1, 3, {1, 2}).toString()));
 }
 
 TEST_CASE("HierarchyCache returns inheritance edges for cyclic inheritance")
@@ -56,28 +80,8 @@ TEST_CASE("HierarchyCache returns inheritance edges for cyclic inheritance")
 	HierarchyCache cache;
 	cache.createInheritance(1, 1, 2);
 	cache.createInheritance(2, 2, 1);
-	std::vector<std::tuple<Id, Id, std::vector<size_t>>> inheritanceEdges =
-		cache.getInheritanceEdgesForNodeId(1, {1, 2});
+	std::vector<std::string> inheritanceEdges = getSerializedInheritanceEdges(cache, 1, {1, 2});
 	REQUIRE(inheritanceEdges.size() == 2);
-	{
-		const std::tuple<Id, Id, std::vector<Id>>& edge = inheritanceEdges[0];
-		const Id sourceId = std::get<0>(edge);
-		const Id targetId = std::get<1>(edge);
-		const std::vector<Id> edgeIds = std::get<2>(edge);
-		REQUIRE(sourceId == 1);
-		REQUIRE(targetId == 2);
-		REQUIRE(edgeIds.size() == 1);
-		REQUIRE(edgeIds[0] == 1);
-	}
-	{
-		const std::tuple<Id, Id, std::vector<Id>>& edge = inheritanceEdges[1];
-		const Id sourceId = std::get<0>(edge);
-		const Id targetId = std::get<1>(edge);
-		const std::vector<Id> edgeIds = std::get<2>(edge);
-		REQUIRE(sourceId == 1);
-		REQUIRE(targetId == 1);
-		REQUIRE(edgeIds.size() == 2);
-		REQUIRE(edgeIds[0] == 1);
-		REQUIRE(edgeIds[1] == 2);
-	}
+	REQUIRE(utility::containsElement(inheritanceEdges, TestEdge(1, 2, {1}).toString()));
+	REQUIRE(utility::containsElement(inheritanceEdges, TestEdge(1, 1, {1, 2}).toString()));
 }