feat: NumberResolver

src/main/kotlin/dev/appoutlet/some/config/SomeConfig.kt

@@ -28,6 +28,7 @@ import dev.appoutlet.some.resolver.LocalDateTimeResolver
 import dev.appoutlet.some.resolver.LongResolver
 import dev.appoutlet.some.resolver.MapResolver
 import dev.appoutlet.some.resolver.NullableResolver
+import dev.appoutlet.some.resolver.NumberResolver
 import dev.appoutlet.some.resolver.ObjectResolver
 import dev.appoutlet.some.resolver.SealedClassResolver
 import dev.appoutlet.some.resolver.SetResolver
@@ -109,6 +110,7 @@ data class SomeConfig(
             CharResolver(random),
             ByteResolver(random),
             ShortResolver(random),
+            NumberResolver(random),
             KotlinUuidResolver(),
             KotlinInstantResolver(random),
             KotlinDurationResolver(random),

src/main/kotlin/dev/appoutlet/some/resolver/NumberResolver.kt

@@ -0,0 +1,26 @@
+package dev.appoutlet.some.resolver
+
+import dev.appoutlet.some.core.ResolverChain
+import dev.appoutlet.some.core.TypeResolver
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+class NumberResolver(
+    private val random: Random
+) : TypeResolver {
+    override fun canResolve(type: KType): Boolean = type == typeOf<Number>()
+
+    override fun resolve(type: KType, chain: ResolverChain): Any? {
+        val types = listOf(
+            typeOf<Int>(),
+            typeOf<Long>(),
+            typeOf<Double>(),
+            typeOf<Float>(),
+            typeOf<Short>(),
+            typeOf<Byte>()
+        )
+        val selectedType = types.random(random)
+        return chain.resolve(selectedType)
+    }
+}

src/test/kotlin/dev/appoutlet/some/resolver/NumberResolverTest.kt

@@ -0,0 +1,36 @@
+package dev.appoutlet.some.resolver
+
+import dev.appoutlet.some.test.defaultTestChain
+import kotlin.random.Random
+import kotlin.reflect.typeOf
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+
+class NumberResolverTest {
+    @Test
+    fun `NumberResolver generates a value of type Number`() {
+        val resolver = NumberResolver(Random.Default)
+        val result = resolver.resolve(typeOf<Number>(), defaultTestChain)
+        assertIs<Number>(result)
+    }
+
+    @Test
+    fun `NumberResolver canResolve detects Number type`() {
+        val resolver = NumberResolver(Random.Default)
+        assertTrue(resolver.canResolve(typeOf<Number>()))
+    }
+
+    @Test
+    fun `NumberResolver rejects non-Number types`() {
+        val resolver = NumberResolver(Random.Default)
+        assertFalse(resolver.canResolve(typeOf<String>()))
+        assertFalse(resolver.canResolve(typeOf<Int>()))
+        assertFalse(resolver.canResolve(typeOf<Long>()))
+        assertFalse(resolver.canResolve(typeOf<Double>()))
+        assertFalse(resolver.canResolve(typeOf<Float>()))
+        assertFalse(resolver.canResolve(typeOf<Short>()))
+        assertFalse(resolver.canResolve(typeOf<Byte>()))
+    }
+}