refactor: Move functions to top level

src/commonTest/kotlin/app/revanced/library/MostCommonCompatibleVersionsTest.kt

@@ -1,27 +1,19 @@
 package app.revanced.library
 
-import app.revanced.patcher.PatchSet
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.booleanPatchOption
-import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.intArrayPatchOption
-import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.stringPatchOption
-import java.io.ByteArrayInputStream
-import java.io.ByteArrayOutputStream
+import app.revanced.patcher.patch.*
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
-internal class PatchUtilsTest {
+internal class MostCommonCompatibleVersionsTest {
     private val patches =
         arrayOf(
-            newPatch("some.package", setOf("a")) { stringPatchOption("string", "value") },
+            newPatch("some.package", setOf("a")) { stringOption("string", "value") },
             newPatch("some.package", setOf("a", "b"), use = false),
             newPatch("some.package", setOf("a", "b", "c"), use = false),
             newPatch("some.other.package", setOf("b"), use = false),
-            newPatch("some.other.package", setOf("b", "c")) { booleanPatchOption("bool", true) },
+            newPatch("some.other.package", setOf("b", "c")) { booleanOption("bool", true) },
             newPatch("some.other.package", setOf("b", "c", "d")),
-            newPatch("some.other.other.package") { intArrayPatchOption("intArray", arrayOf(1, 2, 3)) },
+            newPatch("some.other.other.package") { intsOption("intArray", listOf(1, 2, 3)) },
             newPatch("some.other.other.package", setOf("a")),
             newPatch("some.other.other.package", setOf("b")),
             newPatch("some.other.other.other.package", use = false),
@@ -141,38 +133,24 @@ internal class PatchUtilsTest {
         assertEqualsVersion(null, patches, "other.package")
     }
 
-    @Test
-    fun `serializes to and deserializes from JSON string correctly`() {
-        val out = ByteArrayOutputStream()
-        PatchUtils.Json.serialize(patches, outputStream = out)
-
-        val deserialized =
-            PatchUtils.Json.deserialize(
-                ByteArrayInputStream(out.toByteArray()),
-                PatchUtils.Json.FullJsonPatch::class.java,
-            )
-
-        assert(patches.size == deserialized.size)
-    }
-
     private fun assertEqualsVersions(
         expected: PackageNameMap,
-        patches: PatchSet,
+        patches: Set<Patch<*>>,
         compatiblePackageNames: Set<String>?,
         countUnusedPatches: Boolean = false,
     ) = assertEquals(
         expected,
-        PatchUtils.getMostCommonCompatibleVersions(patches, compatiblePackageNames, countUnusedPatches),
+        patches.mostCommonCompatibleVersions(compatiblePackageNames, countUnusedPatches),
     )
 
     private fun assertEqualsVersion(
         expected: String?,
-        patches: PatchSet,
+        patches: Set<Patch<*>>,
         compatiblePackageName: String,
     ) {
         assertEquals(
             expected,
-            PatchUtils.getMostCommonCompatibleVersions(patches, setOf(compatiblePackageName))
+            patches.mostCommonCompatibleVersions(setOf(compatiblePackageName))
                 .entries.firstOrNull()?.value?.keys?.firstOrNull(),
         )
     }
@@ -181,19 +159,23 @@ internal class PatchUtilsTest {
         packageName: String,
         versions: Set<String>? = null,
         use: Boolean = true,
-        options: Patch<*>.() -> Unit = {},
-    ) = object : BytecodePatch(
+        options: PatchBuilder<*>.() -> Unit = {},
+    ) = bytecodePatch(
         name = "test",
-        compatiblePackages = setOf(CompatiblePackage(packageName, versions?.toSet())),
         use = use,
     ) {
-        init {
-            options()
+        if (versions == null) {
+            compatibleWith(packageName)
+        } else {
+            compatibleWith(
+                if (versions.isEmpty()) {
+                    packageName()
+                } else {
+                    packageName(*versions.toTypedArray())
+                },
+            )
         }
 
-        override fun execute(context: BytecodeContext) {}
-
-        // Needed to make the patches unique.
-        override fun equals(other: Any?) = false
+        options()
     }
 }

src/commonTest/kotlin/app/revanced/library/OptionsTest.kt

@@ -0,0 +1,36 @@
+package app.revanced.library
+
+import app.revanced.patcher.patch.booleanOption
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patcher.patch.stringOption
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class OptionsTest {
+    @Test
+    fun `serializes and deserializes`() {
+        val options = mapOf(
+            "Test patch" to mapOf("key1" to "test", "key2" to false),
+        )
+
+        val patch = bytecodePatch("Test patch") {
+            stringOption("key1")
+            booleanOption("key2", true)
+        }
+        val duplicatePatch = bytecodePatch("Test patch") {
+            stringOption("key1")
+        }
+        val unnamedPatch = bytecodePatch {
+            booleanOption("key1")
+        }
+
+        setOf(patch, duplicatePatch, unnamedPatch).setOptions(options)
+
+        assert(patch.options["key1"].value == "test")
+        assert(patch.options["key2"].value == false)
+
+        assertEquals(patch.options["key1"].value, duplicatePatch.options["key1"].value)
+
+        assert(unnamedPatch.options["key1"].value == null)
+    }
+}

src/commonTest/kotlin/app/revanced/library/PatchOptionsTest.kt

@@ -1,41 +0,0 @@
-package app.revanced.library
-
-import app.revanced.library.Options.setOptions
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotation.Patch
-import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.booleanPatchOption
-import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.stringPatchOption
-import kotlin.test.Test
-
-class PatchOptionsTest {
-    private var patches = setOf(PatchOptionsTestPatch)
-
-    private val serializedJson =
-        "[{\"patchName\":\"PatchOptionsTestPatch\",\"options\":[{\"key\":\"key1\",\"value\":null},{\"key\":\"key2\"," +
-            "\"value\":true}]}]"
-
-    private val changedJson =
-        "[{\"patchName\":\"PatchOptionsTestPatch\",\"options\":[{\"key\":\"key1\",\"value\":\"test\"},{\"key\":\"key2" +
-            "\",\"value\":false}]}]"
-
-    @Test
-    fun `serializes and deserializes`() {
-        assert(serializedJson == Options.serialize(patches))
-
-        patches.setOptions(changedJson)
-
-        assert(PatchOptionsTestPatch.option1 == "test")
-        assert(PatchOptionsTestPatch.option2 == false)
-    }
-
-    @Patch("PatchOptionsTestPatch")
-    object PatchOptionsTestPatch : BytecodePatch(emptySet()) {
-        var option1 by stringPatchOption("key1", null, null, "title1", "description1")
-        var option2 by booleanPatchOption("key2", true, null, "title2", "description2")
-
-        override fun execute(context: BytecodeContext) {
-            // Do nothing
-        }
-    }
-}

src/commonTest/kotlin/app/revanced/library/SerializationTest.kt

@@ -0,0 +1,55 @@
+package app.revanced.library
+
+import app.revanced.patcher.patch.*
+import kotlinx.serialization.json.*
+import java.io.ByteArrayOutputStream
+import kotlin.test.Test
+import kotlin.test.assertIs
+
+class SerializationTest {
+    private val testPatch = bytecodePatch("Test patch") {
+        compatibleWith("com.example.package"("1.0.0"))
+        compatibleWith("com.example.package2")
+
+        dependsOn(bytecodePatch(), bytecodePatch())
+
+        stringOption("key1", null, null, "title1", "description1")
+        booleanOption("key2", true, null, "title2", "description2")
+        floatsOption("key3", listOf(1.0f), mapOf("list" to listOf(1f)), "title3", "description3")
+    }
+
+    private var patches = setOf(testPatch)
+
+    @Test
+    fun `serializes and deserializes`() {
+        val serializedJson = ByteArrayOutputStream().apply { patches.serializeTo(this) }.toString()
+        val deserializedJson = Json.parseToJsonElement(serializedJson)
+
+        // Test patch serialization.
+
+        assertIs<JsonArray>(deserializedJson)
+
+        val deserializedPatch = deserializedJson[0].jsonObject
+
+        assert(deserializedPatch["name"]!!.jsonPrimitive.content == "Test patch")
+
+        assert(deserializedPatch["compatiblePackages"]!!.jsonArray.size == 2) {
+            "The patch should be compatible with two packages."
+        }
+
+        assert(deserializedPatch["dependencies"]!!.jsonArray.size == 2) {
+            "Even though the dependencies are named the same, they are different objects."
+        }
+
+        // Test option serialization.
+
+        val options = deserializedPatch["options"]!!.jsonArray
+
+        assert(options.size == 3) { "The patch should have three options." }
+
+        assert(options[0].jsonObject["title"]!!.jsonPrimitive.content == "title1")
+        assert(options[0].jsonObject["default"]!!.jsonPrimitive.contentOrNull == null)
+        assert(options[1].jsonObject["default"]!!.jsonPrimitive.boolean)
+        assert(options[2].jsonObject["values"]!!.jsonObject["list"]!!.jsonArray[0].jsonPrimitive.float == 1f)
+    }
+}