|
5589
|
1 ## Copyright (C) 2000 Paul Kienzle |
|
|
2 ## |
|
|
3 ## This program is free software; you can redistribute it and/or modify |
|
|
4 ## it under the terms of the GNU General Public License as published by |
|
|
5 ## the Free Software Foundation; either version 2 of the License, or |
|
|
6 ## (at your option) any later version. |
|
|
7 ## |
|
|
8 ## This program is distributed in the hope that it will be useful, |
|
|
9 ## but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
10 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
11 ## GNU General Public License for more details. |
|
|
12 ## |
|
|
13 ## You should have received a copy of the GNU General Public License |
|
|
14 ## along with this program; if not, write to the Free Software |
|
|
15 ## Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
|
|
16 ## 02110-1301 USA |
|
|
17 |
|
|
18 ## -*- texinfo -*- |
|
|
19 ## @deftypefn {Function File} {} assert (@var{cond}) |
|
|
20 ## @deftypefnx {Function File} {} assert (@var{observed},@var{expected}) |
|
|
21 ## @deftypefnx {Function File} {} assert (@var{observed},@var{expected},@var{tol}) |
|
|
22 ## |
|
|
23 ## Produces an error if the condition is not met. @code{assert} can be |
|
|
24 ## called in three different ways. |
|
|
25 ## |
|
|
26 ## @table @code |
|
|
27 ## @item assert (@var{cond}) |
|
|
28 ## Called with a single argument @var{cond}, @code{assert} produces an |
|
|
29 ## error if @var{cond} is zero. |
|
|
30 ## |
|
|
31 ## @item assert (@var{observed}, @var{expected}) |
|
|
32 ## Produce an error if observed is not the same as expected. Note that |
|
|
33 ## observed and expected can be strings, scalars, vectors, matrices, |
|
|
34 ## lists or structures. |
|
|
35 ## |
|
|
36 ## @item assert(@var{observed}, @var{expected}, @var{tol}) |
|
|
37 ## Produce an error if relative error is less than tolerance. That is, |
|
|
38 ## @code{abs(@var{observed} - @var{expected}) > @var{tol} * @var{expected}}. |
|
|
39 ## Absolute error @code{abs(@var{observed} - @var{expected}) > abs(@var{tol})} |
|
|
40 ## will be used when tolerance is negative or when the expected value is zero. |
|
|
41 ## @end table |
|
|
42 ## |
|
|
43 ## @end deftypefn |
|
|
44 ## @seealso{test} |
|
|
45 |
|
|
46 ## TODO: Output throttling: don't print out the entire 100x100 matrix, |
|
|
47 ## TODO: but instead give a summary; don't print out the whole list, just |
|
|
48 ## TODO: say what the first different element is, etc. To do this, make |
|
|
49 ## TODO: the message generation type specific. |
|
|
50 function assert(cond, expected, tol) |
|
|
51 |
|
|
52 if (nargin < 1 || nargin > 3) |
|
|
53 usage("assert (cond) or assert (v, expected_v [,tol])"); |
|
|
54 endif |
|
|
55 |
|
|
56 if (nargin < 3) |
|
|
57 tol = 0; |
|
|
58 endif |
|
|
59 |
|
|
60 if exist("argn") == 0, argn=" "; endif |
|
|
61 in = deblank(argn(1,:)); |
|
|
62 for i=2:rows(argn) |
|
|
63 in = [in, ",", deblank(argn(i,:))]; |
|
|
64 end |
|
|
65 in = ["(",in,")"]; |
|
|
66 |
|
|
67 coda = ""; |
|
|
68 iserror = 0; |
|
|
69 if (nargin == 1) |
|
|
70 if (!isnumeric(cond) || !all(cond(:))) |
|
|
71 error ("assert %s failed", in); # say which elements failed? |
|
|
72 endif |
|
|
73 |
|
|
74 elseif (is_list(cond)) |
|
|
75 if (!is_list(expected) || length(cond) != length(expected)) |
|
|
76 iserror = 1; |
|
|
77 else |
|
|
78 try |
|
|
79 for i=1:length(cond) |
|
|
80 assert(nth(cond,i),nth(expected,i)); |
|
|
81 endfor |
|
|
82 catch |
|
|
83 iserror = 1; |
|
|
84 end |
|
|
85 endif |
|
|
86 |
|
|
87 elseif (ischar (expected)) |
|
|
88 iserror = (!ischar (cond) || !strcmp (cond, expected)); |
|
|
89 |
|
|
90 elseif (iscell(expected)) |
|
|
91 if (!iscell (cond) || any(size(cond)!=size(expected))) |
|
|
92 iserror = 1; |
|
|
93 else |
|
|
94 try |
|
|
95 for i=1:length(expected(:)) |
|
|
96 assert(cond{i},expected{i},tol); |
|
|
97 endfor |
|
|
98 catch |
|
|
99 iserror = 1; |
|
|
100 end |
|
|
101 endif |
|
|
102 |
|
|
103 elseif (isstruct (expected)) |
|
|
104 if (!isstruct (cond) || any(size(cond) != size(expected)) || ... |
|
|
105 rows(struct_elements(cond)) != rows(struct_elements(expected))) |
|
|
106 iserror = 1; |
|
|
107 else |
|
|
108 try |
|
|
109 empty=prod(size(cond))==0; |
|
|
110 normal=prod(size(cond))==1; |
|
|
111 for [v,k] = cond |
|
|
112 if !struct_contains(expected,k), error; endif |
|
|
113 if empty, v = cell(1,0); endif |
|
|
114 if normal, v = {v}; endif |
|
|
115 assert(v,{expected.(k)},tol); |
|
|
116 endfor |
|
|
117 catch |
|
|
118 iserror = 1; |
|
|
119 end |
|
|
120 endif |
|
|
121 |
|
|
122 elseif (isempty (expected)) |
|
|
123 iserror = (any (size (cond) != size (expected))); |
|
|
124 |
|
|
125 elseif (any (size (cond) != size (expected))) |
|
|
126 iserror = 1; |
|
|
127 coda = "Dimensions don't match"; |
|
|
128 |
|
|
129 elseif tol==0 && !strcmp(typeinfo(cond),typeinfo(expected)) |
|
|
130 iserror = 1; |
|
|
131 coda = ["Type ",typeinfo(cond)," != ",typeinfo(expected)]; |
|
|
132 |
|
|
133 else # numeric |
|
|
134 A=cond(:); B=expected(:); |
|
|
135 ## Check exceptional values |
|
|
136 if any(isnan(A) != isnan(B)) |
|
|
137 iserror = 1; |
|
|
138 coda = "NaNs don't match"; |
|
|
139 elseif any(isna(A) != isna(B)) |
|
|
140 iserror = 1; |
|
|
141 coda = "NAs don't match"; |
|
|
142 elseif any(A(isinf(A)) != B(isinf(B))) |
|
|
143 iserror = 1; |
|
|
144 coda = "Infs don't match"; |
|
|
145 else |
|
|
146 ## Check normal values |
|
|
147 A = A(finite(A)); B=B(finite(B)); |
|
|
148 if tol == 0, |
|
|
149 err = any(A != B); |
|
|
150 errtype = "values do not match"; |
|
|
151 elseif tol >= 0, |
|
|
152 err = max(abs(A-B)); |
|
|
153 errtype = "maximum absolute error %g exceeds tolerance %g"; |
|
|
154 else |
|
|
155 abserr = max(abs(A(B==0))); |
|
|
156 A = A(B!=0); B = B(B!=0); |
|
|
157 relerr = max(abs(A-B)./abs(B)); |
|
|
158 err = max([abserr;relerr]); |
|
|
159 errtype = "maximum relative error %g exceeds tolerance %g"; |
|
|
160 endif |
|
|
161 if err > abs(tol) |
|
|
162 iserror = 1; |
|
|
163 coda = sprintf(errtype,err,abs(tol)); |
|
|
164 endif |
|
|
165 endif |
|
|
166 endif |
|
|
167 |
|
|
168 if (!iserror) |
|
|
169 return; |
|
|
170 endif |
|
|
171 |
|
|
172 ## pretty print the "expected but got" info, |
|
|
173 ## trimming leading and trailing "\n" |
|
|
174 str = disp (expected); |
|
|
175 idx = find(str!="\n"); |
|
|
176 if (!isempty(idx)) |
|
|
177 str = str(idx(1):idx(length(idx))); |
|
|
178 endif |
|
|
179 str2 = disp (cond); |
|
|
180 idx = find(str2!="\n"); |
|
|
181 if (!isempty(idx)) |
|
|
182 str2 = str2(idx(1):idx(length(idx))); |
|
|
183 endif |
|
|
184 msg = ["assert ",in," expected\n", str, "\nbut got\n", str2]; |
|
|
185 if (!isempty(coda)) |
|
|
186 msg = [ msg, "\n", coda ]; |
|
|
187 endif |
|
|
188 error("%s",msg); |
|
|
189 ## disp(msg); |
|
|
190 ## error("assertion failed"); |
|
|
191 endfunction |
|
|
192 |
|
|
193 ## empty |
|
|
194 %!assert([]) |
|
|
195 %!assert(zeros(3,0),zeros(3,0)) |
|
|
196 %!error assert(zeros(3,0),zeros(0,2)) |
|
|
197 %!error assert(zeros(3,0),[]) |
|
|
198 |
|
|
199 ## conditions |
|
|
200 %!assert(isempty([])) |
|
|
201 %!assert(1) |
|
|
202 %!error assert(0) |
|
|
203 %!assert(ones(3,1)) |
|
|
204 %!assert(ones(1,3)) |
|
|
205 %!assert(ones(3,4)) |
|
|
206 %!error assert([1,0,1]) |
|
|
207 %!error assert([1;1;0]) |
|
|
208 %!error assert([1,0;1,1]) |
|
|
209 |
|
|
210 ## vectors |
|
|
211 %!assert([1,2,3],[1,2,3]); |
|
|
212 %!assert([1;2;3],[1;2;3]); |
|
|
213 %!error assert([2;2;3],[1;2;3]); |
|
|
214 %!error assert([1,2,3],[1;2;3]); |
|
|
215 %!error assert([1,2],[1,2,3]); |
|
|
216 %!error assert([1;2;3],[1;2]); |
|
|
217 %!assert([1,2;3,4],[1,2;3,4]); |
|
|
218 %!error assert([1,4;3,4],[1,2;3,4]) |
|
|
219 %!error assert([1,3;2,4;3,5],[1,2;3,4]) |
|
|
220 |
|
|
221 ## exceptional values |
|
|
222 %!assert([NaN, NA, Inf, -Inf, 1+eps, eps],[NaN, NA, Inf, -Inf, 1, 0],eps) |
|
|
223 %!error assert(NaN, 1) |
|
|
224 %!error assert(NA, 1) |
|
|
225 %!error assert(-Inf, Inf) |
|
|
226 |
|
|
227 ## scalars |
|
|
228 %!error assert(3, [3,3; 3,3]) |
|
|
229 %!error assert([3,3; 3,3], 3) |
|
|
230 %!assert(3, 3); |
|
|
231 %!assert(3+eps, 3, eps); |
|
|
232 %!assert(3, 3+eps, eps); |
|
|
233 %!error assert(3+2*eps, 3, eps); |
|
|
234 %!error assert(3, 3+2*eps, eps); |
|
|
235 |
|
|
236 %## must give a little space for floating point errors on relative |
|
|
237 %!assert(100+100*eps, 100, -2*eps); |
|
|
238 %!assert(100, 100+100*eps, -2*eps); |
|
|
239 %!error assert(100+300*eps, 100, -2*eps); |
|
|
240 %!error assert(100, 100+300*eps, -2*eps); |
|
|
241 %!error assert(3, [3,3]); |
|
|
242 %!error assert(3,4); |
|
|
243 |
|
|
244 ## structures |
|
|
245 %!shared x,y |
|
|
246 %! x.a = 1; x.b=[2, 2]; |
|
|
247 %! y.a = 1; y.b=[2, 2]; |
|
|
248 %!assert (x,y) |
|
|
249 %!test y.b=3; |
|
|
250 %!error assert (x,y) |
|
|
251 %!error assert (3, x); |
|
|
252 %!error assert (x, 3); |
|
|
253 |
|
|
254 ## check usage statements |
|
|
255 %!error assert |
|
|
256 %!error assert(1,2,3,4,5) |
|
|
257 |
|
|
258 ## strings |
|
|
259 %!assert("dog","dog") |
|
|
260 %!error assert("dog","cat") |
|
|
261 %!error assert("dog",3); |
|
|
262 %!error assert(3,"dog"); |
