← Back to branch summary

~willismonroe/ubuntu/precise/xdg-utils/typo-fix-996304

« back to all changes in this revision

Viewing changes to tests/include/testassertions.sh

  • Committer: Bazaar Package Importer
  • Author(s): Per Olofsson
  • Date: 2006-08-29 17:35:02 UTC
  • Revision ID: james.westby@ubuntu.com-20060829173502-ffe063dqe8ajg2rm
Tags: upstream-1.0~beta3
Import upstream version 1.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/include/testassertions.sh
 
1
# Adapted from 
 
2
# shfuncs : test suite common shell functions
 
3
# which was shipped with the TET example code.
 
4
 
 
5
. "$XDG_TEST_DIR/include/testfuncs.sh"
 
6
 
 
7
assert_exit() # execute command (saving output) and check exit code
 
8
{
 
9
    EXPECT="$1"
 
10
    shift 1
 
11
 
 
12
    # make sure nothing is hanging around from a prev. test.
 
13
    rm -f out.stdout out.stderr
 
14
 
 
15
    # $1 is command, $2 is expected exit code (0 or "N" for non-zero)
 
16
    ( "$@" > out.stdout 2> out.stderr )
 
17
    CODE="$?"
 
18
 
 
19
    LASTCOMMAND="$*"
 
20
 
 
21
    if [ -z "$EXPECT" ]; then
 
22
        EXPECT=0;
 
23
    fi
 
24
    if [ "$EXPECT" = N -a "$CODE" -eq 0 ]; then
 
25
        test_fail "Command ($*) gave exit code $CODE, expected nonzero"
 
26
    elif [ "$EXPECT" != N ] && [ "$EXPECT" -ne "$CODE" ]; then
 
27
        test_fail "Command ($*) gave exit code $CODE, expected $EXPECT"
 
28
    fi
 
29
}
 
30
 
 
31
assert_interactive_notroot() {
 
32
        if [ `whoami` != 'root' ] ; then
 
33
                assert_interactive "$@"
 
34
        fi
 
35
}
 
36
 
 
37
assert_interactive() {
 
38
# Useage:
 
39
# assert_interactive {msg} [y|n|C|s varname]
 
40
#
 
41
# msg is the text to print.
 
42
# y -> expect y for [y/n]
 
43
# n -> expect n for [y/n]
 
44
# s -> save y or n into varname. Then, (presumably) $varname can be 
 
45
#      given in place of y or n in subsequent calls to assert_interactive
 
46
# C -> cleanup msg. Always print "msg [enter to continue]" despite test failure.
 
47
# if no argument is given after msg, print "msg [enter to continue]"
 
48
 
 
49
        query=$1
 
50
        expect=$2
 
51
# It seems valuable to see what happens even if the test has failed. 
 
52
# (eg fail on stdout.)
 
53
        if [ "$TEST_STATUS" = 'FAIL' -a -z "$XDG_UTILS_DEBUG_LEVEL" -a "$expect" != C ] ; then
 
54
                ## Don't waste user's time if test has already failed.
 
55
                test_infoline "Test has already failed. Not bothering to ask '$query'" 
 
56
                return
 
57
        fi
 
58
 
 
59
        if [ ! -z "$XDG_TEST_NO_INTERACTIVE" ] ; then
 
60
                test_infoline "Assumed '$query' is '$expect'"
 
61
                return
 
62
        fi
 
63
 
 
64
        if [  ! -z "$expect" -a "$expect" != C ] ; then
 
65
                if [ "$expect" != y -a "$expect" != n -a "$expect" != s -a "$expect" != C ] ; then
 
66
                        echo "TEST SYNTAX ERROR: interactive assertions require one of (y,n,s,C) as choices. (found '$expect')" >&2
 
67
                        exit 255
 
68
                fi
 
69
                unset result
 
70
                while [ "$result" != y -a "$result" != n ] ; do 
 
71
                        echo -ne "\n\t$query [y/n]: " >&2
 
72
                        read result
 
73
                done
 
74
 
 
75
                if [ "$expect" = s ] ; then
 
76
                        if [ -z "$3" ] ; then
 
77
                                echo "TEST SYNTAX ERROR: 's' requires a variable name"
 
78
                                exit 255
 
79
                        fi
 
80
                        eval "$3=$result"
 
81
                elif [ "$result" != "$expect" ] ; then
 
82
                        test_fail "User indicated '$result' instead of '$expect' in respnonse to '$query'"
 
83
                fi
 
84
        else
 
85
                echo -ne "\n\t$query [enter to continue] " >&2
 
86
                read result
 
87
        fi
 
88
}
 
89
                
 
90
 
 
91
assert_file_in_path() {
 
92
        search_dirs=`echo "$2" | tr ':' ' '`
 
93
        found_files=`find $search_dirs -name "$1" 2>/dev/null`
 
94
 
 
95
        if [ -z "$found_files" ] ; then
 
96
                test_fail "Did not find '$1' in '$2'"
 
97
        fi
 
98
}
 
99
 
 
100
assert_file_not_in_path() {
 
101
        search_dirs=`echo "$2" | tr ':' ' '`
 
102
        found_files=`find $search_dirs -name "$1" 2>/dev/null`
 
103
 
 
104
        if [ ! -z "$found_files" ] ; then
 
105
                test_fail "Found '$found_files' in $2"
 
106
        fi
 
107
}
 
108
 
 
109
 
 
110
assert_file() {
 
111
        if [ ! -e "$1" ] ; then
 
112
                test_fail "'$1' does not exist"
 
113
                return 
 
114
        elif [ ! -f "$1" ] ; then
 
115
                test_fail "'$1' is not a regular file"
 
116
                return
 
117
        fi
 
118
        if [ -f "$2" ] ; then
 
119
                compare=`diff -wB "$1" "$2"`
 
120
                if [ ! -z "$compare" ] ; then
 
121
                        test_fail "'$1' is different from '$2'. Diff is:\n$compare"
 
122
                fi
 
123
        fi
 
124
}
 
125
 
 
126
assert_nofile() {
 
127
        if [ -e "$1" ] ; then
 
128
                test_fail "'$1' exists."
 
129
        fi
 
130
}
 
131
 
 
132
 
 
133
assert_nostdout() # check that nothing went to stdout
 
134
{
 
135
    if [ -s out.stdout ]
 
136
    then
 
137
        test_infoline "Unexpected output from '$LASTCOMMAND' written to stdout, as shown below:"
 
138
        infofile out.stdout stdout:
 
139
        test_status WARN
 
140
    fi
 
141
}
 
142
 
 
143
assert_nostderr() # check that nothing went to stderr
 
144
{
 
145
    if [ ! -z "$XDG_UTILS_DEBUG_LEVEL" ] ; then
 
146
        test_infoline "not checking STDERR from '$LASTCOMMAND' because XDG_UTILS_DEBUG_LEVEL=$XDG_UTILS_DEBUG_LEVEL"
 
147
        test_infoline out.stderr stderr:
 
148
    elif [ -s out.stderr ] ; then
 
149
        test_infoline "Unexpected output from '$LASTCOMMAND' written to stderr, as shown below:"
 
150
        infofile out.stderr stderr:
 
151
        test_status WARN
 
152
    fi
 
153
}
 
154
 
 
155
assert_stderr() # check that stderr matches expected error
 
156
{
 
157
    # $1 is file containing regexp for expected error
 
158
    # if no argument supplied, just check out.stderr is not empty
 
159
 
 
160
        if [ ! -s out.stderr ]
 
161
        then
 
162
            test_infoline "Expected output from '$LASTCOMMAND' to stderr, but none written"
 
163
            test_fail
 
164
            return
 
165
        fi
 
166
    if [ ! -z "$1" ] ; then
 
167
        expfile="$1"
 
168
        OK=Y
 
169
        exec 4<&0 0< "$expfile" 3< out.stderr
 
170
        while read expline
 
171
        do
 
172
            if read line <&3
 
173
            then
 
174
                if expr "$line" : "$expline" > /dev/null
 
175
                then
 
176
                    :
 
177
                else
 
178
                    OK=N
 
179
                    break
 
180
                fi
 
181
            else
 
182
                OK=N
 
183
            fi
 
184
        done
 
185
        exec 0<&4 3<&- 4<&-
 
186
        if [ "$OK" = N ]
 
187
        then
 
188
            test_infoline "Incorrect output from '$LASTCOMMAND' written to stderr, as shown below"
 
189
            infofile "$expfile" "expected stderr:"
 
190
            infofile out.stderr "received stderr:"
 
191
            test_fail
 
192
        fi
 
193
    fi 
 
194
}
 
195
 
 
196
assert_stdout() # check that stderr matches expected error
 
197
{
 
198
    # $1 is file containing regexp for expected error
 
199
    # if no argument supplied, just check out.stderr is not empty
 
200
 
 
201
        if [ ! -s out.stdout ]
 
202
        then
 
203
            test_infoline "Expected output from '$LASTCOMMAND' to stdout, but none written"
 
204
            test_fail
 
205
            return
 
206
        fi
 
207
    if [ ! -z "$1" ] ; then 
 
208
        expfile="$1"
 
209
 
 
210
        if [ ! -e "$expfile" ] ; then
 
211
                test_status NORESULT "Could not find file '$expfile' to look up expected pattern!"
 
212
                return
 
213
        fi
 
214
        OK=Y
 
215
        exec 4<&0 0< "$expfile" 3< out.stdout
 
216
        while read expline
 
217
        do
 
218
            if read line <&3
 
219
            then
 
220
                if expr "$line" : "$expline" > /dev/null
 
221
                then
 
222
                    :
 
223
                else
 
224
                    OK=N
 
225
                    break
 
226
                fi
 
227
            else
 
228
                OK=N
 
229
            fi
 
230
        done
 
231
        exec 0<&4 3<&- 4<&-
 
232
        if [ "$OK" = N ]
 
233
        then
 
234
            test_infoline "Incorrect output from '$LASTCOMMAND' written to stdout, as shown below"
 
235
            infofile "$expfile" "expected stdout:"
 
236
            infofile out.stdout "received stdout:"
 
237
            test_fail
 
238
        fi
 
239
    fi
 
240
}
 
241
 
 
242
 
 
243
infofile() # write file to journal using tet_infoline
 
244
{
 
245
    # $1 is file name, $2 is prefix for tet_infoline
 
246
 
 
247
    prefix="$2"
 
248
    while read line
 
249
    do
 
250
        test_infoline "$prefix$line"
 
251
    done < "$1"
 
252
}
 
253
 
 
254
require_interactive() {
 
255
    if [ ! -z "$XDG_TEST_NO_INTERACTIVE" ] ; then
 
256
        test_result UNTESTED "XDG_TEST_NO_INTERACTIVE is set, but this test needs interactive"
 
257
    fi
 
258
}
 
259
 
 
260
require_root() {
 
261
    if [ `whoami` != 'root' ] ; then
 
262
        test_result UNTESTED "not running as root, but test requires root privileges"
 
263
    fi
 
264
}
 
265
 
 
266
require_notroot() {
 
267
    if [ `whoami` = 'root' ] ; then
 
268
        test_result UNTESTED "running as root, but test must be run as a normal user"
 
269
    fi
 
270
}
 
271
 
 
272
set_no_display() {
 
273
        unset DISPLAY
 
274
}
 
275
 
 
276
assert_display() {
 
277
        if [ -z "$DISPLAY" ] ; then 
 
278
                test_fail "DISPLAY not set!"
 
279
        fi
 
280
}
 
281
 
 
282
assert_util_var() {
 
283
if [ "x$XDGUTIL" = x ]; then
 
284
        test_fail "XDGUTIL variable not set"
 
285
fi
 
286
}
 
287