TimeFormat unit test and fix bugs founds

Author: DevSrSouza

core/src/main/kotlin/br/com/devsrsouza/kotlinbukkitapi/utils/TimeFormatUtils.kt

@@ -38,19 +38,21 @@ inline class TimeFormat(private val time: Int) {
         val months = time / 2419200 % 12
         val years = time / 29030400
 
-        var formated = formatStyle.replace(if (seconds > 0) "$seconds ${if (seconds > 1) lang.seconds else lang.second}" else "", "%SEC", true)
+        var formated = formatStyle.replace("%SEC", if (seconds > 0) "$seconds ${if (seconds > 1) lang.seconds else lang.second}" else "", true)
 
-        formated = formated.replace(if (minutes > 0) "$minutes ${if (minutes > 1) lang.minutes else lang.minute}" else "", "%MIN", true)
+        formated = formated.replace("%MIN", if (minutes > 0) "$minutes ${if (minutes > 1) lang.minutes else lang.minute}" else "", true)
 
-        formated = formated.replace(if (hours > 0) "$hours ${if (hours > 1) lang.hours else lang.hour}" else "", "%HOUR", true)
+        formated = formated.replace("%HOUR", if (hours > 0) "$hours ${if (hours > 1) lang.hours else lang.hour}" else "", true)
 
-        formated = formated.replace(if (days > 0) "$days ${if (days > 1) lang.days else lang.day}" else "", "%DAY", true)
+        formated = formated.replace("%DAY", if (days > 0) "$days ${if (days > 1) lang.days else lang.day}" else "", true)
 
-        formated = formated.replace(if (weeks > 0) "$weeks ${if (weeks > 1) lang.weeks else lang.week}" else "", "%WEEK", true)
+        formated = formated.replace("%WEEK", if (weeks > 0) "$weeks ${if (weeks > 1) lang.weeks else lang.week}" else "", true)
 
-        formated = formated.replace(if (months > 0) "$months ${if (months > 1) lang.months else lang.month}" else "", "%MONTH", true)
+        formated = formated.replace("%MONTH", if (months > 0) "$months ${if (months > 1) lang.months else lang.month}" else "", true)
 
-        formated = formated.replace(if (years > 0) "$years ${if (years > 1) lang.years else lang.year}" else "", "%YEAR", true)
+        formated = formated.replace("%YEAR", if (years > 0) "$years ${if (years > 1) lang.years else lang.year}" else "", true)
+
+        formated = formated.replace("$formatSpacer$formatSpacer", "$formatSpacer")
 
         return formated.trim { it == formatSpacer }
     }

core/src/test/kotlin/br/com/devsrsouza/kotlinbukkitapi/utils/TimeFormatUtilsTest.kt

@@ -0,0 +1,63 @@
+package br.com.devsrsouza.kotlinbukkitapi.utils
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class TimeFormatUtilsTest {
+
+    @Test
+    fun `should format time to human readable (EN - SINGLE)`() {
+        val time = 61
+
+        assertEquals("1 minute 1 second", time.formater.EN)
+    }
+
+    @Test
+    fun `should format time to human readable (EN - PLURAL)`() {
+        val time = 330
+
+        assertEquals("5 minutes 30 seconds", time.formater.EN)
+    }
+
+    @Test
+    fun `should format time to human readable (PT-BR - SINGLE)`() {
+        val time = 61
+
+        assertEquals("1 minuto 1 segundo", time.formater.PTBR)
+    }
+
+    @Test
+    fun `should format time to human readable (PT-BR - PLURAL)`() {
+        val time = 330
+
+        assertEquals("5 minutos 30 segundos", time.formater.PTBR)
+    }
+
+    @Test
+    fun `should format time to human readable with new formatter (EN)`() {
+        val time = 3601
+
+        val formater = "%HOUR %MIN %SEC"
+
+        assertEquals("1 hour 1 second", time.formater.format(ENFormat, formater))
+    }
+
+    @Test
+    fun `should format time to human readable with new formatter and spacer (EN)`() {
+        val time = 3601
+
+        val formater = "%HOUR;%MIN;%SEC"
+        val spacer = ';'
+
+        assertEquals("1 hour;1 second", time.formater.format(ENFormat, formater, spacer))
+    }
+
+    @Test
+    fun `should format time to human readable with new formatter without hour (EN)`() {
+        val time = 3661
+
+        val formater = "%MIN %SEC"
+
+        assertEquals("1 minute 1 second", time.formater.format(ENFormat, formater))
+    }
+}

core/src/test/kotlin/br/com/devsrsouza/kotlinbukkitapi/utils/TimeUtilsTest.kt

@@ -1,7 +1,7 @@
 package br.com.devsrsouza.kotlinbukkitapi.utils
 
 import br.com.devsrsouza.kotlinbukkitapi.utils.time.*
-import org.junit.Assert
+import org.junit.Assert.*
 import org.junit.Test
 
 class TimeUtilsTest {
@@ -11,198 +11,198 @@ class TimeUtilsTest {
         val time = 300L
         val millisecond = 300L
 
-        Assert.assertEquals(millisecond, time.millisecond.toMillisecond())
+        assertEquals(millisecond, time.millisecond.toMillisecond())
     }
 
     @Test
     fun `should convert correctly milliseconds to ticks`() {
         val time = 250L
         val tick = 5L
 
-        Assert.assertEquals(tick, time.millisecond.toTick())
+        assertEquals(tick, time.millisecond.toTick())
     }
 
     @Test
     fun `should convert correctly milliseconds to seconds`() {
         val time = 5000L
         val second = 5
 
-        Assert.assertEquals(second, time.millisecond.toSecond())
+        assertEquals(second, time.millisecond.toSecond())
     }
 
     @Test
     fun `should convert correctly milliseconds to minutes`() {
         val time = 60_000L
         val minute = 1
 
-        Assert.assertEquals(minute, time.millisecond.toMinute())
+        assertEquals(minute, time.millisecond.toMinute())
     }
 
     @Test
     fun `should convert correctly milliseconds to hours`() {
         val time = 7_200_000L
         val hour = 2
 
-        Assert.assertEquals(hour, time.millisecond.toHour())
+        assertEquals(hour, time.millisecond.toHour())
     }
 
     @Test
     fun `should convert correctly ticks to milliseconds`() {
         val time = 20L
         val millisecond = 1000L
 
-        Assert.assertEquals(millisecond, time.tick.toMillisecond())
+        assertEquals(millisecond, time.tick.toMillisecond())
     }
 
     @Test
     fun `should convert correctly ticks to ticks`() {
         val time = 20L
         val tick = 20L
 
-        Assert.assertEquals(tick, time.tick.toTick())
+        assertEquals(tick, time.tick.toTick())
     }
 
     @Test
     fun `should convert correctly ticks to seconds`() {
         val time = 20L
         val second = 1
 
-        Assert.assertEquals(second, time.tick.toSecond())
+        assertEquals(second, time.tick.toSecond())
     }
 
     @Test
     fun `should convert correctly ticks to minutes`() {
         val time = 2_400L
         val minute = 2
 
-        Assert.assertEquals(minute, time.tick.toMinute())
+        assertEquals(minute, time.tick.toMinute())
     }
 
     @Test
     fun `should convert correctly ticks to hours`() {
         val time = 144_000L
         val hour = 2
 
-        Assert.assertEquals(hour, time.tick.toHour())
+        assertEquals(hour, time.tick.toHour())
     }
 
     @Test
     fun `should convert correctly seconds to milliseconds`() {
         val time = 8
         val millisecond = 8000L
 
-        Assert.assertEquals(millisecond, time.second.toMillisecond())
+        assertEquals(millisecond, time.second.toMillisecond())
     }
 
     @Test
     fun `should convert correctly seconds to ticks`() {
         val time = 2
         val tick = 40L
 
-        Assert.assertEquals(tick, time.second.toTick())
+        assertEquals(tick, time.second.toTick())
     }
 
     @Test
     fun `should convert correctly seconds to seconds`() {
         val time = 20
         val second = 20
 
-        Assert.assertEquals(second, time.second.toSecond())
+        assertEquals(second, time.second.toSecond())
     }
 
     @Test
     fun `should convert correctly seconds to minutes`() {
         val time = 120
         val minute = 2
 
-        Assert.assertEquals(minute, time.second.toMinute())
+        assertEquals(minute, time.second.toMinute())
     }
 
     @Test
     fun `should convert correctly seconds to hours`() {
         val time = 7_200
         val hour = 2
 
-        Assert.assertEquals(hour, time.second.toHour())
+        assertEquals(hour, time.second.toHour())
     }
 
     @Test
     fun `should convert correctly minutes to milliseconds`() {
         val time = 1
         val millisecond = 60_000L
 
-        Assert.assertEquals(millisecond, time.minute.toMillisecond())
+        assertEquals(millisecond, time.minute.toMillisecond())
     }
 
     @Test
     fun `should convert correctly minutes to ticks`() {
         val time = 1
         val tick = 1_200L
 
-        Assert.assertEquals(tick, time.minute.toTick())
+        assertEquals(tick, time.minute.toTick())
     }
 
     @Test
     fun `should convert correctly minutes to seconds`() {
         val time = 1
         val second = 60
 
-        Assert.assertEquals(second, time.minute.toSecond())
+        assertEquals(second, time.minute.toSecond())
     }
 
     @Test
     fun `should convert correctly minutes to minutes`() {
         val time = 25
         val minute = 25
 
-        Assert.assertEquals(minute, time.minute.toMinute())
+        assertEquals(minute, time.minute.toMinute())
     }
 
     @Test
     fun `should convert correctly minutes to hours`() {
         val time = 120
         val hour = 2
 
-        Assert.assertEquals(hour, time.minute.toHour())
+        assertEquals(hour, time.minute.toHour())
     }
 
     @Test
     fun `should convert correctly hours to milliseconds`() {
         val time = 1
         val millisecond = 3_600_000L
 
-        Assert.assertEquals(millisecond, time.hour.toMillisecond())
+        assertEquals(millisecond, time.hour.toMillisecond())
     }
 
     @Test
     fun `should convert correctly hours to ticks`() {
         val time = 2
         val tick = 144_000L
 
-        Assert.assertEquals(tick, time.hour.toTick())
+        assertEquals(tick, time.hour.toTick())
     }
 
     @Test
     fun `should convert correctly hours to seconds`() {
         val time = 3
         val second = 10_800
 
-        Assert.assertEquals(second, time.hour.toSecond())
+        assertEquals(second, time.hour.toSecond())
     }
 
     @Test
     fun `should convert correctly hours to minutes`() {
         val time = 3
         val minute = 180
 
-        Assert.assertEquals(minute, time.hour.toMinute())
+        assertEquals(minute, time.hour.toMinute())
     }
 
     @Test
     fun `should convert correctly hours to hours`() {
         val time = 3
         val hour = 3
 
-        Assert.assertEquals(hour, time.hour.toHour())
+        assertEquals(hour, time.hour.toHour())
     }
 }