caspervk/AndroidAPS
1
0
Fork 0
Code Releases Activity

Merge remote-tracking branch 'origin/dev' into refactor

Browse source
This commit is contained in:
Milos Kozak 2023-09-19 14:45:50 +02:00
parent 5f92f29f41 434986fddf
commit be78449e33
5 changed files with 206 additions and 206 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
app-wear-shared/shared-impl/src/test/kotlin/info/nightscout/shared/impl/logging/LImplTest.kt
View file

@ -1,8 +1,8 @@
package info.nightscout.shared.impl.logging
import com.google.common.truth.Truth.assertThat
import info.nightscout.rx.logging.LTag
import info.nightscout.shared.sharedPreferences.SP
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
@ -26,13 +26,13 @@ class LImplTest {
@Test
fun findByName() {
Assertions.assertEquals(LTag.APS.name, sut.findByName("APS").name)
Assertions.assertEquals("NONEXISTENT", sut.findByName("APS2").name)
assertThat(sut.findByName("APS").name).isEqualTo(LTag.APS.name)
assertThat(sut.findByName("APS2").name).isEqualTo("NONEXISTENT")
}
@Test
fun getLogElements() {
Assertions.assertTrue(sut.getLogElements().isNotEmpty())
assertThat(sut.getLogElements()).isNotEmpty()
}
@Test
@ -40,6 +40,6 @@ class LImplTest {
val element = sut.findByName("APS")
element.enabled = false
sut.resetToDefaults()
Assertions.assertTrue(element.enabled)
assertThat(element.enabled).isTrue()
}
}
}

110
app-wear-shared/shared-impl/src/test/kotlin/info/nightscout/shared/impl/sharedPreferences/SPImplementationTest.kt
View file

@ -1,8 +1,8 @@
package info.nightscout.shared.impl.sharedPreferences
import com.google.common.truth.Truth.assertThat
import android.content.Context
import info.nightscout.shared.impl.SharedPreferencesMock
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
@ -34,153 +34,153 @@ class SPImplementationTest {
@Test
fun edit() {
sut.edit { putBoolean("test", true) }
Assertions.assertTrue(sut.getBoolean("test", false))
assertThat(sut.getBoolean("test", false)).isTrue()
sut.edit { remove("test") }
Assertions.assertFalse(sut.contains("test"))
assertThat(sut.contains("test")).isFalse()
sut.edit { putBoolean(someResource, true) }
Assertions.assertTrue(sut.getBoolean(someResource, false))
assertThat(sut.getBoolean(someResource, false)).isTrue()
sut.edit { remove(someResource) }
Assertions.assertFalse(sut.contains(someResource))
assertThat(sut.contains(someResource)).isFalse()
sut.edit(commit = true) { putDouble("test", 1.0) }
Assertions.assertEquals(1.0, sut.getDouble("test", 2.0))
assertThat(sut.getDouble("test", 2.0)).isEqualTo(1.0)
sut.edit { putDouble(someResource, 1.0) }
Assertions.assertEquals(1.0, sut.getDouble(someResource, 2.0))
assertThat(sut.getDouble(someResource, 2.0)).isEqualTo(1.0)
sut.edit { clear() }
Assertions.assertFalse(sut.contains(someResource2))
assertThat(sut.contains(someResource2)).isFalse()
sut.edit { putInt("test", 1) }
Assertions.assertEquals(1, sut.getInt("test", 2))
assertThat(sut.getInt("test", 2)).isEqualTo(1)
sut.edit { putInt(someResource, 1) }
Assertions.assertEquals(1, sut.getInt(someResource, 2))
assertThat(sut.getInt(someResource, 2)).isEqualTo(1)
sut.edit { clear() }
sut.edit { putLong("test", 1L) }
Assertions.assertEquals(1L, sut.getLong("test", 2L))
assertThat(sut.getLong("test", 2L)).isEqualTo(1L)
sut.edit { putLong(someResource, 1) }
Assertions.assertEquals(1L, sut.getLong(someResource, 2L))
assertThat(sut.getLong(someResource, 2L)).isEqualTo(1L)
sut.edit { clear() }
sut.edit { putString("test", "string") }
Assertions.assertEquals("string", sut.getString("test", "a"))
assertThat(sut.getString("test", "a")).isEqualTo("string")
sut.edit { putString(someResource, "string") }
Assertions.assertEquals("string", sut.getString(someResource, "a"))
assertThat(sut.getString(someResource, "a")).isEqualTo("string")
sut.edit { clear() }
}
@Test
fun clear() {
sut.putBoolean("test", true)
Assertions.assertTrue(sut.getAll().containsKey("test"))
assertThat(sut.getAll()).containsKey("test")
sut.clear()
Assertions.assertFalse(sut.getAll().containsKey("test"))
assertThat(sut.getAll()).doesNotContainKey("test")
}
@Test
fun contains() {
sut.putBoolean("test", true)
Assertions.assertTrue(sut.contains("test"))
assertThat(sut.contains("test")).isTrue()
sut.putBoolean(someResource, true)
Assertions.assertTrue(sut.contains(someResource))
assertThat(sut.contains(someResource)).isTrue()
}
@Test
fun remove() {
sut.putBoolean("test", true)
sut.remove("test")
Assertions.assertFalse(sut.contains("test"))
assertThat(sut.contains("test")).isFalse()
sut.putBoolean(someResource, true)
sut.remove(someResource)
Assertions.assertFalse(sut.contains(someResource))
assertThat(sut.contains(someResource)).isFalse()
}
@Test
fun getString() {
sut.putString("test", "string")
Assertions.assertTrue(sut.getString("test", "") == "string")
Assertions.assertTrue(sut.getString("test1", "") == "")
assertThat(sut.getString("test", "")).isEqualTo("string")
assertThat(sut.getString("test1", "")).isEmpty()
sut.putString(someResource, "string")
Assertions.assertTrue(sut.getString(someResource, "") == "string")
Assertions.assertTrue(sut.getString(someResource2, "") == "")
assertThat(sut.getString(someResource, "")).isEqualTo("string")
assertThat(sut.getString(someResource2, "")).isEmpty()
}
@Test
fun getStringOrNull() {
sut.putString("test", "string")
Assertions.assertTrue(sut.getStringOrNull("test", "") == "string")
Assertions.assertNull(sut.getStringOrNull("test1", null))
assertThat(sut.getStringOrNull("test", "")).isEqualTo("string")
assertThat(sut.getStringOrNull("test1", null)).isNull()
sut.putString(someResource, "string")
Assertions.assertTrue(sut.getStringOrNull(someResource, null) == "string")
Assertions.assertNull(sut.getStringOrNull(someResource2, null))
assertThat(sut.getStringOrNull(someResource, null)).isEqualTo("string")
assertThat(sut.getStringOrNull(someResource2, null)).isNull()
}
@Test
fun getBoolean() {
sut.putBoolean("test", true)
Assertions.assertTrue(sut.getBoolean("test", false))
assertThat(sut.getBoolean("test", false)).isTrue()
sut.putBoolean(someResource, true)
Assertions.assertTrue(sut.getBoolean(someResource, false))
assertThat(sut.getBoolean(someResource, false)).isTrue()
sut.putString("string_key", "a")
Assertions.assertTrue(sut.getBoolean("string_key", true))
assertThat(sut.getBoolean("string_key", true)).isTrue()
sut.putString(someResource, "a")
Assertions.assertTrue(sut.getBoolean(someResource, true))
assertThat(sut.getBoolean(someResource, true)).isTrue()
}
@Test
fun getDouble() {
sut.putDouble("test", 1.0)
Assertions.assertEquals(1.0, sut.getDouble("test", 2.0))
Assertions.assertEquals(2.0, sut.getDouble("test1", 2.0))
assertThat(sut.getDouble("test", 2.0)).isEqualTo(1.0)
assertThat(sut.getDouble("test1", 2.0)).isEqualTo(2.0)
sut.putDouble(someResource, 1.0)
Assertions.assertEquals(1.0, sut.getDouble(someResource, 2.0))
Assertions.assertEquals(2.0, sut.getDouble(someResource2, 2.0))
assertThat(sut.getDouble(someResource, 2.0)).isEqualTo(1.0)
assertThat(sut.getDouble(someResource2, 2.0)).isEqualTo(2.0)
sut.putString("string_key", "a")
Assertions.assertEquals(1.0, sut.getDouble("string_key", 1.0))
assertThat(sut.getDouble("string_key", 1.0)).isEqualTo(1.0)
sut.putString(someResource, "a")
Assertions.assertEquals(1.0, sut.getDouble(someResource, 1.0))
assertThat(sut.getDouble(someResource, 1.0)).isEqualTo(1.0)
}
@Test
fun getInt() {
sut.putInt("test", 1)
Assertions.assertEquals(1, sut.getInt("test", 2))
Assertions.assertEquals(2, sut.getInt("test1", 2))
assertThat(sut.getInt("test", 2)).isEqualTo(1)
assertThat(sut.getInt("test1", 2)).isEqualTo(2)
sut.putInt(someResource, 1)
Assertions.assertEquals(1, sut.getInt(someResource, 2))
Assertions.assertEquals(2, sut.getInt(someResource2, 2))
assertThat(sut.getInt(someResource, 2)).isEqualTo(1)
assertThat(sut.getInt(someResource2, 2)).isEqualTo(2)
sut.putString("string_key", "a")
Assertions.assertEquals(1, sut.getInt("string_key", 1))
assertThat(sut.getInt("string_key", 1)).isEqualTo(1)
sut.putString(someResource, "a")
Assertions.assertEquals(1, sut.getInt(someResource, 1))
assertThat(sut.getInt(someResource, 1)).isEqualTo(1)
}
@Test
fun getLong() {
sut.putLong("test", 1L)
Assertions.assertEquals(1L, sut.getLong("test", 2L))
Assertions.assertEquals(2L, sut.getLong("test1", 2L))
assertThat(sut.getLong("test", 2L)).isEqualTo(1L)
assertThat(sut.getLong("test1", 2L)).isEqualTo(2L)
sut.putLong(someResource, 1L)
Assertions.assertEquals(1L, sut.getLong(someResource, 2L))
Assertions.assertEquals(2L, sut.getLong(someResource2, 2L))
assertThat(sut.getLong(someResource, 2L)).isEqualTo(1L)
assertThat(sut.getLong(someResource2, 2L)).isEqualTo(2L)
sut.putString("string_key", "a")
Assertions.assertEquals(1L, sut.getLong("string_key", 1L))
assertThat(sut.getLong("string_key", 1L)).isEqualTo(1L)
sut.putString(someResource, "a")
Assertions.assertEquals(1L, sut.getLong(someResource, 1L))
assertThat(sut.getLong(someResource, 1L)).isEqualTo(1L)
}
@Test
fun incLong() {
sut.incLong(someResource)
Assertions.assertEquals(1L, sut.getLong(someResource, 3L))
assertThat(sut.getLong(someResource, 3L)).isEqualTo(1L)
sut.incLong(someResource)
Assertions.assertEquals(2L, sut.getLong(someResource, 3L))
assertThat(sut.getLong(someResource, 3L)).isEqualTo(2L)
}
@Test
fun incInt() {
sut.incInt(someResource)
Assertions.assertEquals(1, sut.getInt(someResource, 3))
assertThat(sut.getInt(someResource, 3)).isEqualTo(1)
sut.incInt(someResource)
Assertions.assertEquals(2, sut.getInt(someResource, 3))
assertThat(sut.getInt(someResource, 3)).isEqualTo(2)
}
}
}

2
build.gradle
View file

@ -79,7 +79,7 @@ buildscript {
plugins {
// Test Gradle build, keep disabled under normal circumstances
// id "com.osacky.doctor" version "0.8.1"
id "org.jlleitschuh.gradle.ktlint" version "11.5.1"
id "org.jlleitschuh.gradle.ktlint" version "11.6.0"
// Aggregates and/or logs Jacoco test coverage to the Gradle build log
//id 'org.barfuin.gradle.jacocolog' version '3.1.0'
id 'org.jetbrains.kotlin.android' version "$kotlin_version" apply false

172
core/interfaces/src/test/java/info/nightscout/rx/weardata/EventDataTest.kt
View file

@ -1,7 +1,7 @@
package info.nightscout.rx.weardata
import com.google.common.truth.Truth.assertThat
import kotlinx.serialization.ExperimentalSerializationApi
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
@ -21,132 +21,132 @@ class EventDataTest {
@Test
fun serializationTest() {
EventData.ActionPong(1, 2).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.WearException(1, byteArrayOf(0xAA.toByte()), "board", "fingerprint", "sdk", "model", "manufacturer", "product").let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.Error(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.CancelBolus(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionResendData("data").let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionPumpStatus(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionLoopStatus(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionTddStatus(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionECarbsPreCheck(1, 2, 3).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionBolusPreCheck(1.0, 2).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionFillPreCheck(1.0).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionFillPresetPreCheck(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionProfileSwitchSendInitialData(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionProfileSwitchPreCheck(1, 2).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionWizardPreCheck(1, 2).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionQuickWizardPreCheck("guid").let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionHeartRate(1, 2, 3.0, "device").let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionTempTargetPreCheck(EventData.ActionTempTargetPreCheck.TempTargetCommand.CANCEL).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionWizardConfirmed(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionTempTargetConfirmed(false).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionBolusConfirmed(1.0, 2).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionECarbsConfirmed(1, 2, 3).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionFillConfirmed(1.0).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionProfileSwitchConfirmed(1, 2).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.OpenLoopRequestConfirmed(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.CancelNotification(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
// EventData.ActionGetCustomWatchface(EventData.ActionSetCustomWatchface(CwfData())).let {
// Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
// Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
// assertThat( EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
// assertThat( EventData.deserialize(it.serialize())).isEqualTo(it)
// }
EventData.ActionPing(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.OpenSettings(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.BolusProgress(1, "status").let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.SingleBg(1, sgv = 2.0, high = 3.0, low = 4.0).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.GraphData(arrayListOf(EventData.SingleBg(1, sgv = 2.0, high = 3.0, low = 4.0))).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.TreatmentData(
arrayListOf(EventData.TreatmentData.TempBasal(1, 2.0, 3, 4.0, 5.0)),
@ -154,44 +154,44 @@ class EventDataTest {
arrayListOf(EventData.TreatmentData.Treatment(1, 2.0, 3.0, true, isValid = true)),
arrayListOf(EventData.SingleBg(1, sgv = 2.0, high = 3.0, low = 4.0))
).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.Preferences(1, wearControl = true, true, 2, 3, 4.0, 5.0, 6.0, 7, 8).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.QuickWizard(arrayListOf(EventData.QuickWizard.QuickWizardEntry("1", "2", 3, 4, 5))).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
// EventData.ActionSetCustomWatchface().let {
// Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
// Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
// assertThat( EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
// assertThat( EventData.deserialize(it.serialize())).isEqualTo(it)
// }
EventData.ActionrequestCustomWatchface(true).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionrequestSetDefaultWatchface(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ActionProfileSwitchOpenActivity(1, 2).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.OpenLoopRequest("1", "2", null).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.ConfirmAction("1", "2", null).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
EventData.SnoozeAlert(1).let {
Assertions.assertEquals(it, EventData.deserializeByte(it.serializeByte()))
Assertions.assertEquals(it, EventData.deserialize(it.serialize()))
assertThat(EventData.deserializeByte(it.serializeByte())).isEqualTo(it)
assertThat(EventData.deserialize(it.serialize())).isEqualTo(it)
}
}
}
}

116
core/interfaces/src/test/java/info/nightscout/shared/SafeParseTest.kt
View file

@ -1,6 +1,6 @@
package info.nightscout.shared
import org.junit.jupiter.api.Assertions
import com.google.common.truth.Truth.assertThat
import org.junit.jupiter.api.Test
@Suppress("SpellCheckingInspection")
@ -8,105 +8,105 @@ class SafeParseTest {
@Test fun stringToDoubleTest() {
// correct values
Assertions.assertEquals(0.1234, SafeParse.stringToDouble("0.1234"), 0.001)
Assertions.assertEquals(0.1234, SafeParse.stringToDouble("0,1234"), 0.001)
Assertions.assertEquals(0.5436564812, SafeParse.stringToDouble(".5436564812"), 0.001)
Assertions.assertEquals(0.5436564812, SafeParse.stringToDouble(",5436564812"), 0.001)
Assertions.assertEquals(1000500100900.0, SafeParse.stringToDouble("1000500100900"), 0.001)
Assertions.assertEquals(42.0, SafeParse.stringToDouble("42"), 0.001)
assertThat(SafeParse.stringToDouble("0.1234")).isWithin(0.001).of(0.1234)
assertThat(SafeParse.stringToDouble("0,1234")).isWithin(0.001).of(0.1234)
assertThat(SafeParse.stringToDouble(".5436564812")).isWithin(0.001).of(0.5436564812)
assertThat(SafeParse.stringToDouble(",5436564812")).isWithin(0.001).of(0.5436564812)
assertThat(SafeParse.stringToDouble("1000500100900")).isWithin(0.001).of(1000500100900.0)
assertThat(SafeParse.stringToDouble("42")).isWithin(0.001).of(42.0)
// units or other extra values are not permitted
Assertions.assertEquals(0.0, SafeParse.stringToDouble("12 U/h"), 0.001)
assertThat(SafeParse.stringToDouble("12 U/h")).isWithin(0.001).of(0.0)
// strings are not parsable
Assertions.assertEquals(0.0, SafeParse.stringToDouble("ala ma kota"), 0.001)
assertThat(SafeParse.stringToDouble("ala ma kota")).isWithin(0.001).of(0.0)
// separator errors
Assertions.assertEquals(0.0, SafeParse.stringToDouble("0.1234.5678"), 0.001)
Assertions.assertEquals(0.0, SafeParse.stringToDouble("0,1234,5678"), 0.001)
assertThat(SafeParse.stringToDouble("0.1234.5678")).isWithin(0.001).of(0.0)
assertThat(SafeParse.stringToDouble("0,1234,5678")).isWithin(0.001).of(0.0)
// various emptiness
Assertions.assertEquals(0.0, SafeParse.stringToDouble(""), 0.001)
Assertions.assertEquals(0.0, SafeParse.stringToDouble(" "), 0.001)
Assertions.assertEquals(0.0, SafeParse.stringToDouble("\n\r"), 0.001)
assertThat(SafeParse.stringToDouble("")).isWithin(0.001).of(0.0)
assertThat(SafeParse.stringToDouble(" ")).isWithin(0.001).of(0.0)
assertThat(SafeParse.stringToDouble("\n\r")).isWithin(0.001).of(0.0)
}
@Test fun stringToIntTest() {
// correct values
Assertions.assertEquals(1052934, SafeParse.stringToInt("1052934"))
Assertions.assertEquals(-42, SafeParse.stringToInt("-42"))
Assertions.assertEquals(2147483647, SafeParse.stringToInt("2147483647"))
Assertions.assertEquals(-2147483648, SafeParse.stringToInt("-2147483648"))
assertThat(SafeParse.stringToInt("1052934")).isEqualTo(1052934)
assertThat(SafeParse.stringToInt("-42")).isEqualTo(-42)
assertThat(SafeParse.stringToInt("2147483647")).isEqualTo(2147483647)
assertThat(SafeParse.stringToInt("-2147483648")).isEqualTo(-2147483648)
// outside Integer range
Assertions.assertEquals(0, SafeParse.stringToInt("2147483648"))
Assertions.assertEquals(0, SafeParse.stringToInt("-2147483649"))
assertThat(SafeParse.stringToInt("2147483648")).isEqualTo(0)
assertThat(SafeParse.stringToInt("-2147483649")).isEqualTo(0)
// units or other extra values are not permitted
Assertions.assertEquals(0, SafeParse.stringToInt("12 U/h"))
Assertions.assertEquals(0, SafeParse.stringToInt("0.1234"))
Assertions.assertEquals(0, SafeParse.stringToInt("0,1234"))
Assertions.assertEquals(0, SafeParse.stringToInt(".5436564812"))
Assertions.assertEquals(0, SafeParse.stringToInt(",5436564812"))
Assertions.assertEquals(0, SafeParse.stringToInt("42.1234"))
Assertions.assertEquals(0, SafeParse.stringToInt("42,1234"))
Assertions.assertEquals(0, SafeParse.stringToInt("3212.5436564812"))
Assertions.assertEquals(0, SafeParse.stringToInt("3212,5436564812"))
Assertions.assertEquals(0, SafeParse.stringToInt("1000500100900"))
assertThat(SafeParse.stringToInt("12 U/h")).isEqualTo(0)
assertThat(SafeParse.stringToInt("0.1234")).isEqualTo(0)
assertThat(SafeParse.stringToInt("0,1234")).isEqualTo(0)
assertThat(SafeParse.stringToInt(".5436564812")).isEqualTo(0)
assertThat(SafeParse.stringToInt(",5436564812")).isEqualTo(0)
assertThat(SafeParse.stringToInt("42.1234")).isEqualTo(0)
assertThat(SafeParse.stringToInt("42,1234")).isEqualTo(0)
assertThat(SafeParse.stringToInt("3212.5436564812")).isEqualTo(0)
assertThat(SafeParse.stringToInt("3212,5436564812")).isEqualTo(0)
assertThat(SafeParse.stringToInt("1000500100900")).isEqualTo(0)
// strings are not parsable
Assertions.assertEquals(0, SafeParse.stringToInt("ala ma kota"))
assertThat(SafeParse.stringToInt("ala ma kota")).isEqualTo(0)
// various emptiness
Assertions.assertEquals(0, SafeParse.stringToInt(""))
Assertions.assertEquals(0, SafeParse.stringToInt(" "))
Assertions.assertEquals(0, SafeParse.stringToInt("\n\r"))
assertThat(SafeParse.stringToInt("")).isEqualTo(0)
assertThat(SafeParse.stringToInt(" ")).isEqualTo(0)
assertThat(SafeParse.stringToInt("\n\r")).isEqualTo(0)
}
@Test fun stringToLongTest() {
// correct values
Assertions.assertEquals(1052934L, SafeParse.stringToLong("1052934"))
Assertions.assertEquals(-42L, SafeParse.stringToLong("-42"))
Assertions.assertEquals(2147483647L, SafeParse.stringToLong("2147483647"))
Assertions.assertEquals(-2147483648L, SafeParse.stringToLong("-2147483648"))
Assertions.assertEquals(1000500100900L, SafeParse.stringToLong("1000500100900"))
assertThat(SafeParse.stringToLong("1052934")).isEqualTo(1052934L)
assertThat(SafeParse.stringToLong("-42")).isEqualTo(-42L)
assertThat(SafeParse.stringToLong("2147483647")).isEqualTo(2147483647L)
assertThat(SafeParse.stringToLong("-2147483648")).isEqualTo(-2147483648L)
assertThat(SafeParse.stringToLong("1000500100900")).isEqualTo(1000500100900L)
// outside Integer range
Assertions.assertEquals(2147483648L, SafeParse.stringToLong("2147483648"))
Assertions.assertEquals(-2147483649L, SafeParse.stringToLong("-2147483649"))
assertThat(SafeParse.stringToLong("2147483648")).isEqualTo(2147483648L)
assertThat(SafeParse.stringToLong("-2147483649")).isEqualTo(-2147483649L)
// units or other extra values are not permitted
Assertions.assertEquals(0L, SafeParse.stringToLong("12 U/h"))
Assertions.assertEquals(0L, SafeParse.stringToLong("0.1234"))
Assertions.assertEquals(0L, SafeParse.stringToLong("0,1234"))
Assertions.assertEquals(0L, SafeParse.stringToLong(".5436564812"))
Assertions.assertEquals(0L, SafeParse.stringToLong(",5436564812"))
Assertions.assertEquals(0L, SafeParse.stringToLong("42.1234"))
Assertions.assertEquals(0L, SafeParse.stringToLong("42,1234"))
Assertions.assertEquals(0L, SafeParse.stringToLong("3212.5436564812"))
Assertions.assertEquals(0L, SafeParse.stringToLong("3212,5436564812"))
assertThat(SafeParse.stringToLong("12 U/h")).isEqualTo(0L)
assertThat(SafeParse.stringToLong("0.1234")).isEqualTo(0L)
assertThat(SafeParse.stringToLong("0,1234")).isEqualTo(0L)
assertThat(SafeParse.stringToLong(".5436564812")).isEqualTo(0L)
assertThat(SafeParse.stringToLong(",5436564812")).isEqualTo(0L)
assertThat(SafeParse.stringToLong("42.1234")).isEqualTo(0L)
assertThat(SafeParse.stringToLong("42,1234")).isEqualTo(0L)
assertThat(SafeParse.stringToLong("3212.5436564812")).isEqualTo(0L)
assertThat(SafeParse.stringToLong("3212,5436564812")).isEqualTo(0L)
// strings are not parsable
Assertions.assertEquals(0L, SafeParse.stringToLong("ala ma kota"))
assertThat(SafeParse.stringToLong("ala ma kota")).isEqualTo(0L)
// various emptiness
Assertions.assertEquals(0L, SafeParse.stringToLong(""))
Assertions.assertEquals(0L, SafeParse.stringToLong(" "))
Assertions.assertEquals(0L, SafeParse.stringToLong("\n\r"))
assertThat(SafeParse.stringToLong("")).isEqualTo(0L)
assertThat(SafeParse.stringToLong(" ")).isEqualTo(0L)
assertThat(SafeParse.stringToLong("\n\r")).isEqualTo(0L)
}
@Test
fun stringToDoubleNullTest() {
Assertions.assertEquals(0.0, SafeParse.stringToDouble(null), 0.001)
assertThat(SafeParse.stringToDouble(null)).isWithin(0.001).of(0.0)
}
@Test
fun stringToIntNullTest() {
Assertions.assertEquals(0, SafeParse.stringToInt(null))
assertThat(SafeParse.stringToInt(null)).isEqualTo(0)
}
@Test
fun stringToLongNullTest() {
Assertions.assertEquals(0L, SafeParse.stringToLong(null))
assertThat(SafeParse.stringToLong(null)).isEqualTo(0L)
}
}
}