1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
#!/bin/bash
#
# regression tests for helpers.bash
#
# Some of those helper functions are fragile, and we don't want to break
# anything if we have to mess with them.
#
source $(dirname $0)/helpers.bash
die() {
echo "$(basename $0): $*" >&2
exit 1
}
# Iterator and return code; updated in check_result()
testnum=0
rc=0
###############################################################################
# BEGIN test the parse_table helper
function check_result {
testnum=$(expr $testnum + 1)
if [ "$1" = "$2" ]; then
# Multi-level echo flattens newlines, makes success messages readable
echo $(echo "ok $testnum $3 = $1")
else
echo "not ok $testnum $3"
echo "# expected: $2"
echo "# actual: $1"
rc=1
fi
}
# IMPORTANT NOTE: you have to do
# this: while ... done < <(parse_table)
# and not: parse_table | while read ...
#
# ...because piping to 'while' makes it a subshell, hence testnum and rc
# will not be updated.
#
while read x y z; do
check_result "$x" "a" "parse_table simple: column 1"
check_result "$y" "b" "parse_table simple: column 2"
check_result "$z" "c" "parse_table simple: column 3"
done < <(parse_table "a | b | c")
# More complicated example, with spaces
while read x y z; do
check_result "$x" "a b" "parse_table with spaces: column 1"
check_result "$y" "c d" "parse_table with spaces: column 2"
check_result "$z" "e f g" "parse_table with spaces: column 3"
done < <(parse_table "a b | c d | e f g")
# Multi-row, with spaces and with blank lines
table="
a | b | c d e
d e f | g h | i j
"
declare -A expect=(
[0,0]="a"
[0,1]="b"
[0,2]="c d e"
[1,0]="d e f"
[1,1]="g h"
[1,2]="i j"
)
row=0
while read x y z;do
check_result "$x" "${expect[$row,0]}" "parse_table multi_row[$row,0]"
check_result "$y" "${expect[$row,1]}" "parse_table multi_row[$row,1]"
check_result "$z" "${expect[$row,2]}" "parse_table multi_row[$row,2]"
row=$(expr $row + 1)
done < <(parse_table "$table")
# Backslash handling. The first element should have none, the second some
while read x y;do
check_result "$x" '[0-9]{2}' "backslash test - no backslashes"
check_result "$y" '[0-9]\{3\}' "backslash test - one backslash each"
done < <(parse_table "[0-9]{2} | [0-9]\\\{3\\\}")
# Empty strings. I wish we could convert those to real empty strings.
while read x y z; do
check_result "$x" "''" "empty string - left-hand"
check_result "$y" "''" "empty string - middle"
check_result "$z" "''" "empty string - right"
done < <(parse_table " | |")
# Quotes
while read x y z;do
check_result "$x" "a 'b c'" "single quotes"
check_result "$y" "d \"e f\" g" "double quotes"
check_result "$z" "h" "no quotes"
# FIXME FIXME FIXME: this is the only way I can find to get bash-like
# splitting of tokens. It really should be done inside parse_table
# but I can't find any way of doing so. If you can find a way, please
# update this test and any BATS tests that rely on quoting.
eval set "$x"
check_result "$1" "a" "single quotes - token split - 1"
check_result "$2" "b c" "single quotes - token split - 2"
check_result "$3" "" "single quotes - token split - 3"
eval set "$y"
check_result "$1" "d" "double quotes - token split - 1"
check_result "$2" "e f" "double quotes - token split - 2"
check_result "$3" "g" "double quotes - token split - 3"
done < <(parse_table "a 'b c' | d \"e f\" g | h")
# END test the parse_table helper
###############################################################################
# BEGIN dprint
function dprint_test_1() {
dprint "$*"
}
# parse_table works, might as well use it
#
# <value of PODMAN_TEST_DEBUG> | <blank for no msg, - for msg> | <desc>
#
table="
| | debug unset
dprint_test | - | substring match
dprint_test_1 | - | exact match
dprint_test_10 | | caller name mismatch
xxx yyy zzz | | multiple callers, no match
dprint_test_1 xxx yyy zzz | - | multiple callers, match at start
xxx dprint_test_1 yyy zzz | - | multiple callers, match in middle
xxx yyy zzz dprint_test_1 | - | multiple callers, match at end
"
while read var expect name; do
random_string=$(random_string 20)
PODMAN_TEST_DEBUG="$var" result=$(dprint_test_1 "$random_string" 3>&1)
expect_full=""
if [ -n "$expect" -a "$expect" != "''" ]; then
expect_full="# dprint_test_1() : $random_string"
fi
check_result "$result" "$expect_full" "DEBUG='$var' - $name"
done < <(parse_table "$table")
# END dprint
###############################################################################
# BEGIN remove_same_dev_warning
# Test-helper function: runs remove_same_dev_warning, compares resulting
# value of $lines and $output to expected values given on command line
function check_same_dev() {
local testname="$1"; shift
local -a expect_lines=("$@")
local nl="
"
remove_same_dev_warning
# After processing, check the expected number of lines
check_result "${#lines[@]}" "${#@}" "$testname: expected # of lines"
# ...and each expected line
local expect_output=""
local i=0
while [ $i -lt ${#expect_lines[@]} ]; do
check_result "${lines[$i]}" "${expect_lines[$i]}" "$testname: line $i"
expect_output+="${expect_lines[$i]}$nl"
i=$(( i + 1 ))
done
# ...and the possibly-multi-line $output
check_result "$output" "${expect_output%%$nl}" "$testname: output"
}
# Simplest case: nothing removed.
declare -a lines=("a b c" "d" "e f")
check_same_dev "abc" "a b c" "d" "e f"
# Confirm that the warning message is removed from the beginning
declare -a lines=(
"WARNING: The same type, major and minor should not be used for multiple devices."
"a"
"b"
"c"
)
check_same_dev "warning is removed" a b c
# ...and from the middle (we do not expect to see this)
declare -a lines=(
"WARNING: The same type, major and minor should not be used for multiple devices."
"a"
"b"
"WARNING: The same type, major and minor should not be used for multiple devices."
"c"
)
check_same_dev "multiple warnings removed" a b c
# Corner case: two lines of output, only one of which we care about
declare -a lines=(
"WARNING: The same type, major and minor should not be used for multiple devices."
"this is the only line we care about"
)
check_same_dev "one-line output" "this is the only line we care about"
# Corner case: one line of output, but we expect zero.
declare -a lines=(
"WARNING: The same type, major and minor should not be used for multiple devices."
)
check_same_dev "zero-line output"
# END remove_same_dev_warning
###############################################################################
exit $rc
|
