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