* Bug 15028 fixed: assert_checkalmostequal() did not accept polynomials
[scilab.git] / scilab / modules / development_tools / tests / unit_tests / assert / checkalmostequal.tst
1 // Copyright (C) 2008 - INRIA - Michael Baudin
2 // Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
3 // Copyright (C) 2017 - Samuel GOUGEON
4 //
5 // Copyright (C) 2012 - 2016 - Scilab Enterprises
6 //
7 // This file is hereby licensed under the terms of the GNU GPL v2.0,
8 // pursuant to article 5.3.4 of the CeCILL v.2.1.
9 // This file was originally licensed under the terms of the CeCILL v2.1,
10 // and continues to be available under such terms.
11 // For more information, see the COPYING file which you should have received
12 // along with this program.
13
14 // <-- CLI SHELL MODE -->
15 // <-- ENGLISH IMPOSED -->
16 // <-- NO CHECK REF -->
17
18 function flag = MY_assert_equal ( computed , expected )
19   if computed==expected then
20     flag = 1;
21   else
22     flag = 0;
23   end
24   if flag <> 1 then pause,end
25 endfunction
26
27 function checkassert ( flag , errmsg , ctype )
28   if ( ctype == "success" ) then
29     MY_assert_equal ( (flag==%t) & (errmsg==""), %t )
30   else
31     MY_assert_equal ( (flag==%f) & (errmsg<>""), %t )
32   end
33 endfunction
34
35
36 format("v",10);
37
38 // Check error message when number of arguments is false
39 instr = "assert_checkalmostequal ( )";
40 ierr=execstr(instr,"errcatch");
41 MY_assert_equal ( ierr , 10000 );
42 //
43 instr = "assert_checkalmostequal ( 1 )";
44 ierr=execstr(instr,"errcatch");
45 MY_assert_equal ( ierr , 10000 );
46 //
47 instr = "[o1,o2,o3]=assert_checkalmostequal ( 1 , 1 , %eps )";
48 ierr=execstr(instr,"errcatch");
49 MY_assert_equal ( ierr , 999 );
50 //
51 //////////////////////////////////////////
52 // Check error message when type of arguments is false
53 instr = "assert_checkalmostequal ( ""a"" , 2 , %eps )";
54 ierr=execstr(instr,"errcatch");
55 MY_assert_equal ( ierr , 10000 );
56 //
57 instr = "assert_checkalmostequal ( 1 , ""b"" , %eps )";
58 ierr=execstr(instr,"errcatch");
59 MY_assert_equal ( ierr , 10000 );
60 //
61 instr = "assert_checkalmostequal ( 1 , 2 , ""c"" )";
62 ierr=execstr(instr,"errcatch");
63 MY_assert_equal ( ierr , 10000 );
64 //
65 instr = "assert_checkalmostequal ( 1 , 2 , %eps , ""c"" )";
66 ierr=execstr(instr,"errcatch");
67 MY_assert_equal ( ierr , 10000 );
68 //
69 instr = "assert_checkalmostequal ( 1 , 2 , %eps , 0 , %t )";
70 ierr=execstr(instr,"errcatch");
71 MY_assert_equal ( ierr , 10000 );
72 //////////////////////////////////////////
73 // Check error message when size of arguments is false
74 instr = "assert_checkalmostequal ( 1 , 2 , [1 1] )";
75 ierr=execstr(instr,"errcatch");
76 MY_assert_equal ( ierr , 10000 );
77 //
78 instr = "assert_checkalmostequal ( 1 , 2 , %eps , [1 1] )";
79 ierr=execstr(instr,"errcatch");
80 MY_assert_equal ( ierr , 10000 );
81 //
82 instr = "assert_checkalmostequal ( 1 , 2 , %eps , 0 , [""a"" ""b""] )";
83 ierr=execstr(instr,"errcatch");
84 MY_assert_equal ( ierr , 10000 );
85 //
86 instr = "assert_checkalmostequal ( 1 , [2 3] , %eps )";
87 ierr=execstr(instr,"errcatch");
88 MY_assert_equal ( ierr , 10000 );
89
90 //////////////////////////////////////////
91 //
92 // Check that the error message is correctly handled.
93 instr = "assert_checkalmostequal ( 1 , 2 )";
94 ierr=execstr(instr,"errcatch");
95 MY_assert_equal ( ierr , 10000 );
96 errmsg = lasterror();
97 refmsg = msprintf(_("%s: Assertion failed: expected = %s while computed = %s"), "assert_checkalmostequal", "2", "1");
98 MY_assert_equal ( errmsg , refmsg );
99 //
100 // Check that the error message is correctly handled.
101 instr = "assert_checkalmostequal ( 1 , 2 , %eps )";
102 ierr=execstr(instr,"errcatch");
103 MY_assert_equal ( ierr , 10000 );
104 errmsg = lasterror();
105 refmsg = msprintf(_("%s: Assertion failed: expected = %s while computed = %s"), "assert_checkalmostequal", "2", "1");
106 MY_assert_equal ( errmsg , refmsg );
107 //
108 // Check that the error message is correctly handled.
109 instr = "assert_checkalmostequal ( 1 , 1 , %eps )";
110 ierr=execstr(instr,"errcatch");
111 MY_assert_equal ( ierr , 0 );
112 errmsg = lasterror();
113 MY_assert_equal ( errmsg , [] );
114 //
115 // Obvious failure : Check the error message
116 instr = "assert_checkalmostequal ( zeros(10,1)+1.e-4 , zeros(10,1) , 1.e-5 )";
117 ierr=execstr(instr,"errcatch");
118 MY_assert_equal ( ierr , 10000 );
119 errmsg = lasterror();
120 refmsg = msprintf(_("%s: Assertion failed: expected = %s while computed = %s"), "assert_checkalmostequal", "[0 ...]", "[0.0001 ...]");
121 MY_assert_equal ( errmsg , refmsg );
122
123 //////////////////////////////////////////
124 //
125 // Test empty matrix
126 //
127 // Obvious success
128 [flag,errmsg] = assert_checkalmostequal ( [] , [] );
129 checkassert ( flag , errmsg , "success" );
130 //
131 // Obvious success
132 [flag,errmsg] = assert_checkalmostequal ( [] , [] , [], [], "matrix");
133 checkassert ( flag , errmsg , "success" );
134 //
135 // Obvious success
136 [flag,errmsg] = assert_checkalmostequal ( [] , [] , [], [], "element");
137 checkassert ( flag , errmsg , "success" );
138
139 //////////////////////////////////////////
140 //
141 //
142 // Obvious success
143 [flag,errmsg] = assert_checkalmostequal ( 1 , 1 );
144 checkassert ( flag , errmsg , "success" );
145 // Obvious success
146 [flag,errmsg] = assert_checkalmostequal ( 1 , 1 , %eps );
147 checkassert ( flag , errmsg , "success" );
148 //
149 // Obvious success
150 [flag,errmsg] = assert_checkalmostequal ( ones(10,1) , ones(10,1) , %eps );
151 checkassert ( flag , errmsg , "success" );
152 //
153 // Obvious success
154 [flag,errmsg] = assert_checkalmostequal ( ones(10,1)+%eps , ones(10,1) , %eps );
155 checkassert ( flag , errmsg , "success" );
156 //
157 // Obvious success
158 [flag,errmsg] = assert_checkalmostequal ( zeros(10,1) , zeros(10,1) , 1.e-5 );
159 checkassert ( flag , errmsg , "success" );
160 //
161 // Obvious failure
162 [flag,errmsg] = assert_checkalmostequal ( 1 , 2 , %eps );
163 checkassert ( flag , errmsg , "failure" );
164 //
165 // Obvious failure
166 [flag,errmsg] = assert_checkalmostequal ( zeros(10,1)+1.e-4 , zeros(10,1) , 1.e-5 );
167 checkassert ( flag , errmsg , "failure" );
168 //
169 // Success: not obvious!
170 // The two values are equal, very small, but nonzero.
171 // The relative tolerance must be used here.
172 // If, instead, a bug in the assert function is so that the
173 // absolute tolerance is used as 10^-16, then the output
174 // of this comparison is wrong.
175 [flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 1.23456789123456789e-30 , %eps );
176 checkassert ( flag , errmsg , "success" );
177 //
178 // Failure : not obvious!
179 // There is only one significant digit here and we require the
180 // maximum precision.
181 // The test must fail because the relative tolerance must be used here.
182 // If, instead, there is a bug in the comparison and
183 // the absolute tolerance is used and set to
184 // 10^-16, the output of this test is wrong.
185 [flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 1.3e-30 , %eps );
186 checkassert ( flag , errmsg , "failure" );
187 //
188 // Success : not obvious!
189 // The expected result is zero, so that the absolute tolerance is used.
190 [flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 0 , 0 , 1.e-10 );
191 checkassert ( flag , errmsg , "success" );
192 //
193 // Check that nans are correctly handled
194 [flag,errmsg] = assert_checkalmostequal ( [1 %nan], [1 %nan] , %eps );
195 checkassert ( flag , errmsg , "success" );
196 //
197 // Check that nans are correctly handled
198 [flag,errmsg] = assert_checkalmostequal ( [1 %nan 1 %nan] , [1 %nan 1 %nan] , %eps );
199 checkassert ( flag , errmsg , "success" );
200 //
201 [flag,errmsg] = assert_checkalmostequal ( [%nan 1], [1 %nan] , %eps );
202 checkassert ( flag , errmsg , "failure" );
203 //
204 // Check that slightly different values cannot pass basic test
205 // Simple sequence with default settings
206 [flag,errmsg] = assert_checkalmostequal ( 1 + 5 * %eps , 1 , %eps );
207 checkassert ( flag , errmsg , "failure" );
208 //
209 // Customize the relative precision so that a test can pass
210 // Simple sequence with default settings
211 [flag,errmsg] = assert_checkalmostequal ( 1 + 5 * %eps , 1 , 10*%eps );
212 checkassert ( flag , errmsg , "success" );
213 //
214 // Customize the absolute precision so that a test can pass
215 // Simple sequence with default settings
216 [flag,errmsg] = assert_checkalmostequal ( 0 + 5 * %eps , 0 , 0 , 10*%eps );
217 checkassert ( flag , errmsg , "success" );
218 //
219 // An example where the relative error is used,
220 // with a customized tolerance.
221 [flag,errmsg] = assert_checkalmostequal ( 1.23456 , 1.23457 , 1.e11*%eps );
222 checkassert ( flag , errmsg , "success" );
223 //
224 // Put all IEEE values
225 [flag,errmsg] = assert_checkalmostequal ( [1.2345 %inf -%inf %nan] , [1.2346 %inf -%inf %nan] , 1.e-4 );
226 checkassert ( flag , errmsg , "success" );
227
228
229 ///////////////////////////////////////////////////////////////////////////////
230 // Test elementwise algo
231
232 // If "matrix" type is used, this test pass.
233 [flag,errmsg] = assert_checkalmostequal ( [1 1.e5] , [2 1.e5] , 1.e-3 , [], "element" );
234 checkassert ( flag , errmsg , "failure" );
235 //
236 // Force the test to pass
237 [flag,errmsg] = assert_checkalmostequal ( [1 1.e5] , [1 1.e5] , 1.e-3 , [], "element" );
238 checkassert ( flag , errmsg , "success" );
239 //
240 [flag,errmsg] = assert_checkalmostequal ( [1 %nan] , [2 %nan] , 1.e-3 , [], "element" );
241 checkassert ( flag , errmsg , "failure" );
242 //
243 [flag,errmsg] = assert_checkalmostequal ( [1 %inf] , [2 %inf] , 1.e-3 , [], "element" );
244 checkassert ( flag , errmsg , "failure" );
245 //
246 [flag,errmsg] = assert_checkalmostequal ( [1 %inf] , [1 %inf] , 1.e-3 , [], "element" );
247 checkassert ( flag , errmsg , "success" );
248 //
249 [flag,errmsg] = assert_checkalmostequal ( [1 %inf -%inf %nan] , [1 %inf -%inf %nan] , 1.e-3 , [], "element" );
250 checkassert ( flag , errmsg , "success" );
251 //
252 [flag,errmsg] = assert_checkalmostequal ( [1 %inf -%inf %nan] , [1 -%inf %inf %nan] , 1.e-3 , [], "element" );
253 checkassert ( flag , errmsg , "failure" );
254
255 ///////////////////////////////////////////////////////////////////////////////
256 // Test complex elementwise algo
257 //
258 [flag,errmsg] = assert_checkalmostequal ( 1+%i , 1+(1+1.e-4)*%i , 1.e-3 , [], "element" );
259 checkassert ( flag , errmsg , "success" );
260 [flag,errmsg] = assert_checkalmostequal ( 1+%i , 1+(1+1.e-4)*%i , 1.e-5 , [], "element" );
261 checkassert ( flag , errmsg , "failure" );
262 //
263 // Use absolute tolerance
264 [flag,errmsg] = assert_checkalmostequal ( 1+%i , 0 , [], 1.e-3 , "element" );
265 checkassert ( flag , errmsg , "failure" );
266 //
267 ///////////////////////////////////////////////////////////////////////////////
268 // Tests with polynomials
269 //
270 assert_checkalmostequal(%z, %z);
271 assert_checkalmostequal([%z %z], [%z %z]);
272 assert_checkalmostequal([%z %z^2], [%z %z^2]);
273
274 assert_checkalmostequal(%z+%eps, %z-%eps, [], 10*%eps);
275 assert_checkalmostequal([(1+%eps)*%z %z], [(1-%eps)*%z %z], [], %eps);
276 assert_checkalmostequal([%z %z^2]+%eps, [%z %z^2]-%eps, [], 2*%eps);
277
278 assert_checkalmostequal(%i+%z, %i+%z);
279 assert_checkalmostequal([%i+%z %i*%z], [%i+%z %i*%z]);
280 assert_checkalmostequal([1+%i*%z, %i-%z^2], [1+%i*%z, %i-%z^2]);
281
282 assert_checkalmostequal(%i+%z+%eps, %i+%z-%eps, [], 2*%eps);
283 assert_checkalmostequal([%i+%z %i*%z]+%eps, [%i+%z %i*%z]-%eps, [], 2*%eps);
284 assert_checkalmostequal([1+%i*%z, %i-%z^2]-%eps, [1+%i*%z, %i-%z^2]+%eps, [], 2*%eps);