denuvo-ref/rizin
1
0
Fork 0
mirror of https://github.com/rizinorg/rizin synced 2026-08-22 20:26:16 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
rizin/test/db/cmd/cmd_math
Anton Kochkov 0d362aab25 test: do not pin a libm pow() result to full precision 
% 2**4.5 asserted both the %.17g rendering and the exact bit pattern of
pow(2.0, 4.5). The exact value is 22.62741699796952078...; glibc and the
UCRT return the correctly rounded 0x4036a09e667f3bcd, while FreeBSD and
NetBSD return 0x4036a09e667f3bcc, one ULP low. msun's pow is documented as
under one ULP, not correctly rounded, so the test asserted bit-exact libm
behaviour for a transcendental and could not pass everywhere.

Filter the output down to the rounded line, which every implementation
within one ULP agrees on. The full float/scifmt/hex table stays covered by
the tests whose results are exactly representable.
2026-07-24 10:36:25 +02:00

956 lines
13 KiB
Text
Raw Permalink Blame History

FILE=malloc://1024
NAME=%vi-1
CMDS=<<EOF
%vi 0xffffffff
%vi8 0xffffffff
%vi4 0xffffffff
%vi2 0xffffffff
%vi1 0xffffffff
%vi4 0xffffffff
%vi2 0xffff
%vi1 0xff
EOF
EXPECT=<<EOF
4294967295
4294967295
-1
-1
-1
-1
-1
-1
EOF
RUN
FILE=malloc://1024
NAME=%vi-8
CMDS=<<EOF
%vi 0xfffffff8
%vi4 0xfffffff8
%vi2 0xfffffff8
%vi1 0xfffffff8
%vi4 0xfffffff8
%vi2 0xfff8
%vi1 0xf8
EOF
EXPECT=<<EOF
4294967288
-8
-8
-8
-8
-8
-8
EOF
RUN
FILE=malloc://1024
CMDS=<<EOF
%v
%p
EOF
EXPECT=<<EOF
0x0
0x00000000
EOF
RUN
NAME=%v
FILE=--
CMDS=<<EOF
%v 1024
%v 0x42
EOF
EXPECT=<<EOF
0x400
0x42
EOF
RUN
NAME="%v 'A'"
# BROKEN: char literals ('X') were dropped from the new grammar, which has
# no char-literal rule, so a quoted character no longer evaluates to its code
BROKEN=1
FILE=--
CMDS=%v "'A'"
EXPECT=<<EOF
0x41
EOF
RUN
NAME="%v 'A'+3"
# BROKEN: char literals ('X') were dropped from the new grammar, which has
# no char-literal rule, so a quoted character no longer evaluates to its code
BROKEN=1
FILE=--
CMDS=%v "'A'+3"
EXPECT=<<EOF
0x44
EOF
RUN
NAME="%v 3+'A'-3"
# BROKEN: char literals ('X') were dropped from the new grammar, which has
# no char-literal rule, so a quoted character no longer evaluates to its code
BROKEN=1
FILE=--
CMDS=%v "3+'A'-3"
EXPECT=<<EOF
0x41
EOF
RUN
NAME="%v 33^'A'"
# BROKEN: char literals ('X') were dropped from the new grammar, which has
# no char-literal rule, so a quoted character no longer evaluates to its code
BROKEN=1
FILE=--
CMDS=%v "32^'A'"
EXPECT=<<EOF
0x61
EOF
RUN
NAME="% 1;%v"
FILE=--
CMDS=% 1;%v
EXPECT=<<EOF
int32 1
uint32 1
hex 0x1
octal 01
unit 1
segment 0000:0001
string "\x01"
fvalue 1.0
float 1.000000f
double 1.000000
binary 0b00000001
trits 0t1
0x1
EOF
RUN
NAME="% 0;%v"
FILE=--
CMDS=% 0;%v
EXPECT=<<EOF
int32 0
uint32 0
hex 0x0
octal 00
unit 0
segment 0000:0000
string "\0"
fvalue 0.0
float 0.000000f
double 0.000000
binary 0b00000000
trits 0t0
0x0
EOF
RUN
NAME="% -1"
FILE=--
CMDS=% -1
EXPECT=<<EOF
int64 -1
uint64 18446744073709551615
hex 0xffffffffffffffff
octal 01777777777777777777777
unit 16E
segment fffff000:0fff
string "\xff\xff\xff\xff\xff\xff\xff\xff"
fvalue -1.0
float -1.000000f
double -1.000000
binary 0b1111111111111111111111111111111111111111111111111111111111111111
trits 0t11112220022122120101211020120210210211220
EOF
RUN
NAME="% 2*1.5"
# BROKEN: a fractional result is now an exact RzBigDecimal ('decimal N'),
# not a 64-bit double, so the old 'float'/'hex' (double bit-pattern) lines differ
BROKEN=1
FILE=--
CMDS=% 2*1.5
EXPECT=<<EOF
float 3
scifmt 3
hex 0x4008000000000000
EOF
RUN
NAME="% 2**3"
FILE=--
CMDS=% 2**3
EXPECT=<<EOF
int32 8
uint32 8
hex 0x8
octal 010
unit 8
segment 0000:0008
string "\b"
fvalue 8.0
float 8.000000f
double 8.000000
binary 0b00001000
trits 0t22
EOF
RUN
NAME="% -25**3"
FILE=--
CMDS=% -25**3
EXPECT=<<EOF
int64 -15625
uint64 18446744073709535991
hex 0xffffffffffffc2f7
octal 01777777777777777741367
unit 16.0E
segment fffff000:02f7
string "\xf7\xc2\xff\xff\xff\xff\xff\xff"
fvalue -15625.0
float -15625.000000f
double -15625.000000
binary 0b1111111111111111111111111111111111111111111111111100001011110111
trits 0t11112220022122120101211020120210000102020
EOF
RUN
NAME="% -76**2"
FILE=--
CMDS=% -76**2
EXPECT=<<EOF
int32 5776
uint32 5776
hex 0x1690
octal 013220
unit 5.6K
segment 0000:0690
string "\x90\x16"
fvalue 5776.0
float 5776.000000f
double 5776.000000
binary 0b0001011010010000
trits 0t21220221
EOF
RUN
NAME="% 10**-2"
FILE=--
CMDS=% 10**-2
EXPECT=<<EOF
float 0.01
scifmt 0.01
hex 0x3f847ae147ae147b
EOF
RUN
NAME="% 1024**0"
FILE=--
CMDS=% 1024**0
EXPECT=<<EOF
int32 1
uint32 1
hex 0x1
octal 01
unit 1
segment 0000:0001
string "\x01"
fvalue 1.0
float 1.000000f
double 1.000000
binary 0b00000001
trits 0t1
EOF
RUN
NAME="% 2**4.5"
FILE=--
CMDS=% 2**4.5
# pow() is not correctly rounded on every libm. FreeBSD and NetBSD (msun)
# return 22.627416997969519, one ULP below the correctly rounded
# 22.627416997969522 that glibc and the UCRT give, so scifmt and hex cannot
# be pinned here. Assert the rounded line, which any implementation within
# one ULP agrees on.
REGEXP_FILTER_OUT=float[[:space:]]+22\.6274
EXPECT=<<EOF
float 22.6274
EOF
RUN
NAME="% 10 ** 2 * 3"
FILE=--
CMDS=% 10 ** 2 * 3
EXPECT=<<EOF
int32 300
uint32 300
hex 0x12c
octal 0454
unit 300
segment 0000:012c
string ",\x01"
fvalue 300.0
float 300.000000f
double 300.000000
binary 0b0000000100101100
trits 0t102010
EOF
RUN
NAME="% 10 ** 2 / 3"
FILE=--
CMDS=% 10 ** 2 / 3
EXPECT=<<EOF
int32 33
uint32 33
hex 0x21
octal 041
unit 33
segment 0000:0021
string "!"
fvalue 33.0
float 33.000000f
double 33.000000
binary 0b00100001
trits 0t1020
EOF
RUN
NAME="% 10 ** 2 + 3"
FILE=--
CMDS=% 10 ** 2 + 3
EXPECT=<<EOF
int32 103
uint32 103
hex 0x67
octal 0147
unit 103
segment 0000:0067
string "g"
fvalue 103.0
float 103.000000f
double 103.000000
binary 0b01100111
trits 0t10211
EOF
RUN
NAME="% 10 - 2 ** 3"
FILE=--
CMDS=% 10 - 2 ** 3
EXPECT=<<EOF
int32 2
uint32 2
hex 0x2
octal 02
unit 2
segment 0000:0002
string "\x02"
fvalue 2.0
float 2.000000f
double 2.000000
binary 0b00000010
trits 0t2
EOF
RUN
NAME="% 2**-1+4"
FILE=--
CMDS=% 2**-1+4
EXPECT=<<EOF
float 4.5
scifmt 4.5
hex 0x4012000000000000
EOF
RUN
NAME="math help"
FILE==
CMDS=<<EOF
%?~Usage
EOF
EXPECT=<<EOF
Usage: %[?] # Math commands
EOF
RUN
NAME=expr with parentheses
FILE==
CMDS=<<EOF
%v (0x10000192c + 4294965314) & 0xffffffff
EOF
EXPECT=<<EOF
0x116e
EOF
RUN
NAME=binary shift
FILE==
CMDS=<<EOF
%b 1<<1
%b 1 << 1
%b 1 << 2
EOF
EXPECT=<<EOF
10b
10b
100b
EOF
RUN
NAME="comparison operators"
FILE==
CMDS=<<EOF
%v "1<1"
%v "1<2"
%v "2<1"
%v "1>1"
%v "1>2"
%v "2>1"
EOF
EXPECT=<<EOF
0x0
0x1
0x0
0x0
0x0
0x1
EOF
RUN
NAME=%p and %P ignore io.va
FILE=bins/elf/analysis/ls2
CMDS=<<EOF
%p main @e:io.va=true
%p main @e:io.va=false
%v main
%P 0x28a0 @e:io.va=1
%P 0x28a0 @e:io.va=0
EOF
EXPECT=<<EOF
0x000028a0
0x000028a0
0x4028a0
0x004028a0
0x004028a0
EOF
RUN
NAME=djb2 hash
FILE==
CMDS=<<EOF
%h 1024
%h ILoveRizin
%h RizinLovesMe2
EOF
EXPECT=<<EOF
0x50489162
0x56b7215a
0xe859883a
EOF
RUN
FILE=malloc://1024
NAME=% bignum literal
CMDS=<<EOF
% 0x10000000000000000
EOF
EXPECT=<<EOF
decimal 18446744073709551616
hex 0x10000000000000000
width 68 bits (approx)
EOF
RUN
FILE=malloc://1024
NAME=% exact integer power
CMDS=<<EOF
% 2 ** 100
EOF
EXPECT=<<EOF
decimal 1267650600228229401496703205376
hex 0x10000000000000000000000000
width 104 bits (approx)
EOF
RUN
FILE=malloc://1024
NAME=% float power
CMDS=<<EOF
% 3.14159 ** 2
EOF
EXPECT=<<EOF
float 9.86959
scifmt 9.8695877280999991
hex 0x4023bd3a9a4a6287
EOF
RUN
FILE=malloc://1024
NAME=% builtin min max
CMDS=<<EOF
% min(0x100, max(0x50, 0x80))
EOF
EXPECT=<<EOF
int32 128
uint32 128
hex 0x80
octal 0200
unit 128
segment 0000:0080
string "\x80"
fvalue 128.0
float 128.000000f
double 128.000000
binary 0b10000000
trits 0t11202
EOF
RUN
FILE=malloc://1024
NAME=% unicode function minimum
CMDS=<<EOF
% минимум(0x100, 0x200)
EOF
EXPECT=<<EOF
int32 256
uint32 256
hex 0x100
octal 0400
unit 256
segment 0000:0100
string "\x01"
fvalue 256.0
float 256.000000f
double 256.000000
binary 0b0000000100000000
trits 0t100111
EOF
RUN
FILE=malloc://1024
NAME=% let binding reassignment
CMDS=<<EOF
% (c = 1) + (c = 9) + c
EOF
EXPECT=<<EOF
int32 19
uint32 19
hex 0x13
octal 023
unit 19
segment 0000:0013
string "\x13"
fvalue 19.0
float 19.000000f
double 19.000000
binary 0b00010011
trits 0t201
EOF
RUN
FILE=malloc://1024
NAME=% crc32 default
CMDS=<<EOF
w AAAABBBBCCCCDDDD
% crc(0, 16)
EOF
EXPECT=<<EOF
int32 1501082128
uint32 1501082128
hex 0x5978b210
octal 013136131020
unit 1.4G
segment 5978000:0210
string "\x10\xb2xY"
fvalue 1501082128.0
float 1501082112.000000f
double 1501082128.000000
binary 0b01011001011110001011001000010000
trits 0t10212121112212120101
EOF
RUN
FILE=malloc://1024
NAME=% crc width 16 selector
CMDS=<<EOF
w AAAABBBBCCCCDDDD
% crc(0, 16, 16)
EOF
EXPECT=<<EOF
int32 26619
uint32 26619
hex 0x67fb
octal 063773
unit 26.0K
segment 0000:07fb
string "\xfbg"
fvalue 26619.0
float 26619.000000f
double 26619.000000
binary 0b0110011111111011
trits 0t1100111220
EOF
RUN
FILE=malloc://1024
NAME=% md5 digest
CMDS=<<EOF
w AAAABBBBCCCCDDDD
% md5(0, 16)
EOF
EXPECT=<<EOF
decimal 196160137941607695467225652873056001787
hex 0x9393117fc22175732ea7042f33d89efb
width 128 bits (approx)
EOF
RUN
FILE=malloc://1024
NAME=% sha256 digest
CMDS=<<EOF
w AAAABBBBCCCCDDDD
% sha256(0, 16)
EOF
EXPECT=<<EOF
decimal 46411692673025759693186424457495866733606273688990416351710414590085438416608
hex 0x669c164f44198b43b7175ac0dff496fe43393717428747ccb44c294fbeaca6e0
width 256 bits (approx)
EOF
RUN
FILE=malloc://1024
NAME=% entropy uniform data
CMDS=<<EOF
w AAAABBBBCCCCDDDD
% entropy(0, 16)
EOF
EXPECT=<<EOF
float 2
scifmt 2
hex 0x4000000000000000
EOF
RUN
FILE=malloc://1024
NAME=% division by zero
CMDS=<<EOF
% 1/0
EOF
EXPECT=<<EOF
EOF
EXPECT_ERR=<<EOF
ERROR: core: RzNum ERROR: Division by Zero
EOF
RUN
FILE=malloc://1024
NAME=% bitvector arithmetic wraps at width
CMDS=<<EOF
e scr.utf8=false
% 200u8 + 100u8
EOF
EXPECT=<<EOF
hex 0x2c
binary 0b00101100
width 8 bits
EOF
RUN
FILE=malloc://1024
NAME=% bitvector multiply 16-bit
CMDS=<<EOF
e scr.utf8=false
% 10u16 * 10u16
EOF
EXPECT=<<EOF
hex 0x0064
binary 0b0000000001100100
width 16 bits
EOF
RUN
FILE=malloc://1024
NAME=% bitvector unicode rendering with scr.utf8
CMDS=<<EOF
e scr.utf8=true
% 200u8 + 100u8
EOF
EXPECT=<<EOF
hex 0x2c₈
binary 00101100₈
width 8 bits
EOF
RUN
FILE=malloc://1024
NAME=% bitvector ascii rendering without scr.utf8
CMDS=<<EOF
e scr.utf8=false
% 200u8 + 100u8
EOF
EXPECT=<<EOF
hex 0x2c
binary 0b00101100
width 8 bits
EOF
RUN
FILE=malloc://1024
NAME=% unicode function Chinese max
CMDS=<<EOF
% 最大(0x10, 0x20)
EOF
EXPECT=<<EOF
int32 32
uint32 32
hex 0x20
octal 040
unit 32
segment 0000:0020
string " "
fvalue 32.0
float 32.000000f
double 32.000000
binary 0b00100000
trits 0t1012
EOF
RUN
FILE=malloc://1024
NAME=% unicode function Arabic abs
CMDS=<<EOF
% دالة(0xfffffffffffffffb)
EOF
EXPECT=<<EOF
int32 5
uint32 5
hex 0x5
octal 05
unit 5
segment 0000:0005
string "\x05"
fvalue 5.0
float 5.000000f
double 5.000000
binary 0b00000101
trits 0t12
EOF
RUN
FILE=malloc://1024
NAME=% unicode variable Chinese radius
CMDS=<<EOF
% (半径 = 5) * 半径
EOF
EXPECT=<<EOF
int32 25
uint32 25
hex 0x19
octal 031
unit 25
segment 0000:0019
string "\x19"
fvalue 25.0
float 25.000000f
double 25.000000
binary 0b00011001
trits 0t221
EOF
RUN
FILE=malloc://1024
NAME=% sequence semicolon
CMDS=<<EOF
% x = 10; y = 20; x + y
EOF
EXPECT=<<EOF
int32 10
uint32 10
hex 0xa
octal 012
unit 10
segment 0000:000a
string "\n"
fvalue 10.0
float 10.000000f
double 10.000000
binary 0b00001010
trits 0t101
EOF
RUN
FILE=malloc://1024
NAME=% signed division
CMDS=<<EOF
% 0xfffffffffffffffb sdiv 2
EOF
EXPECT=<<EOF
int64 -2
uint64 18446744073709551614
hex 0xfffffffffffffffe
octal 01777777777777777777776
unit 16E
segment fffff000:0ffe
string "\xfe\xff\xff\xff\xff\xff\xff\xff"
fvalue -2.0
float -2.000000f
double -2.000000
binary 0b1111111111111111111111111111111111111111111111111111111111111110
trits 0t11112220022122120101211020120210210211212
EOF
RUN
FILE=malloc://1024
NAME=% arithmetic shift right
CMDS=<<EOF
% 0xffffffffffffff00 sar 4
EOF
EXPECT=<<EOF
int64 -16
uint64 18446744073709551600
hex 0xfffffffffffffff0
octal 01777777777777777777760
unit 16E
segment fffff000:0ff0
string "\xf0\xff\xff\xff\xff\xff\xff\xff"
fvalue -16.0
float -16.000000f
double -16.000000
binary 0b1111111111111111111111111111111111111111111111111111111111110000
trits 0t11112220022122120101211020120210210211100
EOF
RUN
FILE=malloc://1024
NAME=% len of string bytes
CMDS=<<EOF
% len("ABCD") / 8
EOF
EXPECT=<<EOF
int32 4
uint32 4
hex 0x4
octal 04
unit 4
segment 0000:0004
string "\x04"
fvalue 4.0
float 4.000000f
double 4.000000
binary 0b00000100
trits 0t11
EOF
RUN
FILE=malloc://1024
NAME=% len of bitvector
CMDS=<<EOF
% len(0xffu16)
EOF
EXPECT=<<EOF
int32 16
uint32 16
hex 0x10
octal 020
unit 16
segment 0000:0010
string "\x10"
fvalue 16.0
float 16.000000f
double 16.000000
binary 0b00010000
trits 0t121
EOF
RUN
FILE=malloc://1024
NAME=% persistent variable across commands
CMDS=<<EOF
% bla = 0x100
% bla + 5
EOF
EXPECT=<<EOF
int32 256
uint32 256
hex 0x100
octal 0400
unit 256
segment 0000:0100
string "\x01"
fvalue 256.0
float 256.000000f
double 256.000000
binary 0b0000000100000000
trits 0t100111
int32 261
uint32 261
hex 0x105
octal 0405
unit 261
segment 0000:0105
string "\x05\x01"
fvalue 261.0
float 261.000000f
double 261.000000
binary 0b0000000100000101
trits 0t100200
EOF
RUN
FILE=malloc://1024
NAME=% conditional truthy
CMDS=<<EOF
% 1 ? 0xaa : 0xbb
EOF
EXPECT=<<EOF
int32 170
uint32 170
hex 0xaa
octal 0252
unit 170
segment 0000:00aa
string "\xaa"
fvalue 170.0
float 170.000000f
double 170.000000
binary 0b10101010
trits 0t20022
EOF
RUN
FILE=malloc://1024
NAME=% conditional comparison
CMDS=<<EOF
% 5 > 3 ? 100 : 200
EOF
EXPECT=<<EOF
EOF
RUN
FILE=malloc://1024
NAME=% conditional short-circuit
CMDS=<<EOF
% 1 ? 42 : 1 / 0
EOF
EXPECT=<<EOF
int32 42
uint32 42
hex 0x2a
octal 052
unit 42
segment 0000:002a
string "*"
fvalue 42.0
float 42.000000f
double 42.000000
binary 0b00101010
trits 0t1120
EOF
RUN
Reference in a new issue View git blame Copy permalink