Framework/Scripting/ScriptingSelfTest.cs

Self-test harness for the Lua gamemode/realm layer. Builds an in-memory filesystem of fake gamemodes, addons and manifests, then checks discovery, version constraints, dependency ordering, realm file filtering, include sandboxing, hooks, timers, serialization and content-manifest hashing. Exposes `rp_selftest` as a ConCmd that logs a pass/fail report.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RoleplayFramework.Lua;

namespace RoleplayFramework.Scripting;

/// <summary>
/// Tests for the gamemode/realm layer, run against an in-memory filesystem so nothing on disk is touched.
/// <c>rp_selftest</c> runs these plus the Lua runtime tests.
/// </summary>
public static class ScriptingSelfTest
{
	public sealed record Result( string Name, bool Passed, string Detail );

	const string GoodManifest = """
		{ "id": "good", "title": "Good", "version": "1.0.0", "apiVersion": 1,
		  "entry": { "shared": "gamemode/sh_init.lua", "server": "gamemode/sv_init.lua", "client": "gamemode/cl_init.lua" } }
		""";

	static BaseFileSystem MakeFs()
	{
		var fs = FileSystem.CreateMemoryFileSystem();
		fs.CreateDirectory( "lua/framework" );
		fs.WriteAllText( "lua/framework/sh_core.lua", FileSystem.Mounted.ReadAllText( "lua/framework/sh_core.lua" ) );

		Gamemode( fs, "good", GoodManifest, new()
		{
			["gamemode/sh_init.lua"] = "SHARED_LOADED = true\ninclude('gamemode/sh_extra.lua')\nfunction GM:Greet(name) return 'GM hello ' .. name end",
			["gamemode/sh_extra.lua"] = "EXTRA_LOADED = REALM",
			["gamemode/sv_init.lua"] = "SERVER_ONLY_SECRET = 42",
			["gamemode/cl_init.lua"] = "CLIENT_LOADED = true",
			["gamemode/sv_private.lua"] = "-- private server code",
		} );

		Gamemode( fs, "badapi", GoodManifest.Replace( "\"good\"", "\"badapi\"" ).Replace( "\"apiVersion\": 1", "\"apiVersion\": 99" ), new() );
		Gamemode( fs, "nofields", "{ \"id\": \"nofields\" }", new() );
		Gamemode( fs, "badpath", GoodManifest.Replace( "\"good\"", "\"badpath\"" ).Replace( "gamemode/sv_init.lua", "../../escape/sv_x.lua" ), new() );
		Gamemode( fs, "wrongfolder", GoodManifest, new() );
		Gamemode( fs, "cyc_a", Dep( "cyc_a", "cyc_b" ), Files() );
		Gamemode( fs, "cyc_b", Dep( "cyc_b", "cyc_a" ), Files() );
		Gamemode( fs, "child", Dep( "child", "good" ), new()
		{
			["gamemode/sh_init.lua"] = "CHILD_SAW_GOOD = SHARED_LOADED == true",
			["gamemode/sv_init.lua"] = "",
			["gamemode/cl_init.lua"] = "",
		} );
		Gamemode( fs, "orphan", Dep( "orphan", "missing_gm" ), Files() );
		Gamemode( fs, "syntaxerr", GoodManifest.Replace( "\"good\"", "\"syntaxerr\"" ), new()
		{
			["gamemode/sh_init.lua"] = "local ok = true",
			["gamemode/sv_init.lua"] = "local x = 1\nlocal y = = 2",
			["gamemode/cl_init.lua"] = "",
		} );
		Gamemode( fs, "crossrealm", GoodManifest.Replace( "\"good\"", "\"crossrealm\"" ), new()
		{
			["gamemode/sh_init.lua"] = "",
			["gamemode/sv_init.lua"] = "include('gamemode/cl_hud.lua')",
			["gamemode/cl_init.lua"] = "include('gamemode/sv_secret.lua')",
			["gamemode/cl_hud.lua"] = "",
			["gamemode/sv_secret.lua"] = "",
		} );
		Gamemode( fs, "escape", GoodManifest.Replace( "\"good\"", "\"escape\"" ), new()
		{
			["gamemode/sh_init.lua"] = "include('../good/gamemode/sv_init.lua')",
			["gamemode/sv_init.lua"] = "",
			["gamemode/cl_init.lua"] = "",
		} );
		return fs;
	}

	static Dictionary<string, string> Files() => new()
	{
		["gamemode/sh_init.lua"] = "",
		["gamemode/sv_init.lua"] = "",
		["gamemode/cl_init.lua"] = "",
	};

	static string Dep( string id, string dep ) =>
		GoodManifest.Replace( "\"good\"", $"\"{id}\"" ).Replace( "\"apiVersion\": 1,", $"\"apiVersion\": 1, \"dependencies\": [\"{dep}\"]," );

	static void Gamemode( BaseFileSystem fs, string folder, string manifest, Dictionary<string, string> files )
	{
		var root = $"lua/gamemodes/{folder}";
		fs.CreateDirectory( root + "/gamemode" );
		fs.WriteAllText( root + "/gamemode.json", manifest );
		foreach ( var (path, text) in files ) fs.WriteAllText( $"{root}/{path}", text );
	}

	public static List<Result> RunAll()
	{
		var results = new List<Result>();
		void Check( string name, Func<(bool ok, string detail)> test )
		{
			try
			{
				var (ok, detail) = test();
				results.Add( new Result( name, ok, detail ) );
			}
			catch ( Exception e )
			{
				results.Add( new Result( name, false, $"{e.GetType().Name}: {e.Message}" ) );
			}
		}

		var fs = MakeFs();
		var reg = GamemodeRegistry.Discover( fs, makeCurrent: false );
		string Problems( string id ) => reg.Invalid.TryGetValue( id, out var p ) ? string.Join( "; ", p ) : "(accepted)";

		Check( "valid gamemode accepted", () => (reg.Valid.ContainsKey( "good" ), string.Join( ",", reg.Valid.Keys )) );
		Check( "incompatible apiVersion rejected", () => (Problems( "badapi" ).Contains( "'apiVersion' 99 is not supported" ), Problems( "badapi" )) );
		Check( "missing fields rejected", () => (Problems( "nofields" ).Contains( "missing 'title'" ) && Problems( "nofields" ).Contains( "missing 'entry'" ), Problems( "nofields" )) );
		Check( "path traversal in entry rejected", () => (Problems( "badpath" ).Contains( "'..' is not allowed" ), Problems( "badpath" )) );
		Check( "id must match folder", () => (Problems( "wrongfolder" ).Contains( "must match its folder name" ), Problems( "wrongfolder" )) );
		Check( "dependency cycle rejected", () => (Problems( "cyc_a" ).Contains( "cycle" ) && Problems( "cyc_b" ).Contains( "cycle" ), Problems( "cyc_a" )) );
		Check( "missing dependency rejected", () => (Problems( "orphan" ).Contains( "missing_gm" ), Problems( "orphan" )) );
		Check( "dependency load order", () =>
		{
			var order = string.Join( ",", reg.LoadOrder( "child" ).Select( m => m.Id ) );
			return (order == "good,child", order);
		} );

		Check( "server realm loads shared + server files", () =>
		{
			var r = new LuaRealm( LuaRealmKind.Server, fs );
			r.LoadFrameworkFiles();
			r.LoadGamemode( reg, "good" );
			var g = r.State.Globals;
			bool ok = g.Get( "SHARED_LOADED" ).IsTruthy && g.Get( "EXTRA_LOADED" ).AsString == "server"
				&& g.Get( "SERVER_ONLY_SECRET" ).Number == 42 && g.Get( "CLIENT_LOADED" ).IsNil;
			return (ok, string.Join( ", ", r.LoadedFiles ));
		} );

		Check( "client realm never runs server files", () =>
		{
			var r = new LuaRealm( LuaRealmKind.Client, fs );
			r.LoadFrameworkFiles();
			r.LoadGamemode( reg, "good" );
			var g = r.State.Globals;
			bool ok = g.Get( "CLIENT_LOADED" ).IsTruthy && g.Get( "SERVER_ONLY_SECRET" ).IsNil && g.Get( "EXTRA_LOADED" ).AsString == "client"
				&& !r.LoadedFiles.Any( f => f.Contains( "/sv_" ) );
			return (ok, string.Join( ", ", r.LoadedFiles ));
		} );

		Check( "dependencies load first", () =>
		{
			var r = new LuaRealm( LuaRealmKind.Server, fs );
			r.LoadFrameworkFiles();
			r.LoadGamemode( reg, "child" );
			return (r.State.Globals.Get( "CHILD_SAW_GOOD" ).IsTruthy, string.Join( ", ", r.LoadedFiles ));
		} );

		Check( "syntax error names file, line and realm", () =>
		{
			var errors = new List<ScriptError>();
			Action<ScriptError> h = e => errors.Add( e );
			LuaRealm.OnScriptError += h;
			try
			{
				var r = new LuaRealm( LuaRealmKind.Server, fs );
				r.LoadFrameworkFiles();
				try { r.LoadGamemode( reg, "syntaxerr" ); return (false, "no error"); }
				catch ( LuaSyntaxException e )
				{
					return (e.ChunkName == "gamemodes/syntaxerr/gamemode/sv_init.lua" && e.Line == 2 && r.Name == "server", e.Message);
				}
			}
			finally { LuaRealm.OnScriptError -= h; }
		} );

		Check( "server cannot include client files", () => ExpectLoadError( fs, reg, "crossrealm", LuaRealmKind.Server, "in the server realm" ) );
		Check( "client cannot include server files", () => ExpectLoadError( fs, reg, "crossrealm", LuaRealmKind.Client, "in the client realm" ) );
		Check( "include cannot escape the gamemode folder", () => ExpectLoadError( fs, reg, "escape", LuaRealmKind.Server, "'..' is not allowed" ) );
		Check( "unknown gamemode reports clearly", () => ExpectLoadError( fs, reg, "nope", LuaRealmKind.Server, "was not found" ) );
		Check( "invalid gamemode cannot be loaded", () => ExpectLoadError( fs, reg, "badapi", LuaRealmKind.Server, "is invalid" ) );

		Check( "hook.Run order, early return and GM fallback", () =>
		{
			var r = Loaded( fs, reg );
			var res = r.State.DoString( """
				local log = {}
				hook.Add("Test", "a", function(x) log[#log+1] = "a" .. x end)
				hook.Add("Test", "b", function(x) log[#log+1] = "b" .. x end)
				hook.Run("Test", 1)
				hook.Add("Stop", "first", function() return "stopped" end)
				hook.Add("Stop", "second", function() log[#log+1] = "should not run" end)
				local stop = hook.Run("Stop")
				local gm = hook.Run("Greet", "bob")
				hook.Remove("Test", "a")
				hook.Run("Test", 2)
				return table.concat(log, ","), stop, gm
				""", "hooktest" );
			var got = $"{res[0]}|{res[1]}|{res[2]}";
			return (got == "a1,b1,b2|stopped|GM hello bob", got);
		} );

		Check( "a failing hook does not stop the others", () =>
		{
			int before = LuaRealm.RecentErrors.Count;
			var r = Loaded( fs, reg );
			var res = r.State.DoString( """
				local ran = false
				hook.Add("Boom", "bad", function() error("kaboom") end)
				hook.Add("Boom", "good", function() ran = true end)
				hook.Run("Boom")
				return ran
				""", "hookerr" );
			var reported = LuaRealm.RecentErrors.Count > before && LuaRealm.RecentErrors[^1].Message.Contains( "kaboom" );
			return (res[0].IsTruthy && reported, LuaRealm.RecentErrors.LastOrDefault().Message);
		} );

		Check( "Color / Vector / helpers", () =>
		{
			var r = Loaded( fs, reg );
			var res = r.State.DoString( """
				local c = Color(300, 20.4, -5)
				local v = Vector(3, 4, 0) + Vector(0, 0, 12)
				return tostring(c) .. "|" .. v:Length() .. "|" .. tostring(IsValid(c)) .. tostring(IsValid(nil)) .. tostring(IsValid({}))
				  .. "|" .. table.concat(string.Explode(",", "a,b,,c"), ";") .. "|" .. math.Round(2.567, 2)
				""", "helpers" );
			var got = res[0].AsString;
			return (got == "Color(255, 20, 0, 255)|13|truefalsefalse|a;b;;c|2.57", got);
		} );

		Check( "timer.Simple / Create / Remove", () =>
		{
			var r = Loaded( fs, reg );
			r.State.DoString( """
				COUNT_SIMPLE, COUNT_REPEAT = 0, 0
				timer.Simple(0, function() COUNT_SIMPLE = COUNT_SIMPLE + 1 end)
				timer.Create("rep", 0.01, 3, function() COUNT_REPEAT = COUNT_REPEAT + 1 end)
				timer.Create("gone", 0.01, 0, function() error("should have been removed") end)
				timer.Remove("gone")
				""", "timers" );
			double t = Time.Now;
			for ( int i = 1; i <= 6; i++ ) r.Tick( t + i );
			var g = r.State.Globals;
			var got = $"{g.Get( "COUNT_SIMPLE" )}/{g.Get( "COUNT_REPEAT" )}/{r.TimerCount}";
			return (got == "1/3/0", got);
		} );

		Check( "net payload round trip", () =>
		{
			var L = new LuaState();
			var v = L.DoString( "return { name = 'x\"y', list = {1, 2.5, -3}, flag = true, nested = { deep = { ok = 'yes' } } }", "p" )[0];
			var text = LuaSerializer.Serialize( v );
			var back = LuaSerializer.Deserialize( text );
			var check = L.Call( L.Load( "local t = ...; return t.name .. '|' .. #t.list .. '|' .. t.list[2] .. '|' .. tostring(t.flag) .. '|' .. t.nested.deep.ok", "c" ), back )[0];
			return (check.AsString == "x\"y|3|2.5|true|yes", check.AsString + "  " + text);
		} );

		Check( "net payload rejects unsafe values", () =>
		{
			var L = new LuaState();
			string Try( string expr )
			{
				try { LuaSerializer.Serialize( L.DoString( "return " + expr, "p" )[0] ); return "accepted"; }
				catch ( LuaRuntimeException e ) { return e.Message; }
			}
			var fn = Try( "{ f = print }" );
			var mixed = Try( "{ 1, 2, x = 3 }" );
			var deep = Try( "{{{{{{{{{{}}}}}}}}}}" );
			var big = Try( "string.rep('a', 3000)" );
			bool ok = fn.Contains( "function" ) && mixed.Contains( "arrays or string-keyed" ) && deep.Contains( "deeper" ) && big.Contains( "longer than" );
			return (ok, $"{fn} / {mixed} / {deep} / {big}");
		} );

		Check( "net payload parser rejects hostile input", () =>
		{
			string Try( string text )
			{
				try { LuaSerializer.Deserialize( text ); return "accepted"; }
				catch ( FormatException e ) { return e.Message; }
			}
			var deep = Try( new string( '[', 50 ) + new string( ']', 50 ) );
			var big = Try( "\"" + new string( 'a', 9000 ) + "\"" );
			var junk = Try( "{\"a\":1} trailing" );
			var bad = Try( "{\"a\": nan}" );
			bool ok = deep.Contains( "deeper" ) && big.Contains( "too large" ) && junk.Contains( "trailing" ) && bad != "accepted";
			return (ok, $"{deep} / {big} / {junk} / {bad}");
		} );

		Check( "content manifest excludes server files", () =>
		{
			var files = LuaContent.Build( fs, reg, "good" );
			var paths = files.Select( f => f.Path ).ToList();
			bool ok = paths.Contains( "lua/gamemodes/good/gamemode/cl_init.lua" ) && paths.Contains( "lua/gamemodes/good/gamemode/sh_extra.lua" )
				&& paths.Contains( "lua/framework/sh_core.lua" ) && !paths.Any( p => p.Contains( "/sv_" ) );
			return (ok, string.Join( ", ", paths ));
		} );

		Check( "content verification detects changes and refuses server files", () =>
		{
			var files = LuaContent.Build( fs, reg, "good" );
			var okResult = LuaContent.Verify( fs, files );

			var tampered = files.Select( f => new ContentFile { Path = f.Path, Hash = f.Hash } ).ToList();
			tampered[0].Hash = new string( '0', 64 );
			var changed = LuaContent.Verify( fs, tampered );

			var sneaky = new List<ContentFile> { new() { Path = "lua/gamemodes/good/gamemode/sv_private.lua", Hash = new string( 'a', 64 ) } };
			var refused = LuaContent.Verify( fs, sneaky );

			var traversal = LuaContent.Verify( fs, new List<ContentFile> { new() { Path = "lua/../secret.lua", Hash = new string( 'a', 64 ) } } );

			bool ok = okResult is null && changed?.Contains( "differ" ) == true && refused?.Contains( "server-only" ) == true && traversal?.Contains( "not allowed" ) == true;
			return (ok, $"{okResult ?? "ok"} / {changed} / {refused} / {traversal}");
		} );

		AddAddonTests( fs, reg, Check );
		return results;
	}

	// ------------------------------------------------------------ addons

	static string AddonJson( string id, string extra = "" ) =>
		$"{{ \"id\": \"{id}\", \"title\": \"{id}\", \"version\": \"1.0.0\", \"apiVersion\": 1{extra} }}";

	static void Addon( BaseFileSystem fs, string folder, string manifest, Dictionary<string, string> files )
	{
		var root = $"lua/addons/{folder}";
		fs.CreateDirectory( root );
		fs.WriteAllText( root + "/addon.json", manifest );
		foreach ( var (path, text) in files )
		{
			var full = $"{root}/{path}";
			fs.CreateDirectory( full.Substring( 0, full.LastIndexOf( '/' ) ) );
			fs.WriteAllText( full, text );
		}
	}

	static void AddAddonTests( BaseFileSystem fs, GamemodeRegistry reg, Action<string, Func<(bool ok, string detail)>> Check )
	{
		Addon( fs, "a_lib", AddonJson( "a_lib" ).Replace( "1.0.0", "1.2.0" ), new() { ["sh_a.lua"] = "A_LOADED = true" } );
		Addon( fs, "b_user", AddonJson( "b_user", ", \"dependencies\": { \"a_lib\": \">=1.0.0 <2.0.0\" }" ), new()
		{
			["sh_b.lua"] = "B_SAW_A = A_LOADED == true",
			["sv_b.lua"] = "B_SERVER = true",
			["cl_b.lua"] = "B_CLIENT = true",
			["sv_zz_secret.lua"] = "-- server-only addon code",
		} );
		Addon( fs, "c_needs_v2", AddonJson( "c_needs_v2", ", \"dependencies\": { \"a_lib\": \"^2.0.0\" }" ), new() { ["sh_c.lua"] = "C_LOADED = true" } );
		Addon( fs, "d_othergm", AddonJson( "d_othergm", ", \"gamemodes\": [ \"othergm\" ]" ), new() { ["sh_d.lua"] = "D_LOADED = true" } );
		Addon( fs, "e_off", AddonJson( "e_off" ), new() { ["sh_e.lua"] = "E_LOADED = true", ["cl_e.lua"] = "" } );
		Addon( fs, "f_needs_off", AddonJson( "f_needs_off", ", \"dependencies\": { \"e_off\": \"*\" }" ), new() { ["sh_f.lua"] = "" } );
		Addon( fs, "g_cyc1", AddonJson( "g_cyc1", ", \"dependencies\": { \"g_cyc2\": \"\" }" ), new() );
		Addon( fs, "g_cyc2", AddonJson( "g_cyc2", ", \"dependencies\": { \"g_cyc1\": \"\" }" ), new() );
		Addon( fs, "h_badjson", "{ not json", new() );
		Addon( fs, "h_badfields", "{ \"id\": \"h_badfields\", \"version\": \"one\", \"apiVersion\": 1, \"dependencies\": { \"a_lib\": \"about 1\" } }", new() );
		Addon( fs, "i_broken", AddonJson( "i_broken" ), new() { ["sh_i.lua"] = "I_STARTED = true\nerror('boom')" } );
		Addon( fs, "j_after_broken", AddonJson( "j_after_broken", ", \"dependencies\": { \"i_broken\": \"\" }" ), new() { ["sh_j.lua"] = "J_LOADED = true" } );
		Addon( fs, "z_good", AddonJson( "z_good", ", \"gamemodes\": [ \"good\" ], \"entry\": { \"shared\": \"lua/sh_main.lua\" }" ), new()
		{
			["lua/sh_main.lua"] = "include('lua/sh_part.lua')\nfunction GM:Greet(name) return 'addon ' .. name end\nZ_FILES = #(file.Find('lua/*.lua'))",
			["lua/sh_part.lua"] = "Z_PART = true",
			["sh_ignored.lua"] = "Z_IGNORED = true", // entry given: other files only load through include
		} );
		Addon( fs, "_template", AddonJson( "_template" ), new() { ["sh_t.lua"] = "" } );

		var chain = reg.LoadOrder( "child" ).Select( m => m.Id ).ToList(); // good, child
		var addons = AddonRegistry.Resolve( fs, chain, new[] { "e_off" } );
		string Status( string id ) => addons.All.TryGetValue( id, out var e ) ? $"{e.Status}: {e.Reason}" : "(missing)";

		Check( "version constraints", () =>
		{
			bool ok = VersionConstraint.Satisfies( "1.2.0", ">=1.0.0 <2.0.0" ) && !VersionConstraint.Satisfies( "2.0.0", ">=1.0.0 <2.0.0" )
				&& VersionConstraint.Satisfies( "1.9.3", "^1.2.0" ) && !VersionConstraint.Satisfies( "1.1.0", "^1.2.0" )
				&& VersionConstraint.Satisfies( "1.2.9", "~1.2.0" ) && !VersionConstraint.Satisfies( "1.3.0", "~1.2.0" )
				&& VersionConstraint.Satisfies( "1.0.0", "1.0.0" ) && !VersionConstraint.Satisfies( "1.0.1", "=1.0.0" )
				&& VersionConstraint.Satisfies( "0.1.0", "*" ) && VersionConstraint.Satisfies( "0.1.0", "" )
				&& VersionConstraint.Check( "about 1" ) is not null && VersionConstraint.Check( ">=1.0.0 <2.0.0" ) is null;
			return (ok, "");
		} );

		Check( "addon statuses: active, disabled, incompatible, blocked, invalid", () =>
		{
			bool ok = Status( "a_lib" ).StartsWith( "Active" ) && Status( "b_user" ).StartsWith( "Active" ) && Status( "z_good" ).StartsWith( "Active" )
				&& Status( "c_needs_v2" ).Contains( "needs 'a_lib' ^2.0.0, but 1.2.0" )
				&& Status( "d_othergm" ).StartsWith( "Incompatible" )
				&& Status( "e_off" ).StartsWith( "Disabled" )
				&& Status( "f_needs_off" ).Contains( "which is disabled" )
				&& Status( "g_cyc1" ).Contains( "cycle" ) && Status( "g_cyc2" ).Contains( "cycle" )
				&& Status( "h_badjson" ).Contains( "not valid JSON" )
				&& Status( "h_badfields" ).Contains( "missing 'title'" ) && Status( "h_badfields" ).Contains( "not semver" ) && Status( "h_badfields" ).Contains( "not a version constraint" )
				&& !addons.All.ContainsKey( "_template" );
			return (ok, string.Join( " | ", addons.All.Select( kv => $"{kv.Key}={kv.Value.Status}" ) ));
		} );

		Check( "addon load order: dependencies first, then alphabetical", () =>
		{
			var order = string.Join( ",", addons.LoadOrder.Select( m => m.Id ) );
			return (order == "a_lib,b_user,i_broken,j_after_broken,z_good", order);
		} );

		Check( "addons load after the gamemode; a broken addon is skipped, not fatal", () =>
		{
			var errors = new List<ScriptError>();
			Action<ScriptError> h = e => errors.Add( e );
			LuaRealm.OnScriptError += h;
			try
			{
				var r = new LuaRealm( LuaRealmKind.Server, fs );
				LuaAddons.Register( r );
				r.LoadFrameworkFiles();
				r.LoadGamemode( reg, "child" );
				r.LoadAddons( addons.LoadOrder );
				var g = r.State.Globals;
				var greet = r.Call( r.GM.Get( "Greet" ), r.GM, "x" )?[0].AsString;
				var isLoaded = r.Call( ((LuaTable)g.Get( "addons" ).AsTable).Get( "IsLoaded" ), "b_user" )?[0].IsTruthy;
				var brokenLoaded = r.Call( ((LuaTable)g.Get( "addons" ).AsTable).Get( "IsLoaded" ), "i_broken" )?[0].IsTruthy;
				bool ok = g.Get( "B_SAW_A" ).IsTruthy && g.Get( "B_SERVER" ).IsTruthy && g.Get( "B_CLIENT" ).IsNil
					&& g.Get( "I_STARTED" ).IsTruthy && g.Get( "J_LOADED" ).IsNil && g.Get( "Z_PART" ).IsTruthy && g.Get( "Z_IGNORED" ).IsNil
					&& g.Get( "Z_FILES" ).Number == 2 && g.Get( "E_LOADED" ).IsNil && greet == "addon x" && isLoaded == true && brokenLoaded == false
					&& errors.Any( e => e.Message.Contains( "Addon 'i_broken' failed to load" ) && e.Message.Contains( "boom" ) && e.Gamemode == "child+i_broken" )
					&& errors.Any( e => e.Message.Contains( "'j_after_broken' skipped" ) );
				return (ok, $"greet={greet}, errors: {string.Join( " / ", errors.Select( e => $"[{e.Gamemode}] {e.Message}" ) )}");
			}
			finally { LuaRealm.OnScriptError -= h; }
		} );

		Check( "client realm runs addon sh_/cl_ files only", () =>
		{
			var r = new LuaRealm( LuaRealmKind.Client, fs );
			r.LoadFrameworkFiles();
			r.LoadGamemode( reg, "child" );
			r.LoadAddons( addons.LoadOrder.Where( m => m.Id is "a_lib" or "b_user" ) );
			var g = r.State.Globals;
			bool ok = g.Get( "B_CLIENT" ).IsTruthy && g.Get( "B_SERVER" ).IsNil && !r.LoadedFiles.Any( f => f.Contains( "/sv_" ) );
			return (ok, string.Join( ", ", r.LoadedFiles ));
		} );

		Check( "content manifest carries active addons only, never sv_ files", () =>
		{
			var files = LuaContent.Build( fs, reg, "child", null, addons.LoadOrder );
			var paths = files.Select( f => f.Path ).ToList();
			bool ok = paths.Contains( "lua/addons/b_user/addon.json" ) && paths.Contains( "lua/addons/b_user/cl_b.lua" ) && paths.Contains( "lua/addons/z_good/lua/sh_part.lua" )
				&& !paths.Any( p => p.Contains( "/sv_" ) ) && !paths.Any( p => p.Contains( "e_off" ) || p.Contains( "d_othergm" ) || p.Contains( "c_needs_v2" ) )
				&& LuaContent.Verify( fs, files ) is null;

			// A client given exactly that set resolves the same addons, in the same order, without any local config.
			var clientFs = FileSystem.CreateMemoryFileSystem();
			foreach ( var f in paths )
			{
				clientFs.CreateDirectory( f.Substring( 0, f.LastIndexOf( '/' ) ) );
				clientFs.WriteAllText( f, fs.ReadAllText( f ) );
			}
			var clientReg = GamemodeRegistry.Discover( clientFs, makeCurrent: false );
			var clientAddons = AddonRegistry.Resolve( clientFs, clientReg.LoadOrder( "child" )?.Select( m => m.Id ).ToList(), null );
			var same = string.Join( ",", clientAddons.LoadOrder.Select( m => m.Id ) ) == string.Join( ",", addons.LoadOrder.Select( m => m.Id ) );
			return (ok && same, $"client order {string.Join( ",", clientAddons.LoadOrder.Select( m => m.Id ) )}");
		} );
	}

	static LuaRealm Loaded( BaseFileSystem fs, GamemodeRegistry reg )
	{
		var r = new LuaRealm( LuaRealmKind.Server, fs );
		r.LoadFrameworkFiles();
		r.LoadGamemode( reg, "good" );
		return r;
	}

	static (bool, string) ExpectLoadError( BaseFileSystem fs, GamemodeRegistry reg, string id, LuaRealmKind kind, string expected )
	{
		var r = new LuaRealm( kind, fs );
		r.LoadFrameworkFiles();
		try
		{
			r.LoadGamemode( reg, id );
			return (false, "loaded without error");
		}
		catch ( LuaException e )
		{
			return (e.Message.Contains( expected ), e.Message);
		}
	}

	/// <summary>Runs these tests and the Lua runtime tests; returns a printable report.</summary>
	public static string Report()
	{
		var start = DateTime.UtcNow;
		var lua = Lua.Diagnostics.LuaSelfTest.RunAll();
		var scripting = RunAll();
		var failed = scripting.Where( r => !r.Passed ).ToList();

		var sb = new StringBuilder();
		sb.AppendLine( lua.Report );
		sb.Append( $"Scripting layer: {scripting.Count - failed.Count}/{scripting.Count} passed" );
		foreach ( var f in failed ) sb.Append( $"\n  FAIL {f.Name}: {f.Detail}" );
		sb.Append( $"\nTotal time {(DateTime.UtcNow - start).TotalMilliseconds:F0} ms" );
		return sb.ToString();
	}

	[ConCmd( "rp_selftest", Help = "Run the Lua runtime and scripting-layer self-tests" )]
	public static void Command()
	{
		foreach ( var line in Report().Split( '\n' ) ) Diagnostics.RpLog.Info( "selftest", line );
	}
}