Add humanize for packet count

Author: seladb

app/src/androidTest/java/com/pcapplusplus/toyvpn/StatsScreenTest.kt

@@ -162,6 +162,48 @@ class StatsScreenTest {
         }
     }
 
+    @Test
+    fun testHumanizePacketCount() {
+        val totalPacketCount = 996099
+        val ipv4PacketCount = 123
+        val ipv6PacketCount = 1234
+        val tcpPacketCount = 12_345
+        val udpPacketCount = 122_000
+        val dnsPacketCount = 4_599_888
+        val tlsPacketCount = 34_829_007
+        val tcpConnectionCount = 999_999_999
+        val udpConnectionCount = 1_000_990_000
+
+        renderScreen(
+            totalPacketCount = totalPacketCount,
+            ipv4PacketCount = ipv4PacketCount,
+            ipv6PacketCount = ipv6PacketCount,
+            tcpPacketCount = tcpPacketCount,
+            udpPacketCount = udpPacketCount,
+            dnsPacketCount = dnsPacketCount,
+            tlsPacketCount = tlsPacketCount,
+            tcpConnectionCount = tcpConnectionCount,
+            udpConnectionCount = udpConnectionCount,
+        )
+
+        val expectedValues =
+            listOf(
+                Pair("IPv4", "123"),
+                Pair("IPv6", "1234"),
+                Pair("TCP", "12.35K"),
+                Pair("UDP", "122K"),
+                Pair("DNS", "4.6M"),
+                Pair("TLS", "34.83M"),
+                Pair("TCPConn", "1B"),
+                Pair("UDPConn", "1.001B"),
+            )
+
+        composeTestRule.onNodeWithText("Total Packets").onSibling().assertTextEquals(totalPacketCount.toString())
+        expectedValues.forEach { (testTag, humanizedCount) ->
+            composeTestRule.onNodeWithTag("${testTag}_count").assertTextEquals(humanizedCount)
+        }
+    }
+
     @Test
     fun testVpnConnectedWithTopDnsDomainData() {
         val topDnsDomains =

app/src/main/java/com/pcapplusplus/toyvpn/StatsScreen.kt

@@ -246,7 +246,7 @@ fun TrafficStatRow(stat: TrafficStat) {
             total = if (stat.total != 0) stat.total else 1,
         )
         Text(
-            text = stat.count.toString(),
+            text = stat.count.humanize(),
             style = MaterialTheme.typography.titleMedium.copy(fontSize = 20.sp),
             modifier = Modifier.align(Alignment.CenterVertically).testTag("${stat.testTag}_count"),
             textAlign = TextAlign.End,

app/src/main/java/com/pcapplusplus/toyvpn/Utils.kt

@@ -3,6 +3,7 @@ package com.pcapplusplus.toyvpn
 import android.content.Intent
 import android.os.Build
 import android.os.Parcelable
+import kotlin.collections.ArrayList
 
 @Suppress("DEPRECATION")
 inline fun <reified T : Parcelable> Intent.getParcelableArrayListExtraCompat(key: String): ArrayList<T>? {
@@ -12,3 +13,41 @@ inline fun <reified T : Parcelable> Intent.getParcelableArrayListExtraCompat(key
         getParcelableArrayListExtra(key)
     }
 }
+
+fun Int.humanize(): String {
+    if (this < 10000) {
+        return this.toString()
+    }
+
+    var (divisor, suffix) =
+        when {
+            this < 1000000 -> 1000.0 to "K"
+            this < 1000000000 -> 1000000.0 to "M"
+            else -> 1000000000.0 to "B"
+        }
+
+    var value = this / divisor
+
+    if (value >= 999.95) {
+        when (suffix) {
+            "K" -> {
+                value /= 1000
+                suffix = "M"
+            }
+            "M" -> {
+                value /= 1000
+                suffix = "B"
+            }
+        }
+    }
+
+    val format =
+        when {
+            value < 10 -> "%.3f"
+            value < 100 -> "%.2f"
+            else -> "%.1f"
+        }
+
+    val formatted = String.format(format, value).toDouble().toString().removeSuffix(".0")
+    return "$formatted$suffix"
+}

app/src/test/java/com/pcapplusplus/toyvpn/HumanizeTest.kt

@@ -0,0 +1,73 @@
+package com.pcapplusplus.toyvpn
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class HumanizeTest {
+    @Test
+    fun `test numbers less than 10,000`() {
+        assertEquals("0", 0.humanize())
+        assertEquals("1", 1.humanize())
+        assertEquals("42", 42.humanize())
+        assertEquals("999", 999.humanize())
+        assertEquals("1000", 1000.humanize())
+        assertEquals("9999", 9999.humanize())
+    }
+
+    @Test
+    fun `test numbers in thousands range`() {
+        assertEquals("10K", 10000.humanize())
+        assertEquals("10.01K", 10010.humanize())
+        assertEquals("12.35K", 12345.humanize())
+        assertEquals("25.36K", 25359.humanize())
+        assertEquals("52K", 51999.humanize())
+        assertEquals("40K", 39999.humanize())
+        assertEquals("39.1K", 39099.humanize())
+        assertEquals("99.95K", 99950.humanize())
+        assertEquals("99.99K", 99990.humanize())
+        assertEquals("100K", 99997.humanize())
+        assertEquals("100K", 100000.humanize())
+        assertEquals("150.3K", 150300.humanize())
+        assertEquals("150.6K", 150554.humanize())
+        assertEquals("999.5K", 999500.humanize())
+    }
+
+    @Test
+    fun `test boundary cases for K to M transition`() {
+        assertEquals("999.9K", 999900.humanize())
+        assertEquals("1M", 999950.humanize())
+        assertEquals("1M", 999999.humanize())
+        assertEquals("1M", 1000000.humanize())
+        assertEquals("1M", 1000010.humanize())
+    }
+
+    @Test
+    fun `test numbers in millions range`() {
+        assertEquals("1.001M", 1001000.humanize())
+        assertEquals("1.234M", 1234000.humanize())
+        assertEquals("1.335M", 1334556.humanize())
+        assertEquals("9.999M", 9999000.humanize())
+        assertEquals("10.45M", 10446888.humanize())
+        assertEquals("50.01M", 50010000.humanize())
+        assertEquals("99.99M", 99990000.humanize())
+        assertEquals("100M", 100000000.humanize())
+        assertEquals("500.5M", 500500000.humanize())
+        assertEquals("999.5M", 999500000.humanize())
+    }
+
+    @Test
+    fun `test boundary cases for M to B transition`() {
+        assertEquals("999.9M", 999900000.humanize())
+        assertEquals("1B", 999950000.humanize())
+        assertEquals("1B", 999999900.humanize())
+        assertEquals("1B", 1000000000.humanize())
+    }
+
+    @Test
+    fun `test numbers in billions range`() {
+        assertEquals("1.001B", 1001000000.humanize())
+        assertEquals("1.5B", 1500000000.humanize())
+        assertEquals("1.672B", 1671900246.humanize())
+        assertEquals("2.147B", Int.MAX_VALUE.humanize())
+    }
+}