From 47caf2629c0e7b926259fa47c4a2d234b69d2490 Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Thu, 17 Aug 2023 05:12:54 -0300
Subject: [PATCH 01/14] feat: create Resource

---
 src/main/kotlin/Resource.kt | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 src/main/kotlin/Resource.kt

diff --git a/src/main/kotlin/Resource.kt b/src/main/kotlin/Resource.kt
new file mode 100644
index 0000000..a9efa29
--- /dev/null
+++ b/src/main/kotlin/Resource.kt
@@ -0,0 +1,11 @@
+sealed class Resource<out T, out E> {
+
+    sealed class Result<out T, out E> : Resource<T, E>() {
+
+        data class Success<T>(val data: T) : Result<T, Nothing>()
+
+        data class Failure<E>(val error: E) : Result<Nothing, E>()
+    }
+
+    data object Loading : Resource<Nothing, Nothing>()
+}
\ No newline at end of file

From be549a830b19a8adbf0a67d9f52073da96c72c10 Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Thu, 17 Aug 2023 05:38:47 -0300
Subject: [PATCH 02/14] test: create Resource unit test

---
 src/test/kotlin/ResourceTest.kt | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 src/test/kotlin/ResourceTest.kt

diff --git a/src/test/kotlin/ResourceTest.kt b/src/test/kotlin/ResourceTest.kt
new file mode 100644
index 0000000..cf06f79
--- /dev/null
+++ b/src/test/kotlin/ResourceTest.kt
@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+
+class ResourceTest {
+
+    @Test
+    fun successResult_shouldHoldData() {
+        val success = Resource.Result.Success("Test Data")
+        assertEquals("Test Data", success.data)
+    }
+
+    @Test
+    fun failureResult_shouldHoldError() {
+        val failure = Resource.Result.Failure("Test Error")
+        assertEquals("Test Error", failure.error)
+    }
+
+    @Test
+    fun loadingResource_shouldBeLoading() {
+        assertEquals(Resource.Loading, Resource.Loading)
+    }
+}
\ No newline at end of file

From 2c596c04a555def07b90509f63a4d7c44e9c2316 Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Thu, 17 Aug 2023 05:51:22 -0300
Subject: [PATCH 03/14] feat: create Result::toResource extension

---
 .idea/gradle.xml                          |  1 +
 src/main/kotlin/extension/Result.kt       |  9 +++++++++
 src/test/kotlin/extension/ResultKtTest.kt | 24 +++++++++++++++++++++++
 3 files changed, 34 insertions(+)
 create mode 100644 src/main/kotlin/extension/Result.kt
 create mode 100644 src/test/kotlin/extension/ResultKtTest.kt

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index f9163b4..ce1c62c 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
diff --git a/src/main/kotlin/extension/Result.kt b/src/main/kotlin/extension/Result.kt
new file mode 100644
index 0000000..d6726c2
--- /dev/null
+++ b/src/main/kotlin/extension/Result.kt
@@ -0,0 +1,9 @@
+package extension
+
+fun <T> Result<T>.toResource(): Resource.Result<T, Throwable> {
+    return Resource.Result.Success(
+        getOrElse {
+            return Resource.Result.Failure(it)
+        }
+    )
+}
\ No newline at end of file
diff --git a/src/test/kotlin/extension/ResultKtTest.kt b/src/test/kotlin/extension/ResultKtTest.kt
new file mode 100644
index 0000000..b6e7c0c
--- /dev/null
+++ b/src/test/kotlin/extension/ResultKtTest.kt
@@ -0,0 +1,24 @@
+package extension
+
+import Resource
+import org.junit.jupiter.api.Assertions.assertEquals
+import kotlin.test.Test
+
+class ResultKtTest {
+
+    @Test
+    fun successResult_toResource() {
+        val result = Result.success("Test Data").toResource()
+
+        assertEquals(Resource.Result.Success("Test Data"), result)
+    }
+
+    @Test
+    fun failureResult_toResource() {
+        val exception = Throwable("Test Error")
+
+        val result = Result.failure<Nothing>(exception).toResource()
+
+        assertEquals(Resource.Result.Failure(exception), result)
+    }
+}
\ No newline at end of file

From 3a0d789ab402c9e2cf6113b90ecd4a8cfd0f9070 Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Thu, 17 Aug 2023 06:24:13 -0300
Subject: [PATCH 04/14] feat: create Resource extensions

---
 .idea/.gitignore                      |  1 +
 src/main/kotlin/extension/Resource.kt | 88 +++++++++++++++++++++++++++
 2 files changed, 89 insertions(+)
 create mode 100644 src/main/kotlin/extension/Resource.kt

diff --git a/.idea/.gitignore b/.idea/.gitignore
index 26d3352..8df39e0 100644
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -1,3 +1,4 @@
 # Default ignored files
 /shelf/
 /workspace.xml
+/uiDesigner.xml
diff --git a/src/main/kotlin/extension/Resource.kt b/src/main/kotlin/extension/Resource.kt
new file mode 100644
index 0000000..6365ef0
--- /dev/null
+++ b/src/main/kotlin/extension/Resource.kt
@@ -0,0 +1,88 @@
+package extension
+
+import Resource
+
+// basic
+
+inline val Resource<*, *>.isLoading get() = this == Resource.Loading
+inline val Resource<*, *>.isSuccess get() = this is Resource.Result.Success
+inline val Resource<*, *>.isError get() = this is Resource.Result.Failure
+
+fun <T, E> Resource.Result<T, E>.asResource() = this as Resource<T, E>
+
+// map
+
+inline fun <T, E, T2> Resource<T, E>.mapSuccess(
+    transform: (T) -> T2
+) = when (this) {
+    is Resource.Result.Failure -> Resource.Result.Failure(error)
+    is Resource.Result.Success -> Resource.Result.Success(transform(data))
+    Resource.Loading -> Resource.Loading
+}
+
+inline fun <T, E, E2> Resource<T, E>.mapError(
+    transform: (E) -> E2
+) = when (this) {
+    is Resource.Result.Failure -> Resource.Result.Failure(transform(error))
+    is Resource.Result.Success -> Resource.Result.Success(data)
+    Resource.Loading -> Resource.Loading
+}
+
+inline fun <T, E, T2> Resource.Result<T, E>.mapSuccess(
+    transform: (T) -> T2
+) = asResource().mapSuccess(transform)
+
+inline fun <T, E, E2> Resource.Result<T, E>.mapError(
+    transform: (E) -> E2
+) = asResource().mapError(transform)
+
+// action
+
+inline fun <T, E> Resource<T, E>.ifSuccess(
+    onSuccess: (T) -> Unit,
+) = apply {
+    if (this is Resource.Result.Success) {
+        onSuccess(data)
+    }
+}
+
+inline fun <T, E> Resource<T, E>.ifFailure(
+    onError: (E) -> Unit,
+) = apply {
+    if (this is Resource.Result.Failure) {
+        onError(error)
+    }
+}
+
+inline fun <T, E> Resource<T, E>.ifLoading(
+    onLoading: () -> Unit,
+) = apply {
+    if (this == Resource.Loading) {
+        onLoading()
+    }
+}
+
+// getter
+
+inline fun <R, T : R, E> Resource.Result<T, E>.getOrElse(
+    onElse: (E) -> R,
+) = when (this) {
+    is Resource.Result.Failure -> onElse(error)
+    is Resource.Result.Success -> data
+}
+
+
+inline fun <R, T : R> Resource<T, *>.getOrElse(onElse: () -> R): R {
+
+    ifSuccess { return it }
+
+    return onElse()
+}
+
+
+fun <T> Resource<T, *>.getOrNull() = getOrElse { null }
+
+@Throws(IllegalStateException::class)
+fun <T> Resource<T, *>.getOrThrow(
+    message: String = "$this isn't success",
+) = getOrElse { error(message) }
\ No newline at end of file

From ea04e715335b025a2c7aac316080b90cc3b97b6f Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 01:18:33 -0300
Subject: [PATCH 05/14] feat: create Resource.Result::toResult extension

---
 src/main/kotlin/extension/Resource.kt | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/extension/Resource.kt b/src/main/kotlin/extension/Resource.kt
index 6365ef0..8e61c7b 100644
--- a/src/main/kotlin/extension/Resource.kt
+++ b/src/main/kotlin/extension/Resource.kt
@@ -85,4 +85,11 @@ fun <T> Resource<T, *>.getOrNull() = getOrElse { null }
 @Throws(IllegalStateException::class)
 fun <T> Resource<T, *>.getOrThrow(
     message: String = "$this isn't success",
-) = getOrElse { error(message) }
\ No newline at end of file
+) = getOrElse { error(message) }
+
+// parser
+
+fun <T> Resource.Result<T, Throwable>.toResult() = when (this) {
+    is Resource.Result.Success -> Result.success(data)
+    is Resource.Result.Failure -> Result.failure(error)
+}
\ No newline at end of file

From db8ba550e6c436cf1db69c57551c1c660e4d2fcd Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 01:38:35 -0300
Subject: [PATCH 06/14] test: improve Resource test

---
 src/test/kotlin/ResourceTest.kt | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/test/kotlin/ResourceTest.kt b/src/test/kotlin/ResourceTest.kt
index cf06f79..7bde24e 100644
--- a/src/test/kotlin/ResourceTest.kt
+++ b/src/test/kotlin/ResourceTest.kt
@@ -1,3 +1,4 @@
+import extension.asResource
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
@@ -16,7 +17,16 @@ class ResourceTest {
     }
 
     @Test
-    fun loadingResource_shouldBeLoading() {
+    fun loadingResource_shouldBeAlwaysEquals() {
         assertEquals(Resource.Loading, Resource.Loading)
     }
+
+    @Test
+    fun resource_whenRemainingBranches() {
+        when (Resource.Result.Success("testing").asResource()) {
+            is Resource.Result.Success -> Unit
+            is Resource.Result.Failure -> Unit
+            Resource.Loading -> Unit
+        }
+    }
 }
\ No newline at end of file

From 1598e8c4c9bd7116a054770f82f05ab4f373b558 Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 01:38:55 -0300
Subject: [PATCH 07/14] test: create Resource extensions test

---
 src/test/kotlin/extension/ResourceKtTest.kt | 90 +++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 src/test/kotlin/extension/ResourceKtTest.kt

diff --git a/src/test/kotlin/extension/ResourceKtTest.kt b/src/test/kotlin/extension/ResourceKtTest.kt
new file mode 100644
index 0000000..b866600
--- /dev/null
+++ b/src/test/kotlin/extension/ResourceKtTest.kt
@@ -0,0 +1,90 @@
+package extension
+
+import Resource
+import org.junit.jupiter.api.Test
+
+import org.junit.jupiter.api.Assertions.*
+
+class ResourceKtTest {
+
+    @Test
+    fun isLoading() {
+        val resource = Resource.Loading
+
+        assertTrue(resource.isLoading)
+        assertFalse(resource.isSuccess)
+        assertFalse(resource.isError)
+    }
+
+    @Test
+    fun isSuccess() {
+        val resource = Resource.Result.Success(Unit)
+
+        assertFalse(resource.isLoading)
+        assertTrue(resource.isSuccess)
+        assertFalse(resource.isError)
+    }
+
+    @Test
+    fun isError() {
+        val resource = Resource.Result.Failure(Unit)
+
+        assertFalse(resource.isLoading)
+        assertFalse(resource.isSuccess)
+        assertTrue(resource.isError)
+    }
+
+    @Test
+    fun asResource() {
+        Resource.Result.Success(Unit).asResource()
+        Resource.Result.Failure(Unit).asResource()
+    }
+
+    @Test
+    fun mapSuccess() {
+    }
+
+    @Test
+    fun mapError() {
+    }
+
+    @Test
+    fun testMapSuccess() {
+    }
+
+    @Test
+    fun testMapError() {
+    }
+
+    @Test
+    fun ifSuccess() {
+    }
+
+    @Test
+    fun ifFailure() {
+    }
+
+    @Test
+    fun ifLoading() {
+    }
+
+    @Test
+    fun getOrElse() {
+    }
+
+    @Test
+    fun testGetOrElse() {
+    }
+
+    @Test
+    fun getOrNull() {
+    }
+
+    @Test
+    fun getOrThrow() {
+    }
+
+    @Test
+    fun toResult() {
+    }
+}
\ No newline at end of file

From 8f9b8f41e24e73c4cfacb7ae020239455226caec Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 01:58:22 -0300
Subject: [PATCH 08/14] test: create Resource.Result::mapSuccess &&
 Resource.Result::mapError extensions test

---
 src/main/kotlin/extension/Resource.kt       |  16 ++-
 src/test/kotlin/extension/ResourceKtTest.kt | 122 +++++++++++++++++---
 2 files changed, 114 insertions(+), 24 deletions(-)

diff --git a/src/main/kotlin/extension/Resource.kt b/src/main/kotlin/extension/Resource.kt
index 8e61c7b..6cc807c 100644
--- a/src/main/kotlin/extension/Resource.kt
+++ b/src/main/kotlin/extension/Resource.kt
@@ -20,6 +20,13 @@ inline fun <T, E, T2> Resource<T, E>.mapSuccess(
     Resource.Loading -> Resource.Loading
 }
 
+inline fun <T, E, T2> Resource.Result<T, E>.mapSuccess(
+    transform: (T) -> T2
+) = when (this) {
+    is Resource.Result.Failure -> Resource.Result.Failure(error)
+    is Resource.Result.Success -> Resource.Result.Success(transform(data))
+}
+
 inline fun <T, E, E2> Resource<T, E>.mapError(
     transform: (E) -> E2
 ) = when (this) {
@@ -28,13 +35,12 @@ inline fun <T, E, E2> Resource<T, E>.mapError(
     Resource.Loading -> Resource.Loading
 }
 
-inline fun <T, E, T2> Resource.Result<T, E>.mapSuccess(
-    transform: (T) -> T2
-) = asResource().mapSuccess(transform)
-
 inline fun <T, E, E2> Resource.Result<T, E>.mapError(
     transform: (E) -> E2
-) = asResource().mapError(transform)
+) = when (this) {
+    is Resource.Result.Failure -> Resource.Result.Failure(transform(error))
+    is Resource.Result.Success -> Resource.Result.Success(data)
+}
 
 // action
 
diff --git a/src/test/kotlin/extension/ResourceKtTest.kt b/src/test/kotlin/extension/ResourceKtTest.kt
index b866600..97bb477 100644
--- a/src/test/kotlin/extension/ResourceKtTest.kt
+++ b/src/test/kotlin/extension/ResourceKtTest.kt
@@ -35,25 +35,109 @@ class ResourceKtTest {
     }
 
     @Test
-    fun asResource() {
-        Resource.Result.Success(Unit).asResource()
-        Resource.Result.Failure(Unit).asResource()
-    }
-
-    @Test
-    fun mapSuccess() {
-    }
-
-    @Test
-    fun mapError() {
-    }
-
-    @Test
-    fun testMapSuccess() {
-    }
-
-    @Test
-    fun testMapError() {
+    fun result_mapSuccess() {
+        listOf(
+            Pair(Resource.Result.Success(listOf("one")), listOf("one", "two")),
+            Pair(Resource.Result.Failure("error"), "error"),
+        ).map {
+            it.copy(
+                first = it.first.mapSuccess { data ->
+                    data + "two"
+                }
+            )
+        }.forEach { (resource, expected) ->
+            when (resource) {
+                is Resource.Result.Success -> {
+                    assertEquals(expected, resource.data)
+                }
+
+                is Resource.Result.Failure -> {
+                    assertEquals(expected, resource.error)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun resource_mapSuccess() {
+        listOf(
+            Pair(Resource.Result.Success(listOf("one")), listOf("one", "two")),
+            Pair(Resource.Result.Failure("error"), "error"),
+            Pair(Resource.Loading, "loading"),
+        ).map {
+            it.copy(
+                first = it.first.mapSuccess { data ->
+                    data + "two"
+                }
+            )
+        }.forEach { (resource, expected) ->
+            when (resource) {
+                is Resource.Result.Success -> {
+                    assertEquals(expected, resource.data)
+                }
+
+                is Resource.Result.Failure -> {
+                    assertEquals(expected, resource.error)
+                }
+
+                Resource.Loading -> {
+                    assertEquals(expected, "loading")
+                }
+            }
+        }
+    }
+
+    @Test
+    fun result_mapError() {
+        listOf(
+            Pair(Resource.Result.Success("data"), "data"),
+            Pair(Resource.Result.Failure(listOf("one")), listOf("one", "two")),
+        ).map {
+            it.copy(
+                first = it.first.mapError { data ->
+                    data + "two"
+                }
+            )
+        }.forEach { (resource, expected) ->
+            when (resource) {
+                is Resource.Result.Success -> {
+                    assertEquals(expected, resource.data)
+                }
+
+                is Resource.Result.Failure -> {
+                    assertEquals(expected, resource.error)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun resource_mapError() {
+        listOf(
+            Pair(Resource.Result.Success("data"), "data"),
+            Pair(Resource.Result.Failure(listOf("one")), listOf("one", "two")),
+            Pair(Resource.Loading, "loading"),
+        ).map {
+            it.copy(
+                first = it.first.mapError { data ->
+                    data + "two"
+                }
+            )
+        }.forEach { (resource, expected) ->
+            when (resource) {
+                is Resource.Result.Success -> {
+                    assertEquals(expected, resource.data)
+                }
+
+                is Resource.Result.Failure -> {
+                    assertEquals(expected, resource.error)
+                }
+
+                Resource.Loading -> {
+                    assertEquals(expected, "loading")
+                }
+            }
+        }
     }
 
     @Test

From 5a8a8ee1cec648194ff3353503f83bc6cc0461ff Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 02:16:09 -0300
Subject: [PATCH 09/14] test: create Resource::ifSuccess && Resource::ifFailure
 && Resource::ifLoading extensions test

---
 src/test/kotlin/extension/ResourceKtTest.kt | 51 +++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/src/test/kotlin/extension/ResourceKtTest.kt b/src/test/kotlin/extension/ResourceKtTest.kt
index 97bb477..ce3b3c7 100644
--- a/src/test/kotlin/extension/ResourceKtTest.kt
+++ b/src/test/kotlin/extension/ResourceKtTest.kt
@@ -142,14 +142,65 @@ class ResourceKtTest {
 
     @Test
     fun ifSuccess() {
+
+        var onSuccessCalled = false
+
+        Resource.Result.Success("test data").ifSuccess {
+            assertEquals("test data", it)
+            onSuccessCalled = true
+        }
+
+        assertTrue(onSuccessCalled)
+
+        listOf(
+            Resource.Result.Failure(Unit),
+            Resource.Loading
+        ).forEach { resource ->
+            resource.ifSuccess {
+                fail("${resource::class.java.simpleName} don't call onSuccess")
+            }
+        }
     }
 
     @Test
     fun ifFailure() {
+        var onFailureCalled = false
+
+        Resource.Result.Failure("test error").ifFailure {
+            assertEquals("test error", it)
+            onFailureCalled = true
+        }
+
+        assertTrue(onFailureCalled)
+
+        listOf(
+            Resource.Result.Success(Unit),
+            Resource.Loading
+        ).forEach { resource ->
+            resource.ifFailure {
+                fail("${resource::class.java.simpleName} don't call onFailure")
+            }
+        }
     }
 
     @Test
     fun ifLoading() {
+        var onLoadingCalled = false
+
+        Resource.Loading.ifLoading {
+            onLoadingCalled = true
+        }
+
+        assertTrue(onLoadingCalled)
+
+        listOf(
+            Resource.Result.Success(Unit),
+            Resource.Result.Failure(Unit)
+        ).forEach { resource ->
+            resource.ifLoading {
+                fail("${resource::class.java.simpleName} don't call onLoading")
+            }
+        }
     }
 
     @Test

From 9577f850d5a8105d9470357a8ef8f8d0a7da7251 Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 02:31:23 -0300
Subject: [PATCH 10/14] test: create Resource::getOrElse && Resource::getOrNull
 && Resource::getOrThrow test

---
 src/main/kotlin/extension/Resource.kt       | 12 +----
 src/test/kotlin/extension/ResourceKtTest.kt | 55 ++++++++++++++++++---
 2 files changed, 50 insertions(+), 17 deletions(-)

diff --git a/src/main/kotlin/extension/Resource.kt b/src/main/kotlin/extension/Resource.kt
index 6cc807c..aba6fca 100644
--- a/src/main/kotlin/extension/Resource.kt
+++ b/src/main/kotlin/extension/Resource.kt
@@ -70,15 +70,7 @@ inline fun <T, E> Resource<T, E>.ifLoading(
 
 // getter
 
-inline fun <R, T : R, E> Resource.Result<T, E>.getOrElse(
-    onElse: (E) -> R,
-) = when (this) {
-    is Resource.Result.Failure -> onElse(error)
-    is Resource.Result.Success -> data
-}
-
-
-inline fun <R, T : R> Resource<T, *>.getOrElse(onElse: () -> R): R {
+inline fun <R, T : R, E> Resource<T, E>.getOrElse(onElse: () -> R): R {
 
     ifSuccess { return it }
 
@@ -86,7 +78,7 @@ inline fun <R, T : R> Resource<T, *>.getOrElse(onElse: () -> R): R {
 }
 
 
-fun <T> Resource<T, *>.getOrNull() = getOrElse { null }
+fun <T, E> Resource<T, E>.getOrNull() = getOrElse { null }
 
 @Throws(IllegalStateException::class)
 fun <T> Resource<T, *>.getOrThrow(
diff --git a/src/test/kotlin/extension/ResourceKtTest.kt b/src/test/kotlin/extension/ResourceKtTest.kt
index ce3b3c7..a5d5e0f 100644
--- a/src/test/kotlin/extension/ResourceKtTest.kt
+++ b/src/test/kotlin/extension/ResourceKtTest.kt
@@ -1,9 +1,11 @@
 package extension
 
 import Resource
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.opentest4j.AssertionFailedError
 
-import org.junit.jupiter.api.Assertions.*
 
 class ResourceKtTest {
 
@@ -157,7 +159,7 @@ class ResourceKtTest {
             Resource.Loading
         ).forEach { resource ->
             resource.ifSuccess {
-                fail("${resource::class.java.simpleName} don't call onSuccess")
+                fail("${resource::class.java.simpleName} don't must call onSuccess")
             }
         }
     }
@@ -178,7 +180,7 @@ class ResourceKtTest {
             Resource.Loading
         ).forEach { resource ->
             resource.ifFailure {
-                fail("${resource::class.java.simpleName} don't call onFailure")
+                fail("${resource::class.java.simpleName} don't must call onFailure")
             }
         }
     }
@@ -198,25 +200,64 @@ class ResourceKtTest {
             Resource.Result.Failure(Unit)
         ).forEach { resource ->
             resource.ifLoading {
-                fail("${resource::class.java.simpleName} don't call onLoading")
+                fail("${resource::class.java.simpleName} don't must call onLoading")
             }
         }
     }
 
     @Test
     fun getOrElse() {
-    }
 
-    @Test
-    fun testGetOrElse() {
+        assertEquals(
+            "test data",
+            Resource.Result.Success("test data").getOrElse {
+                fail("getOrElse don't must call onElse when success")
+            },
+            "getOrElse must return data when success",
+        )
+
+        var failureOnElse = false
+
+        Resource.Result.Failure(Unit).getOrElse {
+            failureOnElse = true
+        }
+
+        var loadingOnElse = false
+
+        Resource.Loading.getOrElse {
+            loadingOnElse = true
+        }
+
+        assertTrue(failureOnElse)
+        assertTrue(loadingOnElse)
     }
 
     @Test
     fun getOrNull() {
+        listOf(
+            Pair(Resource.Result.Success("test data"), "test data"),
+            Pair(Resource.Result.Failure("test error"), null),
+            Pair(Resource.Loading, null),
+        ).forEach { (resource, expected) ->
+            assertEquals(expected, resource.getOrNull())
+        }
     }
 
     @Test
     fun getOrThrow() {
+        assertEquals(
+            "test data",
+            Resource.Result.Success("test data").getOrThrow(),
+            "getOrThrow must return data when success"
+        )
+
+        assertThrows<IllegalStateException> {
+            Resource.Result.Failure(Unit).getOrThrow()
+        }
+
+        assertThrows<IllegalStateException> {
+            Resource.Loading.getOrThrow()
+        }
     }
 
     @Test

From cb9ea6d1a394b74aac5036bacbe51a13e1a4436e Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 03:02:14 -0300
Subject: [PATCH 11/14] test: create Resource::toResult test

---
 src/test/kotlin/extension/ResourceKtTest.kt | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/test/kotlin/extension/ResourceKtTest.kt b/src/test/kotlin/extension/ResourceKtTest.kt
index a5d5e0f..e578bd2 100644
--- a/src/test/kotlin/extension/ResourceKtTest.kt
+++ b/src/test/kotlin/extension/ResourceKtTest.kt
@@ -4,7 +4,6 @@ import Resource
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
-import org.opentest4j.AssertionFailedError
 
 
 class ResourceKtTest {
@@ -262,5 +261,16 @@ class ResourceKtTest {
 
     @Test
     fun toResult() {
+        assertEquals(
+            Result.success("test data"),
+            Resource.Result.Success("test data").toResult()
+        )
+
+        val exception = Throwable("Test Error")
+
+        assertEquals(
+            Result.failure<Unit>(exception),
+            Resource.Result.Failure(exception).toResult()
+        )
     }
 }
\ No newline at end of file

From 79d2940b7636b0a0066cd39df86d985a108bc039 Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Fri, 18 Aug 2023 03:04:53 -0300
Subject: [PATCH 12/14] test: improve Resource::getOrThrow test

---
 src/main/kotlin/extension/Resource.kt       | 6 +++---
 src/test/kotlin/extension/ResourceKtTest.kt | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/kotlin/extension/Resource.kt b/src/main/kotlin/extension/Resource.kt
index aba6fca..f3dc87c 100644
--- a/src/main/kotlin/extension/Resource.kt
+++ b/src/main/kotlin/extension/Resource.kt
@@ -80,10 +80,10 @@ inline fun <R, T : R, E> Resource<T, E>.getOrElse(onElse: () -> R): R {
 
 fun <T, E> Resource<T, E>.getOrNull() = getOrElse { null }
 
-@Throws(IllegalStateException::class)
+
 fun <T> Resource<T, *>.getOrThrow(
-    message: String = "$this isn't success",
-) = getOrElse { error(message) }
+    error: Throwable = Throwable("$this isn't success"),
+) = getOrElse { throw error }
 
 // parser
 
diff --git a/src/test/kotlin/extension/ResourceKtTest.kt b/src/test/kotlin/extension/ResourceKtTest.kt
index e578bd2..74923fc 100644
--- a/src/test/kotlin/extension/ResourceKtTest.kt
+++ b/src/test/kotlin/extension/ResourceKtTest.kt
@@ -250,11 +250,11 @@ class ResourceKtTest {
             "getOrThrow must return data when success"
         )
 
-        assertThrows<IllegalStateException> {
+        assertThrows<Throwable> {
             Resource.Result.Failure(Unit).getOrThrow()
         }
 
-        assertThrows<IllegalStateException> {
+        assertThrows<Throwable> {
             Resource.Loading.getOrThrow()
         }
     }

From b414bdcf46f3d2c8e38a16be67c78ba815caa2dc Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Sun, 20 Aug 2023 03:55:22 -0300
Subject: [PATCH 13/14] feat: configure jitpack

---
 build.gradle.kts | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/build.gradle.kts b/build.gradle.kts
index ccb5cb6..5b6d2a7 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,5 +1,7 @@
 plugins {
     kotlin("jvm") version "1.9.0"
+    id("java-library")
+    id("maven-publish")
 }
 
 group = "com.neo.resource"
@@ -19,4 +21,16 @@ tasks.test {
 
 kotlin {
     jvmToolchain(8)
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            groupId = "com.neo.resource"
+            artifactId = "resource"
+            version = "1.0-DEV"
+
+            from(components["java"])
+        }
+    }
 }
\ No newline at end of file

From 3c00800fffb98f6f8ecdc24ca8924b3eb56af22e Mon Sep 17 00:00:00 2001
From: irineu silva <mmmirineusilva@gmail.com>
Date: Sun, 20 Aug 2023 04:18:29 -0300
Subject: [PATCH 14/14] chore: update version to v1.0

---
 build.gradle.kts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 5b6d2a7..204f06c 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
 }
 
 group = "com.neo.resource"
-version = "1.0-DEV"
+version = "1.0"
 
 repositories {
     mavenCentral()
@@ -28,7 +28,7 @@ publishing {
         create<MavenPublication>("maven") {
             groupId = "com.neo.resource"
             artifactId = "resource"
-            version = "1.0-DEV"
+            version = "1.0"
 
             from(components["java"])
         }