nim-stew/tests/test_byteutils.nim

191 lines
5.0 KiB
Nim
Raw Normal View History

2019-07-06 18:07:41 +00:00
# byteutils
# Copyright (c) 2018-2022 Status Research & Development GmbH
2019-07-06 18:07:41 +00:00
# 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
2019-10-02 10:54:13 +00:00
proc compilationTest {.exportc: "compilationTest".} =
var bytes = @[1.byte, 2, 3, 4]
writeFile("test", bytes)
2019-07-06 18:07:41 +00:00
suite "Byte utils":
const simpleBArray = [0x12.byte, 0x34, 0x56, 0x78]
2019-07-06 18:07:41 +00:00
dualTest "hexToByteArray: Inplace partial string":
2019-07-06 18:07:41 +00:00
let s = "0x1234567890"
var a: array[5, byte]
hexToByteArray(s, a, 1, 3)
check a == [0.byte, 0x34, 0x56, 0x78, 0]
dualTest "hexToByteArray: Inplace full string":
2019-07-06 18:07:41 +00:00
let s = "0xffffffff"
var a: array[4, byte]
hexToByteArray(s, a)
check a == [255.byte, 255, 255, 255]
dualTest "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
dualTest "hexToByteArray: Return array":
2019-07-06 18:07:41 +00:00
let
s = "0x12345678"
a = hexToByteArray[4](s)
check a == simpleBArray
expect(ValueError): discard hexToByteArray[1]("")
expect(ValueError): discard hexToByteArray[1]("1")
dualTest "hexToByteArray: missing bytes":
var buffer: array[1, byte]
expect(ValueError):
hexToByteArray("0x", buffer)
expect(ValueError):
hexToByteArray("", buffer)
expect(ValueError):
hexToByteArray("0", buffer)
dualTest "valid hex with empty array":
var buffer: seq[byte]
hexToByteArray("0x123", openArray[byte](buffer))
check(buffer == seq[byte](@[]))
dualTest "valid hex with empty array of size":
var buffer: seq[byte] = newSeq[byte](4)
hexToByteArray("00000123", openArray[byte](buffer))
check(buffer == @[0.byte, 0.byte, 1.byte, 35.byte])
check buffer.toHex == "00000123"
dualTest "empty output array is ok":
var output: array[0, byte]
hexToByteArray("", output)
hexToByteArray("0x", output)
hexToByteArray("0x32", output)
dualTest "array.fromHex":
2020-07-02 15:00:39 +00:00
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)
dualTest "toHex":
2019-07-06 18:07:41 +00:00
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"
2019-07-06 18:07:41 +00:00
test "Array concatenation":
check simpleBArray & simpleBArray ==
[0x12.byte, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]
dualTest "hexToPaddedByteArray":
2019-07-06 18:07:41 +00:00
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")
2019-12-19 12:29:38 +00:00
dualTest "lessThan":
2019-12-19 12:29:38 +00:00
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)
proc copyView(v: openArray[char]): seq[byte] =
v.toBytes()
dualTest "strings":
check:
"a".toBytes() == @[byte(ord('a'))]
copyView("a") == @[byte(ord('a'))]
string.fromBytes([byte(ord('a'))]) == "a"
2020-03-04 23:42:04 +00:00
2020-03-07 22:29:46 +00:00
"".toBytes().len() == 0
string.fromBytes([]) == ""
@[byte(ord('a'))] == static("a".toBytes())
"a" == static(string.fromBytes([byte(ord('a'))]))
test "strings cast":
check:
cast[ptr UncheckedArray[byte]](cstring(string.fromBytes([byte(ord('a'))])))[1] == byte(0)
2020-03-04 23:42:04 +00:00
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