react-native-libyuv-resizer 0.2.0

package/android/src/androidTest/java/com/libyuvresizer/LibyuvResizerModuleErrorTest.kt

@@ -0,0 +1,135 @@
+package com.libyuvresizer
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class LibyuvResizerModuleErrorTest {
+
+  private lateinit var module: LibyuvResizerModule
+  private lateinit var reactContext: FakeReactContext
+  private val createdFiles = mutableListOf<String>()
+
+  @Before
+  fun setUp() {
+    val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    reactContext = FakeReactContext(ctx)
+    module = LibyuvResizerModule(reactContext)
+  }
+
+  @After
+  fun tearDown() {
+    createdFiles.forEach { TestFixtures.deleteIfExists(it) }
+    createdFiles.clear()
+  }
+
+  private fun resize(
+    filePath: String = "/nonexistent/file.jpg",
+    targetW: Double = 100.0,
+    targetH: Double = 100.0,
+    quality: Double = 80.0,
+    rotation: Double = 0.0,
+    mode: String = "contain",
+    outputPath: String = "",
+    filterMode: String = "box",
+    format: String = "jpeg"
+  ): FakePromise {
+    val promise = FakePromise()
+    module.resize(filePath, targetW, targetH, quality, rotation, mode, outputPath, filterMode, false, format, promise)
+    return promise
+  }
+
+  @Test
+  fun resize_nonexistentFile_rejectsWithFileNotFound() {
+    val promise = resize(filePath = "/nonexistent/path/image.jpg")
+
+    assertTrue(promise.rejected)
+    assertFalse(promise.resolved)
+    assertEquals("E_FILE_NOT_FOUND", promise.errorCode)
+  }
+
+  @Test
+  fun resize_corruptFile_rejectsWithDecodeFailed() {
+    val corrupt = TestFixtures.createCorruptFile(reactContext, "corrupt.jpg")
+    createdFiles += corrupt
+
+    val promise = resize(filePath = corrupt)
+
+    assertTrue(promise.rejected)
+    assertEquals("E_DECODE_FAILED", promise.errorCode)
+  }
+
+  @Test
+  fun resize_zeroDimensions_rejectsWithInvalidDims() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "dims_test.jpg")
+    createdFiles += src
+
+    val promise = resize(filePath = src, targetW = 0.0, targetH = 100.0)
+
+    assertTrue(promise.rejected)
+    assertEquals("E_INVALID_DIMS", promise.errorCode)
+  }
+
+  @Test
+  fun resize_outOfRangeQuality_rejectsWithInvalidQuality() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "quality_test.jpg")
+    createdFiles += src
+
+    val promise = resize(filePath = src, quality = 0.0)
+
+    assertTrue(promise.rejected)
+    assertEquals("E_INVALID_QUALITY", promise.errorCode)
+  }
+
+  @Test
+  fun resize_invalidMode_rejectsWithInvalidMode() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "mode_test.jpg")
+    createdFiles += src
+
+    val promise = resize(filePath = src, mode = "fill")
+
+    assertTrue(promise.rejected)
+    assertEquals("E_INVALID_MODE", promise.errorCode)
+  }
+
+  @Test
+  fun resize_invalidFilterMode_rejectsWithInvalidFilterMode() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "filter_test.jpg")
+    createdFiles += src
+
+    val promise = resize(filePath = src, filterMode = "lanczos")
+
+    assertTrue(promise.rejected)
+    assertEquals("E_INVALID_FILTER_MODE", promise.errorCode)
+  }
+
+  @Test
+  fun resize_invalidRotation_rejectsWithInvalidRotation() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "rot_test.jpg")
+    createdFiles += src
+
+    val promise = resize(filePath = src, rotation = 45.0)
+
+    assertTrue(promise.rejected)
+    assertEquals("E_INVALID_ROTATION", promise.errorCode)
+  }
+
+  @Test
+  fun resize_outputPathIsFile_rejectsWithInvalidOutputPath() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "outpath_test.jpg")
+    createdFiles += src
+
+    // outputPath points to a file, not a directory
+    val promise = resize(filePath = src, outputPath = src)
+
+    assertTrue(promise.rejected)
+    assertEquals("E_INVALID_OUTPUT_PATH", promise.errorCode)
+  }
+}

package/android/src/androidTest/java/com/libyuvresizer/LibyuvResizerModuleExifTest.kt

@@ -0,0 +1,140 @@
+package com.libyuvresizer
+
+import androidx.exifinterface.media.ExifInterface
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.facebook.react.bridge.ReadableMap
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class LibyuvResizerModuleExifTest {
+
+    private lateinit var module: LibyuvResizerModule
+    private lateinit var reactContext: FakeReactContext
+    private val createdFiles = mutableListOf<String>()
+
+    @Before
+    fun setUp() {
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        reactContext = FakeReactContext(ctx)
+        module = LibyuvResizerModule(reactContext)
+    }
+
+    @After
+    fun tearDown() {
+        createdFiles.forEach { TestFixtures.deleteIfExists(it) }
+        createdFiles.clear()
+    }
+
+    private fun createJpegWithGps(name: String): String {
+        val path = TestFixtures.createJpeg(reactContext, 200, 150, name)
+        createdFiles += path
+        ExifInterface(path).apply {
+            setAttribute(ExifInterface.TAG_GPS_LATITUDE, "48/1,51/1,29/1")
+            setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, "N")
+            setAttribute(ExifInterface.TAG_GPS_LONGITUDE, "2/1,17/1,40/1")
+            setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, "E")
+            setAttribute(ExifInterface.TAG_MAKE, "TestCamera")
+            setAttribute(ExifInterface.TAG_MODEL, "TestModel")
+            setAttribute(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_ROTATE_90.toString())
+        }.saveAttributes()
+        return path
+    }
+
+    private fun resize(
+        filePath: String,
+        keepMeta: Boolean,
+        quality: Double = 80.0,
+        format: String = "jpeg"
+    ): FakePromise {
+        val promise = FakePromise()
+        module.resize(filePath, 100.0, 100.0, quality, 0.0, "contain", "", "box", keepMeta, format, promise)
+        return promise
+    }
+
+    @Test
+    fun `resize with keepMeta true preserves GPS coordinates`() {
+        val src = createJpegWithGps("exif_int_gps_src.jpg")
+
+        val promise = resize(src, keepMeta = true)
+
+        assertTrue(promise.resolved)
+        val outPath = (promise.result as ReadableMap).getString("path")!!
+        createdFiles += outPath
+
+        val exif = ExifInterface(outPath)
+        assertEquals("48/1,51/1,29/1", exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE))
+        assertEquals("N", exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF))
+        assertEquals("2/1,17/1,40/1", exif.getAttribute(ExifInterface.TAG_GPS_LONGITUDE))
+        assertEquals("E", exif.getAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF))
+    }
+
+    @Test
+    fun `resize with keepMeta true resets orientation to normal`() {
+        val src = createJpegWithGps("exif_int_orient_src.jpg")
+
+        val promise = resize(src, keepMeta = true)
+
+        assertTrue(promise.resolved)
+        val outPath = (promise.result as ReadableMap).getString("path")!!
+        createdFiles += outPath
+
+        val exif = ExifInterface(outPath)
+        assertEquals(
+            ExifInterface.ORIENTATION_NORMAL,
+            exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED)
+        )
+    }
+
+    @Test
+    fun `resize with keepMeta false produces no GPS in output`() {
+        val src = createJpegWithGps("exif_int_nometa_src.jpg")
+
+        val promise = resize(src, keepMeta = false)
+
+        assertTrue(promise.resolved)
+        val outPath = (promise.result as ReadableMap).getString("path")!!
+        createdFiles += outPath
+
+        val exif = ExifInterface(outPath)
+        assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE))
+        assertNull(exif.getAttribute(ExifInterface.TAG_MAKE))
+    }
+
+    @Test
+    fun `resize with keepMeta omitted default produces no EXIF`() {
+        val src = createJpegWithGps("exif_int_default_src.jpg")
+
+        // keepMeta defaults to false in the bridge call
+        val promise = FakePromise()
+        module.resize(src, 100.0, 100.0, 80.0, 0.0, "contain", "", "box", false, "jpeg", promise)
+
+        assertTrue(promise.resolved)
+        val outPath = (promise.result as ReadableMap).getString("path")!!
+        createdFiles += outPath
+
+        val exif = ExifInterface(outPath)
+        assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE))
+    }
+
+    @Test
+    fun `resize PNG format with keepMeta true resolves without error`() {
+        val src = createJpegWithGps("exif_int_png_src.jpg")
+
+        // format=png → PNG output; keepMeta is no-op for PNG
+        val promise = resize(src, keepMeta = true, format = "png")
+
+        assertTrue("expected resolved, got: ${promise.errorCode}: ${promise.errorMessage}", promise.resolved)
+        val outPath = (promise.result as ReadableMap).getString("path")!!
+        createdFiles += outPath
+        assertTrue("output must be .png", outPath.endsWith(".png"))
+        assertTrue("output file must exist", File(outPath).exists())
+    }
+}

package/android/src/androidTest/java/com/libyuvresizer/LibyuvResizerModuleFilterModeTest.kt

@@ -0,0 +1,85 @@
+package com.libyuvresizer
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.After
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.facebook.react.bridge.ReadableMap
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class LibyuvResizerModuleFilterModeTest {
+
+  private lateinit var module: LibyuvResizerModule
+  private lateinit var reactContext: FakeReactContext
+  private val createdFiles = mutableListOf<String>()
+  private lateinit var srcPath: String
+
+  @Before
+  fun setUp() {
+    val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    reactContext = FakeReactContext(ctx)
+    module = LibyuvResizerModule(reactContext)
+    srcPath = TestFixtures.createJpeg(reactContext, 120, 80, "filter_src.jpg")
+    createdFiles += srcPath
+  }
+
+  @After
+  fun tearDown() {
+    createdFiles.forEach { TestFixtures.deleteIfExists(it) }
+    createdFiles.clear()
+  }
+
+  private fun resizeWithFilter(filterMode: String): FakePromise {
+    val promise = FakePromise()
+    module.resize(srcPath, 60.0, 60.0, 80.0, 0.0, "contain", "", filterMode, false, "jpeg", promise)
+    return promise
+  }
+
+  @Test
+  fun resize_filterModeBox_producesValidOutput() {
+    val promise = resizeWithFilter("box")
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue(File(outPath).exists())
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertTrue(w > 0 && h > 0)
+  }
+
+  @Test
+  fun resize_filterModeBilinear_producesValidOutput() {
+    val promise = resizeWithFilter("bilinear")
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue(File(outPath).exists())
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertTrue(w > 0 && h > 0)
+  }
+
+  @Test
+  fun resize_filterModeLinear_producesValidOutput() {
+    val promise = resizeWithFilter("linear")
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue(File(outPath).exists())
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertTrue(w > 0 && h > 0)
+  }
+
+  @Test
+  fun resize_filterModeNone_producesValidOutput() {
+    val promise = resizeWithFilter("none")
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue(File(outPath).exists())
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertTrue(w > 0 && h > 0)
+  }
+}

package/android/src/androidTest/java/com/libyuvresizer/LibyuvResizerModuleFormatTest.kt

@@ -0,0 +1,146 @@
+package com.libyuvresizer
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.facebook.react.bridge.ReadableMap
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class LibyuvResizerModuleFormatTest {
+
+  private lateinit var module: LibyuvResizerModule
+  private lateinit var reactContext: FakeReactContext
+  private val createdFiles = mutableListOf<String>()
+
+  @Before
+  fun setUp() {
+    val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    reactContext = FakeReactContext(ctx)
+    module = LibyuvResizerModule(reactContext)
+  }
+
+  @After
+  fun tearDown() {
+    createdFiles.forEach { TestFixtures.deleteIfExists(it) }
+    createdFiles.clear()
+  }
+
+  private fun resize(filePath: String, format: String, quality: Double = 80.0, keepMeta: Boolean = false): FakePromise {
+    val promise = FakePromise()
+    module.resize(filePath, 100.0, 100.0, quality, 0.0, "contain", "", "box", keepMeta, format, promise)
+    return promise
+  }
+
+  @Test
+  fun resize_formatWebp_outputPathEndsWithWebp() {
+    val src = TestFixtures.createJpeg(reactContext, 200, 150, "webp_test.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "webp")
+
+    assertTrue("expected resolved, got error=${promise.errorCode}: ${promise.errorMessage}", promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output path must end with .webp", outPath.endsWith(".webp"))
+  }
+
+  @Test
+  fun resize_formatWebp_outputFileIsDecodable() {
+    val src = TestFixtures.createJpeg(reactContext, 200, 150, "webp_decode.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "webp")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output file must exist", File(outPath).exists())
+    assertTrue("output file must be non-empty", File(outPath).length() > 0)
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertTrue("decoded WebP width must be > 0", w > 0)
+    assertTrue("decoded WebP height must be > 0", h > 0)
+  }
+
+  @Test
+  fun resize_formatWebp_resultSizeIsPositive() {
+    val src = TestFixtures.createJpeg(reactContext, 200, 150, "webp_size.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "webp")
+
+    assertTrue(promise.resolved)
+    val map = promise.result as ReadableMap
+    assertTrue("result size must be > 0", map.getDouble("size") > 0)
+  }
+
+  @Test
+  fun resize_formatWebp_resultNameEndsWithWebp() {
+    val src = TestFixtures.createJpeg(reactContext, 200, 150, "webp_name.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "webp")
+
+    assertTrue(promise.resolved)
+    val name = (promise.result as ReadableMap).getString("name")!!
+    assertTrue("result name must end with .webp", name.endsWith(".webp"))
+  }
+
+  @Test
+  fun resize_formatWebp_keepMetaTrue_resolvesWithoutError() {
+    val src = TestFixtures.createJpeg(reactContext, 200, 150, "webp_keepmeta.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "webp", keepMeta = true)
+
+    assertTrue("keepMeta+webp must resolve, got: ${promise.errorCode}: ${promise.errorMessage}", promise.resolved)
+    assertFalse(promise.rejected)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output must be .webp", outPath.endsWith(".webp"))
+  }
+
+  @Test
+  fun resize_formatJpeg_explicit_outputPathEndsWithJpg() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "jpeg_explicit.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "jpeg")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output path must end with .jpg", outPath.endsWith(".jpg"))
+  }
+
+  @Test
+  fun resize_formatPng_explicit_outputPathEndsWithPng() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "png_explicit.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "png")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output path must end with .png", outPath.endsWith(".png"))
+  }
+
+  @Test
+  fun resize_invalidFormat_rejectsWithInvalidFormat() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "fmt_err.jpg")
+    createdFiles += src
+
+    val promise = resize(src, format = "gif")
+
+    assertTrue(promise.rejected)
+    assertFalse(promise.resolved)
+    assertEquals("E_INVALID_FORMAT", promise.errorCode)
+  }
+}

package/android/src/androidTest/java/com/libyuvresizer/LibyuvResizerModuleIntegrationTest.kt

@@ -0,0 +1,157 @@
+package com.libyuvresizer
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.facebook.react.bridge.ReadableMap
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class LibyuvResizerModuleIntegrationTest {
+
+  private lateinit var module: LibyuvResizerModule
+  private lateinit var reactContext: FakeReactContext
+  private val createdFiles = mutableListOf<String>()
+
+  @Before
+  fun setUp() {
+    val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    reactContext = FakeReactContext(ctx)
+    module = LibyuvResizerModule(reactContext)
+  }
+
+  @After
+  fun tearDown() {
+    createdFiles.forEach { TestFixtures.deleteIfExists(it) }
+    createdFiles.clear()
+  }
+
+  private fun resize(
+    filePath: String,
+    targetW: Double,
+    targetH: Double,
+    quality: Double,
+    rotation: Double = 0.0,
+    mode: String = "contain",
+    outputPath: String = "",
+    filterMode: String = "box",
+    format: String = "jpeg"
+  ): FakePromise {
+    val promise = FakePromise()
+    module.resize(filePath, targetW, targetH, quality, rotation, mode, outputPath, filterMode, false, format, promise)
+    return promise
+  }
+
+  @Test
+  fun resize_landscape_contain_returnsScaledJpeg() {
+    // 200x100 → target 300x300 contain → scale=min(1.5,3.0)=1.5 → floor(300)x floor(150) = 300x150
+    val src = TestFixtures.createJpeg(reactContext, 200, 100, "landscape.jpg")
+    createdFiles += src
+
+    val promise = resize(src, 300.0, 300.0, 80.0)
+
+    assertTrue("expected resolved, got error=${promise.errorCode}: ${promise.errorMessage}", promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output file must exist", File(outPath).exists())
+    assertTrue("output must be .jpg", outPath.endsWith(".jpg"))
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(300, w)
+    assertEquals(150, h)
+  }
+
+  @Test
+  fun resize_portrait_cover_producesLargerThanTarget() {
+    // 100x200 → target 150x150 cover → scale=max(1.5,0.75)=1.5 → round(150)x round(300) = 150x300
+    val src = TestFixtures.createJpeg(reactContext, 100, 200, "portrait.jpg")
+    createdFiles += src
+
+    val promise = resize(src, 150.0, 150.0, 80.0, mode = "cover")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(150, w)
+    assertEquals(300, h)
+  }
+
+  @Test
+  fun resize_stretch_ignoresAspectRatio() {
+    // 200x100 → target 300x150 stretch → output exactly 300x150
+    val src = TestFixtures.createJpeg(reactContext, 200, 100, "landscape_stretch.jpg")
+    createdFiles += src
+
+    val promise = resize(src, 300.0, 150.0, 80.0, mode = "stretch")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(300, w)
+    assertEquals(150, h)
+  }
+
+  @Test
+  fun resize_formatPng_writesPng() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "square.jpg")
+    createdFiles += src
+
+    val promise = resize(src, 50.0, 50.0, 80.0, format = "png")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output must be .png", outPath.endsWith(".png"))
+    val decoded = TestFixtures.decodeDimensions(outPath)
+    assertTrue("decoded PNG must be readable", decoded.first > 0 && decoded.second > 0)
+  }
+
+  @Test
+  fun resize_quality80_writesJpeg() {
+    val src = TestFixtures.createJpeg(reactContext, 100, 100, "square_jpeg.jpg")
+    createdFiles += src
+
+    val promise = resize(src, 50.0, 50.0, 80.0)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output must be .jpg", outPath.endsWith(".jpg"))
+    assertTrue("decoded JPEG must be readable", TestFixtures.decodeDimensions(outPath).first > 0)
+  }
+
+  @Test
+  fun resize_smallImageToLargeTarget_contain_upscales() {
+    // 64x64 → 400x400 contain → scale=min(400/64, 400/64)=6.25 → floor(400)x floor(400) = 400x400
+    val src = TestFixtures.createJpeg(reactContext, 64, 64, "tiny.jpg")
+    createdFiles += src
+
+    val promise = resize(src, 400.0, 400.0, 80.0)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(400, w)
+    assertEquals(400, h)
+  }
+
+  @Test
+  fun resize_pngSourceFile_succeeds() {
+    val src = TestFixtures.createPng(reactContext, 120, 80, "source.png")
+    createdFiles += src
+
+    val promise = resize(src, 60.0, 60.0, 80.0)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue(File(outPath).exists())
+  }
+}