~vcs-imports/busybox/trunk

function empty_fun(){}

END {empty_fun()

  print "Ok"

}'

testing "awk handles empty function f(){}" \

        "awk '$prg'" \

        "Ok\n" \

        "" ""

 

prg='

prg='

BEGIN {

  v=1

  a=2

  print v (a)

}'

testing "awk 'v (a)' is not a function call, it is a concatenation" \

        "awk '$prg' 2>&1" \

        "12\n" \

        "" ""

 

prg='func f(){print"F"};func g(){print"G"};BEGIN{f(g(),g())}'

testing "awk unused function args are evaluated" \

        "awk '$prg' 2>&1" \

        "G\nG\nF\n" \

        "" ""

 

testing "awk oct const"   "awk '{ print or(01234,1) }'"      "669\n"        "" "\n"

# check that "hex/oct integer" heuristic doesn't kick in on input

# (must be done only when parsing program text)

testing "awk input is never oct" "awk '{ print \$1, \$1+1 }'" "011 12\n"    "" "011\n"

 

        "awk: -:1: 'break' not in a loop\n1\n" \

        "awk: -:1: 'continue' not in a loop\n1\n" \

optional FEATURE_AWK_GNU_EXTENSIONS

testing "awk printf('%c') can output NUL" \

        "awk '{printf(\"hello%c null\n\", 0)}'" "hello\0 null\n" "" "\n"

SKIP=

 

optional FEATURE_AWK_GNU_EXTENSIONS DESKTOP

testing "awk printf('%-10c') can output NUL" \

        "awk 'BEGIN { printf \"[%-10c]\n\", 0 }' | od -tx1" "\

0000000 5b 00 20 20 20 20 20 20 20 20 20 5d 0a

0000015

" "" ""

SKIP=

 

# was misinterpreted as (("str"++) i) instead of ("str" (++i))

# (and was executed: "str"++ is "0", thus concatenating "0" and "1"):

testing 'awk do not allow "str"++' \

        'awk -v i=1 "BEGIN {print \"str\" ++i}"' \

        "str2\n" \

        '' \

        'anything'

 

# gawk compat: FS regex matches only non-empty separators:

# with -*, the splitting is NOT f o o b a r, but foo bar:

testing 'awk FS regex which can match empty string' \

        "awk -F '-*' '{print \$1 \"-\" \$2 \"=\" \$3 \"*\" \$4}'" \

        "foo-bar=*\n" \

        '' \

        'foo--bar'

 

# last+1 field should be empty (had a bug where it wasn't)

testing 'awk $NF is empty' \

        "awk -F '=+' '{print \$NF}'" \

        "\n" \

        '' \

        'a=====123='

 

testing "awk exit N propagates through END's exit" \

        "awk 'BEGIN { exit 42 } END { exit }'; echo \$?" \

        "42\n" \

        '' ''

 

testing "awk print + redirect" \

        "awk 'BEGIN { print \"STDERR %s\" >\"/dev/stderr\" }' 2>&1" \

        "STDERR %s\n" \

        '' ''

 

testing "awk \"cmd\" | getline" \

        "awk 'BEGIN { \"echo HELLO\" | getline; print }'" \

        "HELLO\n" \

        '' ''

 

# printf %% should print one % (had a bug where it didn't)

testing 'awk printf %% prints one %' \

        "awk 'BEGIN { printf \"%%\n\" }'" \

        "%\n" \

        '' ''

 

testing 'awk backslash+newline eaten with no trace' \

        "awk 'BEGIN { printf \"Hello\\

 world\n\" }'" \

        "Hello world\n" \

        '' ''

 

testing 'awk assign while test' \

        "awk '\$1==\$1=\"foo\" {print \$1}'" \

        "foo\n" \

        "" \

        "foo"

 

# User-supplied bug (SEGV) example, was causing use-after-realloc

testing 'awk assign while assign' \

        "awk '\$5=\$\$5=\$0'; echo \$?" \

        "\

─ process timing ────────────────────────────────────┬─ ─ process timing ────────────────────────────────────┬─ overall results ────┐ results ────┐

│ run time : │        run time : 0 days, 0 hrs, 0 min, 56 sec      │  cycles done : 0     │ days, 0 hrs, 0 min, 56 sec │ cycles done : 0 │

│ last new find │   last new find : 0 days, 0 hrs, 0 min, 1 sec       │ corpus count : 208   │ 0 days, 0 hrs, 0 min, 1 sec │ corpus count : 208 │

│last saved crash : │last saved crash : none seen yet                     │saved crashes : 0     │ seen yet │saved crashes : 0 │

│ last saved hang │ last saved hang : none seen yet                     │  saved hangs : 0     │ none seen yet │ saved hangs : 0 │

├─ cycle progress ─────────────────────┬─ ├─ cycle progress ─────────────────────┬─ map coverage┴──────────────────────┤ coverage┴──────────────────────┤

│ now processing : │  now processing : 184.1 (88.5%)      │    map density : 0.30% / 0.52%      │ (88.5%) │ map density : 0.30% / 0.52% │                                                                                                                                                                          │  now processing : 184.1 (88.5%)      │    map density : 0.30% / 0.52%      │

│ runs timed out │  runs timed out : 0 (0.00%)          │ count coverage : 2.18 bits/tuple    │ 0 (0.00%) │ count coverage : 2.18 bits/tuple │

├─ stage progress ─────────────────────┼─ ├─ stage progress ─────────────────────┼─ findings in depth ─────────────────┤ in depth ─────────────────┤

│ now trying : │  now trying : havoc                  │ favored items : 43 (20.67%)         │ │ favored items : 43 (20.67%) │

│ stage execs : │ stage execs : 11.2k/131k (8.51%)     │  new edges on : 52 (25.00%)         │ (8.51%) │ new edges on │ stage execs : 11.2k/131k (8.51%)     │  new edges on : 52 (25.00%)         │ 52 (25.00%) │

│ total execs : │ total execs : 179k                   │ total crashes : 0 (0 saved)         │ │ total crashes : 0 (0 saved) │                                                                                                                                                                      │ total execs : 179k                   │ total crashes : 0 (0 saved)         │

│ exec speed : │  exec speed : 3143/sec               │  total tmouts : 0 (0 saved)         │ │ total tmouts : 0 (0 saved) │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          │  exec speed : 3143/sec               │  total tmouts : 0 (0 saved)         │

├─ fuzzing strategy yields ├─ fuzzing strategy yields ────────────┴─────────────┬─ item geometry ───────┤ item geometry ───────┤

│ bit flips : │   bit flips : 11/648, 4/638, 5/618                 │    levels : 4         │ 4/638, 5/618 │ levels : │   bit flips : 11/648, 4/638, 5/618                 │    levels : 4         │ │

│ byte flips : │  byte flips : 0/81, 0/71, 0/52                     │   pending : 199       │ 0/71, 0/52 │ pending : 199 │

│ arithmetics : 11/4494, │ arithmetics : 11/4494, 0/1153, 0/0                 │  pend fav : 35        │ 0/0 │ pend fav : 35 │

│  known ints : 1/448, 0/1986, 0/2288                │ own finds : 207       │ known ints : │  known ints : 1/448, 0/1986, 0/2288                │ own finds : 207       │ 0/1986, 0/2288 │ own finds : 207 │

│ dictionary : 0/0, │  dictionary : 0/0, 0/0, 0/0, 0/0                   │  imported : 0         │ 0/0, 0/0 │ imported : 0 │

│havoc/splice : 142/146k, 23/7616 │havoc/splice : 142/146k, 23/7616                    │ stability : 100.00%   │ stability : 100.00% │

│py/custom/rq : unused, unused, │py/custom/rq : unused, unused, unused, unused       ├───────────────────────┘ unused ├───────────────────────┘

│ trim/eff : 57.02%/26, │    trim/eff : 57.02%/26, 0.00%                     │          [cpu000:100%] │ [cpu000:100%]

└────────────────────────────────────────────────────┘^C    └────────────────────────────────────────────────────┘^C

0

" \

        "" \

        "\

─ process timing ────────────────────────────────────┬─ overall results ────┐

│        run time : 0 days, 0 hrs, 0 min, 56 sec      │  cycles done : 0     │

│   last new find : 0 days, 0 hrs, 0 min, 1 sec       │ corpus count : 208   │

│last saved crash : none seen yet                     │saved crashes : 0     │

│ last saved hang : none seen yet                     │  saved hangs : 0     │

├─ cycle progress ─────────────────────┬─ map coverage┴──────────────────────┤

│  now processing : 184.1 (88.5%)      │    map density : 0.30% / 0.52%      │

│  runs timed out : 0 (0.00%)          │ count coverage : 2.18 bits/tuple    │

├─ stage progress ─────────────────────┼─ findings in depth ─────────────────┤

│  now trying : havoc                  │ favored items : 43 (20.67%)         │

│ stage execs : 11.2k/131k (8.51%)     │  new edges on : 52 (25.00%)         │

│ total execs : 179k                   │ total crashes : 0 (0 saved)         │

│  exec speed : 3143/sec               │  total tmouts : 0 (0 saved)         │

├─ fuzzing strategy yields ────────────┴─────────────┬─ item geometry ───────┤

│   bit flips : 11/648, 4/638, 5/618                 │    levels : 4         │

│  byte flips : 0/81, 0/71, 0/52                     │   pending : 199       │

│ arithmetics : 11/4494, 0/1153, 0/0                 │  pend fav : 35        │

│  known ints : 1/448, 0/1986, 0/2288                │ own finds : 207       │

│  dictionary : 0/0, 0/0, 0/0, 0/0                   │  imported : 0         │

│havoc/splice : 142/146k, 23/7616                    │ stability : 100.00%   │

│py/custom/rq : unused, unused, unused, unused       ├───────────────────────┘

│    trim/eff : 57.02%/26, 0.00%                     │          [cpu000:100%]

└────────────────────────────────────────────────────┘^C"

 

# If field separator FS=' ' (default), fields are split only on

# space or tab or linefeed, NOT other whitespace.

testing 'awk does not split on CR (char 13)' \

        "awk '{ \$1=\$0; print }'" \

        'word1 word2 word3\r word2 word3\r\n' \

        '' 'word1 word2 word3\r'

 

testing "awk = has higher precedence than == (despite what gawk manpage claims)" \

        "awk 'BEGIN { v=1; print 2==v; print 2==v=2; print v; print v=3==3; print v}'" \

        '0\n1\n2\n1\n3\n' \

        '' ''

 

sq="'"

testing 'awk gensub backslashes \' \

        'awk '$sq'BEGIN { s="\\"; print "s=" s; print gensub("a", s, "g", "a|a") }'$sq \

        's=\\

\\|\\

' '' ''

testing 'awk gensub backslashes \\' \

        'awk '$sq'BEGIN { s="\\\\"; print "s=" s; print gensub("a", s, "g", "a|a") }'$sq \

        's=\\\\

\\|\\

' '' ''

# gawk 5.1.1 handles trailing unpaired \ inconsistently.

# If replace string is single \, it is used verbatim,

# but if it is \\\ (three slashes), gawk uses "\<NUL>" (!!!), not "\\" as you would expect.

testing 'awk gensub backslashes \\\' \

        'awk '$sq'BEGIN { s="\\\\\\"; print "s=" s; print gensub("a", s, "g", "a|a") }'$sq \

        's=\\\\\\

\\\\|\\\\

' '' ''

testing 'awk gensub backslashes \\\\' \

        'awk '$sq'BEGIN { s="\\\\\\\\"; print "s=" s; print gensub("a", s, "g", "a|a") }'$sq \

        's=\\\\\\\\

\\\\|\\\\

' '' ''

testing 'awk gensub backslashes \&' \

        'awk '$sq'BEGIN { s="\\&"; print "s=" s; print gensub("a", s, "g", "a|a") }'$sq \

        's=\\&

&|&

' '' ''

testing 'awk gensub backslashes \0' \

        'awk '$sq'BEGIN { s="\\0"; print "s=" s; print gensub("a", s, "g", "a|a") }'$sq \

        's=\\0

a|a

' '' ''

testing 'awk gensub backslashes \\0' \

        'awk '$sq'BEGIN { s="\\\\0"; print "s=" s; print gensub("a", s, "g", "a|a") }'$sq \

        's=\\\\0

\\0|\\0

' '' ''

 

# The "b" in "abc" should not match <b* pattern.

# Currently we use REG_STARTEND ("This flag is a BSD extension, not present in POSIX")

# to implement the code to handle this correctly, but if your libc has no REG_STARTEND,

# the alternative code mishandles this case.

testing 'awk gsub erroneous word start match' \

        "awk 'BEGIN { a=\"abc\"; gsub(/\<b*/,\"\",a); print a }'" \

        'abc\n' \

        '' ''