chore: add named snapshot support

Danielku15 · Danielku15 · commit 2cdb2a97dc2c · 2025-10-15T12:19:21.000+09:00
diff --git a/packages/alphatab/test/PrettyFormat.ts b/packages/alphatab/test/PrettyFormat.ts
@@ -210,7 +210,48 @@ export class PrettyFormat {
                 : `Map {${PrettyFormat.printIteratorEntries(TestPlatform.mapAsUnknownIterable(val), config, indentation, depth, refs, PrettyFormat.printer, ' => ')}}`;
         }
 
-        return '';
+        // Avoid failure to serialize global window object in jsdom test environment.
+        // For example, not even relevant if window is prop of React element.
+        const constructorName = TestPlatform.getConstructorName(val);
+        return hitMaxDepth
+            ? `[${constructorName}]`
+            : `${
+                  min ? '' : !config.printBasicPrototype && constructorName === 'Object' ? '' : `${constructorName} `
+              }{${PrettyFormat._printObjectProperties(val as object, config, indentation, depth, refs)}}`;
+    }
+
+    private static _printObjectProperties(
+        val: object,
+        config: PrettyFormatConfig,
+        indentation: string,
+        depth: number,
+        refs: unknown[]
+    ) {
+        let result = '';
+        const entries = Object.entries(val);
+
+        if (entries.length > 0) {
+            result += config.spacingOuter;
+
+            const indentationNext = indentation + config.indent;
+
+            for (let i = 0; i < entries.length; i++) {
+                const name = PrettyFormat.printer(entries[i][0], config, indentationNext, depth, refs);
+                const value = PrettyFormat.printer(entries[i][1], config, indentationNext, depth, refs);
+
+                result += `${indentationNext + name}: ${value}`;
+
+                if (i < entries.length - 1) {
+                    result += `,${config.spacingInner}`;
+                } else if (!config.min) {
+                    result += ',';
+                }
+            }
+
+            result += config.spacingOuter + indentation;
+        }
+
+        return result;
     }
 
     /**
@@ -599,7 +640,10 @@ export class SnapshotFile {
             return `No snapshot '${name}' found`;
         }
 
-        const actual = PrettyFormat.format(value, SnapshotFile.matchOptions).split('\n');
+        // https://github.com/jestjs/jest/blob/8e683abe2a1d3f6f6513dd9467f0f49d3d2ffc0d/packages/jest-snapshot-utils/src/utils.ts#L190C51-L190C70
+        const actual = SnapshotFile._printBacktickString(PrettyFormat.format(value, SnapshotFile._matchOptions)).split(
+            '\n'
+        );
 
         const lines = Math.min(expected.length, actual.length);
         const errors: string[] = [];
@@ -622,6 +666,15 @@ export class SnapshotFile {
         return null;
     }
 
+    // https://github.com/jestjs/jest/blob/8e683abe2a1d3f6f6513dd9467f0f49d3d2ffc0d/packages/jest-snapshot-utils/src/utils.ts#L167-L171
+    private static _printBacktickString(str: string) {
+        return SnapshotFile._escapeBacktickString(str);
+    }
+
+    private static _escapeBacktickString(str: string) {
+        return str.replaceAll(/[`\\]/g, (substring: string) => `\\${substring}`);
+    }
+
     loadFrom(path: string) {
         const content = TestPlatform.loadFileAsStringSync(path);
 
@@ -638,6 +691,13 @@ export class SnapshotFile {
                 }
 
                 const name = lines[i].substring(9, endOfName);
+
+                if (lines[i].endsWith('`;')) {
+                    const startOfValue = lines[i].indexOf('`', endOfName + 2) + 1;
+                    this.snapshots.set(name, lines[i].substring(startOfValue, lines[i].length - 2));
+                    i++;
+                    continue;
+                }
                 i++;
 
                 let value = '';
diff --git a/packages/csharp/src/AlphaTab.Test/Test/Globals.cs b/packages/csharp/src/AlphaTab.Test/Test/Globals.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using System.Threading;
+using AlphaTab.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace AlphaTab.Test;
@@ -34,11 +36,17 @@ public static void Fail(object? message)
         Assert.Fail(Convert.ToString(message));
     }
 
-    internal static AsyncLocal<int> SnapshotAssertionCounter { get; }
-    static TestGlobals()
+    private static readonly Dictionary<string, int> SnapshotAssertionCounters = new();
+    public static string UseSnapshotValue(string baseName, string hint)
     {
-        SnapshotAssertionCounter = new AsyncLocal<int>();
-        TestMethodAttribute.GlobalBeforeTest += () => { SnapshotAssertionCounter.Value = 0; };
+        if (!string.IsNullOrEmpty(hint))
+        {
+            baseName += $": {hint}";
+        }
+
+        var value = SnapshotAssertionCounters.GetValueOrDefault(baseName) + 1;
+        SnapshotAssertionCounters[baseName] = value;
+        return $"{baseName} {value}";
     }
 }
 
@@ -245,19 +253,32 @@ public void ToMatchSnapshot(string hint = "")
             Assert.Fail("Could not find snapshot file at " + absoluteSnapFilePath);
         }
 
-        var snapshotFile = SnapshotFileRepository.LoadSnapshortFile(absoluteSnapFilePath);
+        var snapshotFile = SnapshotFileRepository.LoadSnapshotFile(absoluteSnapFilePath);
 
-        var testSuiteName = testMethodInfo.MethodInfo.DeclaringType!.Name;
-        var testName = testMethodInfo.MethodInfo.GetCustomAttribute<TestMethodAttribute>()!.DisplayName;
+        var parts = new Collections.List<string>();
+        CollectTestSuiteNames(parts, testMethodInfo.MethodInfo.DeclaringType!);
+        var testName = testMethodInfo.MethodInfo.GetCustomAttribute<TestMethodAttribute>()!
+            .DisplayName;
+        parts.Add(testName ?? "");
 
-        var snapshortName = $"{testSuiteName} {testName} {++TestGlobals.SnapshotAssertionCounter.Value}";
+        var snapshotName = TestGlobals.UseSnapshotValue(string.Join(" ", parts), hint);
 
-        var error = snapshotFile.Match(snapshortName, _actual);
+        var error = snapshotFile.Match(snapshotName, _actual);
         if (!string.IsNullOrEmpty(error))
         {
             Assert.Fail(error);
         }
     }
-}
 
+    private static void CollectTestSuiteNames(Collections.List<string> parts, Type testClass)
+    {
+        if (testClass.DeclaringType is not null)
+        {
+            CollectTestSuiteNames(parts, testClass.DeclaringType!);
+        }
 
+        var testSuiteName = testClass.GetCustomAttribute<TestClassAttribute>()?.DisplayName ??
+                            testClass.Name;
+        parts.Add(testSuiteName);
+    }
+}
diff --git a/packages/kotlin/src/android/src/test/java/alphaTab/core/TestGlobals.kt b/packages/kotlin/src/android/src/test/java/alphaTab/core/TestGlobals.kt
@@ -2,17 +2,19 @@ package alphaTab.core
 
 import alphaTab.SnapshotFileRepository
 import alphaTab.TestPlatformPartials
+import alphaTab.collections.List
 import alphaTab.collections.ObjectDoubleMap
 import org.junit.Assert
 import java.lang.reflect.Method
 import java.nio.file.Paths
 import kotlin.contracts.ExperimentalContracts
 import kotlin.reflect.KClass
 
+annotation class TestClass(val name: String)
 annotation class TestName(val name: String)
 annotation class SnapshotFile(val path: String)
 
-typealias Test = org.junit.Test
+
 
 class assert {
     companion object {
@@ -50,6 +52,7 @@ class NotExpector<T>(private val actual: T) {
 class Expector<T>(private val actual: T) {
     val to
         get() = this
+
     fun not() = NotExpector(actual)
 
     val be
@@ -69,8 +72,9 @@ class Expector<T>(private val actual: T) {
             expectedTyped = expected.toInt();
         }
 
-        if(expected is Double && expected == 0.0 &&
-            actualToCheck is Double) {
+        if (expected is Double && expected == 0.0 &&
+            actualToCheck is Double
+        ) {
             val d = actualToCheck as Double;
             if (d == -0.0) {
                 @Suppress("UNCHECKED_CAST")
@@ -84,7 +88,10 @@ class Expector<T>(private val actual: T) {
 
     fun lessThan(expected: Double) {
         if (actual is Number) {
-            Assert.assertTrue("Expected $actual to be less than $expected", actual.toDouble() < expected)
+            Assert.assertTrue(
+                "Expected $actual to be less than $expected",
+                actual.toDouble() < expected
+            )
         } else {
             Assert.fail("lessThan can only be used with numeric operands");
         }
@@ -93,11 +100,15 @@ class Expector<T>(private val actual: T) {
 
     fun greaterThan(expected: Double) {
         if (actual is Number) {
-            Assert.assertTrue("Expected $actual to be greater than $expected", actual.toDouble() > expected)
+            Assert.assertTrue(
+                "Expected $actual to be greater than $expected",
+                actual.toDouble() > expected
+            )
         } else {
             Assert.fail("greaterThan can only be used with numeric operands");
         }
     }
+
     fun closeTo(expected: Double, delta: Double, message: String? = null) {
         if (actual is Number) {
             Assert.assertEquals(message, expected, actual.toDouble(), delta)
@@ -106,21 +117,24 @@ class Expector<T>(private val actual: T) {
         }
     }
 
-    fun length(expected:Double) {
-        if(actual is alphaTab.collections.List<*>) {
+    fun length(expected: Double) {
+        if (actual is alphaTab.collections.List<*>) {
             Assert.assertEquals(expected.toInt(), actual.length.toInt())
-        } else if(actual is alphaTab.collections.DoubleList) {
+        } else if (actual is alphaTab.collections.DoubleList) {
             Assert.assertEquals(expected.toInt(), actual.length.toInt())
-        } else if(actual is alphaTab.collections.BooleanList) {
+        } else if (actual is alphaTab.collections.BooleanList) {
             Assert.assertEquals(expected.toInt(), actual.length.toInt())
         } else {
             Assert.fail("length can only be used with collection operands");
         }
     }
 
     fun contain(value: Any) {
-        if(actual is Iterable<*>) {
-            Assert.assertTrue("Expected collection ${actual.joinToString(",")} to contain $value", actual.contains(value))
+        if (actual is Iterable<*>) {
+            Assert.assertTrue(
+                "Expected collection ${actual.joinToString(",")} to contain $value",
+                actual.contains(value)
+            )
         } else {
             Assert.fail("contain can only be used with Iterable operands");
         }
@@ -180,15 +194,15 @@ class Expector<T>(private val actual: T) {
 
     private fun findTestMethod(): Method {
         val walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE)
-        var testMethod:Method? = null
+        var testMethod: Method? = null
         walker.forEach { frame ->
-            if(testMethod == null) {
+            if (testMethod == null) {
                 val method = frame.declaringClass.getDeclaredMethod(
                     frame.methodName,
                     *frame.methodType.parameterArray()
                 )
 
-                if(method.getAnnotation(Test::class.java) != null) {
+                if (method.getAnnotation(org.junit.Test::class.java) != null) {
                     testMethod = method
                 }
             }
@@ -203,7 +217,7 @@ class Expector<T>(private val actual: T) {
 
     @ExperimentalUnsignedTypes
     @ExperimentalContracts
-    fun toMatchSnapshot() {
+    fun toMatchSnapshot(hint: String = "") {
         val testMethodInfo = findTestMethod()
         val file = testMethodInfo.getAnnotation(SnapshotFile::class.java)?.path
         if (file.isNullOrEmpty()) {
@@ -218,23 +232,35 @@ class Expector<T>(private val actual: T) {
             Assert.fail("Could not find snapshot file at $absoluteSnapFilePath")
         }
 
-        val snapshotFile = SnapshotFileRepository.loadSnapshortFile(absoluteSnapFilePath.toString())
+        val snapshotFile = SnapshotFileRepository.loadSnapshotFile(absoluteSnapFilePath.toString())
 
-        val testSuiteName = testMethodInfo.declaringClass.simpleName
+        val parts = List<String>();
+        collectTestSuiteNames(parts, testMethodInfo.declaringClass)
         val testName = testMethodInfo.getAnnotation(TestName::class.java)!!.name
+        parts.push(testName)
+
+        val snapshotName = TestGlobals.useSnapshotValue(parts.joinToString(" "), hint);
+
+
 
-        val fullTestName = "$testSuiteName $testName "
 
-        val counter = (TestGlobals.snapshotAssertionCounters.get(fullTestName) ?: 0.0) + 1
-        TestGlobals.snapshotAssertionCounters.set(fullTestName, counter)
 
-        val snapshotName = "$fullTestName${counter.toInt()}"
 
         val error = snapshotFile.match(snapshotName, actual)
         if (!error.isNullOrEmpty()) {
             Assert.fail(error)
         }
     }
+
+    private fun collectTestSuiteNames(parts: List<String>, testClass: Class<*>) {
+        if (testClass.declaringClass != null) {
+            collectTestSuiteNames(parts, testClass.declaringClass!!);
+        }
+
+        val testSuiteName =
+            testClass.getAnnotation(TestClass::class.java)?.name ?: testClass.simpleName
+        parts.push(testSuiteName);
+    }
 }
 
 class TestGlobals {
@@ -243,6 +269,18 @@ class TestGlobals {
     companion object {
         val snapshotAssertionCounters: ObjectDoubleMap<String> = ObjectDoubleMap()
 
+        fun useSnapshotValue(baseName: String, hint: String): String {
+            var fullName = baseName
+            if (hint.isNotEmpty()) {
+                fullName += ": $hint";
+            }
+
+            val value =
+                if (snapshotAssertionCounters.has(fullName)) snapshotAssertionCounters.get(fullName)!! + 1 else 1.0
+            snapshotAssertionCounters.set(fullName, value)
+            return "$fullName ${value.toInt()}";
+        }
+
         fun <T> expect(actual: T): Expector<T> {
             return Expector(actual);
         }
