* Bug 16274 fixed: assert_checkequal() with Nan or void in containers
[scilab.git] / scilab / modules / development_tools / tests / unit_tests / assert / checkequal.tst
1 // Copyright (C) 2008 - INRIA - Michael Baudin
2 // Copyright (C) 2010 - DIGITEO - Michael Baudin
3 // Copyright (C) 2012 - 2016 - Scilab Enterprises
4 // Copyright (C) 2019 - Samuel GOUGEON
5 //
6 // This file is hereby licensed under the terms of the GNU GPL v2.0,
7 // pursuant to article 5.3.4 of the CeCILL v.2.1.
8 // This file was originally licensed under the terms of the CeCILL v2.1,
9 // and continues to be available under such terms.
10 // For more information, see the COPYING file which you should have received
11 // along with this program.
12 // --------------------------------------------------------------------------
13 // <-- NO CHECK REF -->
14 // <-- ENGLISH IMPOSED -->
15
16 // ====================================
17 // Unitary tests of assert_checkequal()
18 // ====================================
19
20 function flag = MY_assert_equal ( computed , expected )
21     if ( and ( computed==expected ) ) then
22         flag = 1;
23     else
24         flag = 0;
25     end
26     if flag <> 1 then whereami(), pause,end
27 endfunction
28
29 function checkassert ( flag , errmsg , ctype )
30     if ( ctype == "success" ) then
31         MY_assert_equal ( (flag==%t) & (errmsg==""), %t )
32     else
33         MY_assert_equal ( (flag==%f) & (errmsg<>""), %t )
34     end
35 endfunction
36
37 format("v",10);
38
39 // Check error message when number of arguments is false
40 instr = "assert_checkequal ( )";
41 ierr=execstr(instr,"errcatch");
42 MY_assert_equal ( ierr , 10000 );
43 //
44 instr = "assert_checkequal ( 1 )";
45 ierr=execstr(instr,"errcatch");
46 MY_assert_equal ( ierr , 10000 );
47 //
48 instr = "[o1,o2,o3]=assert_checkequal ( 1 , 1 )";
49 ierr=execstr(instr,"errcatch");
50 MY_assert_equal ( ierr , 999 );
51
52 //////////////////////////////////////////
53 // Check error message when type of arguments is false
54 instr = "assert_checkequal ( ""a"" , 2 )";
55 ierr=execstr(instr,"errcatch");
56 MY_assert_equal ( ierr , 10000 );
57 //
58 instr = "assert_checkequal ( 1 , ""b"" )";
59 ierr=execstr(instr,"errcatch");
60 MY_assert_equal ( ierr , 10000 );
61 //////////////////////////////////////////
62 // Check error message when size of arguments are not equal
63 instr = "assert_checkequal ( 1 , [2 3] )";
64 ierr=execstr(instr,"errcatch");
65 MY_assert_equal ( ierr , 10000 );
66 //
67 // Check that the error message is correctly handled.
68 instr = "assert_checkequal ( [1 2], [3 4] )";
69 ierr=execstr(instr,"errcatch");
70 MY_assert_equal ( ierr , 10000 );
71 errmsg = lasterror();
72 refmsg = _("%s: Assertion failed: %s  while %s (mean diff = %s)");
73 refmsg = msprintf(refmsg, "assert_checkequal", ..
74                           msprintf(_("expected(%d)= "),1)+"3", ..
75                           msprintf(_("computed(%d)= "),1)+"1", "-2");
76 MY_assert_equal ( errmsg , refmsg );
77 //
78 [flag , errmsg] = assert_checkequal ( %T , %T );
79 checkassert ( flag , errmsg , "success" );
80 //
81 [flag , errmsg] = assert_checkequal ( %F , %T );
82 checkassert ( flag , errmsg , "failure" );
83 //
84 [flag , errmsg] = assert_checkequal ( %nan , %nan );
85 checkassert ( flag , errmsg , "success" );
86 //
87 [flag , errmsg] = assert_checkequal ( list() , list() );
88 checkassert ( flag , errmsg , "success" );
89 //
90 [flag , errmsg] = assert_checkequal ( [%T %F], [%T %F] );
91 checkassert ( flag , errmsg , "success" );
92 //
93 // Test all IEEE values
94 [flag , errmsg] = assert_checkequal ( [1 %inf -%inf %nan] , [1 %inf -%inf %nan] );
95 checkassert ( flag , errmsg , "success" );
96 //
97 [flag , errmsg] = assert_checkequal ( [] , [] );
98 checkassert ( flag , errmsg , "success" );
99 ////////////////////////////////////////////////////////
100 // Check complex entries.
101 [flag , errmsg] = assert_checkequal(complex(%nan,%nan),complex(%nan,0));
102 checkassert ( flag , errmsg , "failure" );
103 //
104 [flag , errmsg] = assert_checkequal(complex(%nan,%inf),complex(%nan,0));
105 checkassert ( flag , errmsg , "failure" );
106 //
107 [flag , errmsg] = assert_checkequal(complex(%nan,%nan),complex(0,%nan));
108 checkassert ( flag , errmsg , "failure" );
109 //
110 [flag , errmsg] = assert_checkequal(complex(%nan,%inf),complex(0,%inf));
111 checkassert ( flag , errmsg , "failure" );
112 //
113 [flag , errmsg] = assert_checkequal(complex(0,%inf),complex(0,%inf));
114 checkassert ( flag , errmsg , "success" );
115 //
116 [flag , errmsg] = assert_checkequal(complex(%nan,%nan),complex(%nan,%nan));
117 checkassert ( flag , errmsg , "success" );
118 //
119 [flag , errmsg] = assert_checkequal(complex(%inf,%nan),complex(%inf,%nan));
120 checkassert ( flag , errmsg , "success" );
121 //
122 ////////////////////////////////////////////////////////
123 // Check various types
124 ////////////////////////////////////////////////////////
125 //
126 // Lists
127 // -----
128 assert_checkequal(list(), list());
129 assert_checkequal(list([]), list([]));
130 assert_checkequal(list(list()), list(list()));
131 assert_checkequal(list(%nan), list(%nan));
132 assert_checkequal(list(1,,3), list(1,,3));
133 assert_checkequal(list(1,,%nan+%i), list(1,,%nan+%i));
134 s = list(1,,list(2,,4));
135 assert_checkequal(s, s);
136 s = list("foo",2);
137 assert_checkequal(s, s);
138 s = list(1,list(,%nan,,2),,%nan,1);
139 assert_checkequal(s, s);
140 ierr = execstr("assert_checkequal(list(2,,7), list(2,%F,8))","errcatch");
141 MY_assert_equal(ierr, 10000);
142 errmsg = lasterror();
143 refmsg = _("%s: Assertion failed: %s  while %s");
144 refmsg = msprintf(refmsg, "assert_checkequal", ..
145     msprintf(_("expected(%d)= "),2) + "F", ..
146     msprintf(_("computed(%d)= "),2) + "(void)");
147 MY_assert_equal( errmsg , refmsg );
148
149 // void
150 // ----
151 assert_checkequal(list(,3)(1), list(,3)(1));
152
153 // Mlist
154 // -----
155 s = mlist(["V","name","value"],["a","b";"c" "d"],[1 2; 3 4]);
156 assert_checkequal(s, s);
157 //
158 // Tlist
159 // -----
160 s = tlist(["V","name","value"],["a","b";"c" "d"],[1 2; 3 4]);
161 assert_checkequal(s, s);
162
163 // Cells
164 // -----
165 assert_checkequal({}, {});
166 o = {1, %f, %z ; "abc" %nan list(,3)};
167 assert_checkequal(o, o);
168 assert_checkequal({%nan}, {%nan});  // http://bugzilla.scilab.org/16274
169 //
170 // Polynomial
171 // ----------
172 s = poly(0,"s");
173 assert_checkequal(s, s);
174 //
175 // Sparse
176 // ------
177 s = spzeros(3,5);
178 assert_checkequal(s, s);
179 assert_checkequal(sparse([]), sparse([]));
180 assert_checkequal(sparse(%nan), sparse(%nan));
181 assert_checkequal(sparse([0 %nan 2]), sparse([0 %nan 2]));
182 t = s;
183 s(1)=12;
184 instr="assert_checkequal(s, t)";
185 ierr=execstr(instr,"errcatch");
186 MY_assert_equal(ierr, 999);
187
188 //
189 // Boolean
190 // -------
191 s=(ones(3,5)==ones(3,5));
192 t=s;
193 assert_checkequal(s, t);
194 //
195 // Sparse Boolean
196 // --------------
197 s=(spzeros(3,5)==spzeros(3,5));
198 t=s;
199 assert_checkequal(s, t);
200 s(1)=%f;
201 instr="assert_checkequal(s, t)";
202 ierr=execstr(instr,"errcatch");
203 MY_assert_equal(ierr, 999);
204
205 //
206 // Integer 8
207 // ---------
208 s=int8(3);
209 t=s;
210 assert_checkequal(s, t);
211 //
212 // String
213 // ------
214 assert_checkequal("", "");
215 s = ["foo" "FOO"];
216 assert_checkequal(s,s);
217 //
218 // Hypermatrix
219 // -----------
220 // - Double
221 s = rand(2,2,2);
222 t = s;
223 assert_checkequal(s,t);
224 // - int8
225 s = int8(rand(2,2,2));
226 t = s;
227 assert_checkequal(s,t);
228 // - wrong type
229 s = rand(2,2,2);
230 t = int8(s);
231 instr="assert_checkequal(s, t)";
232 ierr=execstr(instr,"errcatch");
233 MY_assert_equal(ierr, 10000);
234
235 // Implicit lists
236 // --------------
237 assert_checkequal(1:$, 1:$);
238 assert_checkequal(3:2:$-1, 3:2:$-1);
239 ierr = execstr("assert_checkequal(1:$,2:$)","errcatch");
240 MY_assert_equal(ierr, 10000);
241 errmsg = lasterror();
242 refmsg = _("%s: Assertion failed: expected= %s  while computed= %s");
243 refmsg = msprintf(refmsg, "assert_checkequal", "2:1:$", "1:1:$");
244 MY_assert_equal ( errmsg , refmsg );
245
246 ierr = execstr("assert_checkequal(1:$,1:$-1)","errcatch");
247 MY_assert_equal(ierr, 10000);
248
249 // Primitives
250 // ----------
251 assert_checkequal(sin, sin);
252 sine = sin;
253 assert_checkequal(sin, sine);
254 ierr = execstr("assert_checkequal(sin, cos)","errcatch");
255 MY_assert_equal(ierr, 10000);
256 errmsg = lasterror();
257 refmsg = _("%s: Assertion failed: expected and computed are two distinct built-in functions.");
258 refmsg = msprintf(refmsg, "assert_checkequal");
259 MY_assert_equal ( errmsg , refmsg );
260
261 ierr = execstr("assert_checkequal(sin, sind)","errcatch");
262 MY_assert_equal(ierr, 10000);
263
264 // Scilab functions
265 // ----------------
266 assert_checkequal(sind, sind);
267 sined = sind;
268 assert_checkequal(sind, sined);
269
270 ierr = execstr("assert_checkequal(sind, cosd)","errcatch");
271 MY_assert_equal(ierr, 10000);
272 errmsg = lasterror();
273 refmsg = _("%s: Assertion failed: expected= %s  while computed= %s");
274 refmsg = msprintf(refmsg, "assert_checkequal", "cosd()", "sind()");
275 MY_assert_equal ( errmsg , refmsg );
276
277 ierr = execstr("assert_checkequal(sind, sin)","errcatch");
278 MY_assert_equal(ierr, 10000);
279
280 // Scilab libraries
281 // ----------------
282 assert_checkequal(iolib, iolib);
283 ierr = execstr("assert_checkequal(corelib, iolib)","errcatch");
284 MY_assert_equal(ierr, 10000);
285 errmsg = lasterror();
286 refmsg = _("%s: Assertion failed: expected= %s  while computed= %s");
287 refmsg = msprintf(refmsg, "assert_checkequal", ..
288                    "lib@" + string(iolib)(1), "lib@" + string(corelib)(1));
289 MY_assert_equal( errmsg , refmsg );
290
291 // Graphical handles
292 // -----------------
293 assert_checkequal(gdf(), gdf());
294 assert_checkequal(gda(), gda());
295 assert_checkequal([gdf(),gda()], [gdf(),gda()]);
296 ierr = execstr("assert_checkequal(gdf(), gda())","errcatch");
297 MY_assert_equal(ierr, 10000);
298 errmsg = lasterror();
299 refmsg = _("%s: Assertion failed: expected= %s  while computed= %s");
300 refmsg = msprintf(refmsg, "assert_checkequal", ..
301                    msprintf("Axes(uid:%d)",gda().uid), ..
302                    msprintf("Figure(uid:%d)",gdf().uid));
303 MY_assert_equal( errmsg , refmsg );
304 assert_checkequal([gdf(),gda()], [gdf(),gda()]);
305
306 ierr = execstr("assert_checkequal([gdf(),gda()],[gdf(),gdf()])","errcatch");
307 MY_assert_equal(ierr, 10000);
308 errmsg = lasterror();
309 refmsg = _("%s: Assertion failed: %s  while %s");
310 refmsg = msprintf(refmsg, "assert_checkequal", ..
311     msprintf(_("expected(%d)= "),2) + msprintf("Figure(uid:%d)",gdf().uid), ..
312     msprintf(_("computed(%d)= "),2) + msprintf("Axes(uid:%d)",gda().uid));
313 MY_assert_equal( errmsg , refmsg );
314