package com.infendro.bytearray

import com.infendro.bytearray.ByteOrder.LITTLE_ENDIAN
import kotlin.test.Test
import kotlin.test.assertContentEquals
import kotlin.test.assertEquals

class `Conversion Test` {
    @Test
    fun `ByteArray toInt`() {
        val expected = 0x12345678
        val actual = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78).toInt(),
            byteArrayOf(0x78, 0x56, 0x34, 0x12).toInt(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toInt`() {
        val expected = 0x12345678
        val actual = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U).toInt(),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U).toInt(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `ByteArray toUInt`() {
        val expected = 0x12345678U
        val actual = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78).toUInt(),
            byteArrayOf(0x78, 0x56, 0x34, 0x12).toUInt(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toUInt`() {
        val expected = 0x12345678U
        val actual = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U).toUInt(),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U).toUInt(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `ByteArray toIntArray`() {
        val expected = intArrayOf(0x12345678, 0x12345678)
        val actual = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78,
            ).toIntArray(),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12,
            ).toIntArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toIntArray`() {
        val expected = intArrayOf(0x12345678, 0x12345678)
        val actual = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U,
            ).toIntArray(),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U,
            ).toIntArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `ByteArray toUIntArray`() {
        val expected = uintArrayOf(0x12345678U, 0x12345678U)
        val actual = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78,
            ).toUIntArray(),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12,
            ).toUIntArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toUIntArray`() {
        val expected = uintArrayOf(0x12345678U, 0x12345678U)
        val actual = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U,
            ).toUIntArray(),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U,
            ).toUIntArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `Int toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78),
            byteArrayOf(0x78, 0x56, 0x34, 0x12),
        )
        val actual = arrayOf(
            0x12345678.toByteArray(),
            0x12345678.toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `UInt toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78),
            byteArrayOf(0x78, 0x56, 0x34, 0x12),
        )
        val actual = arrayOf(
            0x12345678U.toByteArray(),
            0x12345678U.toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `Int toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U),
        )
        val actual = arrayOf(
            0x12345678.toUByteArray(),
            0x12345678.toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `UInt toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U),
        )
        val actual = arrayOf(
            0x12345678U.toUByteArray(),
            0x12345678U.toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `IntArray toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78,
            ),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12,
            ),
        )
        val actual = arrayOf(
            intArrayOf(
                0x12345678,
                0x12345678,
            ).toByteArray(),
            intArrayOf(
                0x12345678,
                0x12345678,
            ).toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `UIntArray toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78,
            ),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12,
            ),
        )
        val actual = arrayOf(
            uintArrayOf(
                0x12345678U,
                0x12345678U,
            ).toByteArray(),
            uintArrayOf(
                0x12345678U,
                0x12345678U,
            ).toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `IntArray toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U,
            ),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U,
            ),
        )
        val actual = arrayOf(
            intArrayOf(
                0x12345678,
                0x12345678,
            ).toUByteArray(),
            intArrayOf(
                0x12345678,
                0x12345678,
            ).toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `UIntArray toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U,
            ),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U,
            ),
        )
        val actual = arrayOf(
            uintArrayOf(
                0x12345678U,
                0x12345678U,
            ).toUByteArray(),
            uintArrayOf(
                0x12345678U,
                0x12345678U,
            ).toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `ByteArray toLong`() {
        val expected = 0x1234567812345678L
        val actual = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78).toLong(),
            byteArrayOf(0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12).toLong(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toULong`() {
        val expected = 0x1234567812345678UL
        val actual = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U).toULong(),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U).toULong(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toLong`() {
        val expected = 0x1234567812345678L
        val actual = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U).toLong(),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U).toLong(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `ByteArray toULong`() {
        val expected = 0x1234567812345678UL
        val actual = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78).toULong(),
            byteArrayOf(0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12).toULong(LITTLE_ENDIAN),
        )
        assertEquals(expected, actual[0])
        assertEquals(expected, actual[1])
    }

    @Test
    fun `ByteArray toLongArray`() {
        val expected = longArrayOf(0x1234567812345678L, 0x1234567812345678L)
        val actual = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
            ).toLongArray(),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
            ).toLongArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toLongArray`() {
        val expected = longArrayOf(0x1234567812345678L, 0x1234567812345678L)
        val actual = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
            ).toLongArray(),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
            ).toLongArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `ByteArray toULongArray`() {
        val expected = ulongArrayOf(0x1234567812345678UL, 0x1234567812345678UL)
        val actual = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
            ).toULongArray(),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
            ).toULongArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `UByteArray toULongArray`() {
        val expected = ulongArrayOf(0x1234567812345678UL, 0x1234567812345678UL)
        val actual = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
            ).toULongArray(),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
            ).toULongArray(LITTLE_ENDIAN),
        )
        assertContentEquals(expected, actual[0])
        assertContentEquals(expected, actual[1])
    }

    @Test
    fun `Long toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78),
            byteArrayOf(0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12),
        )
        val actual = arrayOf(
            0x1234567812345678L.toByteArray(),
            0x1234567812345678L.toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `ULong toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78),
            byteArrayOf(0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12),
        )
        val actual = arrayOf(
            0x1234567812345678UL.toByteArray(),
            0x1234567812345678UL.toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `Long toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U),
        )
        val actual = arrayOf(
            0x1234567812345678L.toUByteArray(),
            0x1234567812345678L.toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `ULong toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U),
            ubyteArrayOf(0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U),
        )
        val actual = arrayOf(
            0x1234567812345678UL.toUByteArray(),
            0x1234567812345678UL.toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `LongArray toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
            ),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
            ),
        )
        val actual = arrayOf(
            longArrayOf(
                0x1234567812345678L,
                0x1234567812345678L,
            ).toByteArray(),
            longArrayOf(
                0x1234567812345678L,
                0x1234567812345678L,
            ).toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `ULongArray toByteArray`() {
        val expected = arrayOf(
            byteArrayOf(
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
                0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
            ),
            byteArrayOf(
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
                0x78, 0x56, 0x34, 0x12, 0x78, 0x56, 0x34, 0x12,
            ),
        )
        val actual = arrayOf(
            ulongArrayOf(
                0x1234567812345678UL,
                0x1234567812345678UL,
            ).toByteArray(),
            ulongArrayOf(
                0x1234567812345678UL,
                0x1234567812345678UL,
            ).toByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `LongArray toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
            ),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
            ),
        )
        val actual = arrayOf(
            longArrayOf(
                0x1234567812345678L,
                0x1234567812345678L,
            ).toUByteArray(),
            longArrayOf(
                0x1234567812345678L,
                0x1234567812345678L,
            ).toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }

    @Test
    fun `ULongArray toUByteArray`() {
        val expected = arrayOf(
            ubyteArrayOf(
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
                0x12U, 0x34U, 0x56U, 0x78U, 0x12U, 0x34U, 0x56U, 0x78U,
            ),
            ubyteArrayOf(
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
                0x78U, 0x56U, 0x34U, 0x12U, 0x78U, 0x56U, 0x34U, 0x12U,
            ),
        )
        val actual = arrayOf(
            ulongArrayOf(
                0x1234567812345678UL,
                0x1234567812345678UL,
            ).toUByteArray(),
            ulongArrayOf(
                0x1234567812345678UL,
                0x1234567812345678UL,
            ).toUByteArray(LITTLE_ENDIAN),
        )
        for (i in 0..1) {
            assertContentEquals(expected[i], actual[i])
        }
    }
}