From 2d86046067a1db8d6eac019088f511fc192b660c Mon Sep 17 00:00:00 2001
From: Michael Williamson <mike@zwobble.org>
Date: Wed, 20 Dec 2023 18:44:59 +0000
Subject: Extract and test namespace linearisation

---
 .../NamespaceDependencyLineariserTests.java        | 73 ++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 src/test/java/org/shedlang/compiler/typechecker/NamespaceDependencyLineariserTests.java

(limited to 'src/test/java')

diff --git a/src/test/java/org/shedlang/compiler/typechecker/NamespaceDependencyLineariserTests.java b/src/test/java/org/shedlang/compiler/typechecker/NamespaceDependencyLineariserTests.java
new file mode 100644
index 00000000..efbeeeaf
--- /dev/null
+++ b/src/test/java/org/shedlang/compiler/typechecker/NamespaceDependencyLineariserTests.java
@@ -0,0 +1,73 @@
+package org.shedlang.compiler.typechecker;
+
+import org.junit.jupiter.api.Test;
+import org.shedlang.compiler.ast.untyped.Untyped;
+import org.shedlang.compiler.ast.untyped.UntypedNamespaceNode;
+import org.shedlang.compiler.types.NamespaceName;
+import org.zwobble.precisely.Matcher;
+
+import java.util.List;
+
+import static org.zwobble.precisely.AssertThat.assertThat;
+import static org.zwobble.precisely.Matchers.*;
+
+public class NamespaceDependencyLineariserTests {
+    @Test
+    public void emptyListIsLinearisedToEmptyList() {
+        var result = NamespaceDependencyLineariser.orderNamespaces(List.of());
+
+        assertThat(result, isSequence());
+    }
+
+    @Test
+    public void singletonListIsLinearisedToSingletonList() {
+        var namespaces = List.of(
+            namespaceNode("A", List.of())
+        );
+
+        var result = NamespaceDependencyLineariser.orderNamespaces(namespaces);
+
+        assertThat(result, isSequence(
+            isNamespaceNode("A")
+        ));
+    }
+
+    @Test
+    public void namespacesAreReorderedSoThatDependenciesAreFirst() {
+        var namespaces = List.of(
+            namespaceNode("A", List.of("B", "E")),
+            namespaceNode("B", List.of("C")),
+            namespaceNode("D", List.of()),
+            namespaceNode("C", List.of("D")),
+            namespaceNode("E", List.of())
+        );
+
+        var result = NamespaceDependencyLineariser.orderNamespaces(namespaces);
+
+        assertThat(result, isSequence(
+            isNamespaceNode("D"),
+            isNamespaceNode("C"),
+            isNamespaceNode("B"),
+            isNamespaceNode("E"),
+            isNamespaceNode("A")
+        ));
+    }
+
+    private static UntypedNamespaceNode namespaceNode(
+        String namespaceName,
+        List<String> dependencies
+    ) {
+        var builder = UntypedNamespaceNode.builder()
+            .withNamespaceName(NamespaceName.of(namespaceName));
+
+        for (var dependency : dependencies) {
+            builder = builder.addImport(Untyped.import_(NamespaceName.of(dependency)));
+        }
+
+        return builder.build();
+    }
+
+    private static Matcher<UntypedNamespaceNode> isNamespaceNode(String namespaceName) {
+        return has("namespaceName", x -> x.namespaceName(), equalTo(NamespaceName.of(namespaceName)));
+    }
+}
-- 
cgit v1.2.3