* structure TestCompilerOnImportsAndIncludes, add (@Disabled for now) test re %import with string arg

compiler/test/TestCompilerOnImportsAndIncludes.kt

@@ -1,14 +1,15 @@
 package prog8tests
 
+import prog8tests.helpers.*
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.TestFactory
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.DynamicTest
 import org.junit.jupiter.api.DynamicTest.dynamicTest
 import kotlin.test.*
 import kotlin.io.path.*
-import prog8tests.helpers.*
 
 import prog8.ast.expressions.AddressOf
 import prog8.ast.expressions.IdentifierReference
@@ -26,13 +27,16 @@ import prog8.compiler.target.Cx16Target
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class TestCompilerOnImportsAndIncludes {
 
+    @Nested
+    inner class Import {
+
         @Test
         fun testImportFromSameFolder() {
             val filepath = assumeReadableFile(fixturesDir, "importFromSameFolder.p8")
             assumeReadableFile(fixturesDir, "foo_bar.p8")
 
             val platform = Cx16Target
-        val result = compileFile(platform, false, fixturesDir, filepath.name)
+            val result = compileFile(platform, optimize = false, fixturesDir, filepath.name)
                 .assertSuccess()
 
             val program = result.programAst
@@ -48,13 +52,39 @@ class TestCompilerOnImportsAndIncludes {
             assertEquals("foo", strLits[1].definingScope().name)
         }
 
+        @Test
+        @Disabled("TODO: why would we not accept string literals as argument to %import?")
+        fun testImportFromSameFolder_strLit() {
+            val filepath = assumeReadableFile(fixturesDir,"importFromSameFolder_strLit.p8")
+            val imported = assumeReadableFile(fixturesDir, "foo_bar.p8")
+
+            val platform = Cx16Target
+            val result = compileFile(platform, optimize = false, fixturesDir, filepath.name)
+                .assertSuccess()
+
+            val program = result.programAst
+            val startSub = program.entrypoint()
+            val strLits = startSub.statements
+                .filterIsInstance<FunctionCallStatement>()
+                .map { it.args[0] as IdentifierReference }
+                .map { it.targetVarDecl(program)!!.value as StringLiteralValue }
+
+            assertEquals("main.bar", strLits[0].value)
+            assertEquals("foo.bar", strLits[1].value)
+            assertEquals("main", strLits[0].definingScope().name)
+            assertEquals("foo", strLits[1].definingScope().name)
+        }
+    }
+
+    @Nested
+    inner class AsmInclude {
         @Test
         fun testAsmIncludeFromSameFolder() {
             val filepath = assumeReadableFile(fixturesDir, "asmIncludeFromSameFolder.p8")
             assumeReadableFile(fixturesDir, "foo_bar.asm")
 
             val platform = Cx16Target
-        val result = compileFile(platform, false, fixturesDir, filepath.name)
+            val result = compileFile(platform, optimize = false, fixturesDir, filepath.name)
                 .assertSuccess()
 
             val program = result.programAst
@@ -72,7 +102,10 @@ class TestCompilerOnImportsAndIncludes {
             assertEquals("foo_bar", lbl1.name)
             assertEquals("start", lbl1.definingScope().name)
         }
+    }
 
+    @Nested
+    inner class Asmbinary {
         @Test
         fun testAsmbinaryDirectiveWithNonExistingFile() {
             val p8Path = assumeReadableFile(fixturesDir, "asmbinaryNonExisting.p8")
@@ -98,16 +131,14 @@ class TestCompilerOnImportsAndIncludes {
                 Triple("sub", "asmBinaryFromSubFolder.p8", "subFolder/do_nothing2.bin"),
             ).map {
                 val (where, p8Str, binStr) = it
-            val p8Path = fixturesDir.div(p8Str) // sanity check below, *inside dynamicTest*
+                dynamicTest("%asmbinary from ${where}folder") {
-            val binPath = fixturesDir.div(binStr)
+                    val p8Path = assumeReadableFile(fixturesDir, p8Str)
-            val displayName = "%asmbinary from ${where}folder"
+                    val binPath = assumeReadableFile(fixturesDir, binStr)
-            dynamicTest(displayName) {
-                assumeReadableFile(p8Path)
-                assumeReadableFile(binPath)
                     assertNotEquals( // the bug we're testing for (#54) was hidden if outputDir == workinDir
                         workingDir.normalize().toAbsolutePath(),
                         outputDir.normalize().toAbsolutePath(),
-                    "sanity check: workingDir and outputDir should not be the same folder")
+                        "sanity check: workingDir and outputDir should not be the same folder"
+                    )
 
                     compileFile(Cx16Target, false, p8Path.parent, p8Path.name, outputDir)
                         .assertSuccess(
@@ -120,3 +151,4 @@ class TestCompilerOnImportsAndIncludes {
 
     }
 
+}

compiler/test/fixtures/importFromSameFolder_strLit.p8

@@ -0,0 +1,9 @@
+%import textio
+%import "foo_bar.p8"
+main {
+	str myBar = "main.bar"
+	sub start() {
+	    txt.print(myBar)
+	    txt.print(foo.bar)
+	}
+}