chore: increase branch coverage

android/src/test/java/dev/appoutlet/some/android/resolver/PairResolverTest.kt

@@ -15,6 +15,7 @@ import org.robolectric.RobolectricTestRunner
 import kotlin.random.Random
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
+import kotlin.test.assertFailsWith
 
 @RunWith(RobolectricTestRunner::class)
 class PairResolverTest {
@@ -53,6 +54,30 @@ class PairResolverTest {
         assertFalse(resolver.canResolve(typeOf<kotlin.Pair<String, Int>>()))
     }
 
+    @Test
+    fun `PairResolver rejects star projection in the first type`() {
+        val resolver = PairResolver(Random.Default)
+
+        assertFailsWith<IllegalArgumentException> {
+            resolver.resolve(
+                typeOf<Pair<*, Int>>(),
+                ResolverChain(emptyList(), NullableStrategy.NullOnCircularReference)
+            )
+        }
+    }
+
+    @Test
+    fun `PairResolver rejects star projection in the second type`() {
+        val resolver = PairResolver(Random.Default)
+
+        assertFailsWith<IllegalArgumentException> {
+            resolver.resolve(
+                typeOf<Pair<String, *>>(),
+                ResolverChain(emptyList(), NullableStrategy.NullOnCircularReference)
+            )
+        }
+    }
+
     private class TrackingResolver(
         private val supportedType: KType,
         private val value: Any,

core/src/test/kotlin/dev/appoutlet/some/config/SomeConfigTest.kt

@@ -4,6 +4,10 @@ import dev.appoutlet.some.core.ResolverChain
 import kotlin.reflect.typeOf
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+val String.extensionPropertyForSomeConfigTest: Int
+    get() = length
 
 class SomeConfigTest {
     @Test
@@ -31,4 +35,20 @@ class SomeConfigTest {
 
         assertEquals(99L, rebuilt.seed)
     }
+
+    @Test
+    fun `SomeConfigBuilder rejects properties without an instance parameter`() {
+        val property = String::extensionPropertyForSomeConfigTest
+
+        assertFailsWith<IllegalStateException> {
+            SomeConfigBuilder().property(property) { 1 }
+        }
+    }
+
+    @Test
+    fun `DefaultValueStrategy Random validates probability bounds`() {
+        assertEquals(0.5f, DefaultValueStrategy.Random().probability)
+        assertFailsWith<IllegalArgumentException> { DefaultValueStrategy.Random(-0.1f) }
+        assertFailsWith<IllegalArgumentException> { DefaultValueStrategy.Random(1.1f) }
+    }
 }

core/src/test/kotlin/dev/appoutlet/some/resolver/ClassResolverTest.kt

@@ -196,6 +196,16 @@ class ClassResolverTest {
         assertFalse(resolver.canResolve(typeOf<BigInteger>()))
     }
 
+    @Test
+    fun `ClassResolver canResolve rejects Boolean types`() {
+        assertFalse(resolver.canResolve(typeOf<Boolean>()))
+    }
+
+    @Test
+    fun `ClassResolver canResolve rejects Char types`() {
+        assertFalse(resolver.canResolve(typeOf<Char>()))
+    }
+
     @Test
     fun `ClassResolver throws SomeInstantiationException with null message constructor exception`() {
         val exception = assertFailsWith<SomeInstantiationException> {

core/src/test/kotlin/dev/appoutlet/some/resolver/CustomTypeFactoryResolverTest.kt

@@ -7,6 +7,7 @@ import kotlin.reflect.typeOf
 import kotlin.test.Test
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
+import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 data class CustomFactoryClass(val value: String)
@@ -44,4 +45,15 @@ class CustomTypeFactoryResolverTest {
         assertNotNull(result)
         assertTrue(result is CustomFactoryClass)
     }
+
+    @Test
+    fun `CustomTypeFactoryResolver resolve returns null for an unregistered type`() {
+        val resolver = CustomFactoryResolver(
+            DefaultStrategyProvider(),
+            emptyMap(),
+            Random.Default
+        )
+
+        assertNull(resolver.resolve(typeOf<String>(), defaultTestChain))
+    }
 }

core/src/test/kotlin/dev/appoutlet/some/resolver/ResolverTypeParameterTest.kt

@@ -0,0 +1,30 @@
+package dev.appoutlet.some.resolver
+
+import dev.appoutlet.some.config.DefaultStrategyProvider
+import kotlin.random.Random
+import kotlin.reflect.full.createType
+import kotlin.test.Test
+import kotlin.test.assertFalse
+
+private class ResolverTypeParameterContainer<T>
+
+class ResolverTypeParameterTest {
+    private val typeParameter = ResolverTypeParameterContainer::class.typeParameters.single().createType()
+
+    @Test
+    fun `resolvers reject a type parameter classifier`() {
+        assertFalse(ArrayResolver(DefaultStrategyProvider(), Random.Default).canResolve(typeParameter))
+        assertFalse(ClassResolver(DefaultStrategyProvider(), random = Random.Default).canResolve(typeParameter))
+        assertFalse(
+            CustomFactoryResolver(DefaultStrategyProvider(), emptyMap(), Random.Default).canResolve(typeParameter)
+        )
+        assertFalse(EnumResolver(Random.Default).canResolve(typeParameter))
+        assertFalse(ListResolver(DefaultStrategyProvider(), Random.Default).canResolve(typeParameter))
+        assertFalse(MapResolver(DefaultStrategyProvider(), Random.Default).canResolve(typeParameter))
+        assertFalse(ObjectResolver().canResolve(typeParameter))
+        assertFalse(OptionalResolver(DefaultStrategyProvider(), Random.Default).canResolve(typeParameter))
+        assertFalse(SealedClassResolver(Random.Default).canResolve(typeParameter))
+        assertFalse(SetResolver(DefaultStrategyProvider(), Random.Default).canResolve(typeParameter))
+        assertFalse(ValueClassResolver().canResolve(typeParameter))
+    }
+}

settings.gradle.kts

@@ -41,7 +41,7 @@ kover {
                 name = "Minimum coverage"
                 minBound(95, CoverageUnit.LINE)
                 minBound(95, CoverageUnit.INSTRUCTION)
-                minBound(79, CoverageUnit.BRANCH)
+                minBound(90, CoverageUnit.BRANCH)
             }
         }
     }