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