diff --git a/.github/workflows/publish-wiki.yml b/.github/workflows/publish-wiki.yml
index 90e5d5a..a6d142b 100644
--- a/.github/workflows/publish-wiki.yml
+++ b/.github/workflows/publish-wiki.yml
@@ -1,7 +1,7 @@
 name: Publish wiki
 on:
   push:
-    branches: [main]
+    branches: [stable]
     paths:
       - docs/**
       - .github/workflows/publish-wiki.yml
diff --git a/.github/workflows/test-skripts.yml b/.github/workflows/test-skripts.yml
new file mode 100644
index 0000000..a682003
--- /dev/null
+++ b/.github/workflows/test-skripts.yml
@@ -0,0 +1,82 @@
+name: Run tests
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - stable
+      - dev
+    paths:
+      - tests/**
+      - scripts/**
+      - .github/workflows/test-skripts.yml
+  pull_request:
+    branches:
+      - stable
+      - dev
+    paths:
+      - tests/**
+      - scripts/**
+      - .github/workflows/test-skripts.yml
+
+concurrency:
+  group: run-tests
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Pre-create plugin directory
+        run: |
+          mkdir -p build/libs
+          mkdir -p build/libs/skript-reflect
+
+      - name: Download Skript-Reflect
+        run: |
+          mkdir -p build/libs
+          curl -L -o build/libs/skript-reflect.jar \
+            https://github.com/SkriptLang/skript-reflect/releases/download/v2.6.1/skript-reflect-2.6.1.jar
+            
+      - name: Download Routines from JitPack
+        run: |
+          mkdir -p build/libs
+      
+          curl -L --fail -o build/libs/skript-reflect/routines-core.jar \
+            https://jitpack.io/com/github/devdinc/routines/routines-core/v2.2.1/routines-core-v2.2.1.jar
+      
+          curl -L --fail -o build/libs/skript-reflect/routines-paper.jar \
+            https://jitpack.io/com/github/devdinc/routines/routines-paper/v2.2.1/routines-paper-v2.2.1.jar
+      # Disable pdc for now, i want to remove skbee req
+      # Disable config reload
+      - name: Prepare scripts
+        run: |
+          mkdir -p tests/scripts
+          rsync -av scripts/ tests/scripts/
+          mv tests/scripts/libs/singlelinesection.sk tests/scripts/libs/0_singlelinesection.sk
+          rm -f tests/scripts/utils/testframework.sk
+          rm -f tests/scripts/libs/pdc.sk
+          rm -f tests/scripts/utils/configreloadv2.sk
+          
+
+      - name: Run tests
+        uses: devdinc/skript-test-action@v1.3
+        with:
+          skript_repo_url: https://github.com/devdinc/Skript.git
+          # directory where your test scripts are located (relative to repo root)
+          test_script_directory: tests
+
+          # Skript version or ref (tag, branch, or commit)
+          skript_repo_ref: copy-dir-resources # 2.13.2
+
+          # directory containing addon/plugin jars (relative to repo root)
+          extra_plugins_directory: build/libs
+
+          run_vanilla_tests: false
diff --git a/docs/testframework.md b/docs/testframework.md
index f7c3c4e..f87560d 100644
--- a/docs/testframework.md
+++ b/docs/testframework.md
@@ -1,28 +1,60 @@
-# Skript Testing Framework
+Below is a **single, unified Markdown document** that combines both inputs, removes duplication, and reconciles terminology while preserving all technical detail. Structure has been normalized so it reads as one authoritative specification rather than two overlapping documents.
 
-## Purpose
+---
+
+# Skript Runtime Testing Framework
+
+## Overview
+
+This document describes a **self-contained runtime testing framework for Skript**. The framework replicates much of Skript’s internal development test suite while extending it with runtime-safe execution, reflection-based inspection, and deterministic event-driven control.
+
+Unlike Skript’s native internal tests, this framework:
+
+* Runs entirely at runtime
+* Is safe for production servers
+* Supports both **automatic (autorun)** and **manual** execution
+* Tracks failures centrally with optional console suppression
+
+All framework state is stored under the `-test.sk::*` namespace.
+
+---
+
+## Design Goals
+
+The framework is intentionally minimal and predictable, prioritizing correctness and isolation over flexibility.
+
+It is designed to:
+
+* Allow tests to be written directly in `.sk` files
+* Achieve functional parity with Skript’s internal test actions where feasible
+* Enable meta-testing of Skript syntax and parser behavior
+* Support fail-fast behavior with optional non-halting assertions
+* Prevent state leakage between tests
 
-This module implements a lightweight, self-contained **testing framework for Skript**. It allows scripts to define tests, automatically discover them, execute them deterministically, and report failures with precise diagnostics.
+---
 
-The framework is designed to:
+## Feature Parity with Skript’s Native Test Suite
 
-* Run entirely inside Skript
-* Avoid external dependencies
-* Support both manual and automatic test execution
-* Fail fast while still allowing optional non-halting assertions
+| Feature                   | Status       | Description                                           |
+| ------------------------- | ------------ | ----------------------------------------------------- |
+| **Test structure**        | Achieved     | `test %string%` mirrors native test declarations      |
+| **Conditional execution** | Achieved     | `when <condition>` skips tests dynamically            |
+| **Assertions**            | Achieved     | `assert <condition>` and `assert <condition> to fail` |
+| **Explicit failure**      | Achieved     | `fail test` effect                                    |
+| **Parser inspection**     | Experimental | Parse sections and log capture                        |
 
 ---
 
 ## High-Level Architecture
 
-The framework is built around four core ideas:
+The framework is built around four core principles:
 
-1. **Tests are custom events** identified by name
-2. **Tests are registered implicitly** during script parsing
-3. **Execution is event-driven**, not inline
-4. **Failures are tracked centrally** and reported after execution
+1. **Tests are custom events**
+2. **Tests are registered implicitly at parse time**
+3. **Execution is event-driven, not inline**
+4. **Failures are tracked centrally per test**
 
-All internal state is stored under the `-test.sk::*` variable namespace.
+Each test executes inside a dedicated `skriptTest` event context.
 
 ---
 
@@ -31,73 +63,75 @@ All internal state is stored under the `-test.sk::*` variable namespace.
 ### Syntax
 
 ```skript
-test "<test name>":
+test "<test name>" [when <condition>]:
     <test body>
 ```
 
-* `<test name>` must be unique **within the script**.
-* The test body runs inside the `skriptTest` custom event.
-* The event provides two event-values:
+* `<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
 
-  * `string` – the fully-qualified test identifier
-  * `boolean` – whether the test is running in autorun mode
+### Event Context
 
-### Example
+Inside a test, the framework provides:
 
-```skript
-test "basic arithmetic":
-    assert true: 2 + 2 = 4
-```
+* **`event-string` / `event-test`**
+  Fully-qualified test identifier:
+
+  ```
+  <script>/<test name>
+  ```
+
+* **`event-boolean`**
+  Indicates whether the test is running in **autorun mode**
 
 ---
 
 ## Test Registration
 
-Tests are registered automatically at parse time.
+Tests are registered automatically at parse time. No explicit registration step is required.
 
-Internally, the framework records tests under:
+Internal storage format:
 
 ```
 -test.sk::tests::<script>::<test name>
 ```
 
-No explicit registration step is required.
+Registration is deterministic and isolated per script.
 
 ---
 
 ## Running Tests
 
+### Automatic Execution (Autorun)
+
+On script load:
+
+1. Previous global test state is cleared
+2. A hidden sentinel test establishes autorun context
+3. All registered tests are discovered
+4. Tests are executed in autorun mode
+
+Autorun execution passes `true` as the event-boolean value.
+
+---
+
 ### Manual Execution
 
 ```skript
 run test(s) %strings%
 ```
 
-* Accepts one or more test identifiers
-* Identifiers must be fully-qualified:
+* Accepts one or more **fully-qualified test identifiers**
+* Clears prior error state for each test
+* Executes tests outside autorun mode
+
+Identifier format:
 
 ```
 <script>/<test name>
 ```
 
-Before execution:
-
-* Any previous error count for the test is cleared
-* The test is executed via the `skriptTest` custom event
-
----
-
-### Automatic Execution (Autorun)
-
-On script load, the framework:
-
-1. Clears all previous test state
-2. Executes an internal sentinel test
-3. Discovers all registered tests
-4. Executes them using autorun mode
-
-Autorun passes a boolean event-value (`true`) to each test, allowing tests to alter behavior when executed automatically.
-
 ---
 
 ## Test Discovery
@@ -110,102 +144,186 @@ all tests [with test name %-string%] [within|from %-script%]
 
 ### Behavior
 
-* **No arguments** → all tests from all scripts
-* **from `<script>`** → only tests in that script
-* **with test name `<string>`** → only the matching test (if present)
-
-Returned values are fully-qualified identifiers:
+* No arguments → all tests from all scripts
+* `from <script>` → tests scoped to a script
+* `with test name <string>` → exact match only
 
-```
-<script>/<test name>
-```
+Returned values are fully-qualified test identifiers.
 
 ---
 
 ## Assertions
 
-### Syntax
+Assertions validate test behavior and record failures.
+
+### Syntax Variants
 
 ```skript
 assert true: <condition>
 assert false: <condition>
+assert <condition> [to fail]
 ```
 
-Optional error message:
+### Optional Modifiers
+
+* **`without halting`**
+  Records failure but continues execution
+
+* **`with error message "<message>"`**
+  Prints formatted failure output
+
+* **`with no error message`**
+  Suppresses console output entirely
+
+Assertions are only valid inside a test context.
+
+---
+
+## Error Tracking
+
+### Expression
 
 ```skript
-assert true with error message "<message>": <condition>
+test errors [for %-strings%]
 ```
 
-Optional non-halting mode:
+* Returns all recorded failures for the current test
+* Includes:
+
+  * Assertion failures
+  * Explicit `fail test` invocations
+  * Internally tracked errors
+
+Errors are reset between tests and never leak across executions.
+
+---
+
+## Explicit Test Failure
+
+### Syntax
 
 ```skript
-without halting assert true: <condition>
+fail test
+fail test with error message "<message>"
 ```
 
-Optional error message control:
+Behavior:
+
+* Records a failure immediately
+* Optionally prints formatted output
+* Halts execution unless `without halting` is specified
+
+## Autorun Execution Semantics
+
+### Autorun Flag (Test Context)
+
+**Expression:**
 
 ```skript
-assert true with error message "<message>": <condition>
-assert true with no error message: <condition>
+event-test is autorun
+event-test is not autorun
 ```
 
-### Error Message Semantics
+**Type:** Boolean condition
 
-* `with error message "<message>"` – emits a formatted failure message to the console when the assertion fails
-* `with no error message` – suppresses console output entirely
+**Meaning:**
 
-In both cases:
+* Evaluates to `true` when the current test is executing as part of automatic test execution
+* Evaluates to `false` when the test is executed manually via `run test(s)`
 
-* The failure is still recorded internally
-* The test still halts unless `without halting` is specified
+**Scope:**
 
-This allows assertions to be used for:
+* Valid only inside a `test` block
+* Bound to the `skriptTest` event context
 
-* Silent internal invariants
-* Meta-tests that validate the framework itself
-* Failure counting without polluting console output
+**Notes:**
 
-Assertions are only valid inside the `skriptTest` event context.
+* This flag is set by the framework before test execution begins
+* It remains constant for the duration of the test
+* It is commonly used to guard unsafe, destructive, or environment-dependent logic
 
 ---
 
-## Explicit Test Failure
+### Autorun Control Effect
 
-### Syntax
+**Syntax:**
 
 ```skript
-fail test
-fail test with error message "<message>"
+stop auto test execution here
 ```
 
-Behavior:
+**Behavior:**
+
+* If `event-test is autorun`:
+
+  * Immediately halts execution of the current test
+    
+* If `event-test is not autorun`:
+
+  * Has no effect
+
+**Use Case:**
+Allows tests to opt out of autorun safely while still being available for manual execution.
+
+---
+
+### Typical Usage Pattern
 
-* Immediately records a failure
-* Optionally prints a formatted error
-* Halts test execution unless `without halting` is specified
+```skript
+test "destructive test":
+    if event-test is autorun:
+        stop auto test execution here
+    # manual-only logic below
+```
 
 ---
 
-## Controlling Autorun Execution
+### Guarantees
+
+* Autorun mode is always enabled during load-time execution
+* Manual execution always runs with autorun disabled
+* The autorun flag is not mutable by user code
+* Autorun state never leaks between tests
+
+## Experimental: Parsing & Log Inspection
 
-### Effect
+The framework supports testing Skript syntax itself.
+
+### Parse Section
 
 ```skript
-stop auto test execution here
+parse:
+    <skript code>
 ```
 
-* Only meaningful during autorun execution
-* If the test is running in autorun mode, execution stops immediately
-* Has no effect when the test is run manually
+* Attempts to parse the nested code using `ParserInstance`
+* Does not execute the code
+
+### Log Inspection
+
+```skript
+last parse logs
+```
+
+* Returns all `SkriptLogger` messages captured during the most recent parse
+* Enables validation of expected parser errors
+
+---
+
+## Test Environment Utilities
+
+To ensure isolation and repeatability, the framework provides controlled test fixtures:
 
-This allows tests that are unsafe, destructive, or environment-dependent to opt out of autorun.
+* **`test-world`** – dedicated test world
+* **`test-location`** – fixed location (`spawn + 10, 1, 0`)
+* **`test-block`** – self-resetting block restored after tests
+* **`test-offline-player`** – generated offline player instance
 
 ---
 
 ## Failure Reporting
 
-Each test maintains an internal error counter:
+Each test maintains its own failure count:
 
 ```
 -test.sk::errors::<test id>
@@ -213,8 +331,7 @@ Each test maintains an internal error counter:
 
 After execution completes:
 
-* Tests that were intentionally skipped are excluded
-* A summary line is printed to the console:
+* A summary line is printed:
 
 ```
 <X>/<Y> tests passed
@@ -222,42 +339,44 @@ After execution completes:
 
 Where:
 
-* `Y` is the number of valid executed tests
-* `X` is `Y - total failures`
+* `Y` = executed tests
+* `X` = tests without recorded failures
 
 ---
 
 ## Console Output Format
 
-Failures are reported using the following format:
+When enabled, failures are printed as:
 
 ```
 [Skript] [TEST FAILURE] <test name> <optional message>
 ```
 
-This output is emitted only when an error message is enabled for the assertion or failure.
+Output is suppressed entirely when `with no error message` is specified.
 
 ---
 
-## Internal and Non-Public Details
-
-The following are implementation details and should not be relied upon:
-
-* A hidden sentinel test is used during initialization
-* Internal variables are prefixed with `-test.sk::*`
-* The sentinel test ensures framework integrity before user tests run
-
-These details may change without notice.
-
----
+## Internal Guarantees
 
-## Design Guarantees
+The framework guarantees that:
 
 * Tests are isolated by identifier
 * Registration is implicit and deterministic
 * Autorun and manual execution are distinguishable
 * Failures are recorded even in non-halting mode
-* The framework does not leak state between executions
+* State never leaks between tests
+
+---
+
+## Internal & Non-Public Details
+
+The following are implementation details and must not be relied upon:
+
+* Sentinel test usage
+* Internal variable layout
+* Reflection-based hooks
+
+These may change without notice.
 
 ---
 
@@ -265,7 +384,8 @@ These details may change without notice.
 
 * Regression testing for Skript libraries
 * Validation of complex event-driven logic
-* Automated sanity checks during development
-* Lightweight CI-style verification on server startup
+* Syntax and parser validation
+* Automated sanity checks on server startup
+* Lightweight CI-style verification
 
-This framework is intentionally minimal and favors predictability over flexibility.
+This framework is deliberately constrained to ensure reliability and transparency.
diff --git a/functionsv2.sk b/scripts/libs/functionsv2.sk
similarity index 100%
rename from functionsv2.sk
rename to scripts/libs/functionsv2.sk
diff --git a/pdc.sk b/scripts/libs/pdc.sk
similarity index 100%
rename from pdc.sk
rename to scripts/libs/pdc.sk
diff --git a/routines.sk b/scripts/libs/routines.sk
similarity index 100%
rename from routines.sk
rename to scripts/libs/routines.sk
diff --git a/singlelinesection.sk b/scripts/libs/singlelinesection.sk
similarity index 100%
rename from singlelinesection.sk
rename to scripts/libs/singlelinesection.sk
diff --git a/configreloadv2.sk b/scripts/utils/configreloadv2.sk
similarity index 100%
rename from configreloadv2.sk
rename to scripts/utils/configreloadv2.sk
diff --git a/scripts/utils/testframework.sk b/scripts/utils/testframework.sk
new file mode 100644
index 0000000..b07513e
--- /dev/null
+++ b/scripts/utils/testframework.sk
@@ -0,0 +1,331 @@
+using reflection
+
+import:
+    ch.njol.skript.lang.parser.ParserInstance
+    org.bukkit.Bukkit
+    ch.njol.skript.test.utils.TestOfflinePlayer
+    ch.njol.skript.lang.Condition
+
+local effect testFail %string%[, %-string%]:
+    trigger:
+        set {_msg} to " %expr-2%" if expr-2 is set else ""
+        send "[<gold>Skript<reset>] [&cTEST FAILURE<reset>] %expr-1%%{_msg}%" to console
+
+event "skriptTest":
+    pattern: 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 {_raw} to first element of regex-1
+            if {_raw} is set:
+                set {_cond} to Condition.parse({_raw}, "Can't understand condition: " + {_raw})
+        
+            if {_cond} is set:
+                set {_ok} to {_cond}.check(event)
+            continue if {_ok} is true
+
+plural expression all tests [with test name %-string%] [([with]in|from) %-script%]:
+    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::*}
+
+        return {_r::*}
+        
+effect (1:|2:auto)run [test][s] %strings%:
+    trigger:
+        set {_tests::*} to expr-1
+        set {_alltests::*} to all tests
+        loop {_tests::*}:
+            delete {-test.sk::errors::%loop-value%::*} 
+            set {_list::string} to loop-value
+            set {_list::boolean} to true if parse mark is 2 else false
+            call custom event "skriptTest" with {_list::*}
+            if any:
+                loop-value contains "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
+                {_alltests::*} does not contain loop-value
+            then:
+                add 1 to {_forgottenTestResults}
+                continue loop
+            add 1 to {_testFails} if size of {-test.sk::errors::%loop-value%::*} is greater than 0
+        set {_validTestAmount} to size of {_tests::*} - {_forgottenTestResults}
+        if {_validTestAmount} is not 0:
+            send "[<gold>Skript<reset>] <yellow>%{_validTestAmount} - {_testFails}%/%{_validTestAmount}% tests passed." to console
+        else if size of {_alltests::*} is greater than 0: # skipping if there is no initial hidden test 
+            send "[<gold>Skript<reset>] <yellow>No tests found." to console
+
+on load:
+    delete {-test.sk::*}
+    set {_block} to test-block's type
+    wait 1 tick
+    run test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
+    wait 1 tick
+    set {_tests::*} to all tests
+    autorun {_tests::*}
+    set test-block to {_block}
+    broadcast "<red>Test block is permanent!" if test-block is not {_block}
+
+effect:
+    patterns:
+        (3:|4:(no|without) (halt[ing]|fail[(-| )](safe|fast)|abort[ing])) assert(1:|1: true|2: false)[ with (6:|5:no )[[error] message][ %-string%]]\: <(.+)>
+        (3:|4:(no|without) (halt[ing]|fail[(-| )](safe|fast)|abort[ing])) assert <(.+)> (1:|2:to fail)[ with (6:|5:no )[[error][ message]][ %-string%]]
+    usable in:
+        custom event "skriptTest"
+    parse:
+        set {_raw} to first element of regex-1
+        
+        set {_parser} to ParserInstance.get()
+        set {_parser}.[ParserInstance]isActive to true
+        set {_backup} to {_parser}.backup()  
+        
+        {_parser}.setCurrentScript(current script)
+        {_parser}.setCurrentEvent("assert condition", (custom event "skriptTest").getClass())
+        
+        set {_cond} to Condition.parse({_raw}, "Can't understand condition: " + {_raw})
+        
+        set {_parser}.[ParserInstance]isActive to false
+        {_parser}.restoreBackup({_backup})  
+        continue
+    trigger:
+        set {_ok} to {_cond}.check(event)
+        
+        set {_label} to "assert true" if parse tags contains "1" else "assert false"
+        set {_test} to event.getEventValue("string")
+        if all:
+            parse tags contains "1"
+            {_ok} is false
+        then:
+            set {_bool1} to true
+            
+        if all:
+            parse tags contains "2"
+            {_ok} is true
+        then:
+            set {_bool2} to true
+            
+        if any:
+            {_bool1} is true
+            {_bool2} is true
+        then:
+            if parse tags does not contain "5":
+                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
+
+effect (3:|4:(no|without) (halt[ing]|fail[(-| )](safe|fast)|abort[ing])) fail test[ with (6:|5:no )[[error] message][ %-string%]]:
+    usable in: 
+        custom event "skriptTest"
+    trigger:
+        set {_test} to event.getEventValue("string")
+        if parse tags does not contain "5":
+            testFail "Test ""%{_test}%"" failed", expr-1
+        add "%expr-1%" to {-test.sk::errors::%{_test}%::*}
+        if parse tags contains "3":
+            delay effect
+        
+effect stop auto [test] execution [here]:
+    usable in:
+        custom event "skriptTest"
+    trigger:
+        set {_bool} to event.getEventValue("boolean")
+        if {_bool} is true:
+            delay effect
+            
+expression [event(-| )]test:
+    return type: string
+#    usable in:
+#        custom event "skriptTest"
+    get:
+        return event.getEventValue("string")
+        
+condition %string% (1:is|2:is not|2:isn't) autorun:
+    # usable in:
+    #    custom event "skriptTest"
+    check:
+        set {_bool} to event.getEventValue("boolean")
+        if {_bool} is true:
+            parse mark is 1
+            continue
+        else:
+            parse mark is 2
+            continue
+            
+### this section is experimental.
+
+import:
+    ch.njol.skript.ScriptLoader
+    ch.njol.skript.log.SkriptLogger
+            
+condition parse:
+    parse:
+        set {_parser} to ParserInstance.get()
+        set {_parseSection} to {_parser}.getNode()
+        set {_parseBackup} to {_parser}.backup()
+        # nodes are not fully loaded here yet
+        continue
+    usable in:
+        custom event "skriptTest"
+    check:
+        {_parser}.restoreBackup({_parseBackup})
+        set {_logger} to SkriptLogger.startRetainingLog()
+        ScriptLoader.loadItems({_parseSection})
+        clear {-test.sk::latestLogs::*}
+        loop ...{_logger}.getLog():
+            add loop-value.getMessage() to {_logs::*}
+        set {-test.sk::latestLogs::*} to {_logs::*}
+        {_logger}.close()
+        {_parser}.reset()
+        
+local effect no errors\: <.+>:
+    trigger:
+        stop
+
+plural expression last parse logs:
+    usable in:
+        custom event "skriptTest"
+    get:
+        return {-test.sk::latestLogs::*}
+
+# ----
+
+plural expression test errors[ for [test[s]] %-strings%]:
+    return type: strings
+    get:
+        if expr-1 is not set:
+            set {_test} to event.getEventValue("string")
+            return {-test.sk::errors::%{_test}%::*}
+        else:
+            loop ...expr-1:
+                set {_test} to loop-value
+                add {-test.sk::errors::%{_test}%::*} to {_r::*}
+            return {_r::*}
+
+expression [the] test(-| )world:
+    return type: world
+    get:
+        return Bukkit.getWorlds().get(0)
+
+expression [the] test(-| )location:
+    return type: location
+    get:
+        return test-world.getSpawnLocation().add(10, 1, 0)
+
+expression [the] test(-| )block:
+    return type: block
+    get:
+        return test-location.getBlock()
+    set:
+        set block at test-location to change value
+        
+expression [the] test(-| )offline[-| ]player:
+    return type: offlineplayer
+    get:
+        set {_instance} to new TestOfflinePlayer()
+        # TestOfflinePlayer.[TestOfflinePlayer]PLAYER_PROFILE.setProperty(new ProfileProperty("textures", "ewogICJ0aW1lc3RhbXAiIDogMTc0NzQyOTg2MTQwOCwKICAicHJvZmlsZUlkIiA6ICI2OWUzNzAyNjJjN2Q0MjU1YWM3NjliMTNhNWZlOGY3NCIsCiAgInByb2ZpbGVOYW1lIiA6ICJTYWh2ZGUiLAogICJzaWduYXR1cmVSZXF1aXJlZCIgOiB0cnVlLAogICJ0ZXh0dXJlcyIgOiB7CiAgICAiU0tJTiIgOiB7CiAgICAgICJ1cmwiIDogImh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNTE2MGFiZWVhNDI1YzZmODMyYjc0NmE0NTQ0YzVmYjlhOTgxYjAyZTFiZDg1ZmVhNWM3ZWY4MzFiZGM4NzRmMyIKICAgIH0KICB9Cn0="));
+        return {_instance}
+
+test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert true passes":
+    assert true: {_none} is not set
+
+test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 assert false passes":
+    assert false: {_none} is set
+    
+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":
+    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":
+    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":
+    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":
+    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":
+    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":
+    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":
+    fail test with no error message
+    broadcast "<red>ERROR: fail test did not halt"
+
+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:
+    fail test
+    
+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":
+    stop auto test execution here
+    broadcast "<red>ERROR: auto execution not stopped"
+
+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"
+
+test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests scoped by script":
+    set {_all::*} to all tests within current script
+    assert true: size of {_all::*} > 0
+
+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":
+    assert true: size of test errors is 0
+
+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":
+    test block is chest:
+        set test-block to trapped chest
+    else if test block is trapped chest:
+        set test-block to chest
+    else:
+        set test-block to ender chest
+        
+    # test is continued at on load end
+    
+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/worldproperties.sk b/scripts/utils/worldproperties.sk
similarity index 100%
rename from worldproperties.sk
rename to scripts/utils/worldproperties.sk
diff --git a/test/functionsv2.sk b/test/functionsv2.sk
deleted file mode 100644
index 4876c26..0000000
--- a/test/functionsv2.sk
+++ /dev/null
@@ -1,109 +0,0 @@
-import:
-    java.util.HashMap
-
-test "supplier and getter":
-    set {_n} to (lambda:+ 1).get()
-    assert true with error message "supplier fail": {_n} is 1
-    assert true with error message "getter fail": (getter: "ok").get() is "ok"
-    assert true with error message "supplier basic failed": (supplier: "test").get() is "test"
-    assert true with error message "supplier expression failed": (supplier: 2 + 3).get() is 5
-
-
-test "runnable":
-
-    clear {-functions::test::*}
-    (lambda:- set {-functions::test::temp} to 1).run()
-    assert true with error message "runnable fail": {-functions::test::temp} is 1
-
-    (lambda:- set {-functions::test::ran} to true).run()
-    assert true with error message "runnable side-effect failed": {-functions::test::ran} is true
-
-
-test "consumer and accepter":
-
-    clear {-functions::test::*}
-    (consumer {_x}: set {-functions::test::c} to {_x}).accept(5)
-    assert true with error message "consumer fail": {-functions::test::c} is 5
-
-    (accepter {_x}: set {-functions::test::a} to {_x}).accept("ok")
-    assert true with error message "accepter fail": {-functions::test::a} is "ok"
-
-
-test "function and applier":
-
-    assert true with error message "function fail": (function {_x}: {_x} * 2).apply(3) is 6
-    assert true with error message "applier fail": (applier {_x}: "%{_x}%!").apply("hi") is "hi!"
-    assert true with error message "function basic failed": (function {_x}: {_x} * 5).apply(5) is 25
-    assert true with error message "function string failed": (function {_x}: "%{_x}%_ok").apply("abc") is "abc_ok"
-    assert true with error message "mixed usage failed": (function {_x}: {_x} + 1).apply(9) is 10
-
-
-test "biconsumer and biaccepter":
-
-    clear {-functions::test::*}
-    (biconsumer {_a}, {_b}: set {-functions::test::bc} to "%{_a}%,%{_b}%").accept(1, 2)
-    assert true with error message "biconsumer fail": {-functions::test::bc} is "1,2"
-
-    (biaccepter {_a}, {_b}: set {-functions::test::ba} to "%{_a}%-%{_b}%").accept("x", "y")
-    assert true with error message "biaccepter fail": {-functions::test::ba} is "x-y"
-
-
-test "bifunction and biapplier":
-
-    assert true with error message "bifunction fail": (bifunction {_a}, {_b}: {_a} + {_b}).apply(2, 3) is 5
-    assert true with error message "biapplier fail": (biapplier {_a}, {_b}: "%{_a}%:%{_b}%").apply("a", "b") is "a:b"
-    assert true with error message "bifunction failed": (bifunction {_a}, {_b}: {_a} + {_b}).apply(3, 4) is 7
-
-
-test "consumer repeated invocation":
-
-    clear {-functions::test::*}
-    set {-functions::test::sum} to 0
-    set {_adder} to (consumer {_x}: add {_x} to {-functions::test::sum})
-    {_adder}.accept(1)
-    {_adder}.accept(2)
-    {_adder}.accept(3)
-    assert true with error message "consumer repeat failed": {-functions::test::sum} is 6
-
-
-test "biconsumer variable list":
-
-    clear {-functions::test::*}
-    (biconsumer {_a}, {_b}: set {-functions::test::pair::*} to {_a} and {_b}).accept("x", "y")
-    assert true with error message "biconsumer failed": {-functions::test::pair::1} is "x"
-    assert true with error message "biconsumer failed": {-functions::test::pair::2} is "y"
-
-
-test "java stream variable list":
-
-    clear {-functions::test::*}
-    set {-functions::test::varl} to 0
-    set {_map} to new HashMap()
-    {_map}.put(1, 1)
-    {_map}.put(2, 3)
-    {_map}.put(3, 2)
-    (lambda {_arg}:- {_arg}.values().stream().forEach(lambda {_x}:- add {_x} to {-functions::test::varl})).accept({_map})
-    assert true with error message "varlist failed": {-functions::test::varl} is 6
-
-
-test "array handling":
-    assert true with error message "array failed": (lambda {_varl}:+ sum(...{_varl})).apply([1, 2, 3]) is 6
-
-
-test "real variable list rejection":
-
-    set {_test::*} to 1, 2 and 3
-    assert false with error message "unexpected: real variable list succeeded": (function {_varl::*}: sum({_varl::*})).apply(raw expression of {_test::*}) is 6
-
-
-test "run lambda helpers":
-    set {_sup} to lambda:+ "yes"
-    assert true with error message "run supplier fail": (run lambda {_sup}) is "yes"
-    assert true with error message "run function fail": (run lambda (lambda {_x}:+ {_x}) with "test") is "test"
-    
-test "java call":
-    set {_lam} to lambda:+ new HashMap()
-    set {_val} to {_lam}.get()
-    assert true with error message: {_val}.getClass().getSimpleName().equalsIgnoreCase("hashmap") is true
-    
-
diff --git a/test/main.sk b/test/main.sk
deleted file mode 100644
index fb09c10..0000000
--- a/test/main.sk
+++ /dev/null
@@ -1,3 +0,0 @@
-on load:
-    TEST functionsv2
-    TEST routines
diff --git a/test/routines.sk b/test/routines.sk
deleted file mode 100644
index d38c5e8..0000000
--- a/test/routines.sk
+++ /dev/null
@@ -1,23 +0,0 @@
-effect TEST routines:
-    trigger:
-        test()
-
-import:
-    java.net.URL
-    
-local function test():
-    java_call() # this is not failing thanks to new API
-    function_call()
-    
-function routine_local_get_url() :: object: # has to be not local
-    return new URL("https://www.dummy1.com")
-    
-local function java_call():
-    set {_res} to routine.fluent(instant now).context(async context).supply(lambda:+ new URL("https://www.dummy2.com")).join()
-    if "%{_res}%" is not "https://www.dummy2.com":
-        broadcast "<red>failing routine test unsafe_java_call"
-    
-local function function_call():
-    set {_res} to wait for fluent routine lambda: routine_local_get_url()
-    if "%{_res}%" is not "https://www.dummy1.com":
-        broadcast "<red>failing routine test function_call"
diff --git a/testframework.sk b/testframework.sk
deleted file mode 100644
index aedfbdf..0000000
--- a/testframework.sk
+++ /dev/null
@@ -1,130 +0,0 @@
-local effect testFail %string%[, %-string%]:
-    trigger:
-        set {_msg} to " %expr-2%" if expr-2 is set else ""
-        send "[<gold>Skript<reset>] [&cTEST FAILURE<reset>] %expr-1%%{_msg}%" to console
-
-event "skriptTest":
-    pattern: test %string%
-    event-values: string, boolean
-    check:
-        set {-test.sk::tests::%current script%::%expr-1%} to "%expr-1%"
-        if "%current script%/%expr-1%" is event-string:
-            continue
-            
-on load:
-    delete {-test.sk::*}
-
-expression all tests [with test name %-string%] [([with]in|from) %-script%]:
-    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::*}
-
-        return {_r::*}
-        
-effect (1:|2:auto)run [test][s] %strings%:
-    trigger:
-        set {_tests::*} to expr-1
-        set {_alltests::*} to all tests
-        loop {_tests::*}:
-            delete {-test.sk::errors::%loop-value%} 
-            set {_list::string} to loop-value
-            set {_list::boolean} to true if parse mark is 2 else false
-            call custom event "skriptTest" with {_list::*}
-            if any:
-                loop-value contains "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
-                {_alltests::*} does not contain loop-value
-            then:
-                add 1 to {_forgottenTestResults}
-                continue loop
-            add 1 to {_testFails} if {-test.sk::errors::%loop-value%} is greater than 0
-        set {_validTestAmount} to size of {_tests::*} - {_forgottenTestResults}
-        if {_validTestAmount} is not 0:
-            send "[<gold>Skript<reset>] <yellow>%{_validTestAmount} - {_testFails}%/%{_validTestAmount}% tests passed." to console
-        else if size of {_alltests::*} is greater than 0: # skipping if there is no initial hidden test 
-            send "[<gold>Skript<reset>] <yellow>No tests found." to console
-
-on load:
-    wait 1 tick
-    run test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
-    wait 1 tick
-    set {_tests::*} to all tests
-    autorun {_tests::*}
-
-import:
-    ch.njol.skript.lang.Condition
-
-effect (3:|4:(no|without) (halt[ing]|fail[(-| )]safe|abort[ing])) assert(1:|1: true|2: false)[ with (6:|5:no )[[error] message][ %-string%]]\: <(.+)>:
-    usable in:
-        custom event "skriptTest"
-    trigger:
-        set {_raw} to first element of regex-1
-        set {_cond} to Condition.parse({_raw}, "Can't understand condition: " + {_raw})
-        set {_ok} to {_cond}.check(event)
-        set {_label} to "assert true" if parse tags contains "1" else "assert false"
-        set {_test} to event.getEventValue("string")
-        if all:
-            parse tags contains "1"
-            {_ok} is false
-        then:
-            set {_bool1} to true
-            
-        if all:
-            parse tags contains "2"
-            {_ok} is true
-        then:
-            set {_bool2} to true
-            
-        if any:
-            {_bool1} is true
-            {_bool2} is true
-        then:
-            if parse tags contains "6":
-                testFail "Test ""%{_test}%"" with condition ""%{_label}%: %{_raw}%"" failed", expr-1
-            add 1 to {-test.sk::errors::%{_test}%}
-            if parse tags contains "3":
-                delay effect
-
-effect (3:|4:(no|without) (halt[ing]|fail[(-| )]safe|abort[ing])) fail test[ with (6:|5:no )[[error] message][ %-string%]]:
-    usable in: 
-        custom event "skriptTest"
-    trigger:
-        set {_test} to event.getEventValue("string")
-        if parse tags contains "6":
-            testFail "Test ""%{_test}%"" failed", expr-1
-        add 1 to {-test.sk::errors::%{_test}%}
-        if parse tags contains "3":
-            delay effect
-        
-effect stop auto [test] execution [here]:
-    usable in:
-        custom event "skriptTest"
-    trigger:
-        set {_bool} to event.getEventValue("boolean")
-        if {_bool} is true:
-            delay effect
-        
-test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 hidden test":
-    set {_test} to event-string # contains folder so we are fine
-    without halting assert true with no error message: {_none} is set 
-    without halting assert true with no error message: {_none} is set 
-    without halting assert true with no error message: {-test.sk::errors::%{_test}%} is 2
-    broadcast "<red>Something very wrong occurred with test framework(error no 1)" if {-test.sk::errors::%{_test}%} is 3
-    assert true with no error message: {_none} is set 
-    broadcast "<red>Something very wrong occurred with test framework(error no 2)"
diff --git a/tests/functionsv2.sk b/tests/functionsv2.sk
new file mode 100644
index 0000000..1b9e458
--- /dev/null
+++ b/tests/functionsv2.sk
@@ -0,0 +1,107 @@
+import:
+    java.util.HashMap
+
+test "supplier and getter":
+    set {_n} to (lambda:+ 1).get()
+    assert {_n} is 1 with "supplier fail"
+    assert (getter: "ok").get() is "ok" with "getter fail"
+    assert (supplier: "test").get() is "test" with "supplier basic failed"
+    assert (supplier: 2 + 3).get() is 5 with "supplier expression failed"
+
+
+test "runnable":
+
+    clear {-functions::test::*}
+    (lambda:- set {-functions::test::temp} to 1).run()
+    assert {-functions::test::temp} is 1 with "runnable fail"
+
+    (lambda:- set {-functions::test::ran} to true).run()
+    assert {-functions::test::ran} is true with "runnable side-effect failed"
+
+
+test "consumer and accepter":
+
+    clear {-functions::test::*}
+    (consumer {_x}: set {-functions::test::c} to {_x}).accept(5)
+    assert {-functions::test::c} is 5 with "consumer fail"
+
+    (accepter {_x}: set {-functions::test::a} to {_x}).accept("ok")
+    assert {-functions::test::a} is "ok" with "accepter fail"
+
+
+test "function and applier":
+
+    assert (function {_x}: {_x} * 2).apply(3) is 6 with "function fail"
+    assert (applier {_x}: "%{_x}%!").apply("hi") is "hi!" with "applier fail"
+    assert (function {_x}: {_x} * 5).apply(5) is 25 with "function basic failed"
+    assert (function {_x}: "%{_x}%_ok").apply("abc") is "abc_ok" with "function string failed"
+    assert (function {_x}: {_x} + 1).apply(9) is 10 with "mixed usage failed"
+
+
+test "biconsumer and biaccepter":
+
+    clear {-functions::test::*}
+    (biconsumer {_a}, {_b}: set {-functions::test::bc} to "%{_a}%,%{_b}%").accept(1, 2)
+    assert {-functions::test::bc} is "1,2" with "biconsumer fail"
+
+    (biaccepter {_a}, {_b}: set {-functions::test::ba} to "%{_a}%-%{_b}%").accept("x", "y")
+    assert {-functions::test::ba} is "x-y" with "biaccepter fail"
+
+
+test "bifunction and biapplier":
+
+    assert (bifunction {_a}, {_b}: {_a} + {_b}).apply(2, 3) is 5 with "bifunction fail"
+    assert (biapplier {_a}, {_b}: "%{_a}%:%{_b}%").apply("a", "b") is "a:b" with "biapplier fail"
+    assert (bifunction {_a}, {_b}: {_a} + {_b}).apply(3, 4) is 7 with "bifunction failed"
+
+
+test "consumer repeated invocation":
+
+    clear {-functions::test::*}
+    set {-functions::test::sum} to 0
+    set {_adder} to (consumer {_x}: add {_x} to {-functions::test::sum})
+    {_adder}.accept(1)
+    {_adder}.accept(2)
+    {_adder}.accept(3)
+    assert {-functions::test::sum} is 6 with "consumer repeat failed"
+
+
+test "biconsumer variable list":
+
+    clear {-functions::test::*}
+    (biconsumer {_a}, {_b}: set {-functions::test::pair::*} to {_a} and {_b}).accept("x", "y")
+    assert {-functions::test::pair::1} is "x" with "biconsumer failed"
+    assert {-functions::test::pair::2} is "y" with "biconsumer failed"
+
+
+test "java stream variable list":
+
+    clear {-functions::test::*}
+    set {-functions::test::varl} to 0
+    set {_map} to new HashMap()
+    {_map}.put(1, 1)
+    {_map}.put(2, 3)
+    {_map}.put(3, 2)
+    (lambda {_arg}:- {_arg}.values().stream().forEach(lambda {_x}:- add {_x} to {-functions::test::varl})).accept({_map})
+    assert {-functions::test::varl} is 6 with "varlist failed"
+
+
+test "array handling":
+    assert (lambda {_varl}:+ sum(...{_varl})).apply([1, 2, 3]) is 6 with "array failed"
+
+
+test "real variable list rejection":
+
+    set {_test::*} to 1, 2 and 3
+    assert (function {_varl::*}: sum({_varl::*})).apply(raw expression of {_test::*}) is 6 to fail with "unexpected: real variable list succeeded"
+
+
+test "run lambda helpers":
+    set {_sup} to lambda:+ "yes"
+    assert (run lambda {_sup}) is "yes" with "run supplier fail"
+    assert (run lambda (lambda {_x}:+ {_x}) with "test") is "test" with "run function fail"
+    
+test "java call":
+    set {_lam} to lambda:+ new HashMap()
+    set {_val} to {_lam}.get()
+    assert {_val}.getClass().getSimpleName().equalsIgnoreCase("hashmap") is true with "java call failed"
diff --git a/tests/routines.sk b/tests/routines.sk
new file mode 100644
index 0000000..7daff81
--- /dev/null
+++ b/tests/routines.sk
@@ -0,0 +1,13 @@
+import:
+    java.net.URL
+
+test "routines basic":
+    set {_res} to routine.fluent(instant now).context(async context).supply(lambda:+ new URL("https://www.dummy2.com")).join()
+    assert "%{_res}%" is "https://www.dummy2.com" with "java call"
+
+    set {_res} to wait for fluent routine lambda: routine_local_get_url()
+    assert "%{_res}%" is "https://www.dummy1.com" with "function call"
+
+    
+function routine_local_get_url() :: object: # has to be not local
+    return new URL("https://www.dummy1.com")
diff --git a/test/singlinesection.sk b/tests/singlinesection.sk
similarity index 70%
rename from test/singlinesection.sk
rename to tests/singlinesection.sk
index c1f050e..5adefd0 100644
--- a/test/singlinesection.sk
+++ b/tests/singlinesection.sk
@@ -5,23 +5,23 @@ test "new single line section expression":
     set {_test} to "test"
     set {_section} to single line section "return true if ""%%{_x}%% %{_test}%"" is ""what test"" else false" with args {_x}
     run section {_section} with "what" and store result in {_n}
-    assert false with error message "single line section bug": {_n} is false
+    assert {_n} is true with "single line section bug"
     
     set {_section} to single line section "set {_return} to 1" with args {_x}
     run section {_section} with "what" and store result in {_n}
-    assert false with error message "single line section bug 2": {_return} is 1
+    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}
     run section {_section} with 15, 10 and store result in {_n}
-    assert true with error message "single line section bug 3": {_n} is 25
+    assert {_n} is 25 with "single line section bug 3"
     
     set {_a} to 1
     set {_section} to single line section "return {_a}"
     run section {_section} and store result in {_n}
-    assert true with error message "single line section bug 4": {_n} is 1
+    assert {_n} is 1 with "single line section bug 4"
     
     set {_section} to single line section "return new ArrayList()"
     run section {_section} and store result in {_n}
-    assert true with error message "single line section bug 5": "%{_n}%" is "[]"
+    assert "%{_n}%" is "[]" with "single line section bug 5"