music: complete non-android date tests

Complete the date tests that don't require a context.

CHANGELOG.md

@@ -13,6 +13,9 @@ file manager
 #### What's Changed
 - Implemented new queue system
 
+#### Dev/Meta
+- Added unit testing framework
+
 ## 3.0.1
 
 #### What's New

app/src/main/java/org/oxycblt/auxio/music/Date.kt

@@ -74,7 +74,7 @@ class Date private constructor(private val tokens: List<Int>) : Comparable<Date>
 
     override fun hashCode() = tokens.hashCode()
 
-    override fun equals(other: Any?) = other is Date && other.compareTo(this) == 0
+    override fun equals(other: Any?) = other is Date && compareTo(other) == 0
 
     override fun compareTo(other: Date): Int {
         for (i in 0 until max(tokens.size, other.tokens.size)) {

app/src/test/java/org/oxycblt/auxio/music/DateTest.kt

@@ -18,63 +18,137 @@
 package org.oxycblt.auxio.music
 
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class DateTest {
-    // TODO: Incomplete
+    @Test
+    fun date_equals() {
+        assertTrue(
+            requireNotNull(Date.from("2016-08-16T00:01:02")) ==
+                requireNotNull(Date.from("2016-08-16T00:01:02")))
+    }
+
+    @Test
+    fun date_precisionEquals() {
+        assertTrue(
+            requireNotNull(Date.from("2016-08-16T00:01:02")) !=
+                requireNotNull(Date.from("2016-08-16")))
+    }
+
+    @Test
+    fun date_compareDates() {
+        val a = requireNotNull(Date.from("2016-08-16T00:01:02"))
+        val b = requireNotNull(Date.from("2016-09-16T00:01:02"))
+        assertEquals(-1, a.compareTo(b))
+    }
+
+    @Test
+    fun date_compareTimes() {
+        val a = requireNotNull(Date.from("2016-08-16T00:02:02"))
+        val b = requireNotNull(Date.from("2016-08-16T00:01:02"))
+        assertEquals(1, a.compareTo(b))
+    }
+
+    @Test
+    fun date_comparePrecision() {
+        val a = requireNotNull(Date.from("2016-08-16T00:01:02"))
+        val b = requireNotNull(Date.from("2016-08-16"))
+        assertEquals(
+            1,
+            a.compareTo(b),
+        )
+    }
 
     @Test
     fun date_fromYear() {
-        assertEquals(Date.from(2016).toString(), "2016")
+        assertEquals("2016", Date.from(2016).toString())
     }
 
     @Test
     fun date_fromDate() {
-        assertEquals(Date.from(2016, 8, 16).toString(), "2016-08-16")
+        assertEquals("2016-08-16", Date.from(2016, 8, 16).toString())
     }
 
     @Test
     fun date_fromDatetime() {
-        assertEquals(Date.from(2016, 8, 16, 0, 1).toString(), "2016-08-16T00:01Z")
+        assertEquals("2016-08-16T00:01Z", Date.from(2016, 8, 16, 0, 1).toString())
     }
 
     @Test
     fun date_fromFormalTimestamp() {
-        assertEquals(Date.from("2016-08-16T00:01:02").toString(), "2016-08-16T00:01:02Z")
+        assertEquals("2016-08-16T00:01:02Z", Date.from("2016-08-16T00:01:02").toString())
     }
 
     @Test
     fun date_fromSpacedTimestamp() {
-        assertEquals(Date.from("2016-08-16 00:01:02").toString(), "2016-08-16T00:01:02Z")
+        assertEquals("2016-08-16T00:01:02Z", Date.from("2016-08-16 00:01:02").toString())
     }
 
     @Test
     fun date_fromDatestamp() {
-        assertEquals(Date.from("2016-08-16").toString(), "2016-08-16")
+        assertEquals(
+            "2016-08-16",
+            Date.from("2016-08-16").toString(),
+        )
     }
 
     @Test
     fun date_fromWeirdDateTimestamp() {
-        assertEquals(Date.from("2016-08-16T00:01").toString(), "2016-08-16T00:01Z")
+        assertEquals("2016-08-16T00:01Z", Date.from("2016-08-16T00:01").toString())
     }
 
     @Test
     fun date_fromWeirdDatestamp() {
-        assertEquals(Date.from("2016-08").toString(), "2016-08")
+        assertEquals("2016-08", Date.from("2016-08").toString())
     }
 
     @Test
     fun date_fromYearStamp() {
-        assertEquals(Date.from("2016").toString(), "2016")
+        assertEquals("2016", Date.from("2016").toString())
     }
 
     @Test
     fun date_fromWackTimestamp() {
-        assertEquals(Date.from("2016-11-32 25:43:01").toString(), "2016-11")
+        assertEquals("2016-11", Date.from("2016-11-32 25:43:01").toString())
+    }
+
+    @Test
+    fun date_fromBustedTimestamp() {
+        assertEquals(null, Date.from("2016-08-16:00:01:02"))
+        assertEquals(null, Date.from(""))
     }
 
     @Test
     fun date_fromWackYear() {
         assertEquals(Date.from(0), null)
     }
+
+    @Test
+    fun dateRange_fromDates() {
+        val range =
+            requireNotNull(
+                Date.Range.from(
+                    listOf(
+                        requireNotNull(Date.from("2016-08-16T00:01:02")),
+                        requireNotNull(Date.from("2016-07-16")),
+                        requireNotNull(Date.from("2014-03-12T00")),
+                        requireNotNull(Date.from("2022-12-22T22:22:22")))))
+        assertEquals("2014-03-12T00Z", range.min.toString())
+        assertEquals("2022-12-22T22:22:22Z", range.max.toString())
+    }
+
+    @Test
+    fun dateRange_fromSingle() {
+        val range =
+            requireNotNull(
+                Date.Range.from(listOf(requireNotNull(Date.from("2016-08-16T00:01:02")))))
+        assertEquals("2016-08-16T00:01:02Z", range.min.toString())
+        assertEquals("2016-08-16T00:01:02Z", range.max.toString())
+    }
+
+    @Test
+    fun dateRange_empty() {
+        assertEquals(null, Date.Range.from(listOf()))
+    }
 }

app/src/test/java/org/oxycblt/auxio/music/parsing/ParsingUtilTest.kt

@@ -21,63 +21,69 @@ import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class ParsingUtilTest {
+    // TODO: Incomplete
+
     @Test
     fun splitEscaped_correct() {
-        assertEquals("a,b,c".splitEscaped { it == ',' }, listOf("a", "b", "c"))
+        assertEquals(listOf("a", "b", "c"), "a,b,c".splitEscaped { it == ',' })
     }
 
     @Test
     fun splitEscaped_escaped() {
-        assertEquals("a\\,b,c".splitEscaped { it == ',' }, listOf("a,b", "c"))
+        assertEquals(listOf("a,b", "c"), "a\\,b,c".splitEscaped { it == ',' })
     }
 
     @Test
     fun splitEscaped_whitespace() {
-        assertEquals("a , b, c ,  ".splitEscaped { it == ',' }, listOf("a ", " b", " c ", "  "))
+        assertEquals(listOf("a ", " b", " c ", "  "), "a , b, c ,  ".splitEscaped { it == ',' })
     }
 
     @Test
     fun splitEscaped_escapedWhitespace() {
-        assertEquals("a \\, b, c ,  ".splitEscaped { it == ',' }, listOf("a , b", " c ", "  "))
+        assertEquals(listOf("a , b", " c ", "  "), ("a \\, b, c ,  ".splitEscaped { it == ',' }))
     }
 
     @Test
     fun correctWhitespace_stringCorrect() {
         assertEquals(
-            " asymptotic self-improvement  ".correctWhitespace(), "asymptotic self-improvement")
+            "asymptotic self-improvement",
+            " asymptotic self-improvement  ".correctWhitespace(),
+        )
     }
 
     @Test
     fun correctWhitespace_stringOopsAllWhitespace() {
-        assertEquals("      ".correctWhitespace(), null)
+        assertEquals(null, "".correctWhitespace())
+        assertEquals(null, "      ".correctWhitespace())
     }
 
     @Test
     fun correctWhitespace_listCorrect() {
         assertEquals(
+            listOf("asymptotic self-improvement", "daemons never stop", "tcp phagocyte"),
             listOf(" asymptotic self-improvement  ", "  daemons never stop", "tcp phagocyte")
                 .correctWhitespace(),
-            listOf("asymptotic self-improvement", "daemons never stop", "tcp phagocyte"))
+        )
     }
 
     @Test
     fun correctWhitespace_listOopsAllWhitespacE() {
         assertEquals(
-            listOf("      ", "", "  tcp phagocyte").correctWhitespace(), listOf("tcp phagocyte"))
+            listOf("tcp phagocyte"), listOf("      ", "", "  tcp phagocyte").correctWhitespace())
     }
 
     @Test
     fun parseId3v2Position_correct() {
-        assertEquals("16/32".parseId3v2Position(), 16)
+        assertEquals(16, "16/32".parseId3v2Position())
     }
 
     @Test
     fun parseId3v2Position_noTotal() {
-        assertEquals("16".parseId3v2Position(), 16)
+        assertEquals(16, "16".parseId3v2Position())
     }
 
     @Test
     fun parseId3v2Position_wack() {
-        assertEquals("16/".parseId3v2Position(), 16)
+        assertEquals(16, "16/".parseId3v2Position())
     }
 }