Extract and test namespace linearisation

1 files changed, 73 insertions, 0 deletions

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)));
+    }
+}