Added more tests

sources/common-test/measurement/DaysTest.kt

@@ -66,36 +66,36 @@ object DaysTest {
 		assertEquals(Hours(240), Days(10).toHours())
 		assertEquals(10, Days(10).toInt())
 		assertEquals(10L, Days(10).toLong())
-		assertEquals(Microseconds(864_000_000_000L), Days(10).toMicroseconds())
-		assertEquals(Milliseconds(864_000_000L), Days(10).toMilliseconds())
+		assertEquals(Microseconds(864_000_000_000), Days(10).toMicroseconds())
+		assertEquals(Milliseconds(864_000_000), Days(10).toMilliseconds())
 		assertEquals(Minutes(14_400L), Days(10).toMinutes())
-		assertEquals(Nanoseconds(864_000_000_000_000L), Days(10).toNanoseconds())
+		assertEquals(Nanoseconds(864_000_000_000_000), Days(10).toNanoseconds())
 		assertEquals(PreciseDuration.of(days = 10), Days(10).toPreciseDuration())
-		assertEquals(Seconds(864_000L), Days(10).toSeconds())
+		assertEquals(Seconds(864_000), Days(10).toSeconds())
 		assertEquals("10", Days(10).toString())
 
 		assertEquals(Days(10), 10.days.toDays())
 	}
 
 
 	@Test
-	fun testIsNegative() {
+	fun testMap() {
+		assertEquals(Days(20), Days(10).map { it * 2 })
+	}
+
+
+	@Test
+	fun testTests() {
 		assertTrue(Days(-1).isNegative)
 		assertFalse(Days(0).isNegative)
 		assertFalse(Days(1).isNegative)
-	}
 
+		assertFalse(Days(-1).isPositive)
+		assertFalse(Days(0).isPositive)
+		assertTrue(Days(1).isPositive)
 
-	@Test
-	fun testIsZero() {
 		assertFalse(Days(-1).isZero)
 		assertTrue(Days(0).isZero)
 		assertFalse(Days(1).isZero)
 	}
-
-
-	@Test
-	fun testMap() {
-		assertEquals(Days(20), Days(10).map { it * 2 })
-	}
 }

sources/common-test/measurement/HoursTest.kt

@@ -67,36 +67,36 @@ object HoursTest {
 		assertEquals(10.hours, Hours(10).toDuration())
 		assertEquals(10, Hours(10).toInt())
 		assertEquals(10L, Hours(10).toLong())
-		assertEquals(Microseconds(36_000_000_000L), Hours(10).toMicroseconds())
-		assertEquals(Milliseconds(36_000_000L), Hours(10).toMilliseconds())
+		assertEquals(Microseconds(36_000_000_000), Hours(10).toMicroseconds())
+		assertEquals(Milliseconds(36_000_000), Hours(10).toMilliseconds())
 		assertEquals(Minutes(600L), Hours(10).toMinutes())
-		assertEquals(Nanoseconds(36_000_000_000_000L), Hours(10).toNanoseconds())
+		assertEquals(Nanoseconds(36_000_000_000_000), Hours(10).toNanoseconds())
 		assertEquals(PreciseDuration.of(hours = 10), Hours(10).toPreciseDuration())
-		assertEquals(Seconds(36_000L), Hours(10).toSeconds())
+		assertEquals(Seconds(36_000), Hours(10).toSeconds())
 		assertEquals("10", Hours(10).toString())
 
 		assertEquals(Hours(10), 10.hours.toHours())
 	}
 
 
 	@Test
-	fun testIsNegative() {
+	fun testMap() {
+		assertEquals(Hours(20), Hours(10).map { it * 2 })
+	}
+
+
+	@Test
+	fun testTests() {
 		assertTrue(Hours(-1).isNegative)
 		assertFalse(Hours(0).isNegative)
 		assertFalse(Hours(1).isNegative)
-	}
 
+		assertFalse(Hours(-1).isPositive)
+		assertFalse(Hours(0).isPositive)
+		assertTrue(Hours(1).isPositive)
 
-	@Test
-	fun testIsZero() {
 		assertFalse(Hours(-1).isZero)
 		assertTrue(Hours(0).isZero)
 		assertFalse(Hours(1).isZero)
 	}
-
-
-	@Test
-	fun testMap() {
-		assertEquals(Hours(20), Hours(10).map { it * 2 })
-	}
 }

sources/common-test/measurement/MicrosecondsTest.kt

@@ -0,0 +1,106 @@
+package tests
+
+import com.github.fluidsonic.fluid.time.*
+import kotlin.test.*
+import kotlin.time.*
+
+
+object MicrosecondsTest {
+
+	@Test
+	fun testArithmethic() {
+		assertEquals(Microseconds(1), Microseconds(-1).absolute)
+		assertEquals(Microseconds(0), Microseconds(0).absolute)
+		assertEquals(Microseconds(1), Microseconds(1).absolute)
+
+		assertEquals(Microseconds(5), Microseconds(10) / 2)
+		assertEquals(Microseconds(5), Microseconds(10L) / 2)
+		assertEquals(5, Microseconds(10) / Microseconds(2))
+
+		assertEquals(Microseconds(2), Microseconds(10) - Microseconds(8))
+
+		assertEquals(Microseconds(18), Microseconds(10) + Microseconds(8))
+
+		assertEquals(Microseconds(1), Microseconds(10) % 3)
+		assertEquals(Microseconds(1), Microseconds(10) % 3L)
+		assertEquals(Microseconds(1), Microseconds(10) % Microseconds(3))
+
+		assertEquals(Microseconds(20), Microseconds(10) * 2)
+		assertEquals(Microseconds(20), Microseconds(10) * 2L)
+
+		assertEquals(Microseconds(-10), -Microseconds(10))
+
+		assertEquals(Microseconds(20), 2 * Microseconds(10))
+		assertEquals(Microseconds(20), 2L * Microseconds(10))
+	}
+
+
+	@Suppress("ReplaceCallWithBinaryOperator")
+	@Test
+	fun testComparison() {
+		assertTrue(Microseconds(1).compareTo(Microseconds(2)) < 0)
+		assertTrue(Microseconds(1).compareTo(Microseconds(1)) == 0)
+		assertTrue(Microseconds(2).compareTo(Microseconds(1)) > 0)
+	}
+
+
+	@Test
+	fun testConstants() {
+		assertEquals(Microseconds(Long.MAX_VALUE), Microseconds.max)
+		assertEquals(Microseconds(Long.MIN_VALUE), Microseconds.min)
+		assertEquals(Microseconds(86_400_000_000), Microseconds.perDay)
+		assertEquals(Microseconds(3_600_000_000), Microseconds.perHour)
+		assertEquals(Microseconds(1_000), Microseconds.perMillisecond)
+		assertEquals(Microseconds(60_000_000), Microseconds.perMinute)
+		assertEquals(Microseconds(1_000_000), Microseconds.perSecond)
+		assertEquals(Microseconds(0), Microseconds.zero)
+	}
+
+
+	@Test
+	fun testConstruction() {
+		assertEquals(123, Microseconds(123).toInt())
+		assertEquals(123L, Microseconds(123L).toLong())
+	}
+
+
+	@Test
+	@UseExperimental(ExperimentalTime::class)
+	fun testConversion() {
+		assertEquals(Days(1), Microseconds(86_400_000_000).toDays())
+		assertEquals(10.microseconds, Microseconds(10).toDuration())
+		assertEquals(Hours(1), Microseconds(3_600_000_000).toHours())
+		assertEquals(10, Microseconds(10).toInt())
+		assertEquals(10L, Microseconds(10).toLong())
+		assertEquals(Milliseconds(1), Microseconds(1_000).toMilliseconds())
+		assertEquals(Minutes(1), Microseconds(60_000_000).toMinutes())
+		assertEquals(Nanoseconds(10_000), Microseconds(10).toNanoseconds())
+		assertEquals(PreciseDuration.of(microseconds = 10), Microseconds(10).toPreciseDuration())
+		assertEquals(Seconds(1), Microseconds(1_000_000).toSeconds())
+		assertEquals("10", Microseconds(10).toString())
+
+		assertEquals(Microseconds(10), 10.microseconds.toMicroseconds())
+	}
+
+
+	@Test
+	fun testMap() {
+		assertEquals(Microseconds(20), Microseconds(10).map { it * 2 })
+	}
+
+
+	@Test
+	fun testTests() {
+		assertTrue(Microseconds(-1).isNegative)
+		assertFalse(Microseconds(0).isNegative)
+		assertFalse(Microseconds(1).isNegative)
+
+		assertFalse(Microseconds(-1).isPositive)
+		assertFalse(Microseconds(0).isPositive)
+		assertTrue(Microseconds(1).isPositive)
+
+		assertFalse(Microseconds(-1).isZero)
+		assertTrue(Microseconds(0).isZero)
+		assertFalse(Microseconds(1).isZero)
+	}
+}

sources/common-test/measurement/MillisecondsTest.kt

@@ -0,0 +1,105 @@
+package tests
+
+import com.github.fluidsonic.fluid.time.*
+import kotlin.test.*
+import kotlin.time.*
+
+
+object MillisecondsTest {
+
+	@Test
+	fun testArithmethic() {
+		assertEquals(Milliseconds(1), Milliseconds(-1).absolute)
+		assertEquals(Milliseconds(0), Milliseconds(0).absolute)
+		assertEquals(Milliseconds(1), Milliseconds(1).absolute)
+
+		assertEquals(Milliseconds(5), Milliseconds(10) / 2)
+		assertEquals(Milliseconds(5), Milliseconds(10L) / 2)
+		assertEquals(5, Milliseconds(10) / Milliseconds(2))
+
+		assertEquals(Milliseconds(2), Milliseconds(10) - Milliseconds(8))
+
+		assertEquals(Milliseconds(18), Milliseconds(10) + Milliseconds(8))
+
+		assertEquals(Milliseconds(1), Milliseconds(10) % 3)
+		assertEquals(Milliseconds(1), Milliseconds(10) % 3L)
+		assertEquals(Milliseconds(1), Milliseconds(10) % Milliseconds(3))
+
+		assertEquals(Milliseconds(20), Milliseconds(10) * 2)
+		assertEquals(Milliseconds(20), Milliseconds(10) * 2L)
+
+		assertEquals(Milliseconds(-10), -Milliseconds(10))
+
+		assertEquals(Milliseconds(20), 2 * Milliseconds(10))
+		assertEquals(Milliseconds(20), 2L * Milliseconds(10))
+	}
+
+
+	@Suppress("ReplaceCallWithBinaryOperator")
+	@Test
+	fun testComparison() {
+		assertTrue(Milliseconds(1).compareTo(Milliseconds(2)) < 0)
+		assertTrue(Milliseconds(1).compareTo(Milliseconds(1)) == 0)
+		assertTrue(Milliseconds(2).compareTo(Milliseconds(1)) > 0)
+	}
+
+
+	@Test
+	fun testConstants() {
+		assertEquals(Milliseconds(Long.MAX_VALUE), Milliseconds.max)
+		assertEquals(Milliseconds(Long.MIN_VALUE), Milliseconds.min)
+		assertEquals(Milliseconds(86_400_000), Milliseconds.perDay)
+		assertEquals(Milliseconds(3_600_000), Milliseconds.perHour)
+		assertEquals(Milliseconds(60_000), Milliseconds.perMinute)
+		assertEquals(Milliseconds(1_000), Milliseconds.perSecond)
+		assertEquals(Milliseconds(0), Milliseconds.zero)
+	}
+
+
+	@Test
+	fun testConstruction() {
+		assertEquals(123, Milliseconds(123).toInt())
+		assertEquals(123L, Milliseconds(123L).toLong())
+	}
+
+
+	@Test
+	@UseExperimental(ExperimentalTime::class)
+	fun testConversion() {
+		assertEquals(Days(1), Milliseconds(86_400_000).toDays())
+		assertEquals(10.milliseconds, Milliseconds(10).toDuration())
+		assertEquals(Hours(1), Milliseconds(3_600_000).toHours())
+		assertEquals(10, Milliseconds(10).toInt())
+		assertEquals(10L, Milliseconds(10).toLong())
+		assertEquals(Microseconds(10_000L), Milliseconds(10).toMicroseconds())
+		assertEquals(Minutes(1), Milliseconds(60_000).toMinutes())
+		assertEquals(Nanoseconds(10_000_000), Milliseconds(10).toNanoseconds())
+		assertEquals(PreciseDuration.of(milliseconds = 10), Milliseconds(10).toPreciseDuration())
+		assertEquals(Seconds(1), Milliseconds(1_000).toSeconds())
+		assertEquals("10", Milliseconds(10).toString())
+
+		assertEquals(Milliseconds(10), 10.milliseconds.toMilliseconds())
+	}
+
+
+	@Test
+	fun testMap() {
+		assertEquals(Milliseconds(20), Milliseconds(10).map { it * 2 })
+	}
+
+
+	@Test
+	fun testTests() {
+		assertTrue(Milliseconds(-1).isNegative)
+		assertFalse(Milliseconds(0).isNegative)
+		assertFalse(Milliseconds(1).isNegative)
+
+		assertFalse(Milliseconds(-1).isPositive)
+		assertFalse(Milliseconds(0).isPositive)
+		assertTrue(Milliseconds(1).isPositive)
+
+		assertFalse(Milliseconds(-1).isZero)
+		assertTrue(Milliseconds(0).isZero)
+		assertFalse(Milliseconds(1).isZero)
+	}
+}