refactor: streamline CRC implementations by introducing a unified CrcEngine for consistency across CRC8, CRC16, and CRC32 classes; simplify test structure to enhance coverage and clarity

rasros · rasros · commit 3b3801951346 · 2026-04-01T12:14:52.000+02:00
diff --git a/src/main/kotlin/com/eignex/kencode/Crc.kt b/src/main/kotlin/com/eignex/kencode/Crc.kt
@@ -1,5 +1,76 @@
 package com.eignex.kencode
 
+/**
+ * Shared CRC digest engine parameterized by width (up to 32 bits).
+ * Uses Long arithmetic throughout to handle both 16-bit and 32-bit cases uniformly.
+ */
+private class CrcEngine(
+    poly: Int,
+    init: Int,
+    private val refin: Boolean,
+    private val refout: Boolean,
+    xorOut: Int,
+    private val width: Int
+) {
+    private val mask: Long = if (width == 32) 0xFFFFFFFFL else (1L shl width) - 1L
+    private val refPoly: Long = poly.reverseBits(width).toLong() and mask
+    private val refInit: Long = init.reverseBits(width).toLong() and mask
+    private val xorOutL: Long = xorOut.toLong() and mask
+
+    val size: Int = (width + 7) / 8
+
+    fun digest(data: ByteArray): ByteArray {
+        var crc = refInit
+        for (b in data) {
+            val raw = b.toInt() and 0xFF
+            val byte = if (refin) raw else raw.reverseBits8()
+            crc = crc xor byte.toLong()
+            repeat(8) {
+                crc = if ((crc and 1L) != 0L) (crc ushr 1) xor refPoly else crc ushr 1
+            }
+            crc = crc and mask
+        }
+        var finalCrc = if (refout) crc else crc.toInt().reverseBits(width).toLong() and mask
+        finalCrc = (finalCrc xor xorOutL) and mask
+        return ByteArray(size) { i ->
+            val shift = 8 * (size - 1 - i)
+            ((finalCrc ushr shift) and 0xFFL).toByte()
+        }
+    }
+}
+
+/**
+ * CRC-8 implementation with configurable polynomial and parameters.
+ *
+ * Default configuration implements CRC-8/SMBUS.
+ *
+ * Parameters:
+ * @param poly generator polynomial (high bit implicit).
+ * @param init initial CRC register value.
+ * @param refin whether to reflect bits of each input byte.
+ * @param refout whether to reflect the final CRC value.
+ * @param xorOut final XOR mask.
+ *
+ * Output:
+ * - Returned as a single-byte array.
+ */
+open class Crc8(
+    poly: Int = 0x07,
+    init: Int = 0x00,
+    refin: Boolean = false,
+    refout: Boolean = false,
+    xorOut: Int = 0x00
+) : Checksum {
+
+    companion object Default : Crc8()
+
+    private val engine = CrcEngine(poly, init, refin, refout, xorOut, width = 8)
+
+    override val size: Int get() = engine.size
+
+    override fun digest(data: ByteArray): ByteArray = engine.digest(data)
+}
+
 /**
  * CRC-16 implementation with configurable polynomial and parameters.
  *
@@ -20,54 +91,19 @@ package com.eignex.kencode
 open class Crc16(
     poly: Int = 0x1021,
     init: Int = 0xFFFF,
-    private val refin: Boolean = true,
-    private val refout: Boolean = true,
-    private val xorOut: Int = 0xFFFF,
-    private val width: Int = 16
+    refin: Boolean = true,
+    refout: Boolean = true,
+    xorOut: Int = 0xFFFF,
+    width: Int = 16
 ) : Checksum {
 
     companion object Default : Crc16()
 
-    private val mask = (1 shl width) - 1
-
-    // Internal representation is reflected (LSB-first),
-    // so pre-reflect poly and init.
-    private val refPoly: Int = poly.reverseBits(width)
-    private val refInit: Int = init.reverseBits(width)
-
-    override val size: Int = (width + 7) / 8
-
-    override fun digest(data: ByteArray): ByteArray {
-        var crc = refInit and mask
-
-        for (i in data.indices) {
-            val raw = data[i].toInt() and 0xFF
-            val b = if (refin) raw else raw.reverseBits8()
-
-            crc = crc xor b
-            repeat(8) {
-                crc = if ((crc and 1) != 0) {
-                    (crc ushr 1) xor refPoly
-                } else {
-                    crc ushr 1
-                }
-            }
-            crc = crc and mask
-        }
-
-        // Convert from internal reflected form to requested output form.
-        crc = if (refout) crc else crc.reverseBits(width)
+    private val engine = CrcEngine(poly, init, refin, refout, xorOut, width)
 
-        crc = (crc xor xorOut) and mask
+    override val size: Int get() = engine.size
 
-        // Output big-endian (high byte first).
-        val out = ByteArray(size)
-        for (i in 0 until size) {
-            val shift = 8 * (size - 1 - i)
-            out[i] = ((crc ushr shift) and 0xFF).toByte()
-        }
-        return out
-    }
+    override fun digest(data: ByteArray): ByteArray = engine.digest(data)
 }
 
 /**
@@ -88,58 +124,21 @@ open class Crc16(
  * - Internal representation uses reflected form.
  */
 open class Crc32(
-    poly: Int = 0x04C11DB7, // canonical CRC-32 poly
+    poly: Int = 0x04C11DB7,
     init: Int = 0xFFFFFFFF.toInt(),
-    private val refin: Boolean = true,
-    private val refout: Boolean = true,
-    private val xorOut: Int = 0xFFFFFFFF.toInt(),
-    private val width: Int = 32
+    refin: Boolean = true,
+    refout: Boolean = true,
+    xorOut: Int = 0xFFFFFFFF.toInt(),
+    width: Int = 32
 ) : Checksum {
 
     companion object Default : Crc32()
 
-    private val mask: Long = if (width == 32) 0xFFFFFFFFL
-    else (1L shl width) - 1L
-
-    // Internal representation: reflected
-    private val refPoly: Long = poly.reverseBits(width).toLong() and mask
-    private val refInit: Long = init.reverseBits(width).toLong() and mask
-
-    override val size: Int = (width + 7) / 8
-
-    override fun digest(data: ByteArray): ByteArray {
-        var crc = refInit
-
-        for (i in data.indices) {
-            val raw = data[i].toInt() and 0xFF
-            val b = if (refin) raw else raw.reverseBits8()
-
-            crc = crc xor (b.toLong() and 0xFFL)
-            repeat(8) {
-                crc = if ((crc and 1L) != 0L) {
-                    (crc ushr 1) xor refPoly
-                } else {
-                    crc ushr 1
-                }
-            }
-            crc = crc and mask
-        }
-
-        var finalCrc = if (refout) {
-            crc
-        } else {
-            crc.toInt().reverseBits(width).toLong() and mask
-        }
+    private val engine = CrcEngine(poly, init, refin, refout, xorOut, width)
 
-        finalCrc = (finalCrc xor (xorOut.toLong() and mask)) and mask
+    override val size: Int get() = engine.size
 
-        val out = ByteArray(size)
-        for (i in 0 until size) {
-            val shift = 8 * (size - 1 - i)
-            out[i] = ((finalCrc ushr shift) and 0xFFL).toByte()
-        }
-        return out
-    }
+    override fun digest(data: ByteArray): ByteArray = engine.digest(data)
 }
 
 /** Bit helpers */
diff --git a/src/test/kotlin/com/eignex/kencode/CrcTest.kt b/src/test/kotlin/com/eignex/kencode/CrcTest.kt
@@ -2,125 +2,49 @@ package com.eignex.kencode
 
 import kotlin.test.*
 
-class Crc16Test {
-    private val crc16 = Crc16() // defaults = CRC-16/X25
-
-    private fun digest(s: String): ByteArray =
-        crc16.digest(s.toByteArray())
-
-    private fun Int.toBytesBigEndian(size: Int): ByteArray {
-        val out = ByteArray(size)
-        for (i in 0 until size) {
-            val shift = 8 * (size - 1 - i)
-            out[i] = ((this ushr shift) and 0xFF).toByte()
-        }
-        return out
-    }
+class CrcTest {
 
-    @Test
-    fun `crc16 x25 check value 123456789`() {
-        val crc = digest("123456789")
-        val expected = 0x906E.toBytesBigEndian(2)
-        assertContentEquals(expected, crc)
-    }
+    private fun hex(s: String): ByteArray =
+        ByteArray(s.length / 2) { i -> s.substring(i * 2, i * 2 + 2).toInt(16).toByte() }
 
-    @Test
-    fun `crc16 x25 empty string`() {
-        // X25 params: init=0xFFFF, xorOut=0xFFFF, refin+refout => empty -> 0x0000
-        val crc = digest("")
-        val expected = 0x0000.toBytesBigEndian(2)
-        assertContentEquals(expected, crc)
-    }
+    private fun Checksum.digest(s: String): ByteArray = digest(s.toByteArray())
 
-    @Test
-    fun `crc16 size is two bytes`() {
-        assertEquals(2, crc16.size)
-    }
+    @Test fun `crc8 size is one byte`() = assertEquals(1, Crc8.size)
 
-    @Test
-    fun `crc16 is deterministic for same input`() {
-        val data = "some test payload"
-        val c1 = digest(data)
-        val c2 = digest(data)
-        assertContentEquals(c1, c2)
-    }
+    @Test fun `crc8 smbus check value 123456789`() =
+        assertContentEquals(hex("F4"), Crc8.digest("123456789"))
 
-    @Test
-    fun `crc16 ccitt-false check value 123456789`() {
-        // CRC-16/CCITT-FALSE: poly=0x1021, init=0xFFFF, refin=false, refout=false, xorOut=0x0000
-        val ccittFalse = Crc16(
-            poly = 0x1021,
-            init = 0xFFFF,
-            refin = false,
-            refout = false,
-            xorOut = 0x0000,
-            width = 16
-        )
-
-        val crc = ccittFalse.digest("123456789".toByteArray())
-        val expected = 0x29B1.toBytesBigEndian(2)
-        assertContentEquals(expected, crc)
-    }
-}
+    @Test fun `crc8 smbus empty input`() =
+        assertContentEquals(hex("00"), Crc8.digest(""))
 
-class Crc32Test {
+    @Test fun `crc8 rohc check value 123456789`() {
+        val rohc = Crc8(poly = 0x07, init = 0xFF, refin = true, refout = true, xorOut = 0x00)
+        assertContentEquals(hex("D0"), rohc.digest("123456789"))
+    }
 
-    private val crc32 = Crc32() // default = CRC-32/ISO-HDLC
+    @Test fun `crc16 size is two bytes`() = assertEquals(2, Crc16.size)
 
-    private fun digest(s: String): ByteArray =
-        crc32.digest(s.toByteArray())
+    @Test fun `crc16 x25 check value 123456789`() =
+        assertContentEquals(hex("906E"), Crc16.digest("123456789"))
 
-    private fun Int.toBytesBigEndian(size: Int): ByteArray {
-        val out = ByteArray(size)
-        for (i in 0 until size) {
-            val shift = 8 * (size - 1 - i)
-            out[i] = ((this ushr shift) and 0xFF).toByte()
-        }
-        return out
-    }
+    @Test fun `crc16 x25 empty input`() =
+        assertContentEquals(hex("0000"), Crc16.digest(""))
 
-    @Test
-    fun `crc32 check value 123456789`() {
-        val crc = digest("123456789")
-        val expected = 0xCBF43926.toInt().toBytesBigEndian(4)
-        assertContentEquals(expected, crc)
+    @Test fun `crc16 ccitt-false check value 123456789`() {
+        val ccittFalse = Crc16(poly = 0x1021, init = 0xFFFF, refin = false, refout = false, xorOut = 0x0000)
+        assertContentEquals(hex("29B1"), ccittFalse.digest("123456789"))
     }
 
-    @Test
-    fun `crc32 empty string`() {
-        // For standard CRC-32 (init=FFFFFFFF, xorOut=FFFFFFFF, refin+refout), empty message -> 0x00000000
-        val crc = digest("")
-        val expected = 0x00000000.toBytesBigEndian(4)
-        assertContentEquals(expected, crc)
-    }
+    @Test fun `crc32 size is four bytes`() = assertEquals(4, Crc32.size)
 
-    @Test
-    fun `crc32 size is four bytes`() {
-        assertEquals(4, crc32.size)
-    }
+    @Test fun `crc32 iso-hdlc check value 123456789`() =
+        assertContentEquals(hex("CBF43926"), Crc32.digest("123456789"))
 
-    @Test
-    fun `crc32 is deterministic for same input`() {
-        val data = "some test payload"
-        val c1 = digest(data)
-        val c2 = digest(data)
-        assertContentEquals(c1, c2)
-    }
+    @Test fun `crc32 iso-hdlc empty input`() =
+        assertContentEquals(hex("00000000"), Crc32.digest(""))
 
-    @Test
-    fun `crc32 mpeg-2 check value 123456789`() {
-        // CRC-32/MPEG-2: poly=0x04C11DB7, init=0xFFFFFFFF, refin=false, refout=false, xorOut=0x00000000
-        val mpeg2 = Crc32(
-            poly = 0x04C11DB7,
-            init = 0xFFFFFFFF.toInt(),
-            refin = false,
-            refout = false,
-            xorOut = 0x00000000,
-            width = 32
-        )
-
-        val crc = mpeg2.digest("123456789".toByteArray())
-        val expected = 0x0376E6E7.toInt().toBytesBigEndian(4)
-        assertContentEquals(expected, crc)
+    @Test fun `crc32 mpeg-2 check value 123456789`() {
+        val mpeg2 = Crc32(poly = 0x04C11DB7, init = 0xFFFFFFFF.toInt(), refin = false, refout = false, xorOut = 0x00000000)
+        assertContentEquals(hex("0376E6E7"), mpeg2.digest("123456789"))
     }
 }
