NAME=rz-ax -I 3530468537
TOOL=rz-ax
ARGS=-I 3530468537
EXPECT=<<EOF
185.172.110.210
EOF
RUN

NAME=rz-ax -I 185.172.110.210
TOOL=rz-ax
ARGS=-I 185.172.110.210
EXPECT=<<EOF
0xd26eacb9
EOF
RUN

NAME=rz-ax =10 0x46
TOOL=rz-ax
ARGS==10 0x46
EXPECT=<<EOF
70
EOF
RUN

NAME=rz-ax =16 0x3+0x3
TOOL=rz-ax
ARGS==16 0x3+0x3
EXPECT=<<EOF
0x6
EOF
RUN

NAME=rz-ax -E | rz-ax -D
FILE==
CMDS=!rz-ax -E hello |rz-ax -D |rz-ax -E | rz-ax -D  |rz-ax -E|rz-ax -D |rz-ax -E | rz-ax -D
EXPECT=hello
RUN

NAME=rz-ax -E | rz-ax -D 2
FILE==
CMDS=!rz-ax -E hello |rz-ax -D |rz-ax -E | rz-ax -D  |rz-ax -E|rz-ax -D |rz-ax -E | rz-ax -Dl
EXPECT=hello
RUN

NAME=rz-ax -E | rz-ax -D 3
FILE==
CMDS=!echo hello | rz-ax -E |rz-ax -D |rz-ax -E | rz-ax -D  |rz-ax -E|rz-ax -D |rz-ax -E | rz-ax -D
EXPECT=<<EOF
hello
EOF
RUN

NAME=rz-ax -D null byte
FILE==
CMDS=!rz-ax -D ZQBlAA== | rz-ax -S
EXPECT=<<EOF
65006500
EOF
RUN

NAME=rz-ax -S hello | rz-ax -s
FILE==
CMDS=!rz-ax -S hello | rz-ax -s
EXPECT=hello
RUN

NAME=rz-ax -S hello | rz-ax -s 2
FILE==
CMDS=!echo hello | rz-ax -S | rz-ax -s
EXPECT=<<EOF
hello
EOF
RUN

NAME=rz-ax -S hello | rz-ax -s (2)
FILE==
CMDS=!echo hello | rz-ax -S | rz-ax -s | rz-ax -S | rz-ax -s
EXPECT=<<EOF
hello
EOF
RUN

NAME=rz-ax -b 01101000011001010110110001101100011011110111011101101111011100100110110001100100
TOOL=rz-ax
ARGS=-b 01101000011001010110110001101100011011110111011101101111011100100110110001100100
EXPECT=helloworld
RUN

NAME=rz-ax -B hello world
TOOL=rz-ax
ARGS=-B hello world
EXPECT=01101000011001010110110001101100011011110111011101101111011100100110110001100100
RUN

NAME=rz-ax 10
TOOL=rz-ax
ARGS=10
EXPECT=<<EOF
0xa
EOF
RUN

NAME=rz-ax 0xa
TOOL=rz-ax
ARGS=0xa
EXPECT=<<EOF
10
EOF
RUN

NAME=rz-ax -1
TOOL=rz-ax
ARGS=-1
EXPECT=<<EOF
0xffffffffffffffff
EOF
RUN

NAME=rz-ax 0xffffffffffffffff
TOOL=rz-ax
ARGS=0xffffffffffffffff
EXPECT=<<EOF
-1
EOF
RUN

NAME=rz-ax b30
TOOL=rz-ax
ARGS=b3
EXPECT=<<EOF
11b
EOF
RUN

NAME=rz-ax t42
TOOL=rz-ax
ARGS=t42
EXPECT=<<EOF
1120t
EOF
RUN

NAME=rz-ax 1010d
TOOL=rz-ax
ARGS=1010d
EXPECT=<<EOF
10
EOF
RUN

NAME=rz-ax 3.33f
TOOL=rz-ax
ARGS=3.33f
EXPECT=<<EOF
Fx40551eb8
EOF
RUN

NAME=rz-ax Fx40551ed8
TOOL=rz-ax
ARGS=Fx40551ed8
EXPECT=<<EOF
3.330008f
EOF
RUN

NAME=rz-ax 35o
TOOL=rz-ax
ARGS=35o
EXPECT=<<EOF
0x1d
EOF
RUN

NAME=rz-ax Ox12
TOOL=rz-ax
ARGS=Ox12
EXPECT=<<EOF
022
EOF
RUN

NAME=rz-ax 1100011b
TOOL=rz-ax
ARGS=1100011b
EXPECT=<<EOF
0x63
EOF
RUN

NAME=rz-ax Bx63
TOOL=rz-ax
ARGS=Bx63
EXPECT=<<EOF
1100011b
EOF
RUN

NAME=rz-ax Bxffff0000ffff0101
TOOL=rz-ax
ARGS=Bxffff0000ffff0101
EXPECT=<<EOF
1111111111111111000000000000000011111111111111110000000100000001b
EOF
RUN

NAME=rz-ax 64bit binary number
# BROKEN: trailing-suffix binary literal rejected by the new grammar (use a 0b prefix)
BROKEN=1
TOOL=rz-ax
ARGS=1111111111111111000000000000000011111111111111110000000100000001b
EXPECT=<<EOF
0xffff0000ffff0101
EOF
RUN

NAME=rz-ax Tx23
TOOL=rz-ax
ARGS=Tx23
EXPECT=<<EOF
1022t
EOF
RUN

NAME=rz-ax Tx23
TOOL=rz-ax
ARGS=Tx23
EXPECT=<<EOF
1022t
EOF
RUN

NAME=cat bins/other/admin.txt | rz-ax -S
FILE==
CMDS=!cat bins/other/admin.txt | rz-ax -S
EXPECT=<<EOF
6161646d696e61
EOF
RUN

NAME=echo "414141" | rz-ax -s
FILE==
CMDS=!printf 414141 | rz-ax -s
EXPECT=AAA
RUN

NAME=rz-ax -b 01000101 01110110
TOOL=rz-ax
ARGS=-b 01000101 01110110
EXPECT=Ev
RUN

NAME=rz-ax -k 33+3
TOOL=rz-ax
ARGS=-k 33+3
EXPECT=<<EOF
36
EOF
RUN

NAME=rz-ax -e 0x00000401
TOOL=rz-ax
ARGS=-e 0x00000401
EXPECT=<<EOF
0x1040000
EOF
RUN

NAME=rz-ax -f 6.3+2.1
# BROKEN: 'rz-ax -f' no longer prints the bare decimal result; prints a float table now
BROKEN=1
TOOL=rz-ax
ARGS=-f 6.3+2.1
EXPECT=<<EOF
8.4
EOF
RUN

NAME=rz-ax -n 0x1234
TOOL=rz-ax
ARGS=-n 0x1234
EXPECT=<<EOF
34120000
EOF
RUN

NAME=rz-ax -n 0xFEDCBA9876543210
TOOL=rz-ax
ARGS=-n 0xFEDCBA9876543210
EXPECT=<<EOF
1032547698badcfe
EOF
RUN

NAME=rz-ax -N 0xFEDCBA9876543210
TOOL=rz-ax
ARGS=-N 0xFEDCBA9876543210
EXPECT=<<EOF
\x10\x32\x54\x76\x98\xba\xdc\xfe
EOF
RUN

NAME=rz-ax -N 0x1234
TOOL=rz-ax
ARGS=-N 0x1234
EXPECT=<<EOF
\x34\x12\x00\x00
EOF
RUN

NAME=rz-ax -d 3
TOOL=rz-ax
ARGS=-d 3
EXPECT=<<EOF
3
EOF
RUN

NAME=cat bins/other/shellcode.c | rz-ax sF
FILE==
CMDS=!cat bins/other/shellcode.c | rz-ax -F
EXPECT=<<EOF
31c050686e2f7368682f2f626989e35089e25389e1b00bcd80
EOF
RUN

NAME=C array {0x33,33,23,32}
FILE==
CMDS=echo "main() {const char *foo = {0x33,33,23,23,23,23,4,13,32,23,32,23,32};}" | rz-ax -F
EXPECT=<<EOF
332117171717040d2017201720
EOF
RUN

NAME=C string "\x33\x44\x88"
FILE==
CMDS=echo 'main(){const char *foo = "\x33\x44\x88"; }' | rz-ax -F
EXPECT=<<EOF
334488
EOF
RUN

NAME=cat bins/other/shellcode.py | rz-ax sF
FILE==
CMDS=!cat bins/other/shellcode.py | rz-ax -F
EXPECT=<<EOF
31c050686e2f7368682f2f626989e35089e25389e1b00bcd80
EOF
RUN

NAME=Python array [0x33,33,23,32]
FILE==
CMDS=echo "foo = [0x33,33,23,23,23,23,4,13,32,23,32,23,32]" | rz-ax -F
EXPECT=<<EOF
332117171717040d2017201720
EOF
RUN

NAME=Python string '\x33\x44\x88'
FILE==
CMDS=echo foo = "'\x33\x44\x88'" | rz-ax -F
EXPECT=<<EOF
334488
EOF
RUN

NAME=Python string "\x33\x44\x88"
FILE==
CMDS=echo foo = '"\x33\x44\x88"' | rz-ax -F
EXPECT=<<EOF
334488
EOF
RUN

NAME=rz-ax -s 43 4a 50
TOOL=rz-ax
ARGS=-s 43 4a 50
EXPECT=CJP
RUN

NAME=rz-ax -s 434a50
TOOL=rz-ax
ARGS=-s 434a50
EXPECT=CJP
RUN

NAME=rz-ax -S "hello\x2Aworld ZYX\234abc\n"
TOOL=rz-ax
FILE=hello\x2Aworld ZYX\234abc\n
ARGS=-S
EXPECT=<<EOF
68656c6c6f2a776f726c64205a59589c6162630a
EOF
RUN

NAME=rz-ax -t "1234567890 GMT-1"
TOOL=rz-ax
FILE=1234567890 GMT-1
ARGS=-t
REGEXP_FILTER_OUT=Fri Feb
EXPECT=<<EOF
Fri Feb
EOF
RUN

NAME=Timestamp GMT difference
FILE==
CMDS=<<EOF
%v `!rz-ax -t "1234567890 GMT-1" | cut -d " " -f 4 | cut -d ":" -f 1` - `!rz-ax -t "1234567890 GMT-3" | cut -d " " -f 4 | cut -d ":" -f 1`
EOF
EXPECT=<<EOF
0x2
EOF
RUN

NAME=rz-ax -x linux osx
TOOL=rz-ax
ARGS=-x linux osx
EXPECT=<<EOF
0x5ca62a43
0xad593a1
EOF
RUN

NAME=rz-ax -u 3000
TOOL=rz-ax
ARGS=-u 3000
EXPECT=<<EOF
2.9K
EOF
RUN

NAME=long number conversion
# BROKEN: trailing-suffix binary literal rejected by the new grammar (use a 0b prefix)
BROKEN=1
TOOL=rz-ax
ARGS=10000000000000000000000000000000000000000000000b
EXPECT=<<EOF
0x400000000000
EOF
RUN

NAME=long number conversion with shift
FILE==
CMDS=!rz-ax b$(!rz-ax "1<<46")
EXPECT=<<EOF
10000000000000000000000000000000000000000000000b
EOF
RUN

NAME=rz-ax -121.875f
TOOL=rz-ax
ARGS=-121.875f
EXPECT=<<EOF
Fxc2f3c000
EOF
RUN

NAME=rz-ax -0xf
TOOL=rz-ax
ARGS=-0xf
EXPECT=<<EOF
-15
EOF
RUN

NAME=rz-ax -L 0
TOOL=rz-ax
ARGS=-L 0
EXPECT=<<EOF
0x0
EOF
RUN

NAME=rz-ax -L 1
TOOL=rz-ax
ARGS=-L 1
EXPECT=<<EOF
0x1
EOF
RUN

NAME=rz-ax -L 10000010100001001000011010001000100010101000110010001110100100001001001010010100100101101001100010011010100111001001111
TOOL=rz-ax
ARGS=-L 10000010100001001000011010001000100010101000110010001110100100001001001010010100100101101001100010011010100111001001111
EXPECT=<<EOF
0x4142434445464748494a4b4c4d4e4f
EOF
RUN

NAME=rz-ax -L 00000000000000000000000000000000000000000000000000000000000000000
TOOL=rz-ax
ARGS=-L 00000000000000000000000000000000000000000000000000000000000000000
EXPECT=<<EOF
0x0
EOF
RUN

NAME=rz-ax -L 11111111111111111111111111111111111111111111111111111111111111111
TOOL=rz-ax
ARGS=-L 11111111111111111111111111111111111111111111111111111111111111111
EXPECT=<<EOF
0x1ffffffffffffffff
EOF
RUN

NAME=rz-ax -ke 0xdeadbeef
TOOL=rz-ax
ARGS=-ke 0xdeadbeef
EXPECT=<<EOF
0xefbeadde
EOF
RUN

NAME=rz-ax -a
TOOL=rz-ax
ARGS=-a
EXPECT=<<EOF
The following table contains the 128 ASCII characters.

Oct   Dec   Hex   Char                        Oct   Dec   Hex   Char
────────────────────────────────────────────────────────────────────────
000   0     00    NUL '\0' (null character)   100   64    40    @
001   1     01    SOH (start of heading)      101   65    41    A
002   2     02    STX (start of text)         102   66    42    B
003   3     03    ETX (end of text)           103   67    43    C
004   4     04    EOT (end of transmission)   104   68    44    D
005   5     05    ENQ (enquiry)               105   69    45    E
006   6     06    ACK (acknowledge)           106   70    46    F
007   7     07    BEL '\a' (bell)             107   71    47    G
010   8     08    BS  '\b' (backspace)        110   72    48    H
011   9     09    HT  '\t' (horizontal tab)   111   73    49    I
012   10    0A    LF  '\n' (new line)         112   74    4A    J
013   11    0B    VT  '\v' (vertical tab)     113   75    4B    K
014   12    0C    FF  '\f' (form feed)        114   76    4C    L
015   13    0D    CR  '\r' (carriage ret)     115   77    4D    M
016   14    0E    SO  (shift out)             116   78    4E    N
017   15    0F    SI  (shift in)              117   79    4F    O
020   16    10    DLE (data link escape)      120   80    50    P
021   17    11    DC1 (device control 1)      121   81    51    Q
022   18    12    DC2 (device control 2)      122   82    52    R
023   19    13    DC3 (device control 3)      123   83    53    S
024   20    14    DC4 (device control 4)      124   84    54    T
025   21    15    NAK (negative ack.)         125   85    55    U
026   22    16    SYN (synchronous idle)      126   86    56    V
027   23    17    ETB (end of trans. blk)     127   87    57    W
030   24    18    CAN (cancel)                130   88    58    X
031   25    19    EM  (end of medium)         131   89    59    Y
032   26    1A    SUB (substitute)            132   90    5A    Z
033   27    1B    ESC (escape)                133   91    5B    [
034   28    1C    FS  (file separator)        134   92    5C    \  '\\'
035   29    1D    GS  (group separator)       135   93    5D    ]
036   30    1E    RS  (record separator)      136   94    5E    ^
037   31    1F    US  (unit separator)        137   95    5F    _
040   32    20    SPACE                       140   96    60    `
041   33    21    !                           141   97    61    a
042   34    22    "                           142   98    62    b
043   35    23    #                           143   99    63    c
044   36    24    $                           144   100   64    d
045   37    25    %                           145   101   65    e
046   38    26    &                           146   102   66    f
047   39    27    '                           147   103   67    g
050   40    28    (                           150   104   68    h
051   41    29    )                           151   105   69    i
052   42    2A    *                           152   106   6A    j
053   43    2B    +                           153   107   6B    k
054   44    2C    ,                           154   108   6C    l
055   45    2D    -                           155   109   6D    m
056   46    2E    .                           156   110   6E    n
057   47    2F    /                           157   111   6F    o
060   48    30    0                           160   112   70    p
061   49    31    1                           161   113   71    q
062   50    32    2                           162   114   72    r
063   51    33    3                           163   115   73    s
064   52    34    4                           164   116   74    t
065   53    35    5                           165   117   75    u
066   54    36    6                           166   118   76    v
067   55    37    7                           167   119   77    w
070   56    38    8                           170   120   78    x
071   57    39    9                           171   121   79    y
072   58    3A    :                           172   122   7A    z
073   59    3B    ;                           173   123   7B    {
074   60    3C    <                           174   124   7C    |
075   61    3D    =                           175   125   7D    }
076   62    3E    >                           176   126   7E    ~
077   63    3F    ?                           177   127   7F    DEL
EOF
RUN

NAME=rz-ax -w 16 0xffff
TOOL=rz-ax
ARGS=-w 16 0xffff
EXPECT=<<EOF
16
-1
EOF
RUN

NAME=rz-ax -i
FILE==
CMDS=!printf A | rz-ax -i
EXPECT=<<EOF
unsigned char buf[] = {
  0x41
};
unsigned int buf_len = 1;
EOF
RUN

NAME=rz-ax -o
# BROKEN: 'rz-ax -o a b ...' now reads its arguments as decimal byte values, not octal
BROKEN=1
TOOL=rz-ax
ARGS=-o 162 62
EXPECT=r2
RUN

NAME=rz-ax -r 0x1234
TOOL=rz-ax
ARGS=-r 0x1234
REGEXP_FILTER_OUT=octal.+
EXPECT=<<EOF
octal   011064
EOF
RUN

NAME=rz-ax -p
TOOL=rz-ax
ARGS=-p 0xb3
EXPECT=<<EOF
[0-1]: 1
[4-5]: 1
[7]: 1
EOF
RUN

NAME=rz-ax -p
TOOL=rz-ax
ARGS=-p 110
EXPECT=<<EOF
[1-3]: 1
[5-6]: 1
EOF
RUN

NAME=rz-ax stdin input
FILE==
CMDS=!echo 0xff | rz-ax
EXPECT=<<EOF
255
EOF
RUN

NAME=rz-ax float kind
# BROKEN: a plain fractional literal (3.14159) is now parsed as an exact
# RzBigDecimal (kind "decimal"), not a 64-bit double, so the table header
# reads "decimal" and there is no double bit-pattern "hex" line
BROKEN=1
TOOL=rz-ax
ARGS=3.14159
EXPECT=<<EOF
float   3.14159
scifmt  3.1415899999999999
hex     0x400921f9f01b866e
EOF
RUN

NAME=rz-ax bignum literal
TOOL=rz-ax
ARGS=0x10000000000000000
EXPECT=<<EOF
decimal 18446744073709551616
hex     0x10000000000000000
width   68 bits (approx)
EOF
RUN

NAME=rz-ax exact power 2**100
TOOL=rz-ax
ARGS=2**100
EXPECT=<<EOF
decimal 1267650600228229401496703205376
hex     0x10000000000000000000000000
width   104 bits (approx)
EOF
RUN

NAME=rz-ax exact power 10**30
TOOL=rz-ax
ARGS=10**30
EXPECT=<<EOF
decimal 1000000000000000000000000000000
hex     0xc9f2c9cd04674edea40000000
width   100 bits (approx)
EOF
RUN

NAME=rz-ax builtin min
TOOL=rz-ax
ARGS=min(0x10,0x20)
EXPECT=<<EOF
0x10
EOF
RUN

NAME=rz-ax builtin popcount
TOOL=rz-ax
ARGS=popcount(0xff)
EXPECT=<<EOF
0x8
EOF
RUN

NAME=rz-ax unicode function minimum
TOOL=rz-ax
ARGS=минимум(5,10)
EXPECT=<<EOF
0x5
EOF
RUN

NAME=rz-ax let binding read-back
TOOL=rz-ax
ARGS=(x=7)+x
EXPECT=<<EOF
0xe
EOF
RUN

NAME=rz-ax bitvector literal
TOOL=rz-ax
ARGS=5u8
EXPECT=<<EOF
hex     0x05
binary  0b00000101
width   8 bits
EOF
RUN

NAME=rz-ax bitvector wraparound
TOOL=rz-ax
ARGS=0xffu8+1u8
EXPECT=<<EOF
hex     0x00
binary  0b00000000
width   8 bits
EOF
RUN

NAME=rz-ax unicode function Chinese max
TOOL=rz-ax
ARGS=最大(0x10,0x20)
EXPECT=<<EOF
0x20
EOF
RUN

NAME=rz-ax unicode function Arabic abs
TOOL=rz-ax
ARGS=دالة(0xfffffffffffffffb)
EXPECT=<<EOF
0x5
EOF
RUN

NAME=rz-ax unicode variable Greek
TOOL=rz-ax
ARGS=(σ=7)+σ
EXPECT=<<EOF
0xe
EOF
RUN

NAME=rz-ax len bitvector
TOOL=rz-ax
ARGS=len(0xffu16)
EXPECT=<<EOF
0x10
EOF
RUN

NAME=rz-ax sequence
TOOL=rz-ax
ARGS=x=10;y=20;x+y
EXPECT=<<EOF
0x1e
EOF
RUN

NAME=rz-ax nested min max
TOOL=rz-ax
ARGS=max(min(10,20),min(5,15))
EXPECT=<<EOF
0xa
EOF
RUN

NAME=rz-ax unicode nested functions
TOOL=rz-ax
ARGS=минимум(最大(3,9),7)
EXPECT=<<EOF
0x7
EOF
RUN

NAME=rz-ax bignum power plus one
TOOL=rz-ax
ARGS=2**64+1
EXPECT=<<EOF
decimal 18446744073709551617
hex     0x10000000000000001
width   68 bits (approx)
EOF
RUN

NAME=rz-ax popcount plus len
TOOL=rz-ax
ARGS=popcount(0xffff)+len(0xffu16)
EXPECT=<<EOF
0x20
EOF
RUN

NAME=rz-ax unicode var and sigma
TOOL=rz-ax
ARGS=(σ=0xff)+Σ(σ)
EXPECT=<<EOF
0x107
EOF
RUN

NAME=rz-ax len string in arithmetic
TOOL=rz-ax
ARGS=len("ABCD")/8+max(1,2)
EXPECT=<<EOF
0x6
EOF
RUN

NAME=rz-ax bitvector xor width
TOOL=rz-ax
ARGS=0xdeadbeefu32^0xffffffffu32
EXPECT=<<EOF
hex     0x21524110
binary  0b00100001010100100100000100010000
width   32 bits
EOF
RUN

NAME=rz-ax conditional
TOOL=rz-ax
ARGS=5>3?0xaa:0xbb
EXPECT=<<EOF
0xaa
EOF
RUN

NAME=rz-ax conditional nested
TOOL=rz-ax
ARGS=0?1:0?2:3
EXPECT=<<EOF
0x3
EOF
RUN

NAME=rz-ax bv rotate left
TOOL=rz-ax
ARGS=0x12u8<<<4
EXPECT=<<EOF
hex     0x21
binary  0b00100001
width   8 bits
EOF
RUN

NAME=rz-ax bv power modular wrap
TOOL=rz-ax
ARGS=2u8**8u8
EXPECT=<<EOF
hex     0x00
binary  0b00000000
width   8 bits
EOF
RUN

NAME=rz-ax bv signed division
TOOL=rz-ax
ARGS=0xffu8sdiv2u8
EXPECT=<<EOF
hex     0x00
binary  0b00000000
width   8 bits
EOF
RUN

NAME=rz-ax bv arith shift right
TOOL=rz-ax
ARGS=0xfeu8sar1u8
EXPECT=<<EOF
hex     0xff
binary  0b11111111
width   8 bits
EOF
RUN

NAME=rz-ax compound expression output base is consistent
TOOL=rz-ax
ARGS=0x3+0b11+3
EXPECT=<<EOF
0x9
EOF
RUN

NAME=rz-ax expression not starting with 0x is hex too
TOOL=rz-ax
ARGS=(-1+1)
EXPECT=<<EOF
0x0
EOF
RUN

NAME=rz-ax bare hex literal still converts to decimal
TOOL=rz-ax
ARGS=0x3
EXPECT=<<EOF
3
EOF
RUN

NAME=rz-ax let-bound variables evaluate
TOOL=rz-ax
ARGS=x=10;y=20;x*y
EXPECT=<<EOF
0xc8
EOF
RUN

NAME=rz-ax invalid = output base is rejected
TOOL=rz-ax
ARGS==7 3**12
EXPECT=<<EOF
EOF
EXPECT_ERR=<<EOF
rz-ax: invalid output base '7' (use =2, =3, =8, =10, or =16)
EOF
EXIT_STATUS=1
RUN

NAME=rz-ax unresolved identifier is an error
TOOL=rz-ax
ARGS=nanasd
EXPECT=<<EOF
EOF
EXPECT_ERR=<<EOF
rz-ax: cannot resolve 'nanasd'
EOF
EXIT_STATUS=1
RUN

NAME=rz-ax bit-vector width below 8 bits
TOOL=rz-ax
ARGS=8u7
EXPECT=<<EOF
hex     0x08
binary  0b0001000
width   7 bits
EOF
RUN

NAME=rz-ax bit-vector inside an expression
TOOL=rz-ax
ARGS=3-1+3u3+1
EXPECT=<<EOF
hex     0x6
binary  0b110
width   3 bits
EOF
RUN

NAME=rz-ax out-of-range bit-vector width is rejected
TOOL=rz-ax
ARGS=1u99999999
EXPECT=<<EOF
EOF
EXPECT_ERR=<<EOF
rz-ax: bit-vector width must be 1..65536, got 99999999
EOF
EXIT_STATUS=1
RUN

NAME=rz-ax lone output-mode prefix is an error
TOOL=rz-ax
ARGS=t
EXPECT=<<EOF
EOF
EXPECT_ERR=<<EOF
rz-ax: missing value after 't'
EOF
EXIT_STATUS=1
RUN

NAME=rz-ax non-decimal literals print as decimal
TOOL=rz-ax
ARGS=0b1010 0o17 0t12 0x1f
EXPECT=<<EOF
10
15
5
31
EOF
RUN

NAME=rz-ax -N emits the full bit-vector width
TOOL=rz-ax
ARGS=-N 0xfffffffffffffffffffffffffu128
EXPECT=<<EOF
\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x00\x00
EOF
RUN

NAME=rz-ax -p reports when no bits are set
TOOL=rz-ax
ARGS=-p 0
EXPECT=<<EOF
no bits set
EOF
RUN

NAME=rz-ax -e prints the swapped value in hex
TOOL=rz-ax
ARGS=-e 0xffaa
EXPECT=<<EOF
0xaaff0000
EOF
RUN

NAME=rz-ax stdin reads one expression per line
FILE==
CMDS=!printf '33\n0x41\n' | rz-ax
EXPECT=<<EOF
0x21
65
EOF
RUN

NAME=rz-ax stdin stops at q
FILE==
CMDS=!printf '33\nq\n99\n' | rz-ax
EXPECT=<<EOF
0x21
EOF
RUN

NAME=rz-ax -h lists only the flags
FILE==
CMDS=!rz-ax -h | grep -c Conversions
EXPECT=<<EOF
0
EOF
RUN

NAME=rz-ax -H includes the conversion table
FILE==
CMDS=!rz-ax -H | grep -c Conversions
EXPECT=<<EOF
1
EOF
RUN

NAME=rz-ax -H includes the operator list
FILE==
CMDS=!rz-ax -H | grep -c Operators
EXPECT=<<EOF
1
EOF
RUN
