diff --git a/docs/testframework.md b/docs/testframework.md
index 77be093..6c4cec1 100644
--- a/docs/testframework.md
+++ b/docs/testframework.md
@@ -63,7 +63,6 @@ test "<test name>" [when <condition>]:
     <test body>
 ```
 
-* `<test name>` must be unique **within the script**
 * Tests are registered automatically when the script is parsed
 * The optional `when` condition is evaluated immediately before execution
 
@@ -75,7 +74,7 @@ Inside a test, the framework provides:
   Fully-qualified test identifier:
 
   ```
-  <script>/<test name>
+  <test name>
   ```
 
 * **`event-boolean`**
@@ -90,11 +89,9 @@ Tests are registered automatically at parse time. No explicit registration step
 Internal storage format:
 
 ```
--test.sk::tests::<script>::<test name>
+-test.sk::tests::<test name>
 ```
 
-Registration is deterministic and isolated per script.
-
 ---
 
 ## Running Tests
@@ -125,7 +122,7 @@ run test(s) %strings%
 Identifier format:
 
 ```
-<script>/<test name>
+<test name>
 ```
 
 ---
@@ -135,13 +132,12 @@ Identifier format:
 ### Expression
 
 ```skript
-all tests [with test name %-string%] [within|from %-script%]
+all tests [with test name %-string%]
 ```
 
 ### Behavior
 
 * No arguments → all tests from all scripts
-* `from <script>` → tests scoped to a script
 * `with test name <string>` → exact match only
 
 Returned values are fully-qualified test identifiers.
@@ -356,7 +352,7 @@ Output is suppressed entirely when `with no error message` is specified.
 
 The framework guarantees that:
 
-* Tests are isolated by identifier
+* Tests are isolated by themselves
 * Registration is implicit and deterministic
 * Autorun and manual execution are distinguishable
 * Failures are recorded even in non-halting mode
diff --git a/scripts/libs/functionsv2.sk b/scripts/libs/functionsv2.sk
index 8b4755e..3135cdd 100644
--- a/scripts/libs/functionsv2.sk
+++ b/scripts/libs/functionsv2.sk
@@ -70,11 +70,11 @@ expression build lambda args %objects% body %string% noreturn %boolean% script %
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Runnable using {_functionsv2.sk::ctx::functions::*}
             else if {_functionsv2.sk::ctx::arity} is 1:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body} with runtime args {_functionsv2.sk::ctx::proxy}, {_functionsv2.sk::ctx::args::1} in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Consumer using {_functionsv2.sk::ctx::functions::*}
             else:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body} with runtime args {_functionsv2.sk::ctx::proxy}, {_functionsv2.sk::ctx::args::1}, {_functionsv2.sk::ctx::args::2} in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%", "%{_functionsv2.sk::ctx::args::2}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of BiConsumer using {_functionsv2.sk::ctx::functions::*}
         else:
 
@@ -83,11 +83,11 @@ expression build lambda args %objects% body %string% noreturn %boolean% script %
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Supplier using {_functionsv2.sk::ctx::functions::*}
             else if {_functionsv2.sk::ctx::arity} is 1:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::apply} to line section "return %{_functionsv2.sk::ctx::body}%" with runtime args {_functionsv2.sk::ctx::proxy}, {_functionsv2.sk::ctx::args::1} in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::apply} to line section "return %{_functionsv2.sk::ctx::body}%" with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Function using {_functionsv2.sk::ctx::functions::*}
             else:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::apply} to line section "return %{_functionsv2.sk::ctx::body}%" with runtime args {_functionsv2.sk::ctx::proxy}, {_functionsv2.sk::ctx::args::1}, {_functionsv2.sk::ctx::args::2} in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::apply} to line section "return %{_functionsv2.sk::ctx::body}%" with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%", "%{_functionsv2.sk::ctx::args::2}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of BiFunction using {_functionsv2.sk::ctx::functions::*}
         return {_functionsv2.sk::ctx::proxy}
 
@@ -103,6 +103,8 @@ expression:
         set {_functionsv2.sk::ctx::args::*} to FextractArgs({_functionsv2.sk::ctx::vars})
         set {_functionsv2.sk::ctx::origin} to SkriptLogger.getNode()
         set {_functionsv2.sk::ctx::script} to script ({_functionsv2.sk::ctx::origin}.getConfig().getFileName())
+        if {_functionsv2.sk::ctx::script} is not set: # likely inner lambda
+            set {_functionsv2.sk::ctx::script} to current script
         continue
     get:
         return build lambda args {_functionsv2.sk::ctx::args::*} body {_functionsv2.sk::ctx::expr} noreturn {_functionsv2.sk::ctx::noreturn} script {_functionsv2.sk::ctx::script}
@@ -141,7 +143,9 @@ expression:
             if size of {_functionsv2.sk::ctx::args::*} is not 2:
                 stop
         set {_functionsv2.sk::ctx::origin} to SkriptLogger.getNode()
-        set {_functionsv2.sk::ctx::script} to script ({_origin}.getConfig().getFileName())
+        set {_functionsv2.sk::ctx::script} to script ({_functionsv2.sk::ctx::origin}.getConfig().getFileName())
+        if {_functionsv2.sk::ctx::script} is not set: # likely inner lambda
+            set {_functionsv2.sk::ctx::script} to current script
         continue
     get:
         return build lambda args {_functionsv2.sk::ctx::args::*} body {_functionsv2.sk::ctx::expr} noreturn {_functionsv2.sk::ctx::noreturn} script {_functionsv2.sk::ctx::script}
diff --git a/scripts/libs/singlelinesection.sk b/scripts/libs/singlelinesection.sk
index a0ffc2f..ee9d0d2 100644
--- a/scripts/libs/singlelinesection.sk
+++ b/scripts/libs/singlelinesection.sk
@@ -15,6 +15,8 @@ import:
     java.util.HashSet
     org.skriptlang.reflect.java.elements.structures.StructImport
     ch.njol.skript.log.SkriptLogger
+    java.lang.String
+    java.lang.Object
 
 local function extractArgs(vars: object) :: objects:
     if {_vars} is instance of ExpressionList:
@@ -33,12 +35,6 @@ local function extractRuntimeArgs(vars: objects) :: objects:
     
 expression compile line %string% with %object% (1:|2:noreturn) in %script%:    
     get:    
-        set {_section.sk::single::parser} to ParserInstance.get()
-        set {_section.sk::single::parser}.[ParserInstance]isActive to true
-        set {_section.sk::single::parserBackup} to {_section.sk::single::parser}.backup()  
-        set {_section.sk::single::parser}.[ParserInstance]isActive to false
-        {_section.sk::single::parser}.reset()  
-          
         set {_section.sk::single::code} to "%expr-1%"  
         set {_section.sk::single::event} to expr-2  
         set {_section.sk::single::bais} to new ByteArrayInputStream({_section.sk::single::code}.getBytes())  
@@ -46,33 +42,24 @@ expression compile line %string% with %object% (1:|2:noreturn) in %script%:
         
         set {_section.sk::single::config} to new Config({_section.sk::single::bais},"compiled single line for single line section: %expr-1%",true,false,":")  
         set {_section.sk::single::node} to {_section.sk::single::config}.getMainNode()  
-        
-        # a hack to use java calls
-        set {_section.sk::single::imports} to StructImport.[StructImport]imports.get(expr-3)
-        if {_section.sk::single::imports} is not set:
-            set {_section.sk::single::imports} to new HashMap()
-        set {_section.sk::single::importsLocal} to StructImport.[StructImport]imports.getOrDefault(null, new HashMap())
-        set {_section.sk::single::keys} to new HashSet({_section.sk::single::imports}.keySet())
-        {_section.sk::single::keys}.removeAll({_section.sk::single::importsLocal}.keySet())
-        loop ...{_section.sk::single::keys}:
-            set {_section.sk::single::javatype} to {_section.sk::single::imports}.get(loop-value)
-            set {_section.sk::single::javatypeSimpleName} to last element of split "%{_section.sk::single::javatype}%" at "."
-            # simulating effect command !import <import>
-            if loop-value is {_section.sk::single::javatypeSimpleName}:
-                StructImport.registerImport("%{_section.sk::single::javatype}%", null) 
-            else:
-                StructImport.registerImport("%{_section.sk::single::javatype}% as %loop-value%", null) 
-        
+    
+        set {_section.sk::single::parser} to ParserInstance.get()
+        set {_section.sk::single::isActiveOrig} to {_section.sk::single::parser}.[ParserInstance]isActive
+        set {_section.sk::single::parser}.[ParserInstance]isActive to true
+        set {_section.sk::single::parserBackup} to {_section.sk::single::parser}.backup()  
+        {_section.sk::single::parser}.reset()  
+        {_section.sk::single::parser}.setCurrentScript(expr-3)  
         {_section.sk::single::parser}.setCurrentEvent({_section.sk::single::name}, SectionEvent.class)  
         {_section.sk::single::parser}.setCurrentStructure({_section.sk::single::event})  
-  
+
         set {_section.sk::single::items} to ScriptLoader.loadItems({_section.sk::single::node})  
   
         {_section.sk::single::parser}.restoreBackup({_section.sk::single::parserBackup})  
+        set {_section.sk::single::parser}.[ParserInstance]isActive to {_section.sk::single::isActiveOrig}
         return new Trigger(current script, {_section.sk::single::name}, {_section.sk::single::event}, {_section.sk::single::items})
 
 
-expression [new] [single] line section %string%[ with (1:|2:runtime) [arg[ument]s [variables]] %-objects%][in %-script%]:
+expression [new] [single] line section %strings%[ with [arg[ument]s [variables]] %-objects%][in %-script%]:
     return type: section
     parse:
         if expr-3 is not set:
@@ -82,21 +69,25 @@ expression [new] [single] line section %string%[ with (1:|2:runtime) [arg[ument]
     get:
         if {_section.sk::single::script} is not set:
             set {_section.sk::single::script} to expr-3
-        if parse mark is 2:
-            set {_section.sk::single::test::*} to expr-2
+        if expr-2 is instance of String:
+            set {_section.sk::single::array} to [Object.class]
+            set {_section.sk::single::expr2::*} to expr-2
+            loop {_section.sk::single::expr2::*}:
+                set {_section.sk::single::expr2} to loop-value
+                replace "{", "}" with "" in {_section.sk::single::expr2}
+                set {_section.sk::single::test::%loop-index%} to Variable.newInstance({_section.sk::single::expr2}, {_section.sk::single::array})
             set {_section.sk::single::args::*} to extractRuntimeArgs({_section.sk::single::test::*})
         else:
             set {_section.sk::single::test} to raw expression of expr-2
             set {_section.sk::single::args::*} to extractArgs({_section.sk::single::test})
             
-        set {_section.sk::single::code} to expr-1
+        set {_section.sk::single::code} to join expr-1 with nl
         if {_section.sk::single::code} is not set:
             return {_none}
 
         # Compile the line into a trigger
         set {_section.sk::single::name} to "section"
 
-            
         set {_section.sk::single::event} to new SectionSkriptEvent({_section.sk::single::name}, null)
         set {_section.sk::single::trigger} to compile line {_section.sk::single::code} with {_section.sk::single::event} in {_section.sk::single::script}
 
diff --git a/scripts/utils/testframework.sk b/scripts/utils/testframework.sk
index b07513e..4e80bcc 100644
--- a/scripts/utils/testframework.sk
+++ b/scripts/utils/testframework.sk
@@ -12,12 +12,12 @@ local effect testFail %string%[, %-string%]:
         send "[<gold>Skript<reset>] [&cTEST FAILURE<reset>] %expr-1%%{_msg}%" to console
 
 event "skriptTest":
-    pattern: test %string% [when <(.+)>]
+    pattern: [devdinc] test %string% [when <(.+)>]
     event-values: string, boolean
     check:
         set {_ok} to true
-        set {-test.sk::tests::%current script%::%expr-1%} to "%expr-1%"
-        if "%current script%/%expr-1%" is event-string:
+        set {-test.sk::tests::%expr-1%} to "%expr-1%"
+        if "%expr-1%" is event-string:
             set {_raw} to first element of regex-1
             if {_raw} is set:
                 set {_cond} to Condition.parse({_raw}, "Can't understand condition: " + {_raw})
@@ -26,28 +26,15 @@ event "skriptTest":
                 set {_ok} to {_cond}.check(event)
             continue if {_ok} is true
 
-plural expression all tests [with test name %-string%] [([with]in|from) %-script%]:
+plural expression all tests [with test name %-string%]:
     return type: strings
-    parse:
-        set {_scoped} to false if expr-2 is not set
-        continue
-
     get:
-        if {_scoped} is false:
-            loop indices of {-test.sk::tests::*}:
-                loop {-test.sk::tests::%loop-value%::*}:
-                    if any:
-                        expr-1 is not set
-                        loop-value-2 is expr-1
-                    then:
-                        add "%loop-value-1%/%loop-value-2%" to {_r::*}
-
-        else:
-            if expr-1 is not set:
-                loop {-test.sk::tests::%expr-2%::*}:
-                    add "%expr-2%/%loop-value%" to {_r::*}
-            else if {-test.sk::tests::%expr-2%::%expr-1%} is set:
-                add "%expr-2%/%expr-1%" to {_r::*}
+        loop {-test.sk::tests::*}:
+            if any:
+                expr-1 is not set
+                loop-value is expr-1
+            then:
+                add "%loop-value%" to {_r::*}
 
         return {_r::*}
         
@@ -127,7 +114,7 @@ effect:
             {_bool2} is true
         then:
             if parse tags does not contain "5":
-                testFail "Test ""%{_test}%"" with condition ""%{_label}%: %{_raw}%"" failed", expr-1
+                testFail "Test ""%{_test}%"" with condition '%{_label}%: %{_raw}%' failed", expr-1
             add "%expr-1%" to {-test.sk::errors::%{_test}%::*}
             if parse tags contains "3":
                 delay effect
@@ -244,78 +231,78 @@ expression [the] test(-| )offline[-| ]player:
         # TestOfflinePlayer.[TestOfflinePlayer]PLAYER_PROFILE.setProperty(new ProfileProperty("textures", "ewogICJ0aW1lc3RhbXAiIDogMTc0NzQyOTg2MTQwOCwKICAicHJvZmlsZUlkIiA6ICI2OWUzNzAyNjJjN2Q0MjU1YWM3NjliMTNhNWZlOGY3NCIsCiAgInByb2ZpbGVOYW1lIiA6ICJTYWh2ZGUiLAogICJzaWduYXR1cmVSZXF1aXJlZCIgOiB0cnVlLAogICJ0ZXh0dXJlcyIgOiB7CiAgICAiU0tJTiIgOiB7CiAgICAgICJ1cmwiIDogImh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNTE2MGFiZWVhNDI1YzZmODMyYjc0NmE0NTQ0YzVmYjlhOTgxYjAyZTFiZDg1ZmVhNWM3ZWY4MzFiZGM4NzRmMyIKICAgIH0KICB9Cn0="));
         return {_instance}
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert true passes":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert true passes":
     assert true: {_none} is not set
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert false passes":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert false passes":
     assert false: {_none} is set
     
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 framework internal consistency":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 framework internal consistency":
     without halting assert true: size of all tests > 0
     without halting assert true: "%current script%" is set
     assert true: size of test errors is 0
 
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert true failure is recorded":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert true failure is recorded":
     without halting assert true with no error message: {_none} is set
     assert true: size of test errors is 1
     
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert error message is stored":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert error message is stored":
     without halting assert true with no error message "msg1": {_none} is set
     assert true with message "check failed": test errors contains "msg1"
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 no error message produces empty suffix":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 no error message produces empty suffix":
     without halting assert true with no error message: {_none} is set
     assert true: size of test errors is 1
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 halting assert stops execution":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 halting assert stops execution":
     assert true with no error message: {_none} is set
     broadcast "<red>ERROR: this should never execute"
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 without halting continues execution":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 without halting continues execution":
     without halting assert true with no error message: {_none} is set
     assert true: {_none} is not set
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 fail test records error":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 fail test records error":
     without halting fail test with no error message
     assert true: size of test errors is 1
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 fail test halts by default":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 fail test halts by default":
     fail test with no error message
     broadcast "<red>ERROR: fail test did not halt"
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 autorun flag is true":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 autorun flag is true":
     assert true: event-test is autorun
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 manual run flag is false" when {_none} is set:
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 manual run flag is false" when {_none} is set:
     fail test
     
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 manual run flag" when event-test is not autorun:
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 manual run flag" when event-test is not autorun:
     fail test
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 stop auto execution works":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 stop auto execution works":
     stop auto test execution here
     broadcast "<red>ERROR: auto execution not stopped"
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests returns this test":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests returns this test":
     set {_all::*} to all tests
-    assert true: {_all::*} contains "%current script%/f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests returns this test"
+    assert true: {_all::*} contains "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests returns this test"
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests scoped by script":
-    set {_all::*} to all tests within current script
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests":
+    set {_all::*} to all tests
     assert true: size of {_all::*} > 0
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 errors do not leak between tests A":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 errors do not leak between tests A":
     without halting assert true with no message: {_none} is set
     assert true: size of test errors is 1
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 errors do not leak between tests B":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 errors do not leak between tests B":
     assert true: size of test errors is 0
 
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 event-test returns correct name":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 event-test returns correct name":
     assert true: event-test is event-string
     
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 test-block is temporary":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 test-block is temporary":
     test block is chest:
         set test-block to trapped chest
     else if test block is trapped chest:
@@ -325,7 +312,7 @@ test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 test-block is temporary":
         
     # test is continued at on load end
     
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 parse section":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 parse section":
     parse:
         no errors: abc # just an internal stuff to make sure test.sk loads without errors
     assert last parse logs contains "Can't understand this condition/effect: no errors: abc"
diff --git a/tests/functionsv2.sk b/tests/functionsv2.sk
index 1b9e458..d65f537 100644
--- a/tests/functionsv2.sk
+++ b/tests/functionsv2.sk
@@ -101,7 +101,10 @@ test "run lambda helpers":
     assert (run lambda {_sup}) is "yes" with "run supplier fail"
     assert (run lambda (lambda {_x}:+ {_x}) with "test") is "test" with "run function fail"
     
+import:
+    java.net.URL
+    
 test "java call":
-    set {_lam} to lambda:+ new HashMap()
+    set {_lam} to lambda:+ new URL("https://www.dummy2.com")
     set {_val} to {_lam}.get()
-    assert {_val}.getClass().getSimpleName().equalsIgnoreCase("hashmap") is true with "java call failed"
+    assert {_val}.getClass().getSimpleName().equalsIgnoreCase("URL") is true 
diff --git a/tests/singlinesection.sk b/tests/singlinesection.sk
index 5adefd0..045d6f7 100644
--- a/tests/singlinesection.sk
+++ b/tests/singlinesection.sk
@@ -11,9 +11,7 @@ test "new single line section expression":
     run section {_section} with "what" and store result in {_n}
     assert {_return} is not 1 with "single line section bug 2"
     
-    set {_x} to raw expression of {_x}
-    set {_y} to raw expression of {_z}
-    set {_section} to single line section "return {_x} + {_z}" with runtime args {_x}, {_y}
+    set {_section} to single line section "return {_x} + {_z}" with args "{_x}", "{_z}"
     run section {_section} with 15, 10 and store result in {_n}
     assert {_n} is 25 with "single line section bug 3"
     
@@ -25,3 +23,11 @@ test "new single line section expression":
     set {_section} to single line section "return new ArrayList()"
     run section {_section} and store result in {_n}
     assert "%{_n}%" is "[]" with "single line section bug 5"
+
+    set {_section} to single line section "set {_a} to 1%nl%set {_b} to 2%nl%return {_a} + {_b}"
+    run section {_section} and store result in {_n}
+    assert {_n} is 3 with error "single line section bug 6"
+    
+    set {_section} to single line section "set {_a} to 2", "set {_c} to 3", "return {_a} + {_b} + {_c}"
+    run section {_section} and store result in {_n}
+    assert {_n} is 5 with error "single line section bug 7"