156 lines
4.0 KiB
Nim
156 lines
4.0 KiB
Nim
# byteutils
|
|
# Copyright (c) 2018-2022 Status Research & Development GmbH
|
|
# Licensed and distributed under either of
|
|
# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT).
|
|
# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0).
|
|
# at your option. This file may not be copied, modified, or distributed except according to those terms.
|
|
|
|
{.used.}
|
|
|
|
import
|
|
unittest2,
|
|
../stew/byteutils
|
|
|
|
proc compilationTest {.exportc: "compilationTest".} =
|
|
var bytes = @[1.byte, 2, 3, 4]
|
|
writeFile("test", bytes)
|
|
|
|
suite "Byte utils":
|
|
let simpleBArray = [0x12.byte, 0x34, 0x56, 0x78]
|
|
|
|
test "hexToByteArray: Inplace partial string":
|
|
let s = "0x1234567890"
|
|
var a: array[5, byte]
|
|
hexToByteArray(s, a, 1, 3)
|
|
check a == [0.byte, 0x34, 0x56, 0x78, 0]
|
|
|
|
test "hexToByteArray: Inplace full string":
|
|
let s = "0xffffffff"
|
|
var a: array[4, byte]
|
|
hexToByteArray(s, a)
|
|
check a == [255.byte, 255, 255, 255]
|
|
|
|
test "hexToByteArrayStrict":
|
|
let
|
|
short0 = ""
|
|
short1 = "0x"
|
|
short2 = "0x00"
|
|
short3 = "0xffffff"
|
|
short4 = "0xfffffff"
|
|
correct = "0xffffffff"
|
|
long1 = "0xfffffffff"
|
|
long2 = "0xffffffffff"
|
|
|
|
var a: array[4, byte]
|
|
hexToByteArrayStrict(correct, a)
|
|
check a == [255.byte, 255, 255, 255]
|
|
|
|
template reject(val: string) =
|
|
expect ValueError: hexToByteArrayStrict(val, a)
|
|
|
|
reject short0
|
|
reject short1
|
|
reject short2
|
|
reject short3
|
|
reject short4
|
|
reject long1
|
|
reject long2
|
|
|
|
test "hexToByteArray: Return array":
|
|
let
|
|
s = "0x12345678"
|
|
a = hexToByteArray[4](s)
|
|
check a == simpleBArray
|
|
|
|
expect(ValueError): discard hexToByteArray[1]("")
|
|
expect(ValueError): discard hexToByteArray[1]("1")
|
|
|
|
test "array.fromHex":
|
|
let
|
|
s = "0x12345678"
|
|
a2 = array[2, byte].fromHex(s)
|
|
a4 = array[4, byte].fromHex(s)
|
|
|
|
check:
|
|
a2.toHex == "1234"
|
|
a4.toHex == "12345678"
|
|
|
|
expect(ValueError): echo array[5, byte].fromHex(s)
|
|
|
|
test "toHex":
|
|
check simpleBArray.toHex == "12345678"
|
|
check hexToSeqByte("12345678") == simpleBArray
|
|
check hexToSeqByte("00") == [byte 0]
|
|
check hexToSeqByte("0x") == []
|
|
expect(ValueError): discard hexToSeqByte("1234567")
|
|
expect(ValueError): discard hexToSeqByte("X")
|
|
expect(ValueError): discard hexToSeqByte("0")
|
|
check simpleBArray.to0xHex == "0x12345678"
|
|
|
|
test "Array concatenation":
|
|
check simpleBArray & simpleBArray ==
|
|
[0x12.byte, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]
|
|
|
|
test "hexToPaddedByteArray":
|
|
block:
|
|
let a = hexToPaddedByteArray[4]("0x123")
|
|
check a.toHex == "00000123"
|
|
block:
|
|
let a = hexToPaddedByteArray[4]("0x1234")
|
|
check a.toHex == "00001234"
|
|
block:
|
|
let a = hexToPaddedByteArray[4]("0x1234567")
|
|
check a.toHex == "01234567"
|
|
block:
|
|
let a = hexToPaddedByteArray[4]("0x12345678")
|
|
check a.toHex == "12345678"
|
|
block:
|
|
let a = hexToPaddedByteArray[32]("0x68656c6c6f20776f726c64")
|
|
check a.toHex == "00000000000000000000000000000000000000000068656c6c6f20776f726c64"
|
|
block:
|
|
expect ValueError:
|
|
discard hexToPaddedByteArray[2]("0x12345")
|
|
|
|
test "lessThan":
|
|
let
|
|
a = [0'u8, 1, 2]
|
|
b = [2'u8, 1, 0]
|
|
c = [0'u8, 1, 2, 3]
|
|
d = [0'u8, 1, 3, 3]
|
|
|
|
check:
|
|
not (a < a)
|
|
|
|
a < b
|
|
not (b < a)
|
|
|
|
c < b
|
|
not (b < c)
|
|
|
|
a < c
|
|
not (c < a)
|
|
|
|
c < d
|
|
not (d < c)
|
|
|
|
test "strings":
|
|
check:
|
|
"a".toBytes() == @[byte(ord('a'))]
|
|
string.fromBytes([byte(ord('a'))]) == "a"
|
|
cast[ptr UncheckedArray[byte]](cstring(string.fromBytes([byte(ord('a'))])))[1] == byte(0)
|
|
|
|
"".toBytes().len() == 0
|
|
string.fromBytes([]) == ""
|
|
@[byte(ord('a'))] == static("a".toBytes())
|
|
"a" == static(string.fromBytes([byte(ord('a'))]))
|
|
|
|
test "slices":
|
|
var a: array[4, byte]
|
|
a[0..<2] = [2'u8, 3]
|
|
check:
|
|
a[1] == 3
|
|
|
|
a.toOpenArray(0, 3)[0..<2] = [4'u8, 5]
|
|
check:
|
|
a[1] == 5
|