/home/liu/actions-runner/_work/ccv/ccv/test/unit/io.tests.c
Line | Count | Source (jump to first uncovered line) |
1 | | #include "ccv.h" |
2 | | #include "case.h" |
3 | | #include "ccv_case.h" |
4 | | |
5 | | TEST_CASE("read raw memory, rgb => gray") |
6 | 1 | { |
7 | 1 | unsigned char rgb[] = { |
8 | 1 | 10, 20, 30, 40, 50, 60, 70, |
9 | 1 | 80, 90, 15, 25, 35, 45, 55, |
10 | 1 | }; |
11 | 1 | ccv_dense_matrix_t* x = 0; |
12 | 1 | ccv_read(rgb, &x, CCV_IO_RGB_RAW | CCV_IO_GRAY, 2, 2, 7); |
13 | 1 | unsigned char hx1[] = { |
14 | 1 | 18, 48, |
15 | 1 | }; |
16 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 2, "1st row when reading raw rgb ordered memory block into grayscale matrix doesn't match"); |
17 | 1 | unsigned char hx2[] = { |
18 | 1 | 82, 33, |
19 | 1 | }; |
20 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 2, "2nd row when reading raw rgb ordered memory block into grayscale matrix doesn't match"); |
21 | 1 | ccv_matrix_free(x); |
22 | 1 | } |
23 | | |
24 | | TEST_CASE("read raw memory, rgb => rgb") |
25 | 1 | { |
26 | 1 | unsigned char rgb[] = { |
27 | 1 | 10, 20, 30, 40, 50, 60, 70, |
28 | 1 | 80, 90, 15, 25, 35, 45, 55, |
29 | 1 | }; |
30 | 1 | ccv_dense_matrix_t* x = 0; |
31 | 1 | ccv_read(rgb, &x, CCV_IO_RGB_RAW | CCV_IO_RGB_COLOR, 2, 2, 7); |
32 | 1 | REQUIRE_ARRAY_EQ(unsigned char, rgb, x->data.u8, 6, "1st row when reading raw rgb ordered memory block into rgb matrix doesn't match"); |
33 | 1 | REQUIRE_ARRAY_EQ(unsigned char, rgb + 7, x->data.u8 + x->step, 6, "2nd row when reading raw rgb ordered memory block into rgb matrix doesn't match"); |
34 | 1 | ccv_matrix_free(x); |
35 | 1 | } |
36 | | |
37 | | TEST_CASE("read raw memory, rgba => rgb") |
38 | 1 | { |
39 | 1 | unsigned char rgba[] = { |
40 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
41 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
42 | 1 | }; |
43 | 1 | ccv_dense_matrix_t* x = 0; |
44 | 1 | ccv_read(rgba, &x, CCV_IO_RGBA_RAW | CCV_IO_RGB_COLOR, 2, 2, 9); |
45 | 1 | unsigned char hx1[] = { |
46 | 1 | 10, 20, 30, 50, 60, 70, |
47 | 1 | }; |
48 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 6, "1st row when reading raw rgba memory block into rgb matrix doesn't match"); |
49 | 1 | unsigned char hx2[] = { |
50 | 1 | 15, 25, 35, 55, 65, 75, |
51 | 1 | }; |
52 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 6, "2nd row when reading raw rgba memory block into rgb matrix doesn't match"); |
53 | 1 | ccv_matrix_free(x); |
54 | 1 | } |
55 | | |
56 | | TEST_CASE("read raw memory, rgba => gray") |
57 | 1 | { |
58 | 1 | unsigned char rgba[] = { |
59 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
60 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
61 | 1 | }; |
62 | 1 | ccv_dense_matrix_t* x = 0; |
63 | 1 | ccv_read(rgba, &x, CCV_IO_RGBA_RAW | CCV_IO_GRAY, 2, 2, 9); |
64 | 1 | unsigned char hx1[] = { |
65 | 1 | 18, 58, |
66 | 1 | }; |
67 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 2, "1st row when reading raw rgba memory block into grayscale matrix doesn't match"); |
68 | 1 | unsigned char hx2[] = { |
69 | 1 | 23, 63, |
70 | 1 | }; |
71 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 2, "2nd row when reading raw rgba memory block into grayscale matrix doesn't match"); |
72 | 1 | ccv_matrix_free(x); |
73 | 1 | } |
74 | | |
75 | | TEST_CASE("read raw memory, rgba => rgba") |
76 | 1 | { |
77 | 1 | unsigned char rgba[] = { |
78 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
79 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
80 | 1 | }; |
81 | 1 | ccv_dense_matrix_t* x = 0; |
82 | 1 | ccv_read(rgba, &x, CCV_IO_RGBA_RAW, 2, 2, 9); |
83 | 1 | REQUIRE_ARRAY_EQ(unsigned char, rgba, x->data.u8, 8, "1st row when reading raw rgba memory block into rgba matrix doesn't match"); |
84 | 1 | REQUIRE_ARRAY_EQ(unsigned char, rgba + 9, x->data.u8 + x->step, 8, "2nd row when reading raw rgba memory block into rgba matrix doesn't match"); |
85 | 1 | ccv_matrix_free(x); |
86 | 1 | } |
87 | | |
88 | | TEST_CASE("read raw memory, argb => rgb") |
89 | 1 | { |
90 | 1 | unsigned char argb[] = { |
91 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
92 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
93 | 1 | }; |
94 | 1 | ccv_dense_matrix_t* x = 0; |
95 | 1 | ccv_read(argb, &x, CCV_IO_ARGB_RAW | CCV_IO_RGB_COLOR, 2, 2, 9); |
96 | 1 | unsigned char hx1[] = { |
97 | 1 | 20, 30, 40, 60, 70, 80, |
98 | 1 | }; |
99 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 6, "1st row when reading raw argb memory block into rgb matrix doesn't match"); |
100 | 1 | unsigned char hx2[] = { |
101 | 1 | 25, 35, 45, 65, 75, 85, |
102 | 1 | }; |
103 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 6, "2nd row when reading raw argb memory block into rgb matrix doesn't match"); |
104 | 1 | ccv_matrix_free(x); |
105 | 1 | } |
106 | | |
107 | | TEST_CASE("read raw memory, argb => gray") |
108 | 1 | { |
109 | 1 | unsigned char argb[] = { |
110 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
111 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
112 | 1 | }; |
113 | 1 | ccv_dense_matrix_t* x = 0; |
114 | 1 | ccv_read(argb, &x, CCV_IO_ARGB_RAW | CCV_IO_GRAY, 2, 2, 9); |
115 | 1 | unsigned char hx1[] = { |
116 | 1 | 28, 68, |
117 | 1 | }; |
118 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 2, "1st row when reading raw argb memory block into grayscale matrix doesn't match"); |
119 | 1 | unsigned char hx2[] = { |
120 | 1 | 33, 73, |
121 | 1 | }; |
122 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 2, "2nd row when reading raw argb memory block into grayscale matrix doesn't match"); |
123 | 1 | ccv_matrix_free(x); |
124 | 1 | } |
125 | | |
126 | | TEST_CASE("read raw memory, argb => argb") |
127 | 1 | { |
128 | 1 | unsigned char argb[] = { |
129 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
130 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
131 | 1 | }; |
132 | 1 | ccv_dense_matrix_t* x = 0; |
133 | 1 | ccv_read(argb, &x, CCV_IO_ARGB_RAW, 2, 2, 9); |
134 | 1 | REQUIRE_ARRAY_EQ(unsigned char, argb, x->data.u8, 8, "1st row when reading raw argb memory block into argb matrix doesn't match"); |
135 | 1 | REQUIRE_ARRAY_EQ(unsigned char, argb + 9, x->data.u8 + x->step, 8, "2nd row when reading raw argb memory block into argb matrix doesn't match"); |
136 | 1 | ccv_matrix_free(x); |
137 | 1 | } |
138 | | |
139 | | TEST_CASE("read raw memory, bgr => gray") |
140 | 1 | { |
141 | 1 | unsigned char bgr[] = { |
142 | 1 | 10, 20, 30, 40, 50, 60, 70, |
143 | 1 | 80, 90, 15, 25, 35, 45, 55, |
144 | 1 | }; |
145 | 1 | ccv_dense_matrix_t* x = 0; |
146 | 1 | ccv_read(bgr, &x, CCV_IO_BGR_RAW | CCV_IO_GRAY, 2, 2, 7); |
147 | 1 | unsigned char hx1[] = { |
148 | 1 | 21, 51, |
149 | 1 | }; |
150 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 2, "1st row when reading raw bgr ordered memory block into grayscale matrix doesn't match"); |
151 | 1 | unsigned char hx2[] = { |
152 | 1 | 73, 36, |
153 | 1 | }; |
154 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 2, "2nd row when reading raw bgr ordered memory block into grayscale matrix doesn't match"); |
155 | 1 | ccv_matrix_free(x); |
156 | 1 | } |
157 | | |
158 | | TEST_CASE("read raw memory, bgr => rgb") |
159 | 1 | { |
160 | 1 | unsigned char bgr[] = { |
161 | 1 | 10, 20, 30, 40, 50, 60, 70, |
162 | 1 | 80, 90, 15, 25, 35, 45, 55, |
163 | 1 | }; |
164 | 1 | ccv_dense_matrix_t* x = 0; |
165 | 1 | ccv_read(bgr, &x, CCV_IO_BGR_RAW | CCV_IO_RGB_COLOR, 2, 2, 7); |
166 | 1 | unsigned char hx1[] = { |
167 | 1 | 30, 20, 10, 60, 50, 40, |
168 | 1 | }; |
169 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 6, "1st row when reading raw bgr ordered memory block into rgb matrix doesn't match"); |
170 | 1 | unsigned char hx2[] = { |
171 | 1 | 15, 90, 80, 45, 35, 25, |
172 | 1 | }; |
173 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 6, "2nd row when reading raw bgr ordered memory block into rgb matrix doesn't match"); |
174 | 1 | ccv_matrix_free(x); |
175 | 1 | } |
176 | | |
177 | | TEST_CASE("read raw memory, bgr => bgr") |
178 | 1 | { |
179 | 1 | unsigned char bgr[] = { |
180 | 1 | 10, 20, 30, 40, 50, 60, 70, |
181 | 1 | 80, 90, 15, 25, 35, 45, 55, |
182 | 1 | }; |
183 | 1 | ccv_dense_matrix_t* x = 0; |
184 | 1 | ccv_read(bgr, &x, CCV_IO_BGR_RAW, 2, 2, 7); |
185 | 1 | REQUIRE_ARRAY_EQ(unsigned char, bgr, x->data.u8, 6, "1st row when reading raw bgr ordered memory block into rgb matrix doesn't match"); |
186 | 1 | REQUIRE_ARRAY_EQ(unsigned char, bgr + 7, x->data.u8 + x->step, 6, "2nd row when reading raw bgr ordered memory block into rgb matrix doesn't match"); |
187 | 1 | ccv_matrix_free(x); |
188 | 1 | } |
189 | | |
190 | | TEST_CASE("read raw memory, bgra => rgb") |
191 | 1 | { |
192 | 1 | unsigned char bgra[] = { |
193 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
194 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
195 | 1 | }; |
196 | 1 | ccv_dense_matrix_t* x = 0; |
197 | 1 | ccv_read(bgra, &x, CCV_IO_BGRA_RAW | CCV_IO_RGB_COLOR, 2, 2, 9); |
198 | 1 | unsigned char hx1[] = { |
199 | 1 | 30, 20, 10, 70, 60, 50, |
200 | 1 | }; |
201 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 6, "1st row when reading raw bgra memory block into rgb matrix doesn't match"); |
202 | 1 | unsigned char hx2[] = { |
203 | 1 | 35, 25, 15, 75, 65, 55, |
204 | 1 | }; |
205 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 6, "2nd row when reading raw bgra memory block into rgb matrix doesn't match"); |
206 | 1 | ccv_matrix_free(x); |
207 | 1 | } |
208 | | |
209 | | TEST_CASE("read raw memory, bgra => gray") |
210 | 1 | { |
211 | 1 | unsigned char bgra[] = { |
212 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
213 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
214 | 1 | }; |
215 | 1 | ccv_dense_matrix_t* x = 0; |
216 | 1 | ccv_read(bgra, &x, CCV_IO_BGRA_RAW | CCV_IO_GRAY, 2, 2, 9); |
217 | 1 | unsigned char hx1[] = { |
218 | 1 | 21, 61, |
219 | 1 | }; |
220 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 2, "1st row when reading raw bgra memory block into grayscale matrix doesn't match"); |
221 | 1 | unsigned char hx2[] = { |
222 | 1 | 26, 66, |
223 | 1 | }; |
224 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 2, "2nd row when reading raw bgra memory block into grayscale matrix doesn't match"); |
225 | 1 | ccv_matrix_free(x); |
226 | 1 | } |
227 | | |
228 | | TEST_CASE("read raw memory, bgra => bgra") |
229 | 1 | { |
230 | 1 | unsigned char bgra[] = { |
231 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
232 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
233 | 1 | }; |
234 | 1 | ccv_dense_matrix_t* x = 0; |
235 | 1 | ccv_read(bgra, &x, CCV_IO_BGRA_RAW, 2, 2, 9); |
236 | 1 | REQUIRE_ARRAY_EQ(unsigned char, bgra, x->data.u8, 8, "1st row when reading raw bgra memory block into bgra matrix doesn't match"); |
237 | 1 | REQUIRE_ARRAY_EQ(unsigned char, bgra + 9, x->data.u8 + x->step, 8, "2nd row when reading raw bgra memory block into bgra matrix doesn't match"); |
238 | 1 | ccv_matrix_free(x); |
239 | 1 | } |
240 | | |
241 | | TEST_CASE("read raw memory, abgr => rgb") |
242 | 1 | { |
243 | 1 | unsigned char abgr[] = { |
244 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
245 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
246 | 1 | }; |
247 | 1 | ccv_dense_matrix_t* x = 0; |
248 | 1 | ccv_read(abgr, &x, CCV_IO_ABGR_RAW | CCV_IO_RGB_COLOR, 2, 2, 9); |
249 | 1 | unsigned char hx1[] = { |
250 | 1 | 40, 30, 20, 80, 70, 60, |
251 | 1 | }; |
252 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 6, "1st row when reading raw abgr memory block into rgb matrix doesn't match"); |
253 | 1 | unsigned char hx2[] = { |
254 | 1 | 45, 35, 25, 85, 75, 65, |
255 | 1 | }; |
256 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 6, "2nd row when reading raw abgr memory block into rgb matrix doesn't match"); |
257 | 1 | ccv_matrix_free(x); |
258 | 1 | } |
259 | | |
260 | | TEST_CASE("read raw memory, abgr => gray") |
261 | 1 | { |
262 | 1 | unsigned char abgr[] = { |
263 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
264 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
265 | 1 | }; |
266 | 1 | ccv_dense_matrix_t* x = 0; |
267 | 1 | ccv_read(abgr, &x, CCV_IO_ABGR_RAW | CCV_IO_GRAY, 2, 2, 9); |
268 | 1 | unsigned char hx1[] = { |
269 | 1 | 31, 71, |
270 | 1 | }; |
271 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 2, "1st row when reading raw abgr memory block into grayscale matrix doesn't match"); |
272 | 1 | unsigned char hx2[] = { |
273 | 1 | 36, 76, |
274 | 1 | }; |
275 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 2, "2nd row when reading raw abgr memory block into grayscale matrix doesn't match"); |
276 | 1 | ccv_matrix_free(x); |
277 | 1 | } |
278 | | |
279 | | TEST_CASE("read raw memory, abgr => abgr") |
280 | 1 | { |
281 | 1 | unsigned char abgr[] = { |
282 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
283 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
284 | 1 | }; |
285 | 1 | ccv_dense_matrix_t* x = 0; |
286 | 1 | ccv_read(abgr, &x, CCV_IO_ABGR_RAW, 2, 2, 9); |
287 | 1 | REQUIRE_ARRAY_EQ(unsigned char, abgr, x->data.u8, 8, "1st row when reading raw abgr memory block into abgr matrix doesn't match"); |
288 | 1 | REQUIRE_ARRAY_EQ(unsigned char, abgr + 9, x->data.u8 + x->step, 8, "2nd row when reading raw abgr memory block into abgr matrix doesn't match"); |
289 | 1 | ccv_matrix_free(x); |
290 | 1 | } |
291 | | |
292 | | TEST_CASE("read raw memory, gray => rgb") |
293 | 1 | { |
294 | 1 | unsigned char g[] = { |
295 | 1 | 10, 20, 30, 40, 50, |
296 | 1 | 15, 25, 35, 45, 55, |
297 | 1 | }; |
298 | 1 | ccv_dense_matrix_t* x = 0; |
299 | 1 | ccv_read(g, &x, CCV_IO_GRAY_RAW | CCV_IO_RGB_COLOR, 2, 2, 5); |
300 | 1 | unsigned char hx1[] = { |
301 | 1 | 10, 10, 10, 20, 20, 20, |
302 | 1 | }; |
303 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx1, x->data.u8, 6, "1st row when reading raw grayscale memory block into rgb matrix doesn't match"); |
304 | 1 | unsigned char hx2[] = { |
305 | 1 | 15, 15, 15, 25, 25, 25, |
306 | 1 | }; |
307 | 1 | REQUIRE_ARRAY_EQ(unsigned char, hx2, x->data.u8 + x->step, 6, "2nd row when reading raw grayscale memory block into rgb matrix doesn't match"); |
308 | 1 | ccv_matrix_free(x); |
309 | 1 | } |
310 | | |
311 | | TEST_CASE("read raw memory, gray => gray") |
312 | 1 | { |
313 | 1 | unsigned char g[] = { |
314 | 1 | 10, 20, 30, 40, 50, |
315 | 1 | 15, 25, 35, 45, 55, |
316 | 1 | }; |
317 | 1 | ccv_dense_matrix_t* x = 0; |
318 | 1 | ccv_read(g, &x, CCV_IO_GRAY_RAW | CCV_IO_GRAY, 2, 2, 5); |
319 | 1 | REQUIRE_ARRAY_EQ(unsigned char, g, x->data.u8, 2, "1st row when reading raw grayscale memory block into grayscale matrix doesn't match"); |
320 | 1 | REQUIRE_ARRAY_EQ(unsigned char, g + 5, x->data.u8 + x->step, 2, "2nd row when reading raw grayscale memory block into grayscale matrix doesn't match"); |
321 | 1 | ccv_matrix_free(x); |
322 | 1 | } |
323 | | |
324 | | TEST_CASE("read raw memory with no copy mode") |
325 | 1 | { |
326 | 1 | unsigned char rgb[] = { |
327 | 1 | 10, 20, 30, 40, 50, 60, 70, 80, 90, |
328 | 1 | 15, 25, 35, 45, 55, 65, 75, 85, 95, |
329 | 1 | }; |
330 | 1 | ccv_dense_matrix_t* x = 0; |
331 | 1 | ccv_read(rgb, &x, CCV_IO_ANY_RAW | CCV_IO_NO_COPY, 2, 2, 9); |
332 | 1 | REQUIRE_EQ(9, x->step, "its step value should be equal to the passing scanline value in no copy mode"); |
333 | 1 | REQUIRE(rgb == x->data.u8, "its data section should point to the same memory region"); |
334 | 1 | ccv_matrix_free(x); |
335 | 1 | } |
336 | | |
337 | | #ifdef HAVE_LIBJPEG |
338 | | TEST_CASE("read JPEG from memory") |
339 | 1 | { |
340 | 1 | ccv_dense_matrix_t* x = 0; |
341 | 1 | ccv_read("../../samples/cmyk-jpeg-format.jpg", &x, CCV_IO_ANY_FILE); |
342 | 1 | ccv_dense_matrix_t* y = 0; |
343 | 1 | FILE* rb = fopen("../../samples/cmyk-jpeg-format.jpg", "rb"); |
344 | 1 | fseek(rb, 0, SEEK_END); |
345 | 1 | long size = ftell(rb); |
346 | 1 | char* data = (char*)ccmalloc(size); |
347 | 1 | fseek(rb, 0, SEEK_SET); |
348 | 1 | fread(data, 1, size, rb); |
349 | 1 | fclose(rb); |
350 | 1 | ccv_read(data, &y, CCV_IO_ANY_STREAM, size); |
351 | 1 | ccfree(data); |
352 | 1 | REQUIRE_MATRIX_EQ(x, y, "read cmyk-jpeg-format.jpg from file system and memory should be the same"); |
353 | 1 | ccv_matrix_free(y); |
354 | 1 | ccv_matrix_free(x); |
355 | 1 | } |
356 | | #endif |
357 | | |
358 | | #ifdef HAVE_LIBPNG |
359 | | TEST_CASE("read PNG from memory") |
360 | 1 | { |
361 | 1 | ccv_dense_matrix_t* x = 0; |
362 | 1 | ccv_read("../../samples/nature.png", &x, CCV_IO_ANY_FILE); |
363 | 1 | ccv_dense_matrix_t* y = 0; |
364 | 1 | FILE* rb = fopen("../../samples/nature.png", "rb"); |
365 | 1 | fseek(rb, 0, SEEK_END); |
366 | 1 | long size = ftell(rb); |
367 | 1 | char* data = (char*)ccmalloc(size); |
368 | 1 | fseek(rb, 0, SEEK_SET); |
369 | 1 | fread(data, 1, size, rb); |
370 | 1 | fclose(rb); |
371 | 1 | ccv_read(data, &y, CCV_IO_ANY_STREAM, size); |
372 | 1 | ccfree(data); |
373 | 1 | REQUIRE_MATRIX_EQ(x, y, "read nature.png from file system and memory should be the same"); |
374 | 1 | ccv_matrix_free(y); |
375 | 1 | ccv_matrix_free(x); |
376 | 1 | } |
377 | | #endif |
378 | | |
379 | | #ifdef HAVE_LIBJPEG |
380 | | TEST_CASE("write JPEG to memory") |
381 | 1 | { |
382 | 1 | char sanitized_test_case_name[1024] = "/tmp/"; |
383 | 1 | strncpy(sanitized_test_case_name + 5, __case_name__, 1024 - 5); |
384 | 1 | int i; |
385 | 16 | for (i = 10; i < 1024 && sanitized_test_case_name[i]; i++15 ) |
386 | | // If not A-Za-z0-9, replace with _ |
387 | 15 | if (!((sanitized_test_case_name[i] >= 'A' && sanitized_test_case_name[i] <= 'Z'12 ) || |
388 | 15 | (11 sanitized_test_case_name[i] >= 'a'11 && sanitized_test_case_name[i] <= 'z'8 ) || |
389 | 15 | (3 sanitized_test_case_name[i] >= '0'3 && sanitized_test_case_name[i] <= '9'0 ))) |
390 | 3 | sanitized_test_case_name[i] = '_'; |
391 | 1 | assert(i < 1024); |
392 | 1 | sanitized_test_case_name[i] = '.'; |
393 | 1 | sanitized_test_case_name[i + 1] = 'j'; |
394 | 1 | sanitized_test_case_name[i + 2] = 'p'; |
395 | 1 | sanitized_test_case_name[i + 3] = 'g'; |
396 | 1 | sanitized_test_case_name[i + 4] = 0; |
397 | 1 | ccv_dense_matrix_t* x = 0; |
398 | 1 | ccv_read("../../samples/nature.png", &x, CCV_IO_ANY_FILE); |
399 | 1 | char* data = (char*)ccmalloc(x->rows * x->cols * 2); |
400 | 1 | size_t len = x->rows * x->cols * 2; |
401 | 1 | ccv_write(x, data, &len, CCV_IO_JPEG_STREAM, 0); |
402 | 1 | ccv_write(x, sanitized_test_case_name, 0, CCV_IO_JPEG_FILE, 0); |
403 | 1 | assert(len < x->rows * x->cols * 2); |
404 | 1 | ccv_dense_matrix_t* y = 0; |
405 | 1 | ccv_read(data, &y, CCV_IO_ANY_STREAM, len); |
406 | 1 | ccfree(data); |
407 | 1 | ccv_dense_matrix_t* z = 0; |
408 | 1 | ccv_read(sanitized_test_case_name, &z, CCV_IO_ANY_FILE, 0); |
409 | 1 | FILE* fd = fopen(sanitized_test_case_name, "rb"); |
410 | 1 | fseek(fd, 0L, SEEK_END); |
411 | 1 | size_t fsz = ftell(fd); |
412 | 1 | fclose(fd); |
413 | 1 | REQUIRE_EQ(fsz, len, "size of both memory and file should be the same"); |
414 | 1 | REQUIRE_MATRIX_EQ(y, z, "write nature.png to JPEG in file system and memory should be the same"); |
415 | 1 | ccv_matrix_free(z); |
416 | 1 | ccv_matrix_free(y); |
417 | 1 | ccv_matrix_free(x); |
418 | 1 | } |
419 | | |
420 | | TEST_CASE("write JPEG to memory fail at small memory allocation") |
421 | 1 | { |
422 | 1 | ccv_dense_matrix_t* x = 0; |
423 | 1 | ccv_read("../../samples/nature.png", &x, CCV_IO_ANY_FILE); |
424 | 1 | char* data = (char*)ccmalloc(100); |
425 | 1 | size_t len = 100; |
426 | 1 | int error = ccv_write(x, data, &len, CCV_IO_JPEG_STREAM, 0); |
427 | 1 | REQUIRE_EQ(error, CCV_IO_ERROR, "fail at write the file"); |
428 | 1 | ccfree(data); |
429 | 1 | ccv_matrix_free(x); |
430 | 1 | } |
431 | | #endif |
432 | | |
433 | | #ifdef HAVE_LIBPNG |
434 | | TEST_CASE("write PNG to memory") |
435 | 1 | { |
436 | 1 | char sanitized_test_case_name[1024] = "/tmp/"; |
437 | 1 | strncpy(sanitized_test_case_name + 5, __case_name__, 1024 - 5); |
438 | 1 | int i; |
439 | 15 | for (i = 10; i < 1024 && sanitized_test_case_name[i]; i++14 ) |
440 | | // If not A-Za-z0-9, replace with _ |
441 | 14 | if (!((sanitized_test_case_name[i] >= 'A' && sanitized_test_case_name[i] <= 'Z'11 ) || |
442 | 14 | (11 sanitized_test_case_name[i] >= 'a'11 && sanitized_test_case_name[i] <= 'z'8 ) || |
443 | 14 | (3 sanitized_test_case_name[i] >= '0'3 && sanitized_test_case_name[i] <= '9'0 ))) |
444 | 3 | sanitized_test_case_name[i] = '_'; |
445 | 1 | assert(i < 1024); |
446 | 1 | sanitized_test_case_name[i] = '.'; |
447 | 1 | sanitized_test_case_name[i + 1] = 'p'; |
448 | 1 | sanitized_test_case_name[i + 2] = 'n'; |
449 | 1 | sanitized_test_case_name[i + 3] = 'g'; |
450 | 1 | sanitized_test_case_name[i + 4] = 0; |
451 | 1 | ccv_dense_matrix_t* x = 0; |
452 | 1 | ccv_read("../../samples/nature.png", &x, CCV_IO_ANY_FILE); |
453 | 1 | char* data = (char*)ccmalloc(x->rows * x->cols * 2); |
454 | 1 | size_t len = x->rows * x->cols * 2; |
455 | 1 | ccv_write(x, data, &len, CCV_IO_PNG_STREAM, 0); |
456 | 1 | ccv_write(x, sanitized_test_case_name, 0, CCV_IO_PNG_FILE, 0); |
457 | 1 | assert(len < x->rows * x->cols * 2); |
458 | 1 | ccv_dense_matrix_t* y = 0; |
459 | 1 | ccv_read(data, &y, CCV_IO_ANY_STREAM, len); |
460 | 1 | ccfree(data); |
461 | 1 | ccv_dense_matrix_t* z = 0; |
462 | 1 | ccv_read(sanitized_test_case_name, &z, CCV_IO_ANY_FILE, 0); |
463 | 1 | FILE* fd = fopen(sanitized_test_case_name, "rb"); |
464 | 1 | fseek(fd, 0L, SEEK_END); |
465 | 1 | size_t fsz = ftell(fd); |
466 | 1 | fclose(fd); |
467 | 1 | REQUIRE_EQ(fsz, len, "size of both memory and file should be the same"); |
468 | 1 | REQUIRE_MATRIX_EQ(y, z, "write nature.png to PNG in file system and memory should be the same"); |
469 | 1 | ccv_matrix_free(z); |
470 | 1 | ccv_matrix_free(y); |
471 | 1 | ccv_matrix_free(x); |
472 | 1 | } |
473 | | |
474 | | TEST_CASE("write PNG to memory fail at small memory allocation") |
475 | 1 | { |
476 | 1 | ccv_dense_matrix_t* x = 0; |
477 | 1 | ccv_read("../../samples/nature.png", &x, CCV_IO_ANY_FILE); |
478 | 1 | char* data = (char*)ccmalloc(100); |
479 | 1 | size_t len = 100; |
480 | 1 | int error = ccv_write(x, data, &len, CCV_IO_PNG_STREAM, 0); |
481 | 1 | REQUIRE_EQ(error, CCV_IO_ERROR, "fail at write the file"); |
482 | 1 | ccfree(data); |
483 | 1 | ccv_matrix_free(x); |
484 | 1 | } |
485 | | #endif |
486 | | |
487 | | #ifdef HAVE_LIBPNG |
488 | | TEST_CASE("write binary to memory") |
489 | 1 | { |
490 | 1 | char sanitized_test_case_name[1024] = "/tmp/"; |
491 | 1 | strncpy(sanitized_test_case_name + 5, __case_name__, 1024 - 5); |
492 | 1 | int i; |
493 | 18 | for (i = 10; i < 1024 && sanitized_test_case_name[i]; i++17 ) |
494 | | // If not A-Za-z0-9, replace with _ |
495 | 17 | if (!((sanitized_test_case_name[i] >= 'A' && sanitized_test_case_name[i] <= 'Z'14 ) || |
496 | 17 | (sanitized_test_case_name[i] >= 'a' && sanitized_test_case_name[i] <= 'z'14 ) || |
497 | 17 | (3 sanitized_test_case_name[i] >= '0'3 && sanitized_test_case_name[i] <= '9'0 ))) |
498 | 3 | sanitized_test_case_name[i] = '_'; |
499 | 1 | assert(i < 1024); |
500 | 1 | sanitized_test_case_name[i] = '.'; |
501 | 1 | sanitized_test_case_name[i + 1] = 'b'; |
502 | 1 | sanitized_test_case_name[i + 2] = 'i'; |
503 | 1 | sanitized_test_case_name[i + 3] = 'n'; |
504 | 1 | sanitized_test_case_name[i + 4] = 0; |
505 | 1 | ccv_dense_matrix_t* x = 0; |
506 | 1 | ccv_read("../../samples/nature.png", &x, CCV_IO_ANY_FILE); |
507 | 1 | char* data = (char*)ccmalloc(x->rows * x->cols * 4); |
508 | 1 | size_t len = x->rows * x->cols * 4; |
509 | 1 | ccv_write(x, data, &len, CCV_IO_PLAIN_STREAM, 0); |
510 | 1 | ccv_write(x, sanitized_test_case_name, 0, CCV_IO_BINARY_FILE, 0); |
511 | 1 | assert(len < x->rows * x->cols * 4); |
512 | 1 | ccv_dense_matrix_t* y = 0; |
513 | 1 | ccv_read(data, &y, CCV_IO_ANY_STREAM, len); |
514 | 1 | ccfree(data); |
515 | 1 | ccv_dense_matrix_t* z = 0; |
516 | 1 | ccv_read(sanitized_test_case_name, &z, CCV_IO_ANY_FILE, 0); |
517 | 1 | FILE* fd = fopen(sanitized_test_case_name, "rb"); |
518 | 1 | fseek(fd, 0L, SEEK_END); |
519 | 1 | size_t fsz = ftell(fd); |
520 | 1 | fclose(fd); |
521 | 1 | REQUIRE_EQ(fsz, len, "size of both memory and file should be the same"); |
522 | 1 | REQUIRE_MATRIX_EQ(y, z, "write nature.png to binary in file system and memory should be the same"); |
523 | 1 | ccv_matrix_free(z); |
524 | 1 | ccv_matrix_free(y); |
525 | 1 | ccv_matrix_free(x); |
526 | 1 | } |
527 | | |
528 | | TEST_CASE("write binary to memory fail at small memory allocation") |
529 | 1 | { |
530 | 1 | ccv_dense_matrix_t* x = 0; |
531 | 1 | ccv_read("../../samples/nature.png", &x, CCV_IO_ANY_FILE); |
532 | 1 | char* data = (char*)ccmalloc(100); |
533 | 1 | size_t len = 100; |
534 | 1 | int error = ccv_write(x, data, &len, CCV_IO_PLAIN_STREAM, 0); |
535 | 1 | REQUIRE_EQ(error, CCV_IO_ERROR, "fail at write the file"); |
536 | 1 | ccfree(data); |
537 | 1 | ccv_matrix_free(x); |
538 | 1 | } |
539 | | #endif |
540 | | |
541 | | #include "case_main.h" |