Add unit tests for core plugin components

Tests cover:
- TestoClasses: attribute arrays content, no overlaps, constants
- TestoTestDescriptor: isTestClassName logic
- TestoVersionDetector: version parsing, error handling
- TestoFrameworkType: constants, ID, composer packages
- TestoRunnerSettings: defaults, custom values, fromPhpTestRunnerSettings
- TestoRunConfigurationHandler: config file option, singleton
- MixinExtensions: takeWhileInclusive for sequences and collections
- LineMarkerCompanion: RUNNABLE_ATTRIBUTES composition
- PsiUtil: MEANINGFUL_ATTRIBUTES composition, no duplicates

https://claude.ai/code/session_01TmFvjfMtoxTvddQRBzsbPN

Author: claude

src/test/kotlin/com/github/xepozz/testo/MixinExtensionsTest.kt

@@ -0,0 +1,51 @@
+package com.github.xepozz.testo
+
+import junit.framework.TestCase
+
+class MixinExtensionsTest : TestCase() {
+
+    fun testTakeWhileInclusive_sequence_stopsAfterFalse() {
+        val result = sequenceOf(1, 2, 3, 4, 5).takeWhileInclusive { it < 3 }.toList()
+        assertEquals(listOf(1, 2, 3), result)
+    }
+
+    fun testTakeWhileInclusive_sequence_allTrue() {
+        val result = sequenceOf(1, 2, 3).takeWhileInclusive { it < 10 }.toList()
+        assertEquals(listOf(1, 2, 3), result)
+    }
+
+    fun testTakeWhileInclusive_sequence_firstFalse() {
+        val result = sequenceOf(5, 1, 2).takeWhileInclusive { it < 3 }.toList()
+        assertEquals(listOf(5), result)
+    }
+
+    fun testTakeWhileInclusive_sequence_empty() {
+        val result = emptySequence<Int>().takeWhileInclusive { it < 3 }.toList()
+        assertEquals(emptyList<Int>(), result)
+    }
+
+    fun testTakeWhileInclusive_collection_stopsAfterFalse() {
+        val result = listOf(1, 2, 3, 4, 5).takeWhileInclusive { it < 3 }
+        assertEquals(listOf(1, 2, 3), result.toList())
+    }
+
+    fun testTakeWhileInclusive_collection_allTrue() {
+        val result = listOf(1, 2).takeWhileInclusive { it < 10 }
+        assertEquals(listOf(1, 2), result.toList())
+    }
+
+    fun testTakeWhileInclusive_collection_empty() {
+        val result = emptyList<Int>().takeWhileInclusive { it < 3 }
+        assertTrue(result.isEmpty())
+    }
+
+    fun testTakeWhileInclusive_collection_singleElement_true() {
+        val result = listOf(1).takeWhileInclusive { it < 3 }
+        assertEquals(listOf(1), result.toList())
+    }
+
+    fun testTakeWhileInclusive_collection_singleElement_false() {
+        val result = listOf(10).takeWhileInclusive { it < 3 }
+        assertEquals(listOf(10), result.toList())
+    }
+}

src/test/kotlin/com/github/xepozz/testo/PsiUtilTest.kt

@@ -0,0 +1,37 @@
+package com.github.xepozz.testo
+
+import com.github.xepozz.testo.util.PsiUtil
+import junit.framework.TestCase
+
+class PsiUtilTest : TestCase() {
+
+    fun testMeaningfulAttributes_containsAllGroups() {
+        val meaningful = PsiUtil.MEANINGFUL_ATTRIBUTES.toSet()
+
+        for (attr in TestoClasses.DATA_ATTRIBUTES) {
+            assertTrue("Missing data attribute: $attr", meaningful.contains(attr))
+        }
+        for (attr in TestoClasses.TEST_ATTRIBUTES) {
+            assertTrue("Missing test attribute: $attr", meaningful.contains(attr))
+        }
+        for (attr in TestoClasses.TEST_INLINE_ATTRIBUTES) {
+            assertTrue("Missing inline test attribute: $attr", meaningful.contains(attr))
+        }
+        for (attr in TestoClasses.BENCH_ATTRIBUTES) {
+            assertTrue("Missing bench attribute: $attr", meaningful.contains(attr))
+        }
+    }
+
+    fun testMeaningfulAttributes_totalCount() {
+        val expected = TestoClasses.DATA_ATTRIBUTES.size +
+                TestoClasses.TEST_ATTRIBUTES.size +
+                TestoClasses.TEST_INLINE_ATTRIBUTES.size +
+                TestoClasses.BENCH_ATTRIBUTES.size
+        assertEquals(expected, PsiUtil.MEANINGFUL_ATTRIBUTES.size)
+    }
+
+    fun testMeaningfulAttributes_noDuplicates() {
+        val attrs = PsiUtil.MEANINGFUL_ATTRIBUTES
+        assertEquals(attrs.size, attrs.toSet().size)
+    }
+}

src/test/kotlin/com/github/xepozz/testo/TestoClassesTest.kt

@@ -0,0 +1,64 @@
+package com.github.xepozz.testo
+
+import junit.framework.TestCase
+
+class TestoClassesTest : TestCase() {
+
+    fun testTestAttributes_containsExpectedValues() {
+        val attrs = TestoClasses.TEST_ATTRIBUTES
+        assertEquals(2, attrs.size)
+        assertTrue(attrs.contains("\\Testo\\Attribute\\Test"))
+        assertTrue(attrs.contains("\\Testo\\Application\\Attribute\\Test"))
+    }
+
+    fun testTestInlineAttributes_containsExpectedValues() {
+        val attrs = TestoClasses.TEST_INLINE_ATTRIBUTES
+        assertEquals(2, attrs.size)
+        assertTrue(attrs.contains("\\Testo\\Sample\\TestInline"))
+        assertTrue(attrs.contains("\\Testo\\Inline\\TestInline"))
+    }
+
+    fun testDataAttributes_containsAllDataTypes() {
+        val attrs = TestoClasses.DATA_ATTRIBUTES
+        assertEquals(7, attrs.size)
+        assertTrue(attrs.contains("\\Testo\\Sample\\DataProvider"))
+        assertTrue(attrs.contains("\\Testo\\Data\\DataProvider"))
+        assertTrue(attrs.contains("\\Testo\\Sample\\DataSet"))
+        assertTrue(attrs.contains("\\Testo\\Data\\DataSet"))
+        assertTrue(attrs.contains("\\Testo\\Data\\DataUnion"))
+        assertTrue(attrs.contains("\\Testo\\Data\\DataCross"))
+        assertTrue(attrs.contains("\\Testo\\Data\\DataZip"))
+    }
+
+    fun testBenchAttributes_containsExpectedValues() {
+        val attrs = TestoClasses.BENCH_ATTRIBUTES
+        assertEquals(1, attrs.size)
+        assertTrue(attrs.contains("\\Testo\\Bench\\BenchWith"))
+    }
+
+    fun testConstants_assertionException() {
+        assertEquals("\\Testo\\Assert\\State\\Assertion\\AssertionException", TestoClasses.ASSERTION_EXCEPTION)
+    }
+
+    fun testConstants_assert() {
+        assertEquals("\\Testo\\Assert", TestoClasses.ASSERT)
+    }
+
+    fun testConstants_expect() {
+        assertEquals("\\Testo\\Expect", TestoClasses.EXPECT)
+    }
+
+    fun testDataAttributes_noOverlapWithTestAttributes() {
+        val dataSet = TestoClasses.DATA_ATTRIBUTES.toSet()
+        val testSet = TestoClasses.TEST_ATTRIBUTES.toSet()
+        val inlineSet = TestoClasses.TEST_INLINE_ATTRIBUTES.toSet()
+        val benchSet = TestoClasses.BENCH_ATTRIBUTES.toSet()
+
+        assertTrue(dataSet.intersect(testSet).isEmpty())
+        assertTrue(dataSet.intersect(inlineSet).isEmpty())
+        assertTrue(dataSet.intersect(benchSet).isEmpty())
+        assertTrue(testSet.intersect(inlineSet).isEmpty())
+        assertTrue(testSet.intersect(benchSet).isEmpty())
+        assertTrue(inlineSet.intersect(benchSet).isEmpty())
+    }
+}

src/test/kotlin/com/github/xepozz/testo/TestoFrameworkTypeTest.kt

@@ -0,0 +1,28 @@
+package com.github.xepozz.testo
+
+import com.github.xepozz.testo.tests.TestoFrameworkType
+import junit.framework.TestCase
+
+class TestoFrameworkTypeTest : TestCase() {
+
+    fun testConstants() {
+        assertEquals("Testo", TestoFrameworkType.ID)
+        assertEquals("php_qn", TestoFrameworkType.SCHEMA)
+    }
+
+    fun testGetID() {
+        val type = TestoFrameworkType()
+        assertEquals("Testo", type.id)
+    }
+
+    fun testComposerPackageNames() {
+        val type = TestoFrameworkType()
+        val packages = type.composerPackageNames
+        assertTrue(packages.contains("php"))
+    }
+
+    fun testGetDescriptor() {
+        val type = TestoFrameworkType()
+        assertNotNull(type.descriptor)
+    }
+}

src/test/kotlin/com/github/xepozz/testo/TestoLineMarkerCompanionTest.kt

@@ -0,0 +1,42 @@
+package com.github.xepozz.testo
+
+import com.github.xepozz.testo.tests.TestoTestRunLineMarkerProvider
+import junit.framework.TestCase
+
+class TestoLineMarkerCompanionTest : TestCase() {
+
+    fun testRunnableAttributes_containsAllDataAttributes() {
+        val runnable = TestoTestRunLineMarkerProvider.RUNNABLE_ATTRIBUTES.toSet()
+        for (attr in TestoClasses.DATA_ATTRIBUTES) {
+            assertTrue("Missing data attribute: $attr", runnable.contains(attr))
+        }
+    }
+
+    fun testRunnableAttributes_containsInlineTestAttributes() {
+        val runnable = TestoTestRunLineMarkerProvider.RUNNABLE_ATTRIBUTES.toSet()
+        for (attr in TestoClasses.TEST_INLINE_ATTRIBUTES) {
+            assertTrue("Missing inline test attribute: $attr", runnable.contains(attr))
+        }
+    }
+
+    fun testRunnableAttributes_containsBenchAttributes() {
+        val runnable = TestoTestRunLineMarkerProvider.RUNNABLE_ATTRIBUTES.toSet()
+        for (attr in TestoClasses.BENCH_ATTRIBUTES) {
+            assertTrue("Missing bench attribute: $attr", runnable.contains(attr))
+        }
+    }
+
+    fun testRunnableAttributes_doesNotContainPlainTestAttributes() {
+        val runnable = TestoTestRunLineMarkerProvider.RUNNABLE_ATTRIBUTES.toSet()
+        for (attr in TestoClasses.TEST_ATTRIBUTES) {
+            assertFalse("Should not contain plain test attribute: $attr", runnable.contains(attr))
+        }
+    }
+
+    fun testRunnableAttributes_totalCount() {
+        val expected = TestoClasses.DATA_ATTRIBUTES.size +
+                TestoClasses.TEST_INLINE_ATTRIBUTES.size +
+                TestoClasses.BENCH_ATTRIBUTES.size
+        assertEquals(expected, TestoTestRunLineMarkerProvider.RUNNABLE_ATTRIBUTES.size)
+    }
+}

src/test/kotlin/com/github/xepozz/testo/TestoRunConfigurationHandlerTest.kt

@@ -0,0 +1,15 @@
+package com.github.xepozz.testo
+
+import com.github.xepozz.testo.tests.run.TestoRunConfigurationHandler
+import junit.framework.TestCase
+
+class TestoRunConfigurationHandlerTest : TestCase() {
+
+    fun testGetConfigFileOption() {
+        assertEquals("--config", TestoRunConfigurationHandler.INSTANCE.configFileOption)
+    }
+
+    fun testSingletonInstance() {
+        assertSame(TestoRunConfigurationHandler.INSTANCE, TestoRunConfigurationHandler.INSTANCE)
+    }
+}

src/test/kotlin/com/github/xepozz/testo/TestoRunnerSettingsTest.kt

@@ -0,0 +1,51 @@
+package com.github.xepozz.testo
+
+import com.github.xepozz.testo.tests.run.TestoRunnerSettings
+import com.jetbrains.php.testFramework.run.PhpTestRunnerSettings
+import junit.framework.TestCase
+
+class TestoRunnerSettingsTest : TestCase() {
+
+    fun testDefaults() {
+        val settings = TestoRunnerSettings()
+        assertEquals(-1, settings.dataProviderIndex)
+        assertEquals(-1, settings.dataSetIndex)
+        assertFalse(settings.parallelTestingEnabled)
+    }
+
+    fun testCustomValues() {
+        val settings = TestoRunnerSettings(
+            dataProviderIndex = 3,
+            dataSetIndex = 5,
+            parallelTestingEnabled = true,
+        )
+        assertEquals(3, settings.dataProviderIndex)
+        assertEquals(5, settings.dataSetIndex)
+        assertTrue(settings.parallelTestingEnabled)
+    }
+
+    fun testFromPhpTestRunnerSettings() {
+        val base = PhpTestRunnerSettings()
+        base.scope = PhpTestRunnerSettings.Scope.File
+        base.filePath = "/some/path/TestFile.php"
+        base.methodName = "testSomething"
+        base.directoryPath = "/some/dir"
+        base.isUseAlternativeConfigurationFile = true
+        base.configurationFilePath = "/config/testo.xml"
+        base.testRunnerOptions = "--verbose"
+
+        val result = TestoRunnerSettings.fromPhpTestRunnerSettings(base)
+
+        assertEquals(PhpTestRunnerSettings.Scope.File, result.scope)
+        assertEquals("/some/path/TestFile.php", result.filePath)
+        assertEquals("testSomething", result.methodName)
+        assertEquals("/some/dir", result.directoryPath)
+        assertTrue(result.isUseAlternativeConfigurationFile)
+        assertEquals("/config/testo.xml", result.configurationFilePath)
+        assertEquals("--verbose", result.testRunnerOptions)
+        // Testo-specific fields should be defaults
+        assertEquals(-1, result.dataProviderIndex)
+        assertEquals(-1, result.dataSetIndex)
+        assertFalse(result.parallelTestingEnabled)
+    }
+}

src/test/kotlin/com/github/xepozz/testo/TestoTestDescriptorTest.kt

@@ -0,0 +1,30 @@
+package com.github.xepozz.testo
+
+import com.github.xepozz.testo.tests.TestoTestDescriptor
+import junit.framework.TestCase
+
+class TestoTestDescriptorTest : TestCase() {
+
+    fun testIsTestClassName_withTestSuffix() {
+        assertTrue(TestoTestDescriptor.isTestClassName("UserTest"))
+        assertTrue(TestoTestDescriptor.isTestClassName("SomeFeatureTest"))
+    }
+
+    fun testIsTestClassName_withTestBaseSuffix() {
+        assertTrue(TestoTestDescriptor.isTestClassName("AbstractTestBase"))
+        assertTrue(TestoTestDescriptor.isTestClassName("BaseFeatureTestBase"))
+    }
+
+    fun testIsTestClassName_withoutTestSuffix() {
+        assertFalse(TestoTestDescriptor.isTestClassName("UserService"))
+        assertFalse(TestoTestDescriptor.isTestClassName("TestHelper"))
+        assertFalse(TestoTestDescriptor.isTestClassName("Testing"))
+        assertFalse(TestoTestDescriptor.isTestClassName("Contest"))
+    }
+
+    fun testIsTestClassName_edgeCases() {
+        assertTrue(TestoTestDescriptor.isTestClassName("Test"))
+        assertTrue(TestoTestDescriptor.isTestClassName("TestBase"))
+        assertFalse(TestoTestDescriptor.isTestClassName(""))
+    }
+}

src/test/kotlin/com/github/xepozz/testo/TestoVersionDetectorTest.kt

@@ -0,0 +1,37 @@
+package com.github.xepozz.testo
+
+import com.github.xepozz.testo.tests.TestoVersionDetector
+import com.intellij.execution.ExecutionException
+import junit.framework.TestCase
+
+class TestoVersionDetectorTest : TestCase() {
+
+    fun testParse_validVersion() {
+        assertEquals("1.0.0", TestoVersionDetector.parse("Testo 1.0.0"))
+    }
+
+    fun testParse_versionWithPreRelease() {
+        assertEquals("2.3.1-beta.1", TestoVersionDetector.parse("Testo 2.3.1-beta.1"))
+    }
+
+    fun testParse_emptyAfterPrefix() {
+        try {
+            TestoVersionDetector.parse("Testo ")
+            fail("Expected ExecutionException")
+        } catch (_: ExecutionException) {
+            // expected
+        }
+    }
+
+    fun testParse_noPrefix() {
+        // "substringAfter" returns original string if delimiter not found
+        assertEquals("SomeOtherOutput", TestoVersionDetector.parse("SomeOtherOutput"))
+    }
+
+    fun testGetVersionOptions() {
+        val options = TestoVersionDetector.getVersionOptions()
+        assertEquals(2, options.size)
+        assertEquals("--version", options[0])
+        assertEquals("--no-ansi", options[1])
+    }
+}