bb8ab17f9ec8e69e5e8818299527d37742faa139
[scilab.git] / scilab / modules / elementary_functions / tests / nonreg_tests / bug_13515.tst
1 // =============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2014 - Scilab Enterprises - Vladislav TRUBKIN
4 //
5 //  This file is distributed under the same license as the Scilab package.
6 // =============================================================================
7 // <-- Non-regression test for bug 13515 -->
8 //
9 // <-- Bugzilla URL -->
10 // http://bugzilla.scilab.org/13515
11 //
12 // <-- Short Description -->
13 // there were wrong results for matrix/hypermatrix with bitset function
14 //
15 // <-- CLI SHELL MODE -->
16
17 clear "checkBitset"
18 function checkBitset(x, pos, v, isOne, typeOfx)
19     if isOne then
20         select typeOfx
21         case 0 // double
22             assert_checkequal(bitset(x, pos), dbRefOne);
23             assert_checkequal(bitset(x, pos, v), dbRefOne);
24         case 8 // uint8
25             assert_checkequal(bitset(x, pos), uint8RefOne);
26             assert_checkequal(bitset(x, pos, v), uint8RefOne);
27         case 16 // uint16
28             assert_checkequal(bitset(x, pos), uint16RefOne);
29             assert_checkequal(bitset(x, pos, v), uint16RefOne);
30         case 32 // uint32
31             assert_checkequal(bitset(x, pos), uint32RefOne);
32             assert_checkequal(bitset(x, pos, v), uint32RefOne);
33         end
34     else
35         select typeOfx
36         case 0
37             assert_checkequal(bitset(x, pos, v), dbRefZero);
38         case 8
39             assert_checkequal(bitset(x, pos, v), uint8RefZero);
40         case 16
41             assert_checkequal(bitset(x, pos, v), uint16RefZero);
42         case 32
43             assert_checkequal(bitset(x, pos, v), uint32RefZero);
44         end
45     end
46 endfunction
47
48 clear "createValues"
49 function [dbValue, dbPos, dbBitValue, ...
50     uint8Value, uint8Pos, uint8BitValue, ...
51     uint16Value, uint16Pos, uint16BitValue, ...
52     uint32Value, uint32Pos, uint32BitValue] = createValues(value, pos, bitValue)
53     // double
54     dbValue = value;
55     dbPos = pos;
56     dbBitValue = bitValue
57     // uint8
58     uint8Value = uint8(value);
59     uint8Pos = uint8(pos);
60     uint8BitValue = uint8(bitValue);
61     // uint16
62     uint16Value = uint16(value);
63     uint16Pos = uint16(pos);
64     uint16BitValue = uint16(bitValue);
65     // uint32
66     uint32Value = uint32(value);
67     uint32Pos = uint32(pos);
68     uint32BitValue = uint32(bitValue);
69 endfunction
70
71 clear "createReference";
72 function [dbRefOne, dbRefZero, ...
73     uint8RefOne, uint8RefZero, ...
74     uint16RefOne, uint16RefZero, ...
75     uint32RefOne, uint32RefZero] = createReference(refOne, refZero)
76     dbRefOne = refOne;
77     dbRefZero = refZero;
78     uint8RefOne = uint8(dbRefOne);
79     uint16RefOne = uint16(dbRefOne);
80     uint32RefOne = uint32(dbRefOne);
81     uint8RefZero = uint8(dbRefZero);
82     uint16RefZero = uint16(dbRefZero);
83     uint32RefZero = uint32(dbRefZero);
84 endfunction
85
86 // check input arguments
87 lstr = gettext("%s: Wrong number of input argument(s): At least %d expected.\n");
88 errmsg = msprintf (lstr, "bitset", 2);
89 assert_checkerror("bitset(1)", errmsg);
90 assert_checkerror("bitset()", errmsg);
91 lstr = gettext("%s: Wrong size for input arguments: Same sizes expected.\n");
92 errmsg = msprintf (lstr, "bitset");
93 assert_checkerror("bitset([], [1, 2])", errmsg);
94 lstr = gettext("%s: Wrong value for input argument #%d: 0 or 1 expected.\n");
95 errmsg = msprintf (lstr, "bitset", 3);
96 assert_checkerror("bitset(1, 1, 3)", errmsg);
97 assert_checkerror("bitset(1, 1, %t)", errmsg);
98 assert_checkerror("bitset([1, 2], [1, 1], [2, 0])", errmsg);
99 assert_checkerror("bitset([1; 2; 3], [1; 1; 1], [0; 0; 4])", errmsg);
100 lstr = gettext("%s: Wrong size for input arguments: Same sizes expected.\n");
101 errmsg = msprintf (lstr, "bitset");
102 assert_checkerror("bitset(1, [1, 2], 1)", errmsg);
103 assert_checkerror("bitset([1, 2], [1, 2, 3], 1)", errmsg);
104 assert_checkerror("bitset([1, 2, 3], [1, 2, 3], 1)", errmsg);
105 lstr = gettext("%s: Wrong type for input argument #%d: Scalar/matrix/hypermatrix of unsigned integers expected.\n");
106 errmsg = msprintf (lstr, "bitset", 1);
107 assert_checkerror("bitset(""1"", 1, 1)", errmsg);
108 assert_checkerror("bitset(poly(0,""s""), 1, 1)", errmsg);
109 assert_checkerror("bitset([1, -1], [1, 0], [1, 0])", errmsg);
110 assert_checkerror("bitset([0.5, 0.2], [1, 0], [1, 0])", errmsg);
111 assert_checkerror("bitset([%t, %t], [1, 0], [1, 0])", errmsg);
112 assert_checkerror("bitset(int32([1, 1]), [1, 0], [1, 0])", errmsg);
113 assert_checkerror("bitset(int16([1, 1]), [1, 0], [1, 0])", errmsg);
114 assert_checkerror("bitset(int8([1, 1]), [1, 0], [1, 0])", errmsg);
115 errmsg = msprintf (lstr, "bitset", 2);
116 assert_checkerror("bitset(1,""1"", 1)", errmsg);
117 assert_checkerror("bitset(1, poly(0,""s""), 1)", errmsg);
118 assert_checkerror("bitset([1, 0], [1, -1], [1, 0])", errmsg);
119 assert_checkerror("bitset([1, 0], [0.5, 0.2], [1, 0])", errmsg);
120 assert_checkerror("bitset([1; 0], [%t; %t], [1; 0])", errmsg);
121 assert_checkerror("bitset([1, 0], int32([1, 1]), [1, 0])", errmsg);
122 assert_checkerror("bitset([1, 0], int16([1, 1]), [1, 0])", errmsg);
123 assert_checkerror("bitset([1, 0], int8([1, 1]), [1, 0])", errmsg);
124 lstr = gettext("%s: Wrong value for input argument #%d: Must be between %d and %d.\n");
125 errmsg = msprintf (lstr, "bitset", 2, 1, 52);
126 assert_checkerror("bitset([1, 0], [1, 53], [1, 0])", errmsg);
127 assert_checkerror("bitset([1, 0], [0, 5], [1, 0])", errmsg);
128 errmsg = msprintf (lstr, "bitset", 2, 1, 8);
129 assert_checkerror("bitset(uint8([1, 0; 1, 0]), [1, 2; 1, 9], [1, 0; 1, 1])", errmsg);
130 assert_checkerror("bitset(uint8([1, 0; 1, 0]), [1, 0; 0, 1], [1, 0; 1, 1])", errmsg);
131 errmsg = msprintf (lstr, "bitset", 2, 1, 16);
132 assert_checkerror("bitset(uint16([1, 0; 1, 0]), [1, 17; 1, 9], [1, 0; 1, 1])", errmsg);
133 assert_checkerror("bitset(uint16([1, 0; 1, 0]), [1, 0; 0, 1], [1, 0; 1, 1])", errmsg);
134 errmsg = msprintf (lstr, "bitset", 2, 1, 32);
135 assert_checkerror("bitset(uint32([1, 0; 1, 0]), [1, 17; 33, 1], [1, 0; 1, 1])", errmsg);
136 assert_checkerror("bitset(uint32([1, 0; 1, 0]), [1, 1; 0, 1], [1, 0; 1, 1])", errmsg);
137
138 // check results
139 // create value to check
140 value = [9, 10, 11, 12, 13, 14, 15];
141 position = [2, 3, 4, 5, 6, 7, 8];
142 bitValue = zeros(1:7);
143 [dbValue, dbPos, dbBitValue, ...
144 uint8Value, uint8Pos, uint8BitValue, ...
145 uint16Value, uint16Pos, uint16BitValue, ...
146 uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
147
148 // create references
149 refOne = [11, 14, 11, 28, 45, 78, 143];
150 refZero = [9, 10, 3, 12, 13, 14, 15];
151 [dbRefOne, dbRefZero, ...
152 uint8RefOne, uint8RefZero, ...
153 uint16RefOne, uint16RefZero, ...
154 uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
155
156 // check only the same types
157 // only double
158 checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
159 checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
160 // only uint8
161 checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
162 checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
163 // only uint16
164 checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
165 checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
166 // only uint32
167 checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
168 checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
169
170 // check mixte types
171 // double
172 checkBitset(dbValue, uint8Pos, dbBitValue + 1, %t, 0);
173 checkBitset(dbValue, uint8Pos, dbBitValue, %f, 0);
174 checkBitset(dbValue, uint8Pos, uint8BitValue, %f, 0);
175 checkBitset(dbValue, uint16Pos, dbBitValue + 1, %t, 0);
176 checkBitset(dbValue, uint16Pos, dbBitValue, %f, 0);
177 checkBitset(dbValue, uint16Pos, uint8BitValue, %f, 0);
178 checkBitset(dbValue, uint32Pos, dbBitValue + 1, %t, 0);
179 checkBitset(dbValue, uint32Pos, dbBitValue, %f, 0);
180 // uint8
181 checkBitset(uint8Value, dbPos, dbBitValue + 1, %t, 8);
182 checkBitset(uint8Value, dbPos, dbBitValue, %f, 8);
183 checkBitset(uint8Value, uint16Pos, uint16BitValue + 1, %t, 8);
184 checkBitset(uint8Value, uint16Pos, dbBitValue, %f, 8);
185 checkBitset(uint8Value, uint32Pos, uint8BitValue, %f, 8);
186 checkBitset(uint8Value, uint32Pos, dbBitValue + 1, %t, 8);
187 // uint16
188 checkBitset(uint16Value, dbPos, dbBitValue + 1, %t, 16);
189 checkBitset(uint16Value, dbPos, dbBitValue, %f, 16);
190 checkBitset(uint16Value, uint8Pos, uint16BitValue + 1, %t, 16);
191 checkBitset(uint16Value, uint8Pos, dbBitValue, %f, 16);
192 checkBitset(uint16Value, uint32Pos, uint8BitValue, %f, 16);
193 checkBitset(uint16Value, uint32Pos, dbBitValue + 1, %t, 16);
194 // uint32
195 checkBitset(uint32Value, dbPos, uint32BitValue + 1, %t, 32);
196 checkBitset(uint32Value, dbPos, uint32BitValue, %f, 32);
197 checkBitset(uint32Value, uint16Pos, uint16BitValue + 1, %t, 32);
198 checkBitset(uint32Value, uint16Pos, dbBitValue, %f, 32);
199 checkBitset(uint32Value, uint8Pos, uint8BitValue, %f, 32);
200 checkBitset(uint32Value, uint8Pos, dbBitValue + 1, %t, 32);
201
202
203 // create value to check
204 value = [4; 5; 6];
205 position = [1; 2; 3];
206 bitValue = zeros(1:3)';
207 [dbValue, dbPos, dbBitValue, ...
208 uint8Value, uint8Pos, uint8BitValue, ...
209 uint16Value, uint16Pos, uint16BitValue, ...
210 uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
211
212 // create references
213 refOne = [5; 7; 6];
214 refZero = [4; 5; 2];
215 [dbRefOne, dbRefZero, ...
216 uint8RefOne, uint8RefZero, ...
217 uint16RefOne, uint16RefZero, ...
218 uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
219
220 // check values
221 // double
222 checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
223 checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
224 // uint8
225 checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
226 checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
227 // uint16
228 checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
229 checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
230 // uint32
231 checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
232 checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
233
234 // create value to check
235 value = [1, 2, 3; 4, 5, 6];
236 position = [2, 2, 2; 3, 3, 3];
237 bitValue = zeros(2, 3);
238 [dbValue, dbPos, dbBitValue, ...
239 uint8Value, uint8Pos, uint8BitValue, ...
240 uint16Value, uint16Pos, uint16BitValue, ...
241 uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
242
243 // create references
244 refOne = [3, 2, 3; 4, 5, 6];
245 refZero = [1, 0, 1; 0, 1, 2];
246 [dbRefOne, dbRefZero, ...
247 uint8RefOne, uint8RefZero, ...
248 uint16RefOne, uint16RefZero, ...
249 uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
250
251 // check values
252 // double
253 checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
254 checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
255 // uint8
256 checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
257 checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
258 // uint16
259 checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
260 checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
261 // uint32
262 checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
263 checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
264
265 // create value to check
266 value = matrix(1:12, [2 3 1 2]);
267 position = ones(value)*3;
268 position(1:6) = 4;
269 bitValue = matrix(zeros(1:12), size(value));
270 [dbValue, dbPos, dbBitValue, ...
271 uint8Value, uint8Pos, uint8BitValue, ...
272 uint16Value, uint16Pos, uint16BitValue, ...
273 uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
274
275 // create references
276 refOne = [9, 10, 11, 12, 13, 14, 7, 12, 13, 14, 15, 12];
277 refZero = [1, 2, 3, 4, 5, 6, 3, 8, 9, 10, 11, 8];
278 refOne = matrix(refOne, [2 3 1 2]);
279 refZero = matrix(refZero, [2 3 1 2]);
280 [dbRefOne, dbRefZero, ...
281 uint8RefOne, uint8RefZero, ...
282 uint16RefOne, uint16RefZero, ...
283 uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
284
285 // check values
286 // double
287 checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
288 checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
289 // uint8
290 checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
291 checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
292 // uint16
293 checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
294 checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
295 // uint32
296 checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
297 checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
298