caspervk/AndroidAPS
1
0
Fork 0
Code Releases Activity

shared-tests #4

Browse source
This commit is contained in:
Milos Kozak 2023-09-03 18:33:16 +02:00
parent 24c2f47e84
commit d950c7986c
38 changed files with 709 additions and 997 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
app-wear-shared/shared-impl/src/test/kotlin/info/nightscout/androidaps/TestBase.kt
View file

@ -1,37 +0,0 @@
package info.nightscout.androidaps
import info.nightscout.rx.AapsSchedulers
import info.nightscout.rx.TestAapsSchedulers
import info.nightscout.rx.logging.AAPSLoggerTest
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.extension.ExtendWith
import org.mockito.Mockito
import org.mockito.junit.jupiter.MockitoExtension
import org.mockito.junit.jupiter.MockitoSettings
import org.mockito.quality.Strictness
import java.util.Locale
@ExtendWith(MockitoExtension::class)
@MockitoSettings(strictness = Strictness.LENIENT)
open class TestBase {
val aapsLogger = AAPSLoggerTest()
val aapsSchedulers: AapsSchedulers = TestAapsSchedulers()
@BeforeEach
fun setupLocale() {
Locale.setDefault(Locale.ENGLISH)
System.setProperty("disableFirebase", "true")
}
// Workaround for Kotlin nullability.
// https://medium.com/@elye.project/befriending-kotlin-and-mockito-1c2e7b0ef791
// https://stackoverflow.com/questions/30305217/is-it-possible-to-use-mockito-in-kotlin
fun <T> anyObject(): T {
Mockito.any<T>()
return uninitialized()
}
@Suppress("Unchecked_Cast")
fun <T> uninitialized(): T = null as T
}

2
app-wear-shared/shared-impl/src/test/kotlin/info/nightscout/androidaps/mocks/SharedPreferencesMock.kt → app-wear-shared/shared-impl/src/test/kotlin/info/nightscout/shared/impl/SharedPreferencesMock.kt
View file

@ -1,4 +1,4 @@
package info.nightscout.androidaps.mocks
package info.nightscout.shared.impl
import android.content.SharedPreferences
import android.content.SharedPreferences.OnSharedPreferenceChangeListener

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

@ -1,14 +1,19 @@
package info.nightscout.shared.impl.logging
import info.nightscout.androidaps.TestBase
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
import org.mockito.Mock
import org.mockito.junit.jupiter.MockitoExtension
import org.mockito.junit.jupiter.MockitoSettings
import org.mockito.quality.Strictness
class LImplTest : TestBase() {
@ExtendWith(MockitoExtension::class)
@MockitoSettings(strictness = Strictness.LENIENT)
class LImplTest {
@Mock lateinit var sp: SP

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

@ -1,15 +1,20 @@
package info.nightscout.shared.impl.sharedPreferences
import android.content.Context
import info.nightscout.androidaps.TestBase
import info.nightscout.androidaps.mocks.SharedPreferencesMock
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
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.junit.jupiter.MockitoExtension
import org.mockito.junit.jupiter.MockitoSettings
import org.mockito.quality.Strictness
class SPImplementationTest : TestBase() {
@ExtendWith(MockitoExtension::class)
@MockitoSettings(strictness = Strictness.LENIENT)
class SPImplementationTest {
private val sharedPreferences: SharedPreferencesMock = SharedPreferencesMock()
@Mock lateinit var context: Context

2
core/main/build.gradle
View file

@ -20,6 +20,8 @@ dependencies {
implementation project(':core:ui')
implementation project(':core:utils')
testImplementation project(':app-wear-shared:shared-tests')
api "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
api "com.google.guava:guava:$guava_version"

83
core/main/src/test/java/info/nightscout/androidaps/HardLimitsMock.kt
View file

@ -1,83 +0,0 @@
package info.nightscout.androidaps
import info.nightscout.interfaces.utils.HardLimits
import info.nightscout.shared.interfaces.ResourceHelper
import info.nightscout.shared.sharedPreferences.SP
import javax.inject.Inject
import kotlin.math.max
import kotlin.math.min
class HardLimitsMock @Inject constructor(
private val sp: SP,
private val rh: ResourceHelper
) : HardLimits {
companion object {
private const val CHILD = 0
private const val TEENAGE = 1
private const val ADULT = 2
private const val RESISTANT_ADULT = 3
private const val PREGNANT = 4
private val MAX_BOLUS = doubleArrayOf(5.0, 10.0, 17.0, 25.0, 60.0)
// Very Hard Limits Ranges
// First value is the Lowest and second value is the Highest a Limit can define
val VERY_HARD_LIMIT_MIN_BG = doubleArrayOf(80.0, 180.0)
val VERY_HARD_LIMIT_MAX_BG = doubleArrayOf(90.0, 200.0)
val VERY_HARD_LIMIT_TARGET_BG = doubleArrayOf(80.0, 200.0)
// Very Hard Limits Ranges for Temp Targets
val VERY_HARD_LIMIT_TEMP_MIN_BG = intArrayOf(72, 180)
val VERY_HARD_LIMIT_TEMP_MAX_BG = intArrayOf(72, 270)
val VERY_HARD_LIMIT_TEMP_TARGET_BG = intArrayOf(72, 200)
val MIN_DIA = doubleArrayOf(5.0, 5.0, 5.0, 5.0, 5.0)
val MAX_DIA = doubleArrayOf(9.0, 9.0, 9.0, 9.0, 10.0)
val MIN_IC = doubleArrayOf(2.0, 2.0, 2.0, 2.0, 0.3)
val MAX_IC = doubleArrayOf(100.0, 100.0, 100.0, 100.0, 100.0)
const val MIN_ISF = 2.0 // mgdl
const val MAX_ISF = 1000.0 // mgdl
val MAX_IOB_AMA = doubleArrayOf(3.0, 5.0, 7.0, 12.0, 25.0)
val MAX_IOB_SMB = doubleArrayOf(7.0, 13.0, 22.0, 30.0, 70.0)
val MAX_BASAL = doubleArrayOf(2.0, 5.0, 10.0, 12.0, 25.0)
//LGS Hard limits
//No IOB at all
const val MAX_IOB_LGS = 0.0
}
private fun loadAge(): Int = when (sp.getString(info.nightscout.core.utils.R.string.key_age, "")) {
rh.gs(info.nightscout.core.utils.R.string.key_child) -> CHILD
rh.gs(info.nightscout.core.utils.R.string.key_teenage) -> TEENAGE
rh.gs(info.nightscout.core.utils.R.string.key_adult) -> ADULT
rh.gs(info.nightscout.core.utils.R.string.key_resistantadult) -> RESISTANT_ADULT
rh.gs(info.nightscout.core.utils.R.string.key_pregnant) -> PREGNANT
else -> ADULT
}
override fun maxBolus(): Double = MAX_BOLUS[loadAge()]
override fun maxIobAMA(): Double = MAX_IOB_AMA[loadAge()]
override fun maxIobSMB(): Double = MAX_IOB_SMB[loadAge()]
override fun maxBasal(): Double = MAX_BASAL[loadAge()]
override fun minDia(): Double = MIN_DIA[loadAge()]
override fun maxDia(): Double = MAX_DIA[loadAge()]
override fun minIC(): Double = MIN_IC[loadAge()]
override fun maxIC(): Double = MAX_IC[loadAge()]
// safety checks
override fun checkHardLimits(value: Double, valueName: Int, lowLimit: Double, highLimit: Double): Boolean =
value == verifyHardLimits(value, valueName, lowLimit, highLimit)
override fun isInRange(value: Double, lowLimit: Double, highLimit: Double): Boolean =
value in lowLimit..highLimit
override fun verifyHardLimits(value: Double, valueName: Int, lowLimit: Double, highLimit: Double): Double {
var newValue = value
if (newValue < lowLimit || newValue > highLimit) {
newValue = max(newValue, lowLimit)
newValue = min(newValue, highLimit)
}
return newValue
}
}

38
core/main/src/test/java/info/nightscout/androidaps/TestBase.kt
View file

@ -1,38 +0,0 @@
package info.nightscout.androidaps
import info.nightscout.rx.AapsSchedulers
import info.nightscout.rx.TestAapsSchedulers
import info.nightscout.rx.logging.AAPSLoggerTest
import org.junit.Before
import org.junit.jupiter.api.extension.ExtendWith
import org.mockito.Mockito
import org.mockito.junit.jupiter.MockitoExtension
import org.mockito.junit.jupiter.MockitoSettings
import org.mockito.quality.Strictness
import java.util.Locale
@Suppress("SpellCheckingInspection")
@ExtendWith(MockitoExtension::class)
@MockitoSettings(strictness = Strictness.LENIENT)
open class TestBase {
val aapsLogger = AAPSLoggerTest()
val aapsSchedulers: AapsSchedulers = TestAapsSchedulers()
@Before
fun setupLocale() {
Locale.setDefault(Locale.ENGLISH)
System.setProperty("disableFirebase", "true")
}
// Workaround for Kotlin nullability.
// https://medium.com/@elye.project/befriending-kotlin-and-mockito-1c2e7b0ef791
// https://stackoverflow.com/questions/30305217/is-it-possible-to-use-mockito-in-kotlin
fun <T> anyObject(): T {
Mockito.any<T>()
return uninitialized()
}
@Suppress("Unchecked_Cast")
fun <T> uninitialized(): T = null as T
}

61
core/main/src/test/java/info/nightscout/androidaps/TestBaseWithProfile.kt
View file

@ -1,61 +0,0 @@
package info.nightscout.androidaps
import android.content.Context
import dagger.android.AndroidInjector
import dagger.android.HasAndroidInjector
import info.nightscout.core.extensions.pureProfileFromJson
import info.nightscout.core.profile.ProfileSealed
import info.nightscout.interfaces.Config
import info.nightscout.interfaces.plugin.ActivePlugin
import info.nightscout.interfaces.profile.DefaultValueHelper
import info.nightscout.interfaces.profile.Profile
import info.nightscout.interfaces.profile.ProfileFunction
import info.nightscout.interfaces.utils.HardLimits
import info.nightscout.rx.bus.RxBus
import info.nightscout.shared.interfaces.ResourceHelper
import info.nightscout.shared.sharedPreferences.SP
import info.nightscout.shared.utils.DateUtil
import org.json.JSONObject
import org.junit.jupiter.api.BeforeEach
import org.mockito.Mock
import org.mockito.Mockito.`when`
@Suppress("SpellCheckingInspection")
open class TestBaseWithProfile : TestBase() {
@Mock lateinit var activePluginProvider: ActivePlugin
@Mock lateinit var rh: ResourceHelper
@Mock lateinit var profileFunction: ProfileFunction
@Mock lateinit var defaultValueHelper: DefaultValueHelper
@Mock lateinit var dateUtil: DateUtil
@Mock lateinit var config: Config
@Mock lateinit var sp: SP
@Mock lateinit var context: Context
private lateinit var hardLimits: HardLimits
lateinit var testPumpPlugin: TestPumpPlugin
val rxBus = RxBus(aapsSchedulers, aapsLogger)
val profileInjector = HasAndroidInjector { AndroidInjector { } }
private lateinit var invalidProfileJSON: String
private lateinit var validProfileJSON: String
lateinit var validProfile: Profile
lateinit var invalidProfile: Profile
@Suppress("PropertyName") val TESTPROFILENAME = "someProfile"
@BeforeEach
fun prepareMock() {
invalidProfileJSON = "{\"dia\":\"1\",\"carbratio\":[{\"time\":\"00:00\",\"value\":\"30\"}],\"carbs_hr\":\"20\",\"delay\":\"20\",\"sens\":[{\"time\":\"00:00\",\"value\":\"3\"}," +
"{\"time\":\"2:00\",\"value\":\"3.4\"}],\"timezone\":\"UTC\",\"basal\":[{\"time\":\"00:00\",\"value\":\"1\"}],\"target_low\":[{\"time\":\"00:00\",\"value\":\"4.5\"}]," +
"\"target_high\":[{\"time\":\"00:00\",\"value\":\"7\"}],\"startDate\":\"1970-01-01T00:00:00.000Z\",\"units\":\"mmol\"}"
validProfileJSON = "{\"dia\":\"5\",\"carbratio\":[{\"time\":\"00:00\",\"value\":\"30\"}],\"carbs_hr\":\"20\",\"delay\":\"20\",\"sens\":[{\"time\":\"00:00\",\"value\":\"3\"}," +
"{\"time\":\"2:00\",\"value\":\"3.4\"}],\"timezone\":\"UTC\",\"basal\":[{\"time\":\"00:00\",\"value\":\"1\"}],\"target_low\":[{\"time\":\"00:00\",\"value\":\"4.5\"}]," +
"\"target_high\":[{\"time\":\"00:00\",\"value\":\"7\"}],\"startDate\":\"1970-01-01T00:00:00.000Z\",\"units\":\"mmol\"}"
validProfile = ProfileSealed.Pure(pureProfileFromJson(JSONObject(validProfileJSON), dateUtil)!!)
testPumpPlugin = TestPumpPlugin(profileInjector)
`when`(activePluginProvider.activePump).thenReturn(testPumpPlugin)
hardLimits = HardLimitsMock(sp, rh)
}
}

72
core/main/src/test/java/info/nightscout/androidaps/TestPumpPlugin.kt
View file

@ -1,72 +0,0 @@
package info.nightscout.androidaps
import dagger.android.HasAndroidInjector
import info.nightscout.interfaces.profile.Profile
import info.nightscout.interfaces.pump.DetailedBolusInfo
import info.nightscout.interfaces.pump.Pump
import info.nightscout.interfaces.pump.PumpEnactResult
import info.nightscout.interfaces.pump.PumpSync
import info.nightscout.interfaces.pump.defs.ManufacturerType
import info.nightscout.interfaces.pump.defs.PumpDescription
import info.nightscout.interfaces.pump.defs.PumpType
import info.nightscout.interfaces.utils.TimeChangeType
import org.json.JSONObject
@Suppress("MemberVisibilityCanBePrivate")
class TestPumpPlugin(val injector: HasAndroidInjector) : Pump {
var connected = false
var isProfileSet = true
override fun isConnected() = connected
override fun isConnecting() = false
override fun isHandshakeInProgress() = false
val lastData = 0L
val baseBasal = 0.0
override var pumpDescription = PumpDescription()
override fun isInitialized(): Boolean = true
override fun isSuspended(): Boolean = false
override fun isBusy(): Boolean = false
override fun connect(reason: String) {
connected = true
}
override fun disconnect(reason: String) {
connected = false
}
override fun stopConnecting() {
connected = false
}
override fun waitForDisconnectionInSeconds(): Int = 0
override fun getPumpStatus(reason: String) {}
override fun setNewBasalProfile(profile: Profile): PumpEnactResult = PumpEnactResult(injector)
override fun isThisProfileSet(profile: Profile): Boolean = isProfileSet
override fun lastDataTime(): Long = lastData
override val baseBasalRate: Double = baseBasal
override val reservoirLevel: Double = 0.0
override val batteryLevel: Int = 0
override fun deliverTreatment(detailedBolusInfo: DetailedBolusInfo): PumpEnactResult = PumpEnactResult(injector).success(true)
override fun stopBolusDelivering() {}
override fun setTempBasalAbsolute(absoluteRate: Double, durationInMinutes: Int, profile: Profile, enforceNew: Boolean, tbrType: PumpSync.TemporaryBasalType): PumpEnactResult =
PumpEnactResult(injector).success(true)
override fun setTempBasalPercent(percent: Int, durationInMinutes: Int, profile: Profile, enforceNew: Boolean, tbrType: PumpSync.TemporaryBasalType): PumpEnactResult =
PumpEnactResult(injector).success(true)
override fun setExtendedBolus(insulin: Double, durationInMinutes: Int): PumpEnactResult = PumpEnactResult(injector).success(true)
override fun cancelTempBasal(enforceNew: Boolean): PumpEnactResult = PumpEnactResult(injector).success(true)
override fun cancelExtendedBolus(): PumpEnactResult = PumpEnactResult(injector).success(true)
override fun getJSONStatus(profile: Profile, profileName: String, version: String): JSONObject = JSONObject()
override fun manufacturer(): ManufacturerType = ManufacturerType.AAPS
override fun model(): PumpType = PumpType.GENERIC_AAPS
override fun serialNumber(): String = "1"
override fun shortStatus(veryShort: Boolean): String = ""
override val isFakingTempsByExtendedBoluses: Boolean = false
override fun loadTDDs(): PumpEnactResult = PumpEnactResult(injector).success(true)
override fun canHandleDST(): Boolean = true
override fun timezoneOrDSTChanged(timeChangeType: TimeChangeType) {}
}

55
core/main/src/test/java/info/nightscout/androidaps/data/ConstraintTest.kt
View file

@ -1,55 +0,0 @@
package info.nightscout.androidaps.data
import info.nightscout.androidaps.TestBase
import info.nightscout.interfaces.constraints.Constraint
import org.junit.Assert
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
/**
* Created by mike on 19.03.2018.
*/
class ConstraintTest : TestBase() {
@Test fun doTests() {
val b = Constraint(true)
Assert.assertEquals(true, b.value())
Assert.assertEquals("", b.getReasons(aapsLogger))
Assert.assertEquals("", b.getMostLimitedReasons(aapsLogger))
b.set(aapsLogger, false)
Assert.assertEquals(false, b.value())
Assert.assertEquals("", b.getReasons(aapsLogger))
Assert.assertEquals("", b.getMostLimitedReasons(aapsLogger))
b.set(aapsLogger, true, "Set true", this)
Assert.assertEquals(true, b.value())
Assert.assertEquals("ConstraintTest: Set true", b.getReasons(aapsLogger))
Assert.assertEquals("ConstraintTest: Set true", b.getMostLimitedReasons(aapsLogger))
b.set(aapsLogger, false, "Set false", this)
Assert.assertEquals(false, b.value())
Assert.assertEquals("ConstraintTest: Set true\nConstraintTest: Set false", b.getReasons(aapsLogger))
Assert.assertEquals("ConstraintTest: Set true\nConstraintTest: Set false", b.getMostLimitedReasons(aapsLogger))
val d = Constraint(10.0)
d.set(aapsLogger, 5.0, "Set 5d", this)
Assert.assertEquals(5.0, d.value(), 0.01)
Assert.assertEquals("ConstraintTest: Set 5d", d.getReasons(aapsLogger))
Assert.assertEquals("ConstraintTest: Set 5d", d.getMostLimitedReasons(aapsLogger))
d.setIfSmaller(aapsLogger, 6.0, "Set 6d", this)
Assert.assertEquals(5.0, d.value(), 0.01)
Assert.assertEquals("ConstraintTest: Set 5d\nConstraintTest: Set 6d", d.getReasons(aapsLogger))
Assert.assertEquals("ConstraintTest: Set 5d", d.getMostLimitedReasons(aapsLogger))
d.setIfSmaller(aapsLogger, 4.0, "Set 4d", this)
Assert.assertEquals(4.0, d.value(), 0.01)
Assert.assertEquals("ConstraintTest: Set 5d\nConstraintTest: Set 6d\nConstraintTest: Set 4d", d.getReasons(aapsLogger))
Assert.assertEquals("ConstraintTest: Set 4d", d.getMostLimitedReasons(aapsLogger))
Assert.assertEquals(10.0, d.originalValue(), 0.01)
d.setIfDifferent(aapsLogger, 7.0, "Set 7d", this)
Assert.assertEquals(7.0, d.value(), 0.01)
Assert.assertEquals("ConstraintTest: Set 5d\nConstraintTest: Set 6d\nConstraintTest: Set 4d\nConstraintTest: Set 7d", d.getReasons(aapsLogger))
Assert.assertEquals("ConstraintTest: Set 4d\nConstraintTest: Set 7d", d.getMostLimitedReasons(aapsLogger))
Assert.assertEquals(10.0, d.originalValue(), 0.01)
}
@BeforeEach
fun prepareMock() {
}
}

134
core/main/src/test/java/info/nightscout/androidaps/extensions/BlockExtensionKtTest.kt
View file

@ -1,134 +0,0 @@
package info.nightscout.androidaps.extensions
import info.nightscout.core.extensions.blockValueBySeconds
import info.nightscout.core.extensions.highTargetBlockValueBySeconds
import info.nightscout.core.extensions.lowTargetBlockValueBySeconds
import info.nightscout.core.extensions.shiftBlock
import info.nightscout.core.extensions.shiftTargetBlock
import info.nightscout.core.extensions.targetBlockValueBySeconds
import info.nightscout.database.entities.data.Block
import info.nightscout.database.entities.data.TargetBlock
import info.nightscout.database.entities.data.checkSanity
import info.nightscout.shared.utils.T
import org.junit.Assert
import org.junit.jupiter.api.Test
class BlockExtensionKtTest {
@Test
fun shiftBlock() {
val b = arrayListOf<Block>()
b.add(Block(T.hours(1).msecs(), 1.0))
b.add(Block(T.hours(1).msecs(), 2.0))
b.add(Block(T.hours(10).msecs(), 3.0))
b.add(Block(T.hours(12).msecs(), 4.0))
Assert.assertTrue(b.checkSanity())
Assert.assertEquals(1.0, b.blockValueBySeconds(T.hours(0).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(2.0, b.blockValueBySeconds(T.hours(1).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(3.0, b.blockValueBySeconds(T.hours(2).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(3.0, b.blockValueBySeconds(T.hours(3).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(4.0, b.blockValueBySeconds(T.hours(12).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(4.0, b.blockValueBySeconds(T.hours(13).secs().toInt(), 1.0, 0), 0.01)
val s1 = b.shiftBlock(1.0, -1)
Assert.assertTrue(s1.checkSanity())
Assert.assertEquals(1.0, s1.blockValueBySeconds(T.hours(23).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(2.0, s1.blockValueBySeconds(T.hours(0).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(3.0, s1.blockValueBySeconds(T.hours(1).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(3.0, s1.blockValueBySeconds(T.hours(2).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(4.0, s1.blockValueBySeconds(T.hours(11).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(4.0, s1.blockValueBySeconds(T.hours(12).secs().toInt(), 1.0, 0), 0.01)
val s2 = b.shiftBlock(2.0, 1)
Assert.assertTrue(s2.checkSanity())
Assert.assertEquals(2.0, s2.blockValueBySeconds(T.hours(1).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(4.0, s2.blockValueBySeconds(T.hours(2).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(6.0, s2.blockValueBySeconds(T.hours(3).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(6.0, s2.blockValueBySeconds(T.hours(4).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(8.0, s2.blockValueBySeconds(T.hours(13).secs().toInt(), 1.0, 0), 0.01)
Assert.assertEquals(8.0, s2.blockValueBySeconds(T.hours(14).secs().toInt(), 1.0, 0), 0.01)
}
@Test
fun shiftTargetBlock() {
val b = arrayListOf<TargetBlock>()
b.add(TargetBlock(T.hours(1).msecs(), 1.0, 2.0))
b.add(TargetBlock(T.hours(1).msecs(), 2.0, 3.0))
b.add(TargetBlock(T.hours(10).msecs(), 3.0, 4.0))
b.add(TargetBlock(T.hours(12).msecs(), 4.0, 5.0))
Assert.assertTrue(b.checkSanity())
Assert.assertEquals(1.5, b.targetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assert.assertEquals(2.5, b.targetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.5, b.targetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.5, b.targetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.5, b.targetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.5, b.targetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
val s1 = b.shiftTargetBlock(-1)
Assert.assertTrue(s1.checkSanity())
Assert.assertEquals(1.5, s1.targetBlockValueBySeconds(T.hours(23).secs().toInt(), 0), 0.01)
Assert.assertEquals(2.5, s1.targetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.5, s1.targetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.5, s1.targetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.5, s1.targetBlockValueBySeconds(T.hours(11).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.5, s1.targetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
val s2 = b.shiftTargetBlock(1)
Assert.assertTrue(s2.checkSanity())
Assert.assertEquals(1.5, s2.targetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assert.assertEquals(2.5, s2.targetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.5, s2.targetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.5, s2.targetBlockValueBySeconds(T.hours(4).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.5, s2.targetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.5, s2.targetBlockValueBySeconds(T.hours(14).secs().toInt(), 0), 0.01)
}
@Test
fun lowTargetBlockValueBySeconds() {
val b = arrayListOf<TargetBlock>()
b.add(TargetBlock(T.hours(1).msecs(), 1.0, 2.0))
b.add(TargetBlock(T.hours(1).msecs(), 2.0, 3.0))
b.add(TargetBlock(T.hours(10).msecs(), 3.0, 4.0))
b.add(TargetBlock(T.hours(12).msecs(), 4.0, 5.0))
Assert.assertTrue(b.checkSanity())
Assert.assertEquals(1.0, b.lowTargetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assert.assertEquals(2.0, b.lowTargetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.0, b.lowTargetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.0, b.lowTargetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.0, b.lowTargetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.0, b.lowTargetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
}
@Test
fun highTargetBlockValueBySeconds() {
val b = arrayListOf<TargetBlock>()
b.add(TargetBlock(T.hours(1).msecs(), 1.0, 2.0))
b.add(TargetBlock(T.hours(1).msecs(), 2.0, 3.0))
b.add(TargetBlock(T.hours(10).msecs(), 3.0, 4.0))
b.add(TargetBlock(T.hours(12).msecs(), 4.0, 5.0))
Assert.assertTrue(b.checkSanity())
Assert.assertEquals(2.0, b.highTargetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assert.assertEquals(3.0, b.highTargetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.0, b.highTargetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assert.assertEquals(4.0, b.highTargetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assert.assertEquals(5.0, b.highTargetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
Assert.assertEquals(5.0, b.highTargetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
}
}

33
core/main/src/test/java/info/nightscout/androidaps/interfaces/PumpDescriptionTest.kt
View file

@ -1,33 +0,0 @@
package info.nightscout.androidaps.interfaces
import info.nightscout.interfaces.pump.defs.PumpCapability
import info.nightscout.interfaces.pump.defs.PumpDescription
import info.nightscout.interfaces.pump.defs.PumpTempBasalType
import info.nightscout.interfaces.pump.defs.PumpType
import org.junit.Assert
import org.junit.jupiter.api.Test
class PumpDescriptionTest {
@Test fun setPumpDescription() {
val pumpDescription = PumpDescription()
pumpDescription.fillFor(PumpType.ACCU_CHEK_COMBO)
Assert.assertEquals(pumpDescription.bolusStep, PumpType.ACCU_CHEK_COMBO.bolusSize, 0.1)
Assert.assertEquals(pumpDescription.basalMinimumRate, PumpType.ACCU_CHEK_COMBO.baseBasalStep, 0.1)
Assert.assertEquals(pumpDescription.basalStep, PumpType.ACCU_CHEK_COMBO.baseBasalStep, 0.1)
Assert.assertEquals(pumpDescription.extendedBolusDurationStep, PumpType.ACCU_CHEK_COMBO.extendedBolusSettings?.durationStep?.toDouble())
Assert.assertEquals(pumpDescription.extendedBolusMaxDuration, PumpType.ACCU_CHEK_COMBO.extendedBolusSettings?.maxDuration?.toDouble())
Assert.assertEquals(pumpDescription.extendedBolusStep, PumpType.ACCU_CHEK_COMBO.extendedBolusSettings?.step)
Assert.assertEquals(pumpDescription.isExtendedBolusCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.ExtendedBolus))
Assert.assertEquals(pumpDescription.isBolusCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.Bolus))
Assert.assertEquals(pumpDescription.isRefillingCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.Refill))
Assert.assertEquals(pumpDescription.isSetBasalProfileCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.BasalProfileSet))
Assert.assertEquals(pumpDescription.isTempBasalCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.TempBasal))
Assert.assertEquals(pumpDescription.maxTempPercent.toDouble(), PumpType.ACCU_CHEK_COMBO.tbrSettings?.maxDose)
Assert.assertEquals(pumpDescription.tempPercentStep.toDouble(), PumpType.ACCU_CHEK_COMBO.tbrSettings?.step)
Assert.assertEquals(pumpDescription.tempBasalStyle, if (PumpType.ACCU_CHEK_COMBO.pumpTempBasalType == PumpTempBasalType.Percent) PumpDescription.PERCENT else PumpDescription.ABSOLUTE)
Assert.assertEquals(pumpDescription.tempDurationStep.toLong(), PumpType.ACCU_CHEK_COMBO.tbrSettings?.durationStep?.toLong())
Assert.assertEquals(pumpDescription.tempDurationStep15mAllowed, PumpType.ACCU_CHEK_COMBO.specialBasalDurations?.hasCapability(PumpCapability.BasalRate_Duration15minAllowed))
Assert.assertEquals(pumpDescription.tempDurationStep30mAllowed, PumpType.ACCU_CHEK_COMBO.specialBasalDurations?.hasCapability(PumpCapability.BasalRate_Duration30minAllowed))
}
}

72
core/main/src/test/java/info/nightscout/androidaps/utils/DateUtilTest.kt
View file

@ -1,72 +0,0 @@
package info.nightscout.androidaps.utils
import android.content.Context
import info.nightscout.androidaps.TestBase
import info.nightscout.shared.interfaces.ResourceHelper
import info.nightscout.shared.utils.DateUtil
import info.nightscout.shared.utils.T
import org.junit.Assert
import org.junit.jupiter.api.Test
import org.mockito.Mock
import org.mockito.Mockito.`when`
import java.util.Date
class DateUtilTest : TestBase() {
@Mock lateinit var context: Context
@Mock lateinit var rh: ResourceHelper
@Test
fun fromISODateStringTest() {
Assert.assertEquals(1511124634417L, DateUtil(context).fromISODateString("2017-11-19T22:50:34.417+0200"))
Assert.assertEquals(1511124634000L, DateUtil(context).fromISODateString("2017-11-19T22:50:34+0200"))
Assert.assertEquals(1512317365000L, DateUtil(context).fromISODateString("2017-12-03T16:09:25.000Z"))
Assert.assertEquals(1513902750000L, DateUtil(context).fromISODateString("2017-12-22T00:32:30Z"))
}
@Test
fun toISOStringTest() {
Assert.assertEquals("2017-12-22T00:32:30.000Z", DateUtil(context).toISOString(1513902750000L))
}
@Test fun secondsOfTheDayToMillisecondsTest() {
Assert.assertTrue(Date(DateUtil(context).secondsOfTheDayToMilliseconds((T.hours(1).secs() + T.mins(1).secs() + 1).toInt())).toString().contains("01:01:00"))
}
@Test fun toSecondsTest() {
Assert.assertEquals(3600, DateUtil(context).toSeconds("01:00").toLong())
Assert.assertEquals(3600, DateUtil(context).toSeconds("01:00 a.m.").toLong())
Assert.assertEquals(3600, DateUtil(context).toSeconds("01:00 AM").toLong())
}
@Test fun dateStringTest() {
Assert.assertTrue(DateUtil(context).dateString(1513902750000L).contains("22"))
}
@Test fun timeStringTest() {
Assert.assertTrue(DateUtil(context).timeString(1513902750000L).contains("32"))
}
@Test fun dateAndTimeStringTest() {
Assert.assertTrue(DateUtil(context).dateAndTimeString(1513902750000L).contains("22"))
Assert.assertTrue(DateUtil(context).dateAndTimeString(1513902750000L).contains("32"))
}
@Test fun dateAndTimeRangeStringTest() {
Assert.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("22"))
Assert.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("32"))
Assert.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("22"))
Assert.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("32"))
}
/*
@Test
public void timeStringFromSecondsTest() {
Assert.assertEquals("1:00 AM", DateUtil.timeStringFromSeconds((int) T.hours(1).secs()));
}
*/
@Test fun timeFrameStringTest() {
`when`(rh.gs(info.nightscout.shared.R.string.shorthour)).thenReturn("h")
Assert.assertEquals("(1h 1')", DateUtil(context).timeFrameString(T.hours(1).msecs() + T.mins(1).msecs(), rh))
}
}

28
core/main/src/test/java/info/nightscout/androidaps/utils/DecimalFormatterTest.kt
View file

@ -1,28 +0,0 @@
package info.nightscout.androidaps.utils
import info.nightscout.interfaces.utils.DecimalFormatter
import org.junit.Assert
import org.junit.jupiter.api.Test
class DecimalFormatterTest {
@Test fun to0DecimalTest() {
Assert.assertEquals("1", DecimalFormatter.to0Decimal(1.33).replace(",", "."))
Assert.assertEquals("1U", DecimalFormatter.to0Decimal(1.33, "U").replace(",", "."))
}
@Test fun to1DecimalTest() {
Assert.assertEquals("1.3", DecimalFormatter.to1Decimal(1.33).replace(",", "."))
Assert.assertEquals("1.3U", DecimalFormatter.to1Decimal(1.33, "U").replace(",", "."))
}
@Test fun to2DecimalTest() {
Assert.assertEquals("1.33", DecimalFormatter.to2Decimal(1.3333).replace(",", "."))
Assert.assertEquals("1.33U", DecimalFormatter.to2Decimal(1.3333, "U").replace(",", "."))
}
@Test fun to3DecimalTest() {
Assert.assertEquals("1.333", DecimalFormatter.to3Decimal(1.3333).replace(",", "."))
Assert.assertEquals("1.333U", DecimalFormatter.to3Decimal(1.3333, "U").replace(",", "."))
}
}

80
core/main/src/test/java/info/nightscout/androidaps/utils/JsonHelperTest.kt
View file

@ -1,80 +0,0 @@
package info.nightscout.androidaps.utils
import info.nightscout.interfaces.utils.JsonHelper
import org.json.JSONObject
import org.junit.Assert
import org.junit.jupiter.api.Test
@Suppress("SpellCheckingInspection")
class JsonHelperTest {
private val jsonString = "{\"d\":\"3.0\",\"i\":\"4\",\"s\":\"5\",\"b\":\"true\",\"j\":{\"a\": \"1\"}}"
@Test
fun safeGetObjectTest() {
val json = JSONObject(jsonString)
val o = Any()
Assert.assertEquals(o, JsonHelper.safeGetObject(null, "x", o))
Assert.assertEquals(o, JsonHelper.safeGetObject(json, "x", o))
Assert.assertNotEquals(o, JsonHelper.safeGetObject(json, "d", o))
}
@Test
fun safeGetJSONObjectTest() {
val json = JSONObject(jsonString)
val o = JSONObject()
Assert.assertEquals(o, JsonHelper.safeGetJSONObject(null, "x", o))
Assert.assertTrue(JsonHelper.safeGetJSONObject(json, "j", o)!!.has("a"))
Assert.assertEquals(o, JsonHelper.safeGetJSONObject(json, "d", o))
}
@Test
fun safeGetStringTest() {
val json = JSONObject(jsonString)
Assert.assertNull(JsonHelper.safeGetString(null, "s"))
Assert.assertNull(JsonHelper.safeGetString(json, "notexisting"))
Assert.assertEquals("5", JsonHelper.safeGetString(json, "s"))
Assert.assertEquals("default", JsonHelper.safeGetString(null, "notexisting", "default"))
Assert.assertEquals("default", JsonHelper.safeGetString(json, "notexisting", "default"))
Assert.assertEquals("5", JsonHelper.safeGetString(json, "s", "default"))
Assert.assertEquals("default", JsonHelper.safeGetStringAllowNull(null, "notexisting", "default"))
Assert.assertEquals("default", JsonHelper.safeGetStringAllowNull(json, "notexisting", "default"))
Assert.assertNull(JsonHelper.safeGetStringAllowNull(json, "notexisting", null))
Assert.assertEquals("5", JsonHelper.safeGetStringAllowNull(json, "s", "default"))
}
@Test
fun safeGetDoubleTest() {
val json = JSONObject(jsonString)
Assert.assertEquals(0.0, JsonHelper.safeGetDouble(json, "notexisting"), 0.0)
Assert.assertEquals(0.0, JsonHelper.safeGetDouble(null, "notexisting"), 0.0)
Assert.assertEquals(3.0, JsonHelper.safeGetDouble(json, "d"), 0.000001)
Assert.assertEquals(6.0, JsonHelper.safeGetDouble(null, "notexisting", 6.0), 0.0)
Assert.assertEquals(6.0, JsonHelper.safeGetDouble(json, "notexisting", 6.0), 0.0)
Assert.assertEquals(3.0, JsonHelper.safeGetDouble(json, "d", 6.0), 0.0)
}
@Test
fun safeGetLntTest() {
val json = JSONObject(jsonString)
Assert.assertEquals(0, JsonHelper.safeGetInt(null, "notexisting").toLong())
Assert.assertEquals(0, JsonHelper.safeGetInt(json, "notexisting").toLong())
Assert.assertEquals(4, JsonHelper.safeGetInt(json, "i").toLong())
}
@Test
fun safeGetLongTest() {
val json = JSONObject(jsonString)
Assert.assertEquals(0, JsonHelper.safeGetInt(null, "notexisting").toLong())
Assert.assertEquals(0, JsonHelper.safeGetInt(json, "notexisting").toLong())
Assert.assertEquals(4, JsonHelper.safeGetInt(json, "i").toLong())
}
@Test
fun safeGetBooleanTest() {
val json = JSONObject(jsonString)
Assert.assertFalse(JsonHelper.safeGetBoolean(null, "notexisting"))
Assert.assertFalse(JsonHelper.safeGetBoolean(json, "notexisting"))
Assert.assertTrue(JsonHelper.safeGetBoolean(json, "b"))
}
}

49
core/main/src/test/java/info/nightscout/androidaps/utils/MidnightTimeTest.kt
View file

@ -1,49 +0,0 @@
package info.nightscout.androidaps.utils
import info.nightscout.interfaces.utils.MidnightTime
import org.junit.Assert
import org.junit.jupiter.api.Test
import java.util.Calendar
class MidnightTimeTest {
@Test fun calc() {
// We get real midnight
val now = System.currentTimeMillis()
Assert.assertTrue(now >= MidnightTime.calc())
val c = Calendar.getInstance()
c.timeInMillis = MidnightTime.calc()
Assert.assertEquals(c[Calendar.HOUR_OF_DAY].toLong(), 0)
Assert.assertEquals(c[Calendar.MINUTE].toLong(), 0)
Assert.assertEquals(c[Calendar.SECOND].toLong(), 0)
Assert.assertEquals(c[Calendar.MILLISECOND].toLong(), 0)
}
@Test fun calc_time() {
// We get real midnight
val now = System.currentTimeMillis()
val midnight = MidnightTime.calc(now)
Assert.assertTrue(now >= midnight)
val c = Calendar.getInstance()
c.timeInMillis = MidnightTime.calc(now)
Assert.assertEquals(c[Calendar.HOUR_OF_DAY].toLong(), 0)
Assert.assertEquals(c[Calendar.MINUTE].toLong(), 0)
Assert.assertEquals(c[Calendar.SECOND].toLong(), 0)
Assert.assertEquals(c[Calendar.MILLISECOND].toLong(), 0)
// Assure we get the same time from cache
Assert.assertEquals(midnight, MidnightTime.calc(now))
}
@Test fun resetCache() {
val now = System.currentTimeMillis()
MidnightTime.calc(now)
MidnightTime.resetCache()
Assert.assertEquals(0, MidnightTime.times.size().toLong())
}
@Test fun log() {
val now = System.currentTimeMillis()
MidnightTime.calc(now)
Assert.assertTrue(MidnightTime.log().startsWith("Hits:"))
}
}

41
core/main/src/test/java/info/nightscout/androidaps/utils/RoundTest.kt
View file

@ -1,41 +0,0 @@
package info.nightscout.androidaps.utils
import info.nightscout.interfaces.utils.Round
import org.junit.Assert
import org.junit.jupiter.api.Test
class RoundTest {
@Test
fun roundToTest() {
Assert.assertEquals(0.55, Round.roundTo(0.54, 0.05), 0.00000000000000000001)
Assert.assertEquals(-3.26, Round.roundTo(-3.2553715764602713, 0.01), 0.00000000000000000001)
Assert.assertEquals(0.816, Round.roundTo(0.8156666666666667, 0.001), 0.00000000000000000001)
Assert.assertEquals(0.235, Round.roundTo(0.235, 0.001), 0.00000000000000000001)
Assert.assertEquals(0.3, Round.roundTo(0.3, 0.1), 0.00000000000000001)
Assert.assertEquals(0.0017, Round.roundTo(0.0016960652144170627, 0.0001), 0.00000000000000000001)
Assert.assertEquals(0.0078, Round.roundTo(0.007804436682291013, 0.0001), 0.00000000000000000001)
Assert.assertEquals(0.6, Round.roundTo(0.6, 0.05), 0.00000000000000000001)
Assert.assertEquals(1.0, Round.roundTo(1.49, 1.0), 0.00000000000000000001)
Assert.assertEquals(0.0, Round.roundTo(0.0, 1.0), 0.00000000000000000001)
}
@Test
fun floorToTest() {
Assert.assertEquals(0.5, Round.floorTo(0.54, 0.05), 0.00000001)
Assert.assertEquals(1.0, Round.floorTo(1.59, 1.0), 0.00000001)
Assert.assertEquals(0.0, Round.floorTo(0.0, 1.0), 0.00000001)
}
@Test
fun ceilToTest() {
Assert.assertEquals(0.6, Round.ceilTo(0.54, 0.1), 0.00000001)
Assert.assertEquals(2.0, Round.ceilTo(1.49999, 1.0), 0.00000001)
Assert.assertEquals(0.0, Round.ceilTo(0.0, 1.0), 0.00000001)
}
@Test
fun isSameTest() {
Assert.assertTrue(Round.isSame(0.54, 0.54))
}
}

19
core/main/src/test/java/info/nightscout/androidaps/utils/StringUtilsTest.kt
View file

@ -1,19 +0,0 @@
package info.nightscout.androidaps.utils
import info.nightscout.core.utils.receivers.StringUtils
import org.junit.Assert
import org.junit.jupiter.api.Test
class StringUtilsTest {
@Test fun removeSurroundingQuotesTest() {
var compareString = "test"
Assert.assertEquals(compareString, StringUtils.removeSurroundingQuotes(compareString))
Assert.assertEquals(compareString, StringUtils.removeSurroundingQuotes("\"" + compareString + "\""))
Assert.assertEquals("\"" + compareString, StringUtils.removeSurroundingQuotes("\"" + compareString))
compareString = "te\"st"
Assert.assertEquals(compareString, StringUtils.removeSurroundingQuotes(compareString))
Assert.assertEquals(compareString, StringUtils.removeSurroundingQuotes("\"" + compareString + "\""))
Assert.assertEquals("\"" + compareString, StringUtils.removeSurroundingQuotes("\"" + compareString))
}
}

41
core/main/src/test/java/info/nightscout/androidaps/utils/TTest.kt
View file

@ -1,41 +0,0 @@
package info.nightscout.androidaps.utils
import info.nightscout.shared.utils.T
import org.junit.Assert
import org.junit.jupiter.api.Test
import kotlin.math.abs
@Suppress("SpellCheckingInspection")
class TTest {
@Test fun toUnits() {
Assert.assertEquals(1, T.msecs(1000).secs())
Assert.assertEquals(1, T.secs(60).mins())
Assert.assertEquals(1, T.mins(60).hours())
Assert.assertEquals(1, T.hours(24).days())
Assert.assertEquals(24, T.days(1).hours())
Assert.assertEquals(60000, T.mins(1).msecs())
}
@Test fun now() {
Assert.assertTrue(abs(T.now().msecs() - System.currentTimeMillis()) < 5000)
}
@Test fun additions() {
val nowMsecs = System.currentTimeMillis()
val now = T.msecs(nowMsecs)
Assert.assertEquals(now.plus(T.secs(5)).msecs(), nowMsecs + 5 * 1000)
Assert.assertEquals(now.plus(T.mins(5)).msecs(), nowMsecs + 5 * 60 * 1000)
Assert.assertEquals(now.plus(T.hours(5)).msecs(), nowMsecs + 5 * 60 * 60 * 1000)
Assert.assertEquals(now.plus(T.days(5)).msecs(), nowMsecs + 5 * 24 * 60 * 60 * 1000)
}
@Test fun subtractions() {
val nowMsecs = System.currentTimeMillis()
val now = T.msecs(nowMsecs)
Assert.assertEquals(now.minus(T.secs(5)).msecs(), nowMsecs - 5 * 1000)
Assert.assertEquals(now.minus(T.mins(5)).msecs(), nowMsecs - 5 * 60 * 1000)
Assert.assertEquals(now.minus(T.hours(5)).msecs(), nowMsecs - 5 * 60 * 60 * 1000)
Assert.assertEquals(now.minus(T.days(5)).msecs(), nowMsecs - 5 * 24 * 60 * 60 * 1000)
}
}

55
core/main/src/test/java/info/nightscout/core/data/ConstraintTest.kt Normal file
View file

@ -0,0 +1,55 @@
package info.nightscout.core.data
import info.nightscout.interfaces.constraints.Constraint
import info.nightscout.sharedtests.TestBase
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
/**
* Created by mike on 19.03.2018.
*/
class ConstraintTest : TestBase() {
@Test fun doTests() {
val b = Constraint(true)
Assertions.assertEquals(true, b.value())
Assertions.assertEquals("", b.getReasons(aapsLogger))
Assertions.assertEquals("", b.getMostLimitedReasons(aapsLogger))
b.set(aapsLogger, false)
Assertions.assertEquals(false, b.value())
Assertions.assertEquals("", b.getReasons(aapsLogger))
Assertions.assertEquals("", b.getMostLimitedReasons(aapsLogger))
b.set(aapsLogger, true, "Set true", this)
Assertions.assertEquals(true, b.value())
Assertions.assertEquals("ConstraintTest: Set true", b.getReasons(aapsLogger))
Assertions.assertEquals("ConstraintTest: Set true", b.getMostLimitedReasons(aapsLogger))
b.set(aapsLogger, false, "Set false", this)
Assertions.assertEquals(false, b.value())
Assertions.assertEquals("ConstraintTest: Set true\nConstraintTest: Set false", b.getReasons(aapsLogger))
Assertions.assertEquals("ConstraintTest: Set true\nConstraintTest: Set false", b.getMostLimitedReasons(aapsLogger))
val d = Constraint(10.0)
d.set(aapsLogger, 5.0, "Set 5d", this)
Assertions.assertEquals(5.0, d.value(), 0.01)
Assertions.assertEquals("ConstraintTest: Set 5d", d.getReasons(aapsLogger))
Assertions.assertEquals("ConstraintTest: Set 5d", d.getMostLimitedReasons(aapsLogger))
d.setIfSmaller(aapsLogger, 6.0, "Set 6d", this)
Assertions.assertEquals(5.0, d.value(), 0.01)
Assertions.assertEquals("ConstraintTest: Set 5d\nConstraintTest: Set 6d", d.getReasons(aapsLogger))
Assertions.assertEquals("ConstraintTest: Set 5d", d.getMostLimitedReasons(aapsLogger))
d.setIfSmaller(aapsLogger, 4.0, "Set 4d", this)
Assertions.assertEquals(4.0, d.value(), 0.01)
Assertions.assertEquals("ConstraintTest: Set 5d\nConstraintTest: Set 6d\nConstraintTest: Set 4d", d.getReasons(aapsLogger))
Assertions.assertEquals("ConstraintTest: Set 4d", d.getMostLimitedReasons(aapsLogger))
Assertions.assertEquals(10.0, d.originalValue(), 0.01)
d.setIfDifferent(aapsLogger, 7.0, "Set 7d", this)
Assertions.assertEquals(7.0, d.value(), 0.01)
Assertions.assertEquals("ConstraintTest: Set 5d\nConstraintTest: Set 6d\nConstraintTest: Set 4d\nConstraintTest: Set 7d", d.getReasons(aapsLogger))
Assertions.assertEquals("ConstraintTest: Set 4d\nConstraintTest: Set 7d", d.getMostLimitedReasons(aapsLogger))
Assertions.assertEquals(10.0, d.originalValue(), 0.01)
}
@BeforeEach
fun prepareMock() {
}
}

4
core/main/src/test/java/info/nightscout/androidaps/data/DetailedBolusInfoTest.kt → core/main/src/test/java/info/nightscout/core/data/DetailedBolusInfoTest.kt
View file

@ -1,12 +1,12 @@
package info.nightscout.androidaps.data
package info.nightscout.core.data
import android.content.Context
import com.google.gson.Gson
import info.nightscout.androidaps.TestBase
import info.nightscout.database.entities.Bolus
import info.nightscout.database.entities.BolusCalculatorResult
import info.nightscout.database.entities.TherapyEvent
import info.nightscout.interfaces.pump.DetailedBolusInfo
import info.nightscout.sharedtests.TestBase
import org.apache.commons.lang3.builder.EqualsBuilder
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test

19
core/main/src/test/java/info/nightscout/androidaps/data/IobTest.kt → core/main/src/test/java/info/nightscout/core/data/IobTest.kt
View file

@ -1,7 +1,7 @@
package info.nightscout.androidaps.data
package info.nightscout.core.data
import info.nightscout.interfaces.iob.Iob
import org.junit.Assert
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class IobTest {
@ -10,24 +10,23 @@ class IobTest {
val a = Iob().iobContrib(1.0).activityContrib(2.0)
val b = Iob().iobContrib(3.0).activityContrib(4.0)
a.plus(b)
Assert.assertEquals(4.0, a.iobContrib, 0.01)
Assert.assertEquals(6.0, a.activityContrib, 0.01)
Assertions.assertEquals(4.0, a.iobContrib, 0.01)
Assertions.assertEquals(6.0, a.activityContrib, 0.01)
}
@Test fun equalTest() {
val a1 = Iob().iobContrib(1.0).activityContrib(2.0)
val a2 = Iob().iobContrib(1.0).activityContrib(2.0)
val b = Iob().iobContrib(3.0).activityContrib(4.0)
Assert.assertTrue(a1 == a1)
Assert.assertTrue(a1 == a2)
Assert.assertFalse(a1 == b)
Assertions.assertTrue(a1 == a2)
Assertions.assertFalse(a1 == b)
@Suppress("SENSELESS_COMPARISON")
Assert.assertFalse(a1 == null)
Assert.assertFalse(a1 == Any())
Assertions.assertFalse(a1 == null)
Assertions.assertFalse(a1 == Any())
}
@Test fun hashCodeTest() {
val a = Iob().iobContrib(1.0).activityContrib(2.0)
Assert.assertNotEquals(0, a.hashCode().toLong())
Assertions.assertNotEquals(0, a.hashCode().toLong())
}
}

84
core/main/src/test/java/info/nightscout/androidaps/data/IobTotalTest.kt → core/main/src/test/java/info/nightscout/core/data/IobTotalTest.kt
View file

@ -1,7 +1,6 @@
package info.nightscout.androidaps.data
package info.nightscout.core.data
import android.content.Context
import info.nightscout.androidaps.TestBase
import info.nightscout.core.iob.combine
import info.nightscout.core.iob.copy
import info.nightscout.core.iob.determineBasalJson
@ -10,7 +9,8 @@ import info.nightscout.core.iob.plus
import info.nightscout.core.iob.round
import info.nightscout.interfaces.iob.IobTotal
import info.nightscout.shared.utils.DateUtil
import org.junit.Assert
import info.nightscout.sharedtests.TestBase
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.mockito.Mock
@ -33,7 +33,7 @@ class IobTotalTest : TestBase() {
val a = IobTotal(now)
a.iob = 10.0
val b = a.copy()
Assert.assertEquals(a.iob, b.iob, 0.01)
Assertions.assertEquals(a.iob, b.iob, 0.01)
}
@Test fun plusTest() {
@ -47,14 +47,14 @@ class IobTotalTest : TestBase() {
a.netInsulin = 10.0
a.extendedBolusInsulin = 10.0
a.plus(a.copy())
Assert.assertEquals(20.0, a.iob, 0.01)
Assert.assertEquals(20.0, a.activity, 0.01)
Assert.assertEquals(20.0, a.bolussnooze, 0.01)
Assert.assertEquals(20.0, a.basaliob, 0.01)
Assert.assertEquals(20.0, a.netbasalinsulin, 0.01)
Assert.assertEquals(20.0, a.hightempinsulin, 0.01)
Assert.assertEquals(20.0, a.netInsulin, 0.01)
Assert.assertEquals(20.0, a.extendedBolusInsulin, 0.01)
Assertions.assertEquals(20.0, a.iob, 0.01)
Assertions.assertEquals(20.0, a.activity, 0.01)
Assertions.assertEquals(20.0, a.bolussnooze, 0.01)
Assertions.assertEquals(20.0, a.basaliob, 0.01)
Assertions.assertEquals(20.0, a.netbasalinsulin, 0.01)
Assertions.assertEquals(20.0, a.hightempinsulin, 0.01)
Assertions.assertEquals(20.0, a.netInsulin, 0.01)
Assertions.assertEquals(20.0, a.extendedBolusInsulin, 0.01)
}
@Test fun combineTest() {
@ -69,15 +69,15 @@ class IobTotalTest : TestBase() {
a.extendedBolusInsulin = 17.0
val b = a.copy()
val c = IobTotal.combine(a, b)
Assert.assertEquals(a.time.toDouble(), c.time.toDouble(), 0.01)
Assert.assertEquals(23.0, c.iob, 0.01)
Assert.assertEquals(22.0, c.activity, 0.01)
Assert.assertEquals(12.0, c.bolussnooze, 0.01)
Assert.assertEquals(26.0, c.basaliob, 0.01)
Assert.assertEquals(28.0, c.netbasalinsulin, 0.01)
Assert.assertEquals(30.0, c.hightempinsulin, 0.01)
Assert.assertEquals(32.0, c.netInsulin, 0.01)
Assert.assertEquals(34.0, c.extendedBolusInsulin, 0.01)
Assertions.assertEquals(a.time.toDouble(), c.time.toDouble(), 0.01)
Assertions.assertEquals(23.0, c.iob, 0.01)
Assertions.assertEquals(22.0, c.activity, 0.01)
Assertions.assertEquals(12.0, c.bolussnooze, 0.01)
Assertions.assertEquals(26.0, c.basaliob, 0.01)
Assertions.assertEquals(28.0, c.netbasalinsulin, 0.01)
Assertions.assertEquals(30.0, c.hightempinsulin, 0.01)
Assertions.assertEquals(32.0, c.netInsulin, 0.01)
Assertions.assertEquals(34.0, c.extendedBolusInsulin, 0.01)
}
@Test fun roundTest() {
@ -91,14 +91,14 @@ class IobTotalTest : TestBase() {
a.netInsulin = 1.1111111111111
a.extendedBolusInsulin = 1.1111111111111
a.round()
Assert.assertEquals(1.111, a.iob, 0.00001)
Assert.assertEquals(1.1111, a.activity, 0.00001)
Assert.assertEquals(1.1111, a.bolussnooze, 0.00001)
Assert.assertEquals(1.111, a.basaliob, 0.00001)
Assert.assertEquals(1.111, a.netbasalinsulin, 0.00001)
Assert.assertEquals(1.111, a.hightempinsulin, 0.00001)
Assert.assertEquals(1.111, a.netInsulin, 0.00001)
Assert.assertEquals(1.111, a.extendedBolusInsulin, 0.00001)
Assertions.assertEquals(1.111, a.iob, 0.00001)
Assertions.assertEquals(1.1111, a.activity, 0.00001)
Assertions.assertEquals(1.1111, a.bolussnooze, 0.00001)
Assertions.assertEquals(1.111, a.basaliob, 0.00001)
Assertions.assertEquals(1.111, a.netbasalinsulin, 0.00001)
Assertions.assertEquals(1.111, a.hightempinsulin, 0.00001)
Assertions.assertEquals(1.111, a.netInsulin, 0.00001)
Assertions.assertEquals(1.111, a.extendedBolusInsulin, 0.00001)
}
@Test fun jsonTest() {
@ -113,12 +113,12 @@ class IobTotalTest : TestBase() {
a.extendedBolusInsulin = 17.0
try {
val j = a.json(dateUtil)
Assert.assertEquals(a.iob, j.getDouble("iob"), 0.0000001)
Assert.assertEquals(a.basaliob, j.getDouble("basaliob"), 0.0000001)
Assert.assertEquals(a.activity, j.getDouble("activity"), 0.0000001)
Assert.assertEquals(now, dateUtil.fromISODateString(j.getString("time")))
Assertions.assertEquals(a.iob, j.getDouble("iob"), 0.0000001)
Assertions.assertEquals(a.basaliob, j.getDouble("basaliob"), 0.0000001)
Assertions.assertEquals(a.activity, j.getDouble("activity"), 0.0000001)
Assertions.assertEquals(now, dateUtil.fromISODateString(j.getString("time")))
} catch (e: Exception) {
Assert.fail("Exception: " + e.message)
Assertions.fail("Exception: " + e.message)
}
}
@ -135,15 +135,15 @@ class IobTotalTest : TestBase() {
a.iobWithZeroTemp = IobTotal(now)
try {
val j = a.determineBasalJson(dateUtil)
Assert.assertEquals(a.iob, j.getDouble("iob"), 0.0000001)
Assert.assertEquals(a.basaliob, j.getDouble("basaliob"), 0.0000001)
Assert.assertEquals(a.bolussnooze, j.getDouble("bolussnooze"), 0.0000001)
Assert.assertEquals(a.activity, j.getDouble("activity"), 0.0000001)
Assert.assertEquals(0, j.getLong("lastBolusTime"))
Assert.assertEquals(now, dateUtil.fromISODateString(j.getString("time")))
Assert.assertNotNull(j.getJSONObject("iobWithZeroTemp"))
Assertions.assertEquals(a.iob, j.getDouble("iob"), 0.0000001)
Assertions.assertEquals(a.basaliob, j.getDouble("basaliob"), 0.0000001)
Assertions.assertEquals(a.bolussnooze, j.getDouble("bolussnooze"), 0.0000001)
Assertions.assertEquals(a.activity, j.getDouble("activity"), 0.0000001)
Assertions.assertEquals(0, j.getLong("lastBolusTime"))
Assertions.assertEquals(now, dateUtil.fromISODateString(j.getString("time")))
Assertions.assertNotNull(j.getJSONObject("iobWithZeroTemp"))
} catch (e: Exception) {
Assert.fail("Exception: " + e.message)
Assertions.fail("Exception: " + e.message)
}
}
}

6
core/main/src/test/java/info/nightscout/androidaps/data/MealDataTest.kt → core/main/src/test/java/info/nightscout/core/data/MealDataTest.kt
View file

@ -1,13 +1,13 @@
package info.nightscout.androidaps.data
package info.nightscout.core.data
import info.nightscout.interfaces.iob.MealData
import org.junit.Assert
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class MealDataTest {
@Test fun canCreateObject() {
val md = MealData()
Assert.assertEquals(0.0, md.carbs, 0.01)
Assertions.assertEquals(0.0, md.carbs, 0.01)
}
}

106
core/main/src/test/java/info/nightscout/androidaps/data/ProfileTest.kt → core/main/src/test/java/info/nightscout/core/data/ProfileTest.kt
View file

@ -1,10 +1,7 @@
package info.nightscout.androidaps.data
package info.nightscout.core.data
import android.content.Context
import dagger.android.AndroidInjector
import info.nightscout.androidaps.HardLimitsMock
import info.nightscout.androidaps.TestBase
import info.nightscout.androidaps.TestPumpPlugin
import info.nightscout.core.extensions.pureProfileFromJson
import info.nightscout.core.profile.ProfileSealed
import info.nightscout.interfaces.Config
@ -17,8 +14,11 @@ import info.nightscout.rx.bus.RxBus
import info.nightscout.shared.interfaces.ResourceHelper
import info.nightscout.shared.sharedPreferences.SP
import info.nightscout.shared.utils.DateUtil
import info.nightscout.sharedtests.HardLimitsMock
import info.nightscout.sharedtests.TestBase
import info.nightscout.sharedtests.TestPumpPlugin
import org.json.JSONObject
import org.junit.Assert
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.mockito.Mock
@ -76,84 +76,84 @@ class ProfileTest : TestBase() {
// Test valid profile
var p = ProfileSealed.Pure(pureProfileFromJson(JSONObject(okProfile), dateUtil)!!)
Assert.assertEquals(true, p.isValid("Test", testPumpPlugin, config, rh, rxBus, hardLimits, false).isValid)
// Assert.assertEquals(true, p.log().contains("NS units: mmol"))
// JSONAssert.assertEquals(JSONObject(okProfile), p.toPureNsJson(dateUtil), false)
Assert.assertEquals(5.0, p.dia, 0.01)
// Assert.assertEquals(TimeZone.getTimeZone("UTC"), p.timeZone)
Assert.assertEquals("00:30", dateUtil.formatHHMM(30 * 60))
Assertions.assertEquals(true, p.isValid("Test", testPumpPlugin, config, rh, rxBus, hardLimits, false).isValid)
// Assertions.assertEquals(true, p.log().contains("NS units: mmol"))
// JSONAssertions.assertEquals(JSONObject(okProfile), p.toPureNsJson(dateUtil), false)
Assertions.assertEquals(5.0, p.dia, 0.01)
// Assertions.assertEquals(TimeZone.getTimeZone("UTC"), p.timeZone)
Assertions.assertEquals("00:30", dateUtil.formatHHMM(30 * 60))
val c = Calendar.getInstance()
c[Calendar.HOUR_OF_DAY] = 1
c[Calendar.MINUTE] = 0
c[Calendar.SECOND] = 0
c[Calendar.MILLISECOND] = 0
Assert.assertEquals(108.0, p.getIsfMgdl(c.timeInMillis), 0.01)
Assertions.assertEquals(108.0, p.getIsfMgdl(c.timeInMillis), 0.01)
c[Calendar.HOUR_OF_DAY] = 2
Assert.assertEquals(111.6, p.getIsfMgdl(c.timeInMillis), 0.01)
// Assert.assertEquals(110.0, p.getIsfTimeFromMidnight(2 * 60 * 60), 0.01)
Assert.assertEquals(
Assertions.assertEquals(111.6, p.getIsfMgdl(c.timeInMillis), 0.01)
// Assertions.assertEquals(110.0, p.getIsfTimeFromMidnight(2 * 60 * 60), 0.01)
Assertions.assertEquals(
"""
00:00 6,0 mmol/U
02:00 6,2 mmol/U
""".trimIndent(), p.getIsfList(rh, dateUtil).replace(".", ",")
)
Assert.assertEquals(30.0, p.getIc(c.timeInMillis), 0.01)
Assert.assertEquals(30.0, p.getIcTimeFromMidnight(2 * 60 * 60), 0.01)
Assert.assertEquals("00:00 30,0 g/U", p.getIcList(rh, dateUtil).replace(".", ","))
Assert.assertEquals(0.1, p.getBasal(c.timeInMillis), 0.01)
Assert.assertEquals(0.1, p.getBasalTimeFromMidnight(2 * 60 * 60), 0.01)
Assert.assertEquals("00:00 0,10 U/h", p.getBasalList(rh, dateUtil).replace(".", ","))
Assert.assertEquals(0.1, p.getBasalValues()[0].value, 0.01)
Assert.assertEquals(0.1, p.getMaxDailyBasal(), 0.01)
Assert.assertEquals(2.4, p.percentageBasalSum(), 0.01)
Assert.assertEquals(2.4, p.baseBasalSum(), 0.01)
// Assert.assertEquals(81.0, p.getTargetMgdl(2 * 60 * 60), 0.01)
Assert.assertEquals(90.0, p.getTargetLowMgdl(c.timeInMillis), 0.01)
// Assert.assertEquals(4.0, p.getTargetLowTimeFromMidnight(2 * 60 * 60), 0.01)
Assert.assertEquals(90.0, p.getTargetHighMgdl(c.timeInMillis), 0.01)
// Assert.assertEquals(5.0, p.getTargetHighTimeFromMidnight(2 * 60 * 60), 0.01)
Assert.assertEquals("00:00 5,0 - 5,0 mmol", p.getTargetList(rh, dateUtil).replace(".", ","))
Assert.assertEquals(100, p.percentage)
Assert.assertEquals(0, p.timeshift)
Assert.assertEquals(0.1, Profile.toMgdl(0.1, GlucoseUnit.MGDL), 0.01)
Assert.assertEquals(18.0, Profile.toMgdl(1.0, GlucoseUnit.MMOL), 0.01)
Assert.assertEquals(1.0, Profile.toMmol(18.0, GlucoseUnit.MGDL), 0.01)
Assert.assertEquals(18.0, Profile.toMmol(18.0, GlucoseUnit.MMOL), 0.01)
Assert.assertEquals(18.0, Profile.fromMgdlToUnits(18.0, GlucoseUnit.MGDL), 0.01)
Assert.assertEquals(1.0, Profile.fromMgdlToUnits(18.0, GlucoseUnit.MMOL), 0.01)
Assert.assertEquals(18.0, Profile.toUnits(18.0, 1.0, GlucoseUnit.MGDL), 0.01)
Assert.assertEquals(1.0, Profile.toUnits(18.0, 1.0, GlucoseUnit.MMOL), 0.01)
Assert.assertEquals("18", Profile.toUnitsString(18.0, 1.0, GlucoseUnit.MGDL))
Assert.assertEquals("1,0", Profile.toUnitsString(18.0, 1.0, GlucoseUnit.MMOL).replace(".", ","))
Assert.assertEquals("5 - 6", Profile.toTargetRangeString(5.0, 6.0, GlucoseUnit.MGDL, GlucoseUnit.MGDL))
Assert.assertEquals("4", Profile.toTargetRangeString(4.0, 4.0, GlucoseUnit.MGDL, GlucoseUnit.MGDL))
Assertions.assertEquals(30.0, p.getIc(c.timeInMillis), 0.01)
Assertions.assertEquals(30.0, p.getIcTimeFromMidnight(2 * 60 * 60), 0.01)
Assertions.assertEquals("00:00 30,0 g/U", p.getIcList(rh, dateUtil).replace(".", ","))
Assertions.assertEquals(0.1, p.getBasal(c.timeInMillis), 0.01)
Assertions.assertEquals(0.1, p.getBasalTimeFromMidnight(2 * 60 * 60), 0.01)
Assertions.assertEquals("00:00 0,10 U/h", p.getBasalList(rh, dateUtil).replace(".", ","))
Assertions.assertEquals(0.1, p.getBasalValues()[0].value, 0.01)
Assertions.assertEquals(0.1, p.getMaxDailyBasal(), 0.01)
Assertions.assertEquals(2.4, p.percentageBasalSum(), 0.01)
Assertions.assertEquals(2.4, p.baseBasalSum(), 0.01)
// Assertions.assertEquals(81.0, p.getTargetMgdl(2 * 60 * 60), 0.01)
Assertions.assertEquals(90.0, p.getTargetLowMgdl(c.timeInMillis), 0.01)
// Assertions.assertEquals(4.0, p.getTargetLowTimeFromMidnight(2 * 60 * 60), 0.01)
Assertions.assertEquals(90.0, p.getTargetHighMgdl(c.timeInMillis), 0.01)
// Assertions.assertEquals(5.0, p.getTargetHighTimeFromMidnight(2 * 60 * 60), 0.01)
Assertions.assertEquals("00:00 5,0 - 5,0 mmol", p.getTargetList(rh, dateUtil).replace(".", ","))
Assertions.assertEquals(100, p.percentage)
Assertions.assertEquals(0, p.timeshift)
Assertions.assertEquals(0.1, Profile.toMgdl(0.1, GlucoseUnit.MGDL), 0.01)
Assertions.assertEquals(18.0, Profile.toMgdl(1.0, GlucoseUnit.MMOL), 0.01)
Assertions.assertEquals(1.0, Profile.toMmol(18.0, GlucoseUnit.MGDL), 0.01)
Assertions.assertEquals(18.0, Profile.toMmol(18.0, GlucoseUnit.MMOL), 0.01)
Assertions.assertEquals(18.0, Profile.fromMgdlToUnits(18.0, GlucoseUnit.MGDL), 0.01)
Assertions.assertEquals(1.0, Profile.fromMgdlToUnits(18.0, GlucoseUnit.MMOL), 0.01)
Assertions.assertEquals(18.0, Profile.toUnits(18.0, 1.0, GlucoseUnit.MGDL), 0.01)
Assertions.assertEquals(1.0, Profile.toUnits(18.0, 1.0, GlucoseUnit.MMOL), 0.01)
Assertions.assertEquals("18", Profile.toUnitsString(18.0, 1.0, GlucoseUnit.MGDL))
Assertions.assertEquals("1,0", Profile.toUnitsString(18.0, 1.0, GlucoseUnit.MMOL).replace(".", ","))
Assertions.assertEquals("5 - 6", Profile.toTargetRangeString(5.0, 6.0, GlucoseUnit.MGDL, GlucoseUnit.MGDL))
Assertions.assertEquals("4", Profile.toTargetRangeString(4.0, 4.0, GlucoseUnit.MGDL, GlucoseUnit.MGDL))
//Test basal profile below limit
p = ProfileSealed.Pure(pureProfileFromJson(JSONObject(belowLimitValidProfile), dateUtil)!!)
p.isValid("Test", testPumpPlugin, config, rh, rxBus, hardLimits, false)
// Test profile w/o units
Assert.assertNull(pureProfileFromJson(JSONObject(noUnitsValidProfile), dateUtil))
Assertions.assertNull(pureProfileFromJson(JSONObject(noUnitsValidProfile), dateUtil))
//Test profile not starting at midnight
p = ProfileSealed.Pure(pureProfileFromJson(JSONObject(notStartingAtZeroValidProfile), dateUtil)!!)
Assert.assertEquals(30.0, p.getIc(0), 0.01)
Assertions.assertEquals(30.0, p.getIc(0), 0.01)
// Test wrong profile
Assert.assertNull(pureProfileFromJson(JSONObject(wrongProfile), dateUtil))
Assertions.assertNull(pureProfileFromJson(JSONObject(wrongProfile), dateUtil))
// Test percentage functionality
p = ProfileSealed.Pure(pureProfileFromJson(JSONObject(okProfile), dateUtil)!!)
p.pct = 50
Assert.assertEquals(0.05, p.getBasal(c.timeInMillis), 0.01)
Assert.assertEquals(1.2, p.percentageBasalSum(), 0.01)
Assert.assertEquals(60.0, p.getIc(c.timeInMillis), 0.01)
Assert.assertEquals(223.2, p.getIsfMgdl(c.timeInMillis), 0.01)
Assertions.assertEquals(0.05, p.getBasal(c.timeInMillis), 0.01)
Assertions.assertEquals(1.2, p.percentageBasalSum(), 0.01)
Assertions.assertEquals(60.0, p.getIc(c.timeInMillis), 0.01)
Assertions.assertEquals(223.2, p.getIsfMgdl(c.timeInMillis), 0.01)
// Test timeshift functionality
p = ProfileSealed.Pure(pureProfileFromJson(JSONObject(okProfile), dateUtil)!!)
p.ts = 1
Assert.assertEquals(
Assertions.assertEquals(
"""
00:00 6.2 mmol/U
01:00 6.0 mmol/U

127
core/main/src/test/java/info/nightscout/core/extensions/BlockExtensionKtTest.kt Normal file
View file

@ -0,0 +1,127 @@
package info.nightscout.core.extensions
import info.nightscout.database.entities.data.Block
import info.nightscout.database.entities.data.TargetBlock
import info.nightscout.database.entities.data.checkSanity
import info.nightscout.shared.utils.T
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class BlockExtensionKtTest {
@Test
fun shiftBlock() {
val b = arrayListOf<Block>()
b.add(Block(T.hours(1).msecs(), 1.0))
b.add(Block(T.hours(1).msecs(), 2.0))
b.add(Block(T.hours(10).msecs(), 3.0))
b.add(Block(T.hours(12).msecs(), 4.0))
Assertions.assertTrue(b.checkSanity())
Assertions.assertEquals(1.0, b.blockValueBySeconds(T.hours(0).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(2.0, b.blockValueBySeconds(T.hours(1).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(3.0, b.blockValueBySeconds(T.hours(2).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(3.0, b.blockValueBySeconds(T.hours(3).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(4.0, b.blockValueBySeconds(T.hours(12).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(4.0, b.blockValueBySeconds(T.hours(13).secs().toInt(), 1.0, 0), 0.01)
val s1 = b.shiftBlock(1.0, -1)
Assertions.assertTrue(s1.checkSanity())
Assertions.assertEquals(1.0, s1.blockValueBySeconds(T.hours(23).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(2.0, s1.blockValueBySeconds(T.hours(0).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(3.0, s1.blockValueBySeconds(T.hours(1).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(3.0, s1.blockValueBySeconds(T.hours(2).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(4.0, s1.blockValueBySeconds(T.hours(11).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(4.0, s1.blockValueBySeconds(T.hours(12).secs().toInt(), 1.0, 0), 0.01)
val s2 = b.shiftBlock(2.0, 1)
Assertions.assertTrue(s2.checkSanity())
Assertions.assertEquals(2.0, s2.blockValueBySeconds(T.hours(1).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(4.0, s2.blockValueBySeconds(T.hours(2).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(6.0, s2.blockValueBySeconds(T.hours(3).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(6.0, s2.blockValueBySeconds(T.hours(4).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(8.0, s2.blockValueBySeconds(T.hours(13).secs().toInt(), 1.0, 0), 0.01)
Assertions.assertEquals(8.0, s2.blockValueBySeconds(T.hours(14).secs().toInt(), 1.0, 0), 0.01)
}
@Test
fun shiftTargetBlock() {
val b = arrayListOf<TargetBlock>()
b.add(TargetBlock(T.hours(1).msecs(), 1.0, 2.0))
b.add(TargetBlock(T.hours(1).msecs(), 2.0, 3.0))
b.add(TargetBlock(T.hours(10).msecs(), 3.0, 4.0))
b.add(TargetBlock(T.hours(12).msecs(), 4.0, 5.0))
Assertions.assertTrue(b.checkSanity())
Assertions.assertEquals(1.5, b.targetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assertions.assertEquals(2.5, b.targetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.5, b.targetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.5, b.targetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.5, b.targetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.5, b.targetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
val s1 = b.shiftTargetBlock(-1)
Assertions.assertTrue(s1.checkSanity())
Assertions.assertEquals(1.5, s1.targetBlockValueBySeconds(T.hours(23).secs().toInt(), 0), 0.01)
Assertions.assertEquals(2.5, s1.targetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.5, s1.targetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.5, s1.targetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.5, s1.targetBlockValueBySeconds(T.hours(11).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.5, s1.targetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
val s2 = b.shiftTargetBlock(1)
Assertions.assertTrue(s2.checkSanity())
Assertions.assertEquals(1.5, s2.targetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assertions.assertEquals(2.5, s2.targetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.5, s2.targetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.5, s2.targetBlockValueBySeconds(T.hours(4).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.5, s2.targetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.5, s2.targetBlockValueBySeconds(T.hours(14).secs().toInt(), 0), 0.01)
}
@Test
fun lowTargetBlockValueBySeconds() {
val b = arrayListOf<TargetBlock>()
b.add(TargetBlock(T.hours(1).msecs(), 1.0, 2.0))
b.add(TargetBlock(T.hours(1).msecs(), 2.0, 3.0))
b.add(TargetBlock(T.hours(10).msecs(), 3.0, 4.0))
b.add(TargetBlock(T.hours(12).msecs(), 4.0, 5.0))
Assertions.assertTrue(b.checkSanity())
Assertions.assertEquals(1.0, b.lowTargetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assertions.assertEquals(2.0, b.lowTargetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.0, b.lowTargetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.0, b.lowTargetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.0, b.lowTargetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.0, b.lowTargetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
}
@Test
fun highTargetBlockValueBySeconds() {
val b = arrayListOf<TargetBlock>()
b.add(TargetBlock(T.hours(1).msecs(), 1.0, 2.0))
b.add(TargetBlock(T.hours(1).msecs(), 2.0, 3.0))
b.add(TargetBlock(T.hours(10).msecs(), 3.0, 4.0))
b.add(TargetBlock(T.hours(12).msecs(), 4.0, 5.0))
Assertions.assertTrue(b.checkSanity())
Assertions.assertEquals(2.0, b.highTargetBlockValueBySeconds(T.hours(0).secs().toInt(), 0), 0.01)
Assertions.assertEquals(3.0, b.highTargetBlockValueBySeconds(T.hours(1).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.0, b.highTargetBlockValueBySeconds(T.hours(2).secs().toInt(), 0), 0.01)
Assertions.assertEquals(4.0, b.highTargetBlockValueBySeconds(T.hours(3).secs().toInt(), 0), 0.01)
Assertions.assertEquals(5.0, b.highTargetBlockValueBySeconds(T.hours(12).secs().toInt(), 0), 0.01)
Assertions.assertEquals(5.0, b.highTargetBlockValueBySeconds(T.hours(13).secs().toInt(), 0), 0.01)
}
}

28
core/main/src/test/java/info/nightscout/androidaps/interfaces/PluginDescriptionTest.kt → core/main/src/test/java/info/nightscout/core/interfaces/PluginDescriptionTest.kt
View file

@ -1,70 +1,70 @@
package info.nightscout.androidaps.interfaces
package info.nightscout.core.interfaces
import androidx.fragment.app.Fragment
import info.nightscout.interfaces.plugin.PluginDescription
import info.nightscout.interfaces.plugin.PluginType
import org.junit.Assert
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class PluginDescriptionTest {
@Test fun mainTypeTest() {
val pluginDescription = PluginDescription().mainType(PluginType.PUMP)
Assert.assertEquals(PluginType.PUMP, pluginDescription.mainType)
Assertions.assertEquals(PluginType.PUMP, pluginDescription.mainType)
}
@Test fun fragmentClassTest() {
val pluginDescription = PluginDescription().fragmentClass(Fragment::class.java.name)
Assert.assertEquals(Fragment::class.java.name, pluginDescription.fragmentClass)
Assertions.assertEquals(Fragment::class.java.name, pluginDescription.fragmentClass)
}
@Test fun alwaysEnabledTest() {
val pluginDescription = PluginDescription().alwaysEnabled(true)
Assert.assertEquals(true, pluginDescription.alwaysEnabled)
Assertions.assertEquals(true, pluginDescription.alwaysEnabled)
}
@Test fun alwaysVisibleTest() {
val pluginDescription = PluginDescription().alwaysVisible(true)
Assert.assertEquals(true, pluginDescription.alwaysVisible)
Assertions.assertEquals(true, pluginDescription.alwaysVisible)
}
@Test fun neverVisibleTest() {
val pluginDescription = PluginDescription().neverVisible(true)
Assert.assertEquals(true, pluginDescription.neverVisible)
Assertions.assertEquals(true, pluginDescription.neverVisible)
}
@Test fun showInListTest() {
val pluginDescription = PluginDescription().showInList(false)
Assert.assertEquals(false, pluginDescription.showInList)
Assertions.assertEquals(false, pluginDescription.showInList)
}
@Test fun pluginIcon() {
val pluginDescription = PluginDescription().pluginIcon(10)
Assert.assertEquals(10, pluginDescription.pluginIcon.toLong())
Assertions.assertEquals(10, pluginDescription.pluginIcon.toLong())
}
@Test fun pluginName() {
val pluginDescription = PluginDescription().pluginName(10)
Assert.assertEquals(10, pluginDescription.pluginName.toLong())
Assertions.assertEquals(10, pluginDescription.pluginName.toLong())
}
@Test fun shortNameTest() {
val pluginDescription = PluginDescription().shortName(10)
Assert.assertEquals(10, pluginDescription.shortName.toLong())
Assertions.assertEquals(10, pluginDescription.shortName.toLong())
}
@Test fun preferencesIdTest() {
val pluginDescription = PluginDescription().preferencesId(10)
Assert.assertEquals(10, pluginDescription.preferencesId.toLong())
Assertions.assertEquals(10, pluginDescription.preferencesId.toLong())
}
@Test fun enableByDefault() {
val pluginDescription = PluginDescription().enableByDefault(true)
Assert.assertEquals(true, pluginDescription.enableByDefault)
Assertions.assertEquals(true, pluginDescription.enableByDefault)
}
@Test fun visibleByDefault() {
val pluginDescription = PluginDescription().visibleByDefault(true)
Assert.assertEquals(true, pluginDescription.visibleByDefault)
Assertions.assertEquals(true, pluginDescription.visibleByDefault)
}
}

33
core/main/src/test/java/info/nightscout/core/interfaces/PumpDescriptionTest.kt Normal file
View file

@ -0,0 +1,33 @@
package info.nightscout.core.interfaces
import info.nightscout.interfaces.pump.defs.PumpCapability
import info.nightscout.interfaces.pump.defs.PumpDescription
import info.nightscout.interfaces.pump.defs.PumpTempBasalType
import info.nightscout.interfaces.pump.defs.PumpType
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class PumpDescriptionTest {
@Test fun setPumpDescription() {
val pumpDescription = PumpDescription()
pumpDescription.fillFor(PumpType.ACCU_CHEK_COMBO)
Assertions.assertEquals(pumpDescription.bolusStep, PumpType.ACCU_CHEK_COMBO.bolusSize, 0.1)
Assertions.assertEquals(pumpDescription.basalMinimumRate, PumpType.ACCU_CHEK_COMBO.baseBasalStep, 0.1)
Assertions.assertEquals(pumpDescription.basalStep, PumpType.ACCU_CHEK_COMBO.baseBasalStep, 0.1)
Assertions.assertEquals(pumpDescription.extendedBolusDurationStep, PumpType.ACCU_CHEK_COMBO.extendedBolusSettings?.durationStep?.toDouble())
Assertions.assertEquals(pumpDescription.extendedBolusMaxDuration, PumpType.ACCU_CHEK_COMBO.extendedBolusSettings?.maxDuration?.toDouble())
Assertions.assertEquals(pumpDescription.extendedBolusStep, PumpType.ACCU_CHEK_COMBO.extendedBolusSettings?.step)
Assertions.assertEquals(pumpDescription.isExtendedBolusCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.ExtendedBolus))
Assertions.assertEquals(pumpDescription.isBolusCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.Bolus))
Assertions.assertEquals(pumpDescription.isRefillingCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.Refill))
Assertions.assertEquals(pumpDescription.isSetBasalProfileCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.BasalProfileSet))
Assertions.assertEquals(pumpDescription.isTempBasalCapable, PumpType.ACCU_CHEK_COMBO.pumpCapability?.hasCapability(PumpCapability.TempBasal))
Assertions.assertEquals(pumpDescription.maxTempPercent.toDouble(), PumpType.ACCU_CHEK_COMBO.tbrSettings?.maxDose)
Assertions.assertEquals(pumpDescription.tempPercentStep.toDouble(), PumpType.ACCU_CHEK_COMBO.tbrSettings?.step)
Assertions.assertEquals(pumpDescription.tempBasalStyle, if (PumpType.ACCU_CHEK_COMBO.pumpTempBasalType == PumpTempBasalType.Percent) PumpDescription.PERCENT else PumpDescription.ABSOLUTE)
Assertions.assertEquals(pumpDescription.tempDurationStep.toLong(), PumpType.ACCU_CHEK_COMBO.tbrSettings?.durationStep?.toLong())
Assertions.assertEquals(pumpDescription.tempDurationStep15mAllowed, PumpType.ACCU_CHEK_COMBO.specialBasalDurations?.hasCapability(PumpCapability.BasalRate_Duration15minAllowed))
Assertions.assertEquals(pumpDescription.tempDurationStep30mAllowed, PumpType.ACCU_CHEK_COMBO.specialBasalDurations?.hasCapability(PumpCapability.BasalRate_Duration30minAllowed))
}
}

10
core/main/src/test/java/info/nightscout/androidaps/pump/common/utils/DateTimeUtilUTest.java → core/main/src/test/java/info/nightscout/core/pump/common/utils/DateTimeUtilUTest.java
View file

@ -1,21 +1,21 @@
package info.nightscout.androidaps.pump.common.utils;
package info.nightscout.core.pump.common.utils;
import org.junit.Assert;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import info.nightscout.core.utils.DateTimeUtil;
public class DateTimeUtilUTest {
class DateTimeUtilUTest {
@Test
public void getATechDateDifferenceAsMinutes() {
void getATechDateDifferenceAsMinutes() {
long dt1 = 20191001182301L;
long dt2 = 20191001192805L;
int aTechDateDifferenceAsMinutes = DateTimeUtil.getATechDateDifferenceAsMinutes(dt1, dt2);
Assert.assertEquals(65, aTechDateDifferenceAsMinutes);
Assertions.assertEquals(65, aTechDateDifferenceAsMinutes);
//Log.d("DateTimeUtilUTest", "Time difference: " + aTechDateDifferenceAsMinutes);

35
core/main/src/test/java/info/nightscout/androidaps/utils/CryptoUtilTest.kt → core/main/src/test/java/info/nightscout/core/utils/CryptoUtilTest.kt
View file

@ -1,11 +1,10 @@
package info.nightscout.androidaps.utils
package info.nightscout.core.utils
import info.nightscout.androidaps.TestBase
import info.nightscout.core.utils.CryptoUtil
import info.nightscout.sharedtests.TestBase
import org.hamcrest.CoreMatchers.containsString
import org.hamcrest.CoreMatchers.not
import org.junit.Assert
import org.junit.Assume.assumeThat
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
// https://stackoverflow.com/questions/52344522/joseexception-couldnt-create-aes-gcm-nopadding-cipher-illegal-key-size
@ -34,11 +33,11 @@ class CryptoUtilTest : TestBase() {
val encrypted = cryptoUtil.encrypt(password, salt, payload)
assumeAES256isSupported(cryptoUtil)
Assert.assertNotNull(encrypted)
Assertions.assertNotNull(encrypted)
val decrypted = cryptoUtil.decrypt(password, salt, encrypted!!)
assumeAES256isSupported(cryptoUtil)
Assert.assertEquals(decrypted, payload)
Assertions.assertEquals(decrypted, payload)
}
@Test
@ -50,18 +49,18 @@ class CryptoUtilTest : TestBase() {
val encrypted = cryptoUtil.encrypt(password, salt, payload)
assumeAES256isSupported(cryptoUtil)
Assert.assertNotNull(encrypted)
Assertions.assertNotNull(encrypted)
val decrypted = cryptoUtil.decrypt(password, salt, encrypted!!)
assumeAES256isSupported(cryptoUtil)
Assert.assertEquals(decrypted, payload)
Assertions.assertEquals(decrypted, payload)
}
@Test
fun testHashVector() {
val payload = "{what:payloadYouWantToProtect}"
val hash = cryptoUtil.sha256(payload)
Assert.assertEquals(hash, "a1aafe3ed6cc127e6d102ddbc40a205147230e9cfd178daf108c83543bbdcd13")
Assertions.assertEquals(hash, "a1aafe3ed6cc127e6d102ddbc40a205147230e9cfd178daf108c83543bbdcd13")
}
@Test
@ -70,24 +69,24 @@ class CryptoUtilTest : TestBase() {
val password = "topSikret"
val expectedHmac = "ea2213953d0f2e55047cae2d23fb4f0de1b805d55e6271efa70d6b85fb692bea" // generated using other HMAC tool
val hash = cryptoUtil.hmac256(payload, password)
Assert.assertEquals(hash, expectedHmac)
Assertions.assertEquals(hash, expectedHmac)
}
@Test
fun testPlainPasswordCheck() {
Assert.assertTrue(cryptoUtil.checkPassword("same", "same"))
Assert.assertFalse(cryptoUtil.checkPassword("same", "other"))
Assertions.assertTrue(cryptoUtil.checkPassword("same", "same"))
Assertions.assertFalse(cryptoUtil.checkPassword("same", "other"))
}
@Test
fun testHashedPasswordCheck() {
Assert.assertTrue(cryptoUtil.checkPassword("givenSecret", cryptoUtil.hashPassword("givenSecret")))
Assert.assertFalse(cryptoUtil.checkPassword("givenSecret", cryptoUtil.hashPassword("otherSecret")))
Assertions.assertTrue(cryptoUtil.checkPassword("givenSecret", cryptoUtil.hashPassword("givenSecret")))
Assertions.assertFalse(cryptoUtil.checkPassword("givenSecret", cryptoUtil.hashPassword("otherSecret")))
Assert.assertTrue(cryptoUtil.checkPassword("givenHashToCheck", "hmac:7fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:a0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
Assert.assertFalse(cryptoUtil.checkPassword("givenMashToCheck", "hmac:7fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:a0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
Assert.assertFalse(cryptoUtil.checkPassword("givenHashToCheck", "hmac:0fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:a0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
Assert.assertFalse(cryptoUtil.checkPassword("givenHashToCheck", "hmac:7fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:b0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
Assertions.assertTrue(cryptoUtil.checkPassword("givenHashToCheck", "hmac:7fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:a0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
Assertions.assertFalse(cryptoUtil.checkPassword("givenMashToCheck", "hmac:7fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:a0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
Assertions.assertFalse(cryptoUtil.checkPassword("givenHashToCheck", "hmac:0fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:a0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
Assertions.assertFalse(cryptoUtil.checkPassword("givenHashToCheck", "hmac:7fe5f9c7b4b97c5d32d5cfad9d07473543a9938dc07af48a46dbbb49f4f68c12:b0c7cee14312bbe31b51359a67f0d2dfdf46813f319180269796f1f617a64be1"))
}
}

72
core/main/src/test/java/info/nightscout/core/utils/DateUtilTest.kt Normal file
View file

@ -0,0 +1,72 @@
package info.nightscout.core.utils
import android.content.Context
import info.nightscout.shared.interfaces.ResourceHelper
import info.nightscout.shared.utils.DateUtil
import info.nightscout.shared.utils.T
import info.nightscout.sharedtests.TestBase
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.mockito.Mock
import org.mockito.Mockito.`when`
import java.util.Date
class DateUtilTest : TestBase() {
@Mock lateinit var context: Context
@Mock lateinit var rh: ResourceHelper
@Test
fun fromISODateStringTest() {
Assertions.assertEquals(1511124634417L, DateUtil(context).fromISODateString("2017-11-19T22:50:34.417+0200"))
Assertions.assertEquals(1511124634000L, DateUtil(context).fromISODateString("2017-11-19T22:50:34+0200"))
Assertions.assertEquals(1512317365000L, DateUtil(context).fromISODateString("2017-12-03T16:09:25.000Z"))
Assertions.assertEquals(1513902750000L, DateUtil(context).fromISODateString("2017-12-22T00:32:30Z"))
}
@Test
fun toISOStringTest() {
Assertions.assertEquals("2017-12-22T00:32:30.000Z", DateUtil(context).toISOString(1513902750000L))
}
@Test fun secondsOfTheDayToMillisecondsTest() {
Assertions.assertTrue(Date(DateUtil(context).secondsOfTheDayToMilliseconds((T.hours(1).secs() + T.mins(1).secs() + 1).toInt())).toString().contains("01:01:00"))
}
@Test fun toSecondsTest() {
Assertions.assertEquals(3600, DateUtil(context).toSeconds("01:00").toLong())
Assertions.assertEquals(3600, DateUtil(context).toSeconds("01:00 a.m.").toLong())
Assertions.assertEquals(3600, DateUtil(context).toSeconds("01:00 AM").toLong())
}
@Test fun dateStringTest() {
Assertions.assertTrue(DateUtil(context).dateString(1513902750000L).contains("22"))
}
@Test fun timeStringTest() {
Assertions.assertTrue(DateUtil(context).timeString(1513902750000L).contains("32"))
}
@Test fun dateAndTimeStringTest() {
Assertions.assertTrue(DateUtil(context).dateAndTimeString(1513902750000L).contains("22"))
Assertions.assertTrue(DateUtil(context).dateAndTimeString(1513902750000L).contains("32"))
}
@Test fun dateAndTimeRangeStringTest() {
Assertions.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("22"))
Assertions.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("32"))
Assertions.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("22"))
Assertions.assertTrue(DateUtil(context).dateAndTimeRangeString(1513902750000L, 1513902750000L).contains("32"))
}
/*
@Test
public void timeStringFromSecondsTest() {
Assertions.assertEquals("1:00 AM", DateUtil.timeStringFromSeconds((int) T.hours(1).secs()));
}
*/
@Test fun timeFrameStringTest() {
`when`(rh.gs(info.nightscout.shared.R.string.shorthour)).thenReturn("h")
Assertions.assertEquals("(1h 1')", DateUtil(context).timeFrameString(T.hours(1).msecs() + T.mins(1).msecs(), rh))
}
}

28
core/main/src/test/java/info/nightscout/core/utils/DecimalFormatterTest.kt Normal file
View file

@ -0,0 +1,28 @@
package info.nightscout.core.utils
import info.nightscout.interfaces.utils.DecimalFormatter
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class DecimalFormatterTest {
@Test fun to0DecimalTest() {
Assertions.assertEquals("1", DecimalFormatter.to0Decimal(1.33).replace(",", "."))
Assertions.assertEquals("1U", DecimalFormatter.to0Decimal(1.33, "U").replace(",", "."))
}
@Test fun to1DecimalTest() {
Assertions.assertEquals("1.3", DecimalFormatter.to1Decimal(1.33).replace(",", "."))
Assertions.assertEquals("1.3U", DecimalFormatter.to1Decimal(1.33, "U").replace(",", "."))
}
@Test fun to2DecimalTest() {
Assertions.assertEquals("1.33", DecimalFormatter.to2Decimal(1.3333).replace(",", "."))
Assertions.assertEquals("1.33U", DecimalFormatter.to2Decimal(1.3333, "U").replace(",", "."))
}
@Test fun to3DecimalTest() {
Assertions.assertEquals("1.333", DecimalFormatter.to3Decimal(1.3333).replace(",", "."))
Assertions.assertEquals("1.333U", DecimalFormatter.to3Decimal(1.3333, "U").replace(",", "."))
}
}

80
core/main/src/test/java/info/nightscout/core/utils/JsonHelperTest.kt Normal file
View file

@ -0,0 +1,80 @@
package info.nightscout.core.utils
import info.nightscout.interfaces.utils.JsonHelper
import org.json.JSONObject
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
@Suppress("SpellCheckingInspection")
class JsonHelperTest {
private val jsonString = "{\"d\":\"3.0\",\"i\":\"4\",\"s\":\"5\",\"b\":\"true\",\"j\":{\"a\": \"1\"}}"
@Test
fun safeGetObjectTest() {
val json = JSONObject(jsonString)
val o = Any()
Assertions.assertEquals(o, JsonHelper.safeGetObject(null, "x", o))
Assertions.assertEquals(o, JsonHelper.safeGetObject(json, "x", o))
Assertions.assertNotEquals(o, JsonHelper.safeGetObject(json, "d", o))
}
@Test
fun safeGetJSONObjectTest() {
val json = JSONObject(jsonString)
val o = JSONObject()
Assertions.assertEquals(o, JsonHelper.safeGetJSONObject(null, "x", o))
Assertions.assertTrue(JsonHelper.safeGetJSONObject(json, "j", o)!!.has("a"))
Assertions.assertEquals(o, JsonHelper.safeGetJSONObject(json, "d", o))
}
@Test
fun safeGetStringTest() {
val json = JSONObject(jsonString)
Assertions.assertNull(JsonHelper.safeGetString(null, "s"))
Assertions.assertNull(JsonHelper.safeGetString(json, "notexisting"))
Assertions.assertEquals("5", JsonHelper.safeGetString(json, "s"))
Assertions.assertEquals("default", JsonHelper.safeGetString(null, "notexisting", "default"))
Assertions.assertEquals("default", JsonHelper.safeGetString(json, "notexisting", "default"))
Assertions.assertEquals("5", JsonHelper.safeGetString(json, "s", "default"))
Assertions.assertEquals("default", JsonHelper.safeGetStringAllowNull(null, "notexisting", "default"))
Assertions.assertEquals("default", JsonHelper.safeGetStringAllowNull(json, "notexisting", "default"))
Assertions.assertNull(JsonHelper.safeGetStringAllowNull(json, "notexisting", null))
Assertions.assertEquals("5", JsonHelper.safeGetStringAllowNull(json, "s", "default"))
}
@Test
fun safeGetDoubleTest() {
val json = JSONObject(jsonString)
Assertions.assertEquals(0.0, JsonHelper.safeGetDouble(json, "notexisting"), 0.0)
Assertions.assertEquals(0.0, JsonHelper.safeGetDouble(null, "notexisting"), 0.0)
Assertions.assertEquals(3.0, JsonHelper.safeGetDouble(json, "d"), 0.000001)
Assertions.assertEquals(6.0, JsonHelper.safeGetDouble(null, "notexisting", 6.0), 0.0)
Assertions.assertEquals(6.0, JsonHelper.safeGetDouble(json, "notexisting", 6.0), 0.0)
Assertions.assertEquals(3.0, JsonHelper.safeGetDouble(json, "d", 6.0), 0.0)
}
@Test
fun safeGetLntTest() {
val json = JSONObject(jsonString)
Assertions.assertEquals(0, JsonHelper.safeGetInt(null, "notexisting").toLong())
Assertions.assertEquals(0, JsonHelper.safeGetInt(json, "notexisting").toLong())
Assertions.assertEquals(4, JsonHelper.safeGetInt(json, "i").toLong())
}
@Test
fun safeGetLongTest() {
val json = JSONObject(jsonString)
Assertions.assertEquals(0, JsonHelper.safeGetInt(null, "notexisting").toLong())
Assertions.assertEquals(0, JsonHelper.safeGetInt(json, "notexisting").toLong())
Assertions.assertEquals(4, JsonHelper.safeGetInt(json, "i").toLong())
}
@Test
fun safeGetBooleanTest() {
val json = JSONObject(jsonString)
Assertions.assertFalse(JsonHelper.safeGetBoolean(null, "notexisting"))
Assertions.assertFalse(JsonHelper.safeGetBoolean(json, "notexisting"))
Assertions.assertTrue(JsonHelper.safeGetBoolean(json, "b"))
}
}

49
core/main/src/test/java/info/nightscout/core/utils/MidnightTimeTest.kt Normal file
View file

@ -0,0 +1,49 @@
package info.nightscout.core.utils
import info.nightscout.interfaces.utils.MidnightTime
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import java.util.Calendar
class MidnightTimeTest {
@Test fun calc() {
// We get real midnight
val now = System.currentTimeMillis()
Assertions.assertTrue(now >= MidnightTime.calc())
val c = Calendar.getInstance()
c.timeInMillis = MidnightTime.calc()
Assertions.assertEquals(c[Calendar.HOUR_OF_DAY].toLong(), 0)
Assertions.assertEquals(c[Calendar.MINUTE].toLong(), 0)
Assertions.assertEquals(c[Calendar.SECOND].toLong(), 0)
Assertions.assertEquals(c[Calendar.MILLISECOND].toLong(), 0)
}
@Test fun calc_time() {
// We get real midnight
val now = System.currentTimeMillis()
val midnight = MidnightTime.calc(now)
Assertions.assertTrue(now >= midnight)
val c = Calendar.getInstance()
c.timeInMillis = MidnightTime.calc(now)
Assertions.assertEquals(c[Calendar.HOUR_OF_DAY].toLong(), 0)
Assertions.assertEquals(c[Calendar.MINUTE].toLong(), 0)
Assertions.assertEquals(c[Calendar.SECOND].toLong(), 0)
Assertions.assertEquals(c[Calendar.MILLISECOND].toLong(), 0)
// Assure we get the same time from cache
Assertions.assertEquals(midnight, MidnightTime.calc(now))
}
@Test fun resetCache() {
val now = System.currentTimeMillis()
MidnightTime.calc(now)
MidnightTime.resetCache()
Assertions.assertEquals(0, MidnightTime.times.size().toLong())
}
@Test fun log() {
val now = System.currentTimeMillis()
MidnightTime.calc(now)
Assertions.assertTrue(MidnightTime.log().startsWith("Hits:"))
}
}

41
core/main/src/test/java/info/nightscout/core/utils/RoundTest.kt Normal file
View file

@ -0,0 +1,41 @@
package info.nightscout.core.utils
import info.nightscout.interfaces.utils.Round
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class RoundTest {
@Test
fun roundToTest() {
Assertions.assertEquals(0.55, Round.roundTo(0.54, 0.05), 0.00000000000000000001)
Assertions.assertEquals(-3.26, Round.roundTo(-3.2553715764602713, 0.01), 0.00000000000000000001)
Assertions.assertEquals(0.816, Round.roundTo(0.8156666666666667, 0.001), 0.00000000000000000001)
Assertions.assertEquals(0.235, Round.roundTo(0.235, 0.001), 0.00000000000000000001)
Assertions.assertEquals(0.3, Round.roundTo(0.3, 0.1), 0.00000000000000001)
Assertions.assertEquals(0.0017, Round.roundTo(0.0016960652144170627, 0.0001), 0.00000000000000000001)
Assertions.assertEquals(0.0078, Round.roundTo(0.007804436682291013, 0.0001), 0.00000000000000000001)
Assertions.assertEquals(0.6, Round.roundTo(0.6, 0.05), 0.00000000000000000001)
Assertions.assertEquals(1.0, Round.roundTo(1.49, 1.0), 0.00000000000000000001)
Assertions.assertEquals(0.0, Round.roundTo(0.0, 1.0), 0.00000000000000000001)
}
@Test
fun floorToTest() {
Assertions.assertEquals(0.5, Round.floorTo(0.54, 0.05), 0.00000001)
Assertions.assertEquals(1.0, Round.floorTo(1.59, 1.0), 0.00000001)
Assertions.assertEquals(0.0, Round.floorTo(0.0, 1.0), 0.00000001)
}
@Test
fun ceilToTest() {
Assertions.assertEquals(0.6, Round.ceilTo(0.54, 0.1), 0.00000001)
Assertions.assertEquals(2.0, Round.ceilTo(1.49999, 1.0), 0.00000001)
Assertions.assertEquals(0.0, Round.ceilTo(0.0, 1.0), 0.00000001)
}
@Test
fun isSameTest() {
Assertions.assertTrue(Round.isSame(0.54, 0.54))
}
}

19
core/main/src/test/java/info/nightscout/core/utils/StringUtilsTest.kt Normal file
View file

@ -0,0 +1,19 @@
package info.nightscout.core.utils
import info.nightscout.core.utils.receivers.StringUtils
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class StringUtilsTest {
@Test fun removeSurroundingQuotesTest() {
var compareString = "test"
Assertions.assertEquals(compareString, StringUtils.removeSurroundingQuotes(compareString))
Assertions.assertEquals(compareString, StringUtils.removeSurroundingQuotes("\"" + compareString + "\""))
Assertions.assertEquals("\"" + compareString, StringUtils.removeSurroundingQuotes("\"" + compareString))
compareString = "te\"st"
Assertions.assertEquals(compareString, StringUtils.removeSurroundingQuotes(compareString))
Assertions.assertEquals(compareString, StringUtils.removeSurroundingQuotes("\"" + compareString + "\""))
Assertions.assertEquals("\"" + compareString, StringUtils.removeSurroundingQuotes("\"" + compareString))
}
}

41
core/main/src/test/java/info/nightscout/core/utils/TTest.kt Normal file
View file

@ -0,0 +1,41 @@
package info.nightscout.core.utils
import info.nightscout.shared.utils.T
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import kotlin.math.abs
@Suppress("SpellCheckingInspection")
class TTest {
@Test fun toUnits() {
Assertions.assertEquals(1, T.msecs(1000).secs())
Assertions.assertEquals(1, T.secs(60).mins())
Assertions.assertEquals(1, T.mins(60).hours())
Assertions.assertEquals(1, T.hours(24).days())
Assertions.assertEquals(24, T.days(1).hours())
Assertions.assertEquals(60000, T.mins(1).msecs())
}
@Test fun now() {
Assertions.assertTrue(abs(T.now().msecs() - System.currentTimeMillis()) < 5000)
}
@Test fun additions() {
val nowMsecs = System.currentTimeMillis()
val now = T.msecs(nowMsecs)
Assertions.assertEquals(now.plus(T.secs(5)).msecs(), nowMsecs + 5 * 1000)
Assertions.assertEquals(now.plus(T.mins(5)).msecs(), nowMsecs + 5 * 60 * 1000)
Assertions.assertEquals(now.plus(T.hours(5)).msecs(), nowMsecs + 5 * 60 * 60 * 1000)
Assertions.assertEquals(now.plus(T.days(5)).msecs(), nowMsecs + 5 * 24 * 60 * 60 * 1000)
}
@Test fun subtractions() {
val nowMsecs = System.currentTimeMillis()
val now = T.msecs(nowMsecs)
Assertions.assertEquals(now.minus(T.secs(5)).msecs(), nowMsecs - 5 * 1000)
Assertions.assertEquals(now.minus(T.mins(5)).msecs(), nowMsecs - 5 * 60 * 1000)
Assertions.assertEquals(now.minus(T.hours(5)).msecs(), nowMsecs - 5 * 60 * 60 * 1000)
Assertions.assertEquals(now.minus(T.days(5)).msecs(), nowMsecs - 5 * 24 * 60 * 60 * 1000)
}
}

2
core/main/src/test/java/info/nightscout/core/wizard/QuickWizardTest.kt
View file

@ -2,10 +2,10 @@ package info.nightscout.core.wizard
import dagger.android.AndroidInjector
import dagger.android.HasAndroidInjector
import info.nightscout.androidaps.TestBase
import info.nightscout.interfaces.aps.Loop
import info.nightscout.interfaces.profile.ProfileFunction
import info.nightscout.shared.sharedPreferences.SP
import info.nightscout.sharedtests.TestBase
import org.json.JSONArray
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeEach