Add: domain model test coverage for DivePlan, CylinderRole, DivePlanInputModel and others

Author: Rolf-Smit

domain/src/commonTest/kotlin/org/neotech/app/abysner/domain/core/model/CylinderTest.kt

@@ -16,6 +16,9 @@ import org.neotech.app.abysner.domain.core.physics.asBarToPsi
 import kotlin.math.roundToInt
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
 
 class CylinderTest {
 
@@ -43,4 +46,50 @@ class CylinderTest {
         assertEquals(3300, Cylinder.AL100.workingPressure.asBarToPsi().roundToInt())
         assertEquals(3442, Cylinder.HP100.workingPressure.asBarToPsi().roundToInt())
     }
+
+    @Test
+    fun pressureAfter_returnsReducedPressure() {
+        val cylinder = Cylinder(Gas.Air, 200.0, 10.0)
+        val pressure = cylinder.pressureAfter(volumeUsage = 1500.0)
+        // Not asserting on exact value, to avoid coupling to the equation of state model.
+        assertNotNull(pressure)
+        assertTrue(pressure < 100.0)
+        assertTrue(pressure > 0.0)
+    }
+
+    @Test
+    fun pressureAfter_returnsNullWhenVolumeExceedsCapacity() {
+        val cylinder = Cylinder(Gas.Air, 200.0, 10.0)
+        val pressure = cylinder.pressureAfter(volumeUsage = 20000.0)
+        assertNull(pressure)
+    }
+
+    @Test
+    fun sizeFindMatching_returnsMatchingStandardSize() {
+        val found = Cylinder.Size.findMatching(waterVolume = 12.0, workingPressure = 232.0)
+        assertNotNull(found)
+        assertEquals("12L", found.name)
+    }
+
+    @Test
+    fun sizeFindMatching_matchesWithinTolerance() {
+        // Tolerance is 0.05L and 0.5 bar
+        val found = Cylinder.Size.findMatching(waterVolume = 12.04, workingPressure = 231.6)
+        assertNotNull(found)
+        assertEquals("12L", found.name)
+    }
+
+    @Test
+    fun sizeFindMatching_returnsNullForDeviationBeyondTolerance() {
+        val found = Cylinder.Size.findMatching(waterVolume = 12.1, workingPressure = 232.0)
+        assertNull(found)
+    }
+
+    @Test
+    fun sizeFill_createsCylinderWithWorkingPressure() {
+        val cylinder = Cylinder.STEEL_12L.fill(Gas.Air)
+        assertEquals(Cylinder.STEEL_12L.workingPressure, cylinder.pressure)
+        assertEquals(Cylinder.STEEL_12L.waterVolume, cylinder.waterVolume)
+        assertEquals(Gas.Air, cylinder.gas)
+    }
 }

domain/src/commonTest/kotlin/org/neotech/app/abysner/domain/core/model/GasTest.kt

@@ -15,11 +15,19 @@ package org.neotech.app.abysner.domain.core.model
 import org.neotech.app.abysner.domain.core.physics.ambientPressureToMeters
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 import org.neotech.app.abysner.domain.core.physics.metersToAmbientPressure
 import kotlin.math.floor
 
 class GasTest {
 
+    @Test
+    fun init_rejectsGasWhenCombinedOxygenAndHeliumFractionsExceedOneHundredPercent() {
+        assertFailsWith<IllegalStateException> {
+            Gas(oxygenFraction = 0.8, heliumFraction = 0.3)
+        }
+    }
+
     @Test
     fun oxygenMod_returnsCorrectModForCommonGases() {
         assertEquals(metersToAmbientPressure(40.653, Environment.SeaLevelFresh).value, Gas.Nitrox28.oxygenModAmbientPressure(1.4).value, DOUBLE_TOLERANCE)
@@ -72,10 +80,10 @@ class GasTest {
     }
 
     @Test
-    fun nitrogenFraction_isComputedFromOxygenAndHelium() {
-        val newGas = Gas(oxygenFraction = 21f / 100.0, heliumFraction = 0f / 100.0)
-        val nitrogenPercentage = (newGas.nitrogenFraction * 100.0).toInt()
-        println(nitrogenPercentage)
+    fun nitrogenFraction_isRemainderOfOxygenAndHelium() {
+        assertEquals(0.79, Gas.Air.nitrogenFraction, DOUBLE_TOLERANCE)
+        assertEquals(0.44, Gas.Trimix2135.nitrogenFraction, DOUBLE_TOLERANCE)
+        assertEquals(0.0, Gas.Oxygen.nitrogenFraction, DOUBLE_TOLERANCE)
     }
 
     @Test
@@ -188,6 +196,86 @@ class GasTest {
         assertEquals(0.328, inspired.oxygenFraction, DOUBLE_TOLERANCE)
         assertEquals(0.298, inspired.heliumFraction, DOUBLE_TOLERANCE)
     }
+
+    @Test
+    fun inspiredGas_pureOxygenDiluentReturnsOxygenOnly() {
+        val inspired = Gas.Oxygen.inspiredGas(metersToAmbientPressure(6.0, Environment.SeaLevelFresh), 1.3)
+        assertEquals(1.0, inspired.oxygenFraction, DOUBLE_TOLERANCE)
+        assertEquals(0.0, inspired.heliumFraction, DOUBLE_TOLERANCE)
+    }
+
+    @Test
+    fun endAmbientPressure_airEqualsAmbientPressure() {
+        // Air has no helium, so END equals actual depth
+        val ambient = metersToAmbientPressure(30.0, Environment.SeaLevelFresh).value
+        assertEquals(ambient, Gas.Air.endAmbientPressure(ambient), DOUBLE_TOLERANCE)
+    }
+
+    @Test
+    fun endAmbientPressure_trimixReducesNarcoticDepth() {
+        val ambient = metersToAmbientPressure(60.0, Environment.SeaLevelFresh).value
+        // Trimix 21/35 has 35% helium (non-narcotic), so at 60m (6.897 bar ambient) only the
+        // remaining 65% (21% O2 + 44% N2) counts towards narcotic depth, an END of about 4.483 bar.
+        assertEquals(4.483, Gas.Trimix2135.endAmbientPressure(ambient), DOUBLE_TOLERANCE)
+    }
+
+    @Test
+    fun diveIndustryName_returnsOxygenForPureO2() {
+        assertEquals("Oxygen", Gas.Oxygen.diveIndustryName())
+    }
+
+    @Test
+    fun diveIndustryName_returnsAirForStandardAir() {
+        assertEquals("Air", Gas.Air.diveIndustryName())
+    }
+
+    @Test
+    fun diveIndustryName_returnsNitroxForAnyEnrichedAirAbove21Percent() {
+        for (percentage in 22..99) {
+            val gas = Gas(oxygenFraction = percentage / 100.0, heliumFraction = 0.0)
+            assertEquals("Nitrox", gas.diveIndustryName())
+        }
+    }
+
+    @Test
+    fun diveIndustryName_returnsHelioxForAnyZeroNitrogenHeliumBlend() {
+        // Any gas with He > 0 and N2 = 0 (and not pure O2) is Heliox
+        for (oxygenPercentage in 1..99) {
+            val heliumPercentage = 100 - oxygenPercentage
+            val gas = Gas(oxygenFraction = oxygenPercentage / 100.0, heliumFraction = heliumPercentage / 100.0)
+            assertEquals("Heliox", gas.diveIndustryName())
+        }
+    }
+
+    @Test
+    fun diveIndustryName_returnsTrimixForHypoxicHeliumBlendWithNitrogen() {
+        // Any gas with O2 <= 21%, He > 0, and N2 > 0 is Trimix
+        for (oxygenPercentage in 1..21) {
+            for (heliumPercentage in 1 until (100 - oxygenPercentage)) {
+                val gas = Gas(oxygenFraction = oxygenPercentage / 100.0, heliumFraction = heliumPercentage / 100.0)
+                assertEquals("Trimix", gas.diveIndustryName())
+            }
+        }
+    }
+
+    @Test
+    fun diveIndustryName_returnsHelitroxForHyperoxicHeliumBlendWithNitrogen() {
+        // Any gas with O2 > 21%, He > 0, and N2 > 0 is Helitrox
+        for (oxygenPercentage in 22..98) {
+            for (heliumPercentage in 1 until (100 - oxygenPercentage)) {
+                val gas = Gas(oxygenFraction = oxygenPercentage / 100.0, heliumFraction = heliumPercentage / 100.0)
+                assertEquals("Helitrox", gas.diveIndustryName(), "Expected Helitrox for $oxygenPercentage/$heliumPercentage")
+            }
+        }
+    }
+
+    @Test
+    fun diveIndustryName_returnsHypoxicForAnySubAirO2WithoutHelium() {
+        for (percentage in 1..20) {
+            val gas = Gas(oxygenFraction = percentage / 100.0, heliumFraction = 0.0)
+            assertEquals("Hypoxic", gas.diveIndustryName(), "Expected Hypoxic for $percentage% O2")
+        }
+    }
 }
 
 private const val DOUBLE_TOLERANCE = 1e-3

domain/src/commonTest/kotlin/org/neotech/app/abysner/domain/core/physics/PolynomialRealGasModelTest.kt

@@ -16,6 +16,7 @@ import org.neotech.app.abysner.domain.core.model.Cylinder
 import org.neotech.app.abysner.domain.core.model.Gas
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
 class PolynomialRealGasModelTest {
 
@@ -33,6 +34,51 @@ class PolynomialRealGasModelTest {
             test(it * 30.0)
         }
     }
+
+    @Test
+    fun getGasPressure_constantTimeCalculation_producesReasonableResult() {
+        val model = PolynomialRealGasModel(constantTimeCalculation = true)
+        val cylinder = Cylinder(Gas.Air, 200.0, 10.0)
+        val volume = model.getGasVolume(cylinder)
+        val recoveredPressure = model.getGasPressure(cylinder, volume)
+        // constantTimeCalculation is an approximation, allow wider tolerance
+        assertEquals(200.0, recoveredPressure, 5.0)
+    }
+
+    @Test
+    fun getGasVolume_heliumRichGas_differFromIdealGas() {
+        val realModel = PolynomialRealGasModel()
+        val heliox = Gas(oxygenFraction = 0.21, heliumFraction = 0.79)
+        val volume = realModel.getGasVolume(heliox, 12.0, 200.0)
+        val idealVolume = 200.0 * 12.0  // 2400L
+        // Real gas model should produce a different result than ideal gas
+        assertTrue(volume != idealVolume, "Real gas volume should differ from ideal")
+        // But should still be in a reasonable range (within 10% of ideal)
+        assertTrue(volume > idealVolume * 0.9, "Volume $volume too low")
+        assertTrue(volume < idealVolume * 1.1, "Volume $volume too high")
+    }
+
+    @Test
+    fun getGasPressure_heliumRichGasHighPressure_convergesWithinTolerance() {
+        val model = PolynomialRealGasModel()
+        val heliox = Gas(oxygenFraction = 0.10, heliumFraction = 0.90)
+        val cylinder = Cylinder(heliox, 300.0, 10.0)
+        val volume = model.getGasVolume(cylinder)
+        val recoveredPressure = model.getGasPressure(cylinder, volume)
+        assertEquals(300.0, recoveredPressure, 1.0)
+    }
+
+    @Test
+    fun getGasVolume_nitroxAtVariousPressures_increasesMonotonically() {
+        val model = PolynomialRealGasModel()
+        var previousVolume = 0.0
+        for (pressure in 1..300 step 50) {
+            val cylinder = Cylinder(Gas.Nitrox50, pressure.toDouble(), 10.0)
+            val volume = model.getGasVolume(cylinder)
+            assertTrue(volume > previousVolume, "Volume should increase with pressure")
+            previousVolume = volume
+        }
+    }
 }
 
 private const val DOUBLE_TOLERANCE = 1e-6

domain/src/commonTest/kotlin/org/neotech/app/abysner/domain/diveplanning/model/CylinderRoleTest.kt

@@ -0,0 +1,86 @@
+/*
+ * Abysner - Dive planner
+ * Copyright (C) 2026 Neotech
+ *
+ * Abysner is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+
+package org.neotech.app.abysner.domain.diveplanning.model
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class CylinderRoleTest {
+
+    @Test
+    fun isCcrOxygen_trueOnlyForCcrOxygenRole() {
+        assertTrue(CylinderRole.CCR_OXYGEN.isCcrOxygen)
+        assertFalse(CylinderRole.CCR_DILUENT.isCcrOxygen)
+        assertFalse(CylinderRole.CCR_DILUENT_AND_BAILOUT.isCcrOxygen)
+    }
+
+    @Test
+    fun isCcrOxygen_falseForNull() {
+        val role: CylinderRole? = null
+        assertFalse(role.isCcrOxygen)
+    }
+
+    @Test
+    fun isCcrDiluent_trueForDiluentAndDiluentBailout() {
+        assertTrue(CylinderRole.CCR_DILUENT.isCcrDiluent)
+        assertTrue(CylinderRole.CCR_DILUENT_AND_BAILOUT.isCcrDiluent)
+        assertFalse(CylinderRole.CCR_OXYGEN.isCcrDiluent)
+    }
+
+    @Test
+    fun isCcrDiluent_falseForNull() {
+        val role: CylinderRole? = null
+        assertFalse(role.isCcrDiluent)
+    }
+
+    @Test
+    fun isAvailableForBailout_trueForNullAndDiluentBailout() {
+        val nullRole: CylinderRole? = null
+        assertTrue(nullRole.isAvailableForBailout)
+        assertTrue(CylinderRole.CCR_DILUENT_AND_BAILOUT.isAvailableForBailout)
+    }
+
+    @Test
+    fun isAvailableForBailout_falseForOxygenAndDiluent() {
+        assertFalse(CylinderRole.CCR_OXYGEN.isAvailableForBailout)
+        assertFalse(CylinderRole.CCR_DILUENT.isAvailableForBailout)
+    }
+
+    @Test
+    fun toggleAvailableForBailout_togglesDiluentToBailout() {
+        val result = CylinderRole.CCR_DILUENT.toggleAvailableForBailout(true)
+        assertEquals(CylinderRole.CCR_DILUENT_AND_BAILOUT, result)
+    }
+
+    @Test
+    fun toggleAvailableForBailout_togglesBailoutToDiluent() {
+        val result = CylinderRole.CCR_DILUENT_AND_BAILOUT.toggleAvailableForBailout(false)
+        assertEquals(CylinderRole.CCR_DILUENT, result)
+    }
+
+    @Test
+    fun toggleAvailableForBailout_noOpForOxygen() {
+        val result = CylinderRole.CCR_OXYGEN.toggleAvailableForBailout(true)
+        assertEquals(CylinderRole.CCR_OXYGEN, result)
+    }
+
+    @Test
+    fun toggleAvailableForBailout_noOpForNull() {
+        val role: CylinderRole? = null
+        val result = role.toggleAvailableForBailout(true)
+        assertNull(result)
+    }
+}