Refactor test methods for clarity and consistency

VREMSoftwareDevelopment · VREMSoftwareDevelopment · commit ba87caec730a · 2025-07-25T17:24:18.000-04:00
diff --git a/app/build.properties b/app/build.properties
@@ -1,6 +1,6 @@
 #Build Properties
-#Mon Jul 21 15:28:13 EDT 2025
-version_build=20
+#Fri Jul 25 17:22:34 EDT 2025
+version_build=21
 version_major=3
 version_minor=2
 version_patch=1
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/settings/ThemeStyleTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/settings/ThemeStyleTest.kt
@@ -25,31 +25,41 @@ import org.junit.Test
 class ThemeStyleTest {
     @Test
     fun themeStyle() {
-        assertThat(ThemeStyle.entries).hasSize(4)
+        assertThat(ThemeStyle.entries)
+            .hasSize(4)
+            .containsExactly(ThemeStyle.DARK,ThemeStyle.LIGHT,ThemeStyle.SYSTEM,ThemeStyle.BLACK)
     }
 
     @Test
     fun theme() {
         assertThat(ThemeStyle.LIGHT.theme).isEqualTo(R.style.ThemeLight)
         assertThat(ThemeStyle.DARK.theme).isEqualTo(R.style.ThemeDark)
-        assertThat(ThemeStyle.BLACK.theme).isEqualTo(R.style.ThemeBlack)
         assertThat(ThemeStyle.SYSTEM.theme).isEqualTo(R.style.ThemeSystem)
+        assertThat(ThemeStyle.BLACK.theme).isEqualTo(R.style.ThemeBlack)
     }
 
     @Test
     fun themeNoActionBar() {
         assertThat(ThemeStyle.DARK.themeNoActionBar).isEqualTo(R.style.ThemeDarkNoActionBar)
         assertThat(ThemeStyle.LIGHT.themeNoActionBar).isEqualTo(R.style.ThemeLightNoActionBar)
-        assertThat(ThemeStyle.BLACK.themeNoActionBar).isEqualTo(R.style.ThemeBlackNoActionBar)
         assertThat(ThemeStyle.SYSTEM.themeNoActionBar).isEqualTo(R.style.ThemeSystemNoActionBar)
+        assertThat(ThemeStyle.BLACK.themeNoActionBar).isEqualTo(R.style.ThemeBlackNoActionBar)
     }
 
     @Test
     fun colorGraphText() {
         assertThat(ThemeStyle.DARK.colorGraphText).isEqualTo(Color.WHITE)
         assertThat(ThemeStyle.LIGHT.colorGraphText).isEqualTo(Color.BLACK)
-        assertThat(ThemeStyle.BLACK.colorGraphText).isEqualTo(Color.WHITE)
         assertThat(ThemeStyle.SYSTEM.colorGraphText).isEqualTo(Color.GRAY)
+        assertThat(ThemeStyle.BLACK.colorGraphText).isEqualTo(Color.WHITE)
+    }
+
+    @Test
+    fun themeStyleOrdinal() {
+        assertThat(ThemeStyle.DARK.ordinal).isEqualTo(0)
+        assertThat(ThemeStyle.LIGHT.ordinal).isEqualTo(1)
+        assertThat(ThemeStyle.SYSTEM.ordinal).isEqualTo(2)
+        assertThat(ThemeStyle.BLACK.ordinal).isEqualTo(3)
     }
 
 }
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/accesspoint/AccessPointViewTypeTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/accesspoint/AccessPointViewTypeTest.kt
@@ -23,14 +23,19 @@ import org.junit.Test
 
 class AccessPointViewTypeTest {
     @Test
-    fun accessPointViewCount() {
-        assertThat(AccessPointViewType.entries).hasSize(2)
+    fun accessPointViewType() {
+        assertThat(AccessPointViewType.entries)
+            .hasSize(2)
+            .containsExactly(AccessPointViewType.COMPLETE, AccessPointViewType.COMPACT)
+    }
+    @Test
+    fun accessPointViewTypeOrdinal() {
+        assertThat(AccessPointViewType.COMPLETE.ordinal).isEqualTo(0)
+        assertThat(AccessPointViewType.COMPACT.ordinal).isEqualTo(1)
     }
-
     @Test
-    fun getLayout() {
+    fun accessPointViewTypeLayout() {
         assertThat(AccessPointViewType.COMPLETE.layout).isEqualTo(R.layout.access_point_view_complete)
         assertThat(AccessPointViewType.COMPACT.layout).isEqualTo(R.layout.access_point_view_compact)
     }
-
 }
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/accesspoint/ConnectionViewTypeTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/accesspoint/ConnectionViewTypeTest.kt
@@ -23,22 +23,27 @@ import org.junit.Test
 
 class ConnectionViewTypeTest {
     @Test
-    fun connectionViewTypeCount() {
-        assertThat(ConnectionViewType.entries).hasSize(3)
+    fun connectionViewType() {
+        assertThat(ConnectionViewType.entries)
+            .hasSize(3)
+            .containsExactly(ConnectionViewType.COMPLETE, ConnectionViewType.COMPACT, ConnectionViewType.HIDE)
+    }
+    @Test
+    fun connectionViewTypeOrdinal() {
+        assertThat(ConnectionViewType.COMPLETE.ordinal).isEqualTo(0)
+        assertThat(ConnectionViewType.COMPACT.ordinal).isEqualTo(1)
+        assertThat(ConnectionViewType.HIDE.ordinal).isEqualTo(2)
     }
-
     @Test
-    fun getLayout() {
+    fun connectionViewTypeLayout() {
         assertThat(ConnectionViewType.COMPLETE.layout).isEqualTo(R.layout.access_point_view_complete)
         assertThat(ConnectionViewType.COMPACT.layout).isEqualTo(R.layout.access_point_view_compact)
         assertThat(ConnectionViewType.HIDE.layout).isEqualTo(R.layout.access_point_view_hide)
     }
-
     @Test
-    fun isHide() {
+    fun connectionViewTypeHide() {
         assertThat(ConnectionViewType.COMPLETE.hide).isFalse
         assertThat(ConnectionViewType.COMPACT.hide).isFalse
         assertThat(ConnectionViewType.HIDE.hide).isTrue
     }
-
 }
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/band/WiFiBandTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/band/WiFiBandTest.kt
@@ -38,7 +38,9 @@ class WiFiBandTest {
 
     @Test
     fun wiFiBand() {
-        assertThat(WiFiBand.entries).hasSize(3)
+        assertThat(WiFiBand.entries)
+            .hasSize(3)
+            .containsExactly(WiFiBand.GHZ2, WiFiBand.GHZ5, WiFiBand.GHZ6)
     }
 
     @Test
@@ -62,6 +64,13 @@ class WiFiBandTest {
         assertThat(WiFiBand.GHZ6.wiFiChannels).isEqualTo(wiFiChannelsGHZ6)
     }
 
+    @Test
+    fun wiFiBandOrdinal() {
+        assertThat(WiFiBand.GHZ2.ordinal).isEqualTo(0)
+        assertThat(WiFiBand.GHZ5.ordinal).isEqualTo(1)
+        assertThat(WiFiBand.GHZ6.ordinal).isEqualTo(2)
+    }
+
     @Test
     fun ghz5() {
         assertThat(WiFiBand.GHZ2.ghz5).isFalse
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/graphutils/GraphLegendTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/graphutils/GraphLegendTest.kt
@@ -34,39 +34,42 @@ class GraphLegendTest {
     }
 
     @Test
-    fun sortByNumber() {
-        assertThat(GraphLegend.entries).hasSize(3)
+    fun graphLegend() {
+        assertThat(GraphLegend.entries)
+            .hasSize(3)
+            .containsExactly(GraphLegend.LEFT, GraphLegend.RIGHT, GraphLegend.HIDE)
     }
 
     @Test
-    fun getDisplay() {
+    fun graphLegendOrdinal() {
+        assertThat(GraphLegend.LEFT.ordinal).isEqualTo(0)
+        assertThat(GraphLegend.RIGHT.ordinal).isEqualTo(1)
+        assertThat(GraphLegend.HIDE.ordinal).isEqualTo(2)
+    }
+
+    @Test
+    fun graphLegendDisplay() {
         assertThat(legendDisplayNone).isEqualTo(GraphLegend.HIDE.legendDisplay)
         assertThat(legendDisplayLeft).isEqualTo(GraphLegend.LEFT.legendDisplay)
         assertThat(legendDisplayRight).isEqualTo(GraphLegend.RIGHT.legendDisplay)
     }
 
     @Test
-    fun displayHide() {
-        // execute
+    fun graphLegendHideDisplay() {
         GraphLegend.HIDE.display(legendRenderer)
-        // validate
         verify(legendRenderer).isVisible = false
     }
 
     @Test
-    fun displayLeft() {
-        // execute
+    fun graphLegendLeftDisplay() {
         GraphLegend.LEFT.display(legendRenderer)
-        // validate
         verify(legendRenderer).isVisible = true
         verify(legendRenderer).setFixedPosition(0, 0)
     }
 
     @Test
-    fun displayRight() {
-        // execute
+    fun graphLegendRightDisplay() {
         GraphLegend.RIGHT.display(legendRenderer)
-        // validate
         verify(legendRenderer).isVisible = true
         verify(legendRenderer).align = LegendRenderer.LegendAlign.TOP
     }
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/GroupByTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/GroupByTest.kt
@@ -23,8 +23,18 @@ import org.junit.Test
 class GroupByTest {
 
     @Test
-    fun groupByNumber() {
-        assertThat(GroupBy.entries).hasSize(4)
+    fun groupBy() {
+        assertThat(GroupBy.entries)
+            .hasSize(4)
+            .containsExactly(GroupBy.NONE, GroupBy.SSID, GroupBy.CHANNEL, GroupBy.VIRTUAL)
+    }
+
+    @Test
+    fun groupByOrdinal() {
+        assertThat(GroupBy.NONE.ordinal).isEqualTo(0)
+        assertThat(GroupBy.SSID.ordinal).isEqualTo(1)
+        assertThat(GroupBy.CHANNEL.ordinal).isEqualTo(2)
+        assertThat(GroupBy.VIRTUAL.ordinal).isEqualTo(3)
     }
 
     @Test
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/SecurityTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/SecurityTest.kt
@@ -23,8 +23,20 @@ import org.junit.Test
 
 class SecurityTest {
     @Test
-    fun size() {
-        assertThat(Security.entries).hasSize(6)
+    fun security() {
+        assertThat(Security.entries)
+            .hasSize(6)
+            .containsExactly(Security.NONE, Security.WPS, Security.WEP, Security.WPA, Security.WPA2, Security.WPA3)
+    }
+
+    @Test
+    fun securityOrdinal() {
+        assertThat(Security.NONE.ordinal).isEqualTo(0)
+        assertThat(Security.WPS.ordinal).isEqualTo(1)
+        assertThat(Security.WEP.ordinal).isEqualTo(2)
+        assertThat(Security.WPA.ordinal).isEqualTo(3)
+        assertThat(Security.WPA2.ordinal).isEqualTo(4)
+        assertThat(Security.WPA3.ordinal).isEqualTo(5)
     }
 
     @Test
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/SortByTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/SortByTest.kt
@@ -22,8 +22,17 @@ import org.junit.Test
 
 class SortByTest {
     @Test
-    fun sortByNumber() {
-        assertThat(SortBy.entries).hasSize(3)
+    fun sortBy() {
+        assertThat(SortBy.entries)
+            .hasSize(3)
+            .containsExactly(SortBy.STRENGTH, SortBy.SSID, SortBy.CHANNEL)
+    }
+
+    @Test
+    fun sortByOrdinal() {
+        assertThat(SortBy.STRENGTH.ordinal).isEqualTo(0)
+        assertThat(SortBy.SSID.ordinal).isEqualTo(1)
+        assertThat(SortBy.CHANNEL.ordinal).isEqualTo(2)
     }
 
     @Test
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/StrengthTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/StrengthTest.kt
@@ -18,33 +18,52 @@
 package com.vrem.wifianalyzer.wifi.model
 
 import com.vrem.wifianalyzer.R
-import com.vrem.wifianalyzer.wifi.model.Strength.Companion.calculate
-import com.vrem.wifianalyzer.wifi.model.Strength.Companion.reverse
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 
 class StrengthTest {
     @Test
     fun strength() {
-        assertThat(Strength.entries).hasSize(5)
+        assertThat(Strength.entries)
+            .hasSize(5)
+            .containsExactly(Strength.ZERO, Strength.ONE, Strength.TWO, Strength.THREE, Strength.FOUR)
+    }
+
+    @Test
+    fun strengthOrdinal() {
+        assertThat(Strength.ZERO.ordinal).isEqualTo(0)
+        assertThat(Strength.ONE.ordinal).isEqualTo(1)
+        assertThat(Strength.TWO.ordinal).isEqualTo(2)
+        assertThat(Strength.THREE.ordinal).isEqualTo(3)
+        assertThat(Strength.FOUR.ordinal).isEqualTo(4)
     }
 
     @Test
     fun imageResource() {
-        assertThat(Strength.ZERO.imageResource).isEqualTo(R.drawable.ic_signal_wifi_0_bar)
-        assertThat(Strength.ONE.imageResource).isEqualTo(R.drawable.ic_signal_wifi_1_bar)
-        assertThat(Strength.TWO.imageResource).isEqualTo(R.drawable.ic_signal_wifi_2_bar)
-        assertThat(Strength.THREE.imageResource).isEqualTo(R.drawable.ic_signal_wifi_3_bar)
-        assertThat(Strength.FOUR.imageResource).isEqualTo(R.drawable.ic_signal_wifi_4_bar)
+        val expectedImages = listOf(
+            R.drawable.ic_signal_wifi_0_bar,
+            R.drawable.ic_signal_wifi_1_bar,
+            R.drawable.ic_signal_wifi_2_bar,
+            R.drawable.ic_signal_wifi_3_bar,
+            R.drawable.ic_signal_wifi_4_bar
+        )
+        Strength.entries.forEachIndexed { i, strength ->
+            assertThat(strength.imageResource).isEqualTo(expectedImages[i])
+        }
     }
 
     @Test
     fun colorResource() {
-        assertThat(Strength.ZERO.colorResource).isEqualTo(R.color.error)
-        assertThat(Strength.ONE.colorResource).isEqualTo(R.color.warning)
-        assertThat(Strength.TWO.colorResource).isEqualTo(R.color.warning)
-        assertThat(Strength.THREE.colorResource).isEqualTo(R.color.success)
-        assertThat(Strength.FOUR.colorResource).isEqualTo(R.color.success)
+        val expectedColors = listOf(
+            R.color.error,
+            R.color.warning,
+            R.color.warning,
+            R.color.success,
+            R.color.success
+        )
+        Strength.entries.forEachIndexed { i, strength ->
+            assertThat(strength.colorResource).isEqualTo(expectedColors[i])
+        }
     }
 
     @Test
@@ -58,23 +77,27 @@ class StrengthTest {
 
     @Test
     fun calculate() {
-        assertThat(calculate(-89)).isEqualTo(Strength.ZERO)
-        assertThat(calculate(-88)).isEqualTo(Strength.ONE)
-        assertThat(calculate(-78)).isEqualTo(Strength.ONE)
-        assertThat(calculate(-77)).isEqualTo(Strength.TWO)
-        assertThat(calculate(-67)).isEqualTo(Strength.TWO)
-        assertThat(calculate(-66)).isEqualTo(Strength.THREE)
-        assertThat(calculate(-56)).isEqualTo(Strength.THREE)
-        assertThat(calculate(-55)).isEqualTo(Strength.FOUR)
-        assertThat(calculate(0)).isEqualTo(Strength.FOUR)
+        val testCases = listOf(
+            -89 to Strength.ZERO,
+            -88 to Strength.ONE,
+            -78 to Strength.ONE,
+            -77 to Strength.TWO,
+            -67 to Strength.TWO,
+            -66 to Strength.THREE,
+            -56 to Strength.THREE,
+            -55 to Strength.FOUR,
+            0 to Strength.FOUR
+        )
+        testCases.forEach { (input, expected) ->
+            assertThat(Strength.calculate(input)).isEqualTo(expected)
+        }
     }
 
     @Test
     fun reverse() {
-        assertThat(reverse(Strength.ZERO)).isEqualTo(Strength.FOUR)
-        assertThat(reverse(Strength.ONE)).isEqualTo(Strength.THREE)
-        assertThat(reverse(Strength.TWO)).isEqualTo(Strength.TWO)
-        assertThat(reverse(Strength.THREE)).isEqualTo(Strength.ONE)
-        assertThat(reverse(Strength.FOUR)).isEqualTo(Strength.ZERO)
+        val expected = listOf(Strength.FOUR, Strength.THREE, Strength.TWO, Strength.ONE, Strength.ZERO)
+        Strength.entries.forEachIndexed { i, strength ->
+            assertThat(Strength.reverse(strength)).isEqualTo(expected[i])
+        }
     }
 }
diff --git a/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/WiFiWidthTest.kt b/app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/WiFiWidthTest.kt
@@ -26,8 +26,10 @@ import org.junit.Test
 class WiFiWidthTest {
 
     @Test
-    fun width() {
-        assertThat(WiFiWidth.entries.size).isEqualTo(6)
+    fun wiFiWidth() {
+        assertThat(WiFiWidth.entries)
+            .hasSize(6)
+            .containsExactly(WiFiWidth.MHZ_20, WiFiWidth.MHZ_40, WiFiWidth.MHZ_80, WiFiWidth.MHZ_160, WiFiWidth.MHZ_80_PLUS, WiFiWidth.MHZ_320)
     }
 
     @Test
