feat: android geometry resolvers

android/src/main/java/dev/appoutlet/some/android/resolver/PointFResolver.kt

@@ -0,0 +1,27 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.PointF
+import dev.appoutlet.some.core.Resolver
+import dev.appoutlet.some.core.ResolverChain
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+private const val COORDINATE_BOUND = 1_000_000f
+
+/**
+ * Resolves [PointF] types with randomized float coordinates.
+ *
+ * @param random Random source used when generating coordinates.
+ */
+class PointFResolver(
+    private val random: Random
+) : Resolver {
+    override fun canResolve(type: KType): Boolean = type == typeOf<PointF>()
+
+    override fun resolve(type: KType, chain: ResolverChain): Any {
+        val x = random.nextFloat() * (COORDINATE_BOUND * 2) - COORDINATE_BOUND
+        val y = random.nextFloat() * (COORDINATE_BOUND * 2) - COORDINATE_BOUND
+        return PointF(x, y)
+    }
+}

android/src/main/java/dev/appoutlet/some/android/resolver/PointResolver.kt

@@ -0,0 +1,23 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.Point
+import dev.appoutlet.some.core.Resolver
+import dev.appoutlet.some.core.ResolverChain
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Resolves [Point] types with randomized integer coordinates.
+ *
+ * @param random Random source used when generating coordinates.
+ */
+class PointResolver(
+    private val random: Random
+) : Resolver {
+    override fun canResolve(type: KType): Boolean = type == typeOf<Point>()
+
+    override fun resolve(type: KType, chain: ResolverChain): Any {
+        return Point(random.nextInt(), random.nextInt())
+    }
+}

android/src/main/java/dev/appoutlet/some/android/resolver/RectFResolver.kt

@@ -0,0 +1,31 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.RectF
+import dev.appoutlet.some.core.Resolver
+import dev.appoutlet.some.core.ResolverChain
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+private const val COORDINATE_BOUND = 1_000_000f
+
+/**
+ * Resolves [RectF] types with randomized float bounds.
+ *
+ * Generated rectangles always satisfy `left < right` and `top < bottom`.
+ *
+ * @param random Random source used when generating coordinates.
+ */
+class RectFResolver(
+    private val random: Random
+) : Resolver {
+    override fun canResolve(type: KType): Boolean = type == typeOf<RectF>()
+
+    override fun resolve(type: KType, chain: ResolverChain): Any {
+        val left = random.nextFloat() * (COORDINATE_BOUND * 2) - COORDINATE_BOUND
+        val top = random.nextFloat() * (COORDINATE_BOUND * 2) - COORDINATE_BOUND
+        val right = left + random.nextFloat() * (COORDINATE_BOUND - 1) + 1
+        val bottom = top + random.nextFloat() * (COORDINATE_BOUND - 1) + 1
+        return RectF(left, top, right, bottom)
+    }
+}

android/src/main/java/dev/appoutlet/some/android/resolver/RectResolver.kt

@@ -0,0 +1,31 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.Rect
+import dev.appoutlet.some.core.Resolver
+import dev.appoutlet.some.core.ResolverChain
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+private const val COORDINATE_BOUND = 1_000_000
+
+/**
+ * Resolves [Rect] types with randomized integer bounds.
+ *
+ * Generated rectangles always satisfy `left < right` and `top < bottom`.
+ *
+ * @param random Random source used when generating coordinates.
+ */
+class RectResolver(
+    private val random: Random
+) : Resolver {
+    override fun canResolve(type: KType): Boolean = type == typeOf<Rect>()
+
+    override fun resolve(type: KType, chain: ResolverChain): Any {
+        val left = random.nextInt(-COORDINATE_BOUND, COORDINATE_BOUND)
+        val top = random.nextInt(-COORDINATE_BOUND, COORDINATE_BOUND)
+        val right = left + random.nextInt(1, COORDINATE_BOUND)
+        val bottom = top + random.nextInt(1, COORDINATE_BOUND)
+        return Rect(left, top, right, bottom)
+    }
+}

android/src/main/java/dev/appoutlet/some/android/resolver/SizeFResolver.kt

@@ -0,0 +1,27 @@
+package dev.appoutlet.some.android.resolver
+
+import android.util.SizeF
+import dev.appoutlet.some.core.Resolver
+import dev.appoutlet.some.core.ResolverChain
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+private const val DIMENSION_BOUND = 1_000_000f
+
+/**
+ * Resolves [SizeF] types with randomized positive float dimensions.
+ *
+ * @param random Random source used when generating dimensions.
+ */
+class SizeFResolver(
+    private val random: Random
+) : Resolver {
+    override fun canResolve(type: KType): Boolean = type == typeOf<SizeF>()
+
+    override fun resolve(type: KType, chain: ResolverChain): Any {
+        val width = random.nextFloat() * (DIMENSION_BOUND - 1) + 1
+        val height = random.nextFloat() * (DIMENSION_BOUND - 1) + 1
+        return SizeF(width, height)
+    }
+}

android/src/main/java/dev/appoutlet/some/android/resolver/SizeResolver.kt

@@ -0,0 +1,23 @@
+package dev.appoutlet.some.android.resolver
+
+import android.util.Size
+import dev.appoutlet.some.core.Resolver
+import dev.appoutlet.some.core.ResolverChain
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Resolves [Size] types with randomized positive integer dimensions.
+ *
+ * @param random Random source used when generating dimensions.
+ */
+class SizeResolver(
+    private val random: Random
+) : Resolver {
+    override fun canResolve(type: KType): Boolean = type == typeOf<Size>()
+
+    override fun resolve(type: KType, chain: ResolverChain): Any {
+        return Size(random.nextInt(1, Int.MAX_VALUE), random.nextInt(1, Int.MAX_VALUE))
+    }
+}

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

@@ -0,0 +1,49 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.Point
+import android.graphics.PointF
+import android.graphics.Rect
+import android.graphics.RectF
+import android.util.Size
+import android.util.SizeF
+import dev.appoutlet.some.config.NullableStrategy
+import dev.appoutlet.some.core.ResolverChain
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.random.Random
+import kotlin.reflect.typeOf
+
+@RunWith(RobolectricTestRunner::class)
+class PointFResolverTest {
+    @Test
+    fun `PointFResolver generates PointF values`() {
+        val resolver = PointFResolver(Random.Default)
+        val result = resolver.resolve(typeOf<PointF>(), testChain)
+        assertTrue(result is PointF)
+    }
+
+    @Test
+    fun `PointFResolver canResolve detects PointF type`() {
+        val resolver = PointFResolver(Random.Default)
+        assertTrue(resolver.canResolve(typeOf<PointF>()))
+    }
+
+    @Test
+    fun `PointFResolver rejects non-PointF types`() {
+        val resolver = PointFResolver(Random.Default)
+        assertFalse(resolver.canResolve(typeOf<String>()))
+        assertFalse(resolver.canResolve(typeOf<Int>()))
+        assertFalse(resolver.canResolve(typeOf<Rect>()))
+        assertFalse(resolver.canResolve(typeOf<RectF>()))
+        assertFalse(resolver.canResolve(typeOf<Point>()))
+        assertFalse(resolver.canResolve(typeOf<Size>()))
+        assertFalse(resolver.canResolve(typeOf<SizeF>()))
+    }
+
+    companion object {
+        private val testChain = ResolverChain(emptyList(), NullableStrategy.NullOnCircularReference)
+    }
+}

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

@@ -0,0 +1,49 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.Point
+import android.graphics.PointF
+import android.graphics.Rect
+import android.graphics.RectF
+import android.util.Size
+import android.util.SizeF
+import dev.appoutlet.some.config.NullableStrategy
+import dev.appoutlet.some.core.ResolverChain
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.random.Random
+import kotlin.reflect.typeOf
+
+@RunWith(RobolectricTestRunner::class)
+class PointResolverTest {
+    @Test
+    fun `PointResolver generates Point values`() {
+        val resolver = PointResolver(Random.Default)
+        val result = resolver.resolve(typeOf<Point>(), testChain)
+        assertTrue(result is Point)
+    }
+
+    @Test
+    fun `PointResolver canResolve detects Point type`() {
+        val resolver = PointResolver(Random.Default)
+        assertTrue(resolver.canResolve(typeOf<Point>()))
+    }
+
+    @Test
+    fun `PointResolver rejects non-Point types`() {
+        val resolver = PointResolver(Random.Default)
+        assertFalse(resolver.canResolve(typeOf<String>()))
+        assertFalse(resolver.canResolve(typeOf<Int>()))
+        assertFalse(resolver.canResolve(typeOf<Rect>()))
+        assertFalse(resolver.canResolve(typeOf<RectF>()))
+        assertFalse(resolver.canResolve(typeOf<PointF>()))
+        assertFalse(resolver.canResolve(typeOf<Size>()))
+        assertFalse(resolver.canResolve(typeOf<SizeF>()))
+    }
+
+    companion object {
+        private val testChain = ResolverChain(emptyList(), NullableStrategy.NullOnCircularReference)
+    }
+}

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

@@ -0,0 +1,59 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.Point
+import android.graphics.PointF
+import android.graphics.Rect
+import android.graphics.RectF
+import android.util.Size
+import android.util.SizeF
+import dev.appoutlet.some.config.NullableStrategy
+import dev.appoutlet.some.core.ResolverChain
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.random.Random
+import kotlin.reflect.typeOf
+
+@RunWith(RobolectricTestRunner::class)
+class RectFResolverTest {
+    @Test
+    fun `RectFResolver generates RectF values`() {
+        val resolver = RectFResolver(Random.Default)
+        val result = resolver.resolve(typeOf<RectF>(), testChain)
+        assertTrue(result is RectF)
+    }
+
+    @Test
+    fun `RectFResolver canResolve detects RectF type`() {
+        val resolver = RectFResolver(Random.Default)
+        assertTrue(resolver.canResolve(typeOf<RectF>()))
+    }
+
+    @Test
+    fun `RectFResolver rejects non-RectF types`() {
+        val resolver = RectFResolver(Random.Default)
+        assertFalse(resolver.canResolve(typeOf<String>()))
+        assertFalse(resolver.canResolve(typeOf<Int>()))
+        assertFalse(resolver.canResolve(typeOf<Rect>()))
+        assertFalse(resolver.canResolve(typeOf<Point>()))
+        assertFalse(resolver.canResolve(typeOf<PointF>()))
+        assertFalse(resolver.canResolve(typeOf<Size>()))
+        assertFalse(resolver.canResolve(typeOf<SizeF>()))
+    }
+
+    @Test
+    fun `RectFResolver generates rects with valid bounds`() {
+        val resolver = RectFResolver(Random.Default)
+        repeat(20) {
+            val result = resolver.resolve(typeOf<RectF>(), testChain) as RectF
+            assertTrue("left should be less than right", result.left < result.right)
+            assertTrue("top should be less than bottom", result.top < result.bottom)
+        }
+    }
+
+    companion object {
+        private val testChain = ResolverChain(emptyList(), NullableStrategy.NullOnCircularReference)
+    }
+}

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

@@ -0,0 +1,59 @@
+package dev.appoutlet.some.android.resolver
+
+import android.graphics.Point
+import android.graphics.PointF
+import android.graphics.Rect
+import android.graphics.RectF
+import android.util.Size
+import android.util.SizeF
+import dev.appoutlet.some.config.NullableStrategy
+import dev.appoutlet.some.core.ResolverChain
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.random.Random
+import kotlin.reflect.typeOf
+
+@RunWith(RobolectricTestRunner::class)
+class RectResolverTest {
+    @Test
+    fun `RectResolver generates Rect values`() {
+        val resolver = RectResolver(Random.Default)
+        val result = resolver.resolve(typeOf<Rect>(), testChain)
+        assertTrue(result is Rect)
+    }
+
+    @Test
+    fun `RectResolver canResolve detects Rect type`() {
+        val resolver = RectResolver(Random.Default)
+        assertTrue(resolver.canResolve(typeOf<Rect>()))
+    }
+
+    @Test
+    fun `RectResolver rejects non-Rect types`() {
+        val resolver = RectResolver(Random.Default)
+        assertFalse(resolver.canResolve(typeOf<String>()))
+        assertFalse(resolver.canResolve(typeOf<Int>()))
+        assertFalse(resolver.canResolve(typeOf<RectF>()))
+        assertFalse(resolver.canResolve(typeOf<Point>()))
+        assertFalse(resolver.canResolve(typeOf<PointF>()))
+        assertFalse(resolver.canResolve(typeOf<Size>()))
+        assertFalse(resolver.canResolve(typeOf<SizeF>()))
+    }
+
+    @Test
+    fun `RectResolver generates rects with valid bounds`() {
+        val resolver = RectResolver(Random.Default)
+        repeat(20) {
+            val result = resolver.resolve(typeOf<Rect>(), testChain) as Rect
+            assertTrue("left should be less than right", result.left < result.right)
+            assertTrue("top should be less than bottom", result.top < result.bottom)
+        }
+    }
+
+    companion object {
+        private val testChain = ResolverChain(emptyList(), NullableStrategy.NullOnCircularReference)
+    }
+}