1 /* test_libFLAC - Unit tester for libFLAC
2 * Copyright (C) 2002-2009 Josh Coalson
3 * Copyright (C) 2011-2023 Xiph.Org Foundation
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23
24 #include "FLAC/assert.h"
25 #include "FLAC/metadata.h"
26 #include "test_libs_common/metadata_utils.h"
27 #include "share/compat.h"
28 #include "metadata.h"
29 #include <stdio.h>
30 #include <stdlib.h> /* for malloc() */
31 #include <string.h> /* for memcmp() */
32
make_dummydata_(FLAC__byte * dummydata,uint32_t len)33 static FLAC__byte *make_dummydata_(FLAC__byte *dummydata, uint32_t len)
34 {
35 FLAC__byte *ret;
36
37 if(0 == (ret = malloc(len))) {
38 printf("FAILED, malloc error\n");
39 exit(1);
40 }
41 else
42 memcpy(ret, dummydata, len);
43
44 return ret;
45 }
46
compare_track_(const FLAC__StreamMetadata_CueSheet_Track * from,const FLAC__StreamMetadata_CueSheet_Track * to)47 static FLAC__bool compare_track_(const FLAC__StreamMetadata_CueSheet_Track *from, const FLAC__StreamMetadata_CueSheet_Track *to)
48 {
49 uint32_t i;
50
51 if(from->offset != to->offset) {
52 printf("FAILED, track offset mismatch, expected %" PRIu64 ", got %" PRIu64 "\n", to->offset, from->offset);
53 return false;
54 }
55 if(from->number != to->number) {
56 printf("FAILED, track number mismatch, expected %u, got %u\n", (uint32_t)to->number, (uint32_t)from->number);
57 return false;
58 }
59 if(0 != strcmp(from->isrc, to->isrc)) {
60 printf("FAILED, track number mismatch, expected %s, got %s\n", to->isrc, from->isrc);
61 return false;
62 }
63 if(from->type != to->type) {
64 printf("FAILED, track type mismatch, expected %u, got %u\n", (uint32_t)to->type, (uint32_t)from->type);
65 return false;
66 }
67 if(from->pre_emphasis != to->pre_emphasis) {
68 printf("FAILED, track pre_emphasis mismatch, expected %u, got %u\n", (uint32_t)to->pre_emphasis, (uint32_t)from->pre_emphasis);
69 return false;
70 }
71 if(from->num_indices != to->num_indices) {
72 printf("FAILED, track num_indices mismatch, expected %u, got %u\n", (uint32_t)to->num_indices, (uint32_t)from->num_indices);
73 return false;
74 }
75 if(0 == to->indices || 0 == from->indices) {
76 if(to->indices != from->indices) {
77 printf("FAILED, track indices mismatch\n");
78 return false;
79 }
80 }
81 else {
82 for(i = 0; i < to->num_indices; i++) {
83 if(from->indices[i].offset != to->indices[i].offset) {
84 printf("FAILED, track indices[%u].offset mismatch, expected %" PRIu64 ", got %" PRIu64 "\n", i, to->indices[i].offset, from->indices[i].offset);
85 return false;
86 }
87 if(from->indices[i].number != to->indices[i].number) {
88 printf("FAILED, track indices[%u].number mismatch, expected %u, got %u\n", i, (uint32_t)to->indices[i].number, (uint32_t)from->indices[i].number);
89 return false;
90 }
91 }
92 }
93
94 return true;
95 }
96
compare_seekpoint_array_(const FLAC__StreamMetadata_SeekPoint * from,const FLAC__StreamMetadata_SeekPoint * to,uint32_t n)97 static FLAC__bool compare_seekpoint_array_(const FLAC__StreamMetadata_SeekPoint *from, const FLAC__StreamMetadata_SeekPoint *to, uint32_t n)
98 {
99 uint32_t i;
100
101 FLAC__ASSERT(0 != from);
102 FLAC__ASSERT(0 != to);
103
104 for(i = 0; i < n; i++) {
105 if(from[i].sample_number != to[i].sample_number) {
106 printf("FAILED, point[%u].sample_number mismatch, expected %" PRIu64 ", got %" PRIu64 "\n", i, to[i].sample_number, from[i].sample_number);
107 return false;
108 }
109 if(from[i].stream_offset != to[i].stream_offset) {
110 printf("FAILED, point[%u].stream_offset mismatch, expected %" PRIu64 ", got %" PRIu64 "\n", i, to[i].stream_offset, from[i].stream_offset);
111 return false;
112 }
113 if(from[i].frame_samples != to[i].frame_samples) {
114 printf("FAILED, point[%u].frame_samples mismatch, expected %u, got %u\n", i, to[i].frame_samples, from[i].frame_samples);
115 return false;
116 }
117 }
118
119 return true;
120 }
121
check_seektable_(const FLAC__StreamMetadata * block,uint32_t num_points,const FLAC__StreamMetadata_SeekPoint * array)122 static FLAC__bool check_seektable_(const FLAC__StreamMetadata *block, uint32_t num_points, const FLAC__StreamMetadata_SeekPoint *array)
123 {
124 const uint32_t expected_length = num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
125
126 if(block->length != expected_length) {
127 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
128 return false;
129 }
130 if(block->data.seek_table.num_points != num_points) {
131 printf("FAILED, expected %u point, got %u\n", num_points, block->data.seek_table.num_points);
132 return false;
133 }
134 if(0 == array) {
135 if(0 != block->data.seek_table.points) {
136 printf("FAILED, 'points' pointer is not null\n");
137 return false;
138 }
139 }
140 else {
141 if(!compare_seekpoint_array_(block->data.seek_table.points, array, num_points))
142 return false;
143 }
144 printf("OK\n");
145
146 return true;
147 }
148
entry_new_(FLAC__StreamMetadata_VorbisComment_Entry * entry,const char * field)149 static void entry_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field)
150 {
151 entry->length = strlen(field);
152 entry->entry = malloc(entry->length+1);
153 FLAC__ASSERT(0 != entry->entry);
154 memcpy(entry->entry, field, entry->length);
155 entry->entry[entry->length] = '\0';
156 }
157
entry_clone_(FLAC__StreamMetadata_VorbisComment_Entry * entry)158 static void entry_clone_(FLAC__StreamMetadata_VorbisComment_Entry *entry)
159 {
160 FLAC__byte *x = malloc(entry->length+1);
161 FLAC__ASSERT(0 != x);
162 memcpy(x, entry->entry, entry->length);
163 x[entry->length] = '\0';
164 entry->entry = x;
165 }
166
vc_calc_len_(FLAC__StreamMetadata * block)167 static void vc_calc_len_(FLAC__StreamMetadata *block)
168 {
169 const FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
170 uint32_t i;
171
172 block->length = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
173 block->length += vc->vendor_string.length;
174 block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
175 for(i = 0; i < vc->num_comments; i++) {
176 block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
177 block->length += vc->comments[i].length;
178 }
179 }
180
vc_resize_(FLAC__StreamMetadata * block,uint32_t num)181 static void vc_resize_(FLAC__StreamMetadata *block, uint32_t num)
182 {
183 FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
184
185 if(vc->num_comments != 0) {
186 FLAC__ASSERT(0 != vc->comments);
187 if(num < vc->num_comments) {
188 uint32_t i;
189 for(i = num; i < vc->num_comments; i++) {
190 if(0 != vc->comments[i].entry)
191 free(vc->comments[i].entry);
192 }
193 }
194 }
195 if(num == 0) {
196 if(0 != vc->comments) {
197 free(vc->comments);
198 vc->comments = 0;
199 }
200 }
201 else {
202 uint32_t i;
203 vc->comments = realloc(vc->comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*num);
204 FLAC__ASSERT(0 != vc->comments);
205 for(i = vc->num_comments; i < num; i++) {
206 vc->comments[i].length = 0;
207 vc->comments[i].entry = malloc(1);
208 vc->comments[i].entry[0] = '\0';
209 }
210 }
211
212 vc->num_comments = num;
213 vc_calc_len_(block);
214 }
215
vc_find_from_(FLAC__StreamMetadata * block,const char * name,uint32_t start)216 static int vc_find_from_(FLAC__StreamMetadata *block, const char *name, uint32_t start)
217 {
218 const uint32_t n = strlen(name);
219 uint32_t i;
220 for(i = start; i < block->data.vorbis_comment.num_comments; i++) {
221 const FLAC__StreamMetadata_VorbisComment_Entry *entry = &block->data.vorbis_comment.comments[i];
222 if(entry->length > n && 0 == strncmp((const char *)entry->entry, name, n) && entry->entry[n] == '=')
223 return (int)i;
224 }
225 return -1;
226 }
227
vc_set_vs_new_(FLAC__StreamMetadata_VorbisComment_Entry * entry,FLAC__StreamMetadata * block,const char * field)228 static void vc_set_vs_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field)
229 {
230 if(0 != block->data.vorbis_comment.vendor_string.entry)
231 free(block->data.vorbis_comment.vendor_string.entry);
232 entry_new_(entry, field);
233 block->data.vorbis_comment.vendor_string = *entry;
234 vc_calc_len_(block);
235 }
236
vc_set_new_(FLAC__StreamMetadata_VorbisComment_Entry * entry,FLAC__StreamMetadata * block,uint32_t pos,const char * field)237 static void vc_set_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, uint32_t pos, const char *field)
238 {
239 if(0 != block->data.vorbis_comment.comments[pos].entry)
240 free(block->data.vorbis_comment.comments[pos].entry);
241 entry_new_(entry, field);
242 block->data.vorbis_comment.comments[pos] = *entry;
243 vc_calc_len_(block);
244 }
245
vc_insert_new_(FLAC__StreamMetadata_VorbisComment_Entry * entry,FLAC__StreamMetadata * block,uint32_t pos,const char * field)246 static void vc_insert_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, uint32_t pos, const char *field)
247 {
248 FLAC__StreamMetadata_VorbisComment_Entry temp;
249 vc_resize_(block, block->data.vorbis_comment.num_comments+1);
250 temp = block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1];
251 memmove(&block->data.vorbis_comment.comments[pos+1], &block->data.vorbis_comment.comments[pos], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(block->data.vorbis_comment.num_comments-1-pos));
252 block->data.vorbis_comment.comments[pos] = temp;
253 vc_set_new_(entry, block, pos, field);
254 vc_calc_len_(block);
255 }
256
vc_delete_(FLAC__StreamMetadata * block,uint32_t pos)257 static void vc_delete_(FLAC__StreamMetadata *block, uint32_t pos)
258 {
259 if(0 != block->data.vorbis_comment.comments[pos].entry)
260 free(block->data.vorbis_comment.comments[pos].entry);
261 memmove(&block->data.vorbis_comment.comments[pos], &block->data.vorbis_comment.comments[pos+1], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(block->data.vorbis_comment.num_comments-pos-1));
262 block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].entry = 0;
263 block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].length = 0;
264 vc_resize_(block, block->data.vorbis_comment.num_comments-1);
265 vc_calc_len_(block);
266 }
267
vc_replace_new_(FLAC__StreamMetadata_VorbisComment_Entry * entry,FLAC__StreamMetadata * block,const char * field,FLAC__bool all)268 static void vc_replace_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field, FLAC__bool all)
269 {
270 int indx;
271 char field_name[256];
272 const char *eq = strchr(field, '=');
273 FLAC__ASSERT(eq>field && (uint32_t)(eq-field) < sizeof(field_name));
274 memcpy(field_name, field, eq-field);
275 field_name[eq-field]='\0';
276
277 indx = vc_find_from_(block, field_name, 0);
278 if(indx < 0)
279 vc_insert_new_(entry, block, block->data.vorbis_comment.num_comments, field);
280 else {
281 vc_set_new_(entry, block, (uint32_t)indx, field);
282 if(all) {
283 for(indx = indx+1; indx >= 0 && (uint32_t)indx < block->data.vorbis_comment.num_comments; )
284 if((indx = vc_find_from_(block, field_name, (uint32_t)indx)) >= 0)
285 vc_delete_(block, (uint32_t)indx);
286 }
287 }
288
289 vc_calc_len_(block);
290 }
291
track_new_(FLAC__StreamMetadata_CueSheet_Track * track,FLAC__uint64 offset,FLAC__byte number,const char * isrc,FLAC__bool data,FLAC__bool pre_em)292 static void track_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em)
293 {
294 track->offset = offset;
295 track->number = number;
296 memcpy(track->isrc, isrc, sizeof(track->isrc));
297 track->type = data;
298 track->pre_emphasis = pre_em;
299 track->num_indices = 0;
300 track->indices = 0;
301 }
302
track_clone_(FLAC__StreamMetadata_CueSheet_Track * track)303 static void track_clone_(FLAC__StreamMetadata_CueSheet_Track *track)
304 {
305 if(track->num_indices > 0) {
306 size_t bytes = sizeof(FLAC__StreamMetadata_CueSheet_Index) * track->num_indices;
307 FLAC__StreamMetadata_CueSheet_Index *x = malloc(bytes);
308 FLAC__ASSERT(0 != x);
309 memcpy(x, track->indices, bytes);
310 track->indices = x;
311 }
312 }
313
cs_calc_len_(FLAC__StreamMetadata * block)314 static void cs_calc_len_(FLAC__StreamMetadata *block)
315 {
316 const FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
317 uint32_t i;
318
319 block->length = (
320 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
321 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
322 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
323 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
324 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
325 ) / 8;
326 block->length += cs->num_tracks * (
327 FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
328 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
329 FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
330 FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
331 FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
332 FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
333 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
334 ) / 8;
335 for(i = 0; i < cs->num_tracks; i++) {
336 block->length += cs->tracks[i].num_indices * (
337 FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
338 FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
339 FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
340 ) / 8;
341 }
342 }
343
tr_resize_(FLAC__StreamMetadata * block,uint32_t track_num,uint32_t num)344 static void tr_resize_(FLAC__StreamMetadata *block, uint32_t track_num, uint32_t num)
345 {
346 FLAC__StreamMetadata_CueSheet_Track *tr;
347
348 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
349
350 tr = &block->data.cue_sheet.tracks[track_num];
351
352 if(tr->num_indices != 0) {
353 FLAC__ASSERT(0 != tr->indices);
354 }
355 if(num == 0) {
356 if(0 != tr->indices) {
357 free(tr->indices);
358 tr->indices = 0;
359 }
360 }
361 else {
362 tr->indices = realloc(tr->indices, sizeof(FLAC__StreamMetadata_CueSheet_Index)*num);
363 FLAC__ASSERT(0 != tr->indices);
364 if(num > tr->num_indices)
365 memset(tr->indices+tr->num_indices, 0, sizeof(FLAC__StreamMetadata_CueSheet_Index)*(num-tr->num_indices));
366 }
367
368 tr->num_indices = num;
369 cs_calc_len_(block);
370 }
371
tr_set_new_(FLAC__StreamMetadata * block,uint32_t track_num,uint32_t pos,FLAC__StreamMetadata_CueSheet_Index indx)372 static void tr_set_new_(FLAC__StreamMetadata *block, uint32_t track_num, uint32_t pos, FLAC__StreamMetadata_CueSheet_Index indx)
373 {
374 FLAC__StreamMetadata_CueSheet_Track *tr;
375
376 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
377
378 tr = &block->data.cue_sheet.tracks[track_num];
379
380 FLAC__ASSERT(pos < tr->num_indices);
381
382 tr->indices[pos] = indx;
383
384 cs_calc_len_(block);
385 }
386
tr_insert_new_(FLAC__StreamMetadata * block,uint32_t track_num,uint32_t pos,FLAC__StreamMetadata_CueSheet_Index indx)387 static void tr_insert_new_(FLAC__StreamMetadata *block, uint32_t track_num, uint32_t pos, FLAC__StreamMetadata_CueSheet_Index indx)
388 {
389 FLAC__StreamMetadata_CueSheet_Track *tr;
390
391 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
392
393 tr = &block->data.cue_sheet.tracks[track_num];
394
395 FLAC__ASSERT(pos <= tr->num_indices);
396
397 tr_resize_(block, track_num, tr->num_indices+1);
398 memmove(&tr->indices[pos+1], &tr->indices[pos], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-1-pos));
399 tr_set_new_(block, track_num, pos, indx);
400 cs_calc_len_(block);
401 }
402
tr_delete_(FLAC__StreamMetadata * block,uint32_t track_num,uint32_t pos)403 static void tr_delete_(FLAC__StreamMetadata *block, uint32_t track_num, uint32_t pos)
404 {
405 FLAC__StreamMetadata_CueSheet_Track *tr;
406
407 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
408
409 tr = &block->data.cue_sheet.tracks[track_num];
410
411 FLAC__ASSERT(pos <= tr->num_indices);
412
413 memmove(&tr->indices[pos], &tr->indices[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-pos-1));
414 tr_resize_(block, track_num, tr->num_indices-1);
415 cs_calc_len_(block);
416 }
417
cs_resize_(FLAC__StreamMetadata * block,uint32_t num)418 static void cs_resize_(FLAC__StreamMetadata *block, uint32_t num)
419 {
420 FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
421
422 if(cs->num_tracks != 0) {
423 FLAC__ASSERT(0 != cs->tracks);
424 if(num < cs->num_tracks) {
425 uint32_t i;
426 for(i = num; i < cs->num_tracks; i++) {
427 if(0 != cs->tracks[i].indices)
428 free(cs->tracks[i].indices);
429 }
430 }
431 }
432 if(num == 0) {
433 if(0 != cs->tracks) {
434 free(cs->tracks);
435 cs->tracks = 0;
436 }
437 }
438 else {
439 cs->tracks = realloc(cs->tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track)*num);
440 FLAC__ASSERT(0 != cs->tracks);
441 if(num > cs->num_tracks)
442 memset(cs->tracks+cs->num_tracks, 0, sizeof(FLAC__StreamMetadata_CueSheet_Track)*(num-cs->num_tracks));
443 }
444
445 cs->num_tracks = num;
446 cs_calc_len_(block);
447 }
448
cs_set_new_(FLAC__StreamMetadata_CueSheet_Track * track,FLAC__StreamMetadata * block,uint32_t pos,FLAC__uint64 offset,FLAC__byte number,const char * isrc,FLAC__bool data,FLAC__bool pre_em)449 static void cs_set_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__StreamMetadata *block, uint32_t pos, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em)
450 {
451 track_new_(track, offset, number, isrc, data, pre_em);
452 block->data.cue_sheet.tracks[pos] = *track;
453 cs_calc_len_(block);
454 }
455
cs_insert_new_(FLAC__StreamMetadata_CueSheet_Track * track,FLAC__StreamMetadata * block,uint32_t pos,FLAC__uint64 offset,FLAC__byte number,const char * isrc,FLAC__bool data,FLAC__bool pre_em)456 static void cs_insert_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__StreamMetadata *block, uint32_t pos, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em)
457 {
458 cs_resize_(block, block->data.cue_sheet.num_tracks+1);
459 memmove(&block->data.cue_sheet.tracks[pos+1], &block->data.cue_sheet.tracks[pos], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(block->data.cue_sheet.num_tracks-1-pos));
460 cs_set_new_(track, block, pos, offset, number, isrc, data, pre_em);
461 cs_calc_len_(block);
462 }
463
cs_delete_(FLAC__StreamMetadata * block,uint32_t pos)464 static void cs_delete_(FLAC__StreamMetadata *block, uint32_t pos)
465 {
466 if(0 != block->data.cue_sheet.tracks[pos].indices)
467 free(block->data.cue_sheet.tracks[pos].indices);
468 memmove(&block->data.cue_sheet.tracks[pos], &block->data.cue_sheet.tracks[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(block->data.cue_sheet.num_tracks-pos-1));
469 block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].indices = 0;
470 block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].num_indices = 0;
471 cs_resize_(block, block->data.cue_sheet.num_tracks-1);
472 cs_calc_len_(block);
473 }
474
pi_set_mime_type(FLAC__StreamMetadata * block,const char * s)475 static void pi_set_mime_type(FLAC__StreamMetadata *block, const char *s)
476 {
477 if(block->data.picture.mime_type) {
478 block->length -= strlen(block->data.picture.mime_type);
479 free(block->data.picture.mime_type);
480 }
481 block->data.picture.mime_type = strdup(s);
482 FLAC__ASSERT(block->data.picture.mime_type);
483 block->length += strlen(block->data.picture.mime_type);
484 }
485
pi_set_description(FLAC__StreamMetadata * block,const FLAC__byte * s)486 static void pi_set_description(FLAC__StreamMetadata *block, const FLAC__byte *s)
487 {
488 if(block->data.picture.description) {
489 block->length -= strlen((const char *)block->data.picture.description);
490 free(block->data.picture.description);
491 }
492 block->data.picture.description = (FLAC__byte*)strdup((const char *)s);
493 FLAC__ASSERT(block->data.picture.description);
494 block->length += strlen((const char *)block->data.picture.description);
495 }
496
pi_set_data(FLAC__StreamMetadata * block,const FLAC__byte * data,FLAC__uint32 len)497 static void pi_set_data(FLAC__StreamMetadata *block, const FLAC__byte *data, FLAC__uint32 len)
498 {
499 if(block->data.picture.data) {
500 block->length -= block->data.picture.data_length;
501 free(block->data.picture.data);
502 }
503 block->data.picture.data = (FLAC__byte*)strdup((const char *)data);
504 FLAC__ASSERT(block->data.picture.data);
505 block->data.picture.data_length = len;
506 block->length += len;
507 }
508
test_metadata_object(void)509 FLAC__bool test_metadata_object(void)
510 {
511 FLAC__StreamMetadata *block, *blockcopy, *vorbiscomment, *cuesheet, *picture;
512 FLAC__StreamMetadata_SeekPoint seekpoint_array[14];
513 FLAC__StreamMetadata_VorbisComment_Entry entry;
514 FLAC__StreamMetadata_CueSheet_Index indx;
515 FLAC__StreamMetadata_CueSheet_Track track;
516 uint32_t i, expected_length, seekpoints;
517 int j;
518 static FLAC__byte dummydata[4] = { 'a', 'b', 'c', 'd' };
519
520 printf("\n+++ libFLAC unit test: metadata objects\n\n");
521
522
523 printf("testing STREAMINFO\n");
524
525 printf("testing FLAC__metadata_object_new()... ");
526 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_STREAMINFO);
527 if(0 == block) {
528 printf("FAILED, returned NULL\n");
529 return false;
530 }
531 expected_length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
532 if(block->length != expected_length) {
533 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
534 return false;
535 }
536 printf("OK\n");
537
538 printf("testing FLAC__metadata_object_clone()... ");
539 blockcopy = FLAC__metadata_object_clone(block);
540 if(0 == blockcopy) {
541 printf("FAILED, returned NULL\n");
542 return false;
543 }
544 if(!mutils__compare_block(block, blockcopy))
545 return false;
546 printf("OK\n");
547
548 printf("testing FLAC__metadata_object_delete()... ");
549 FLAC__metadata_object_delete(blockcopy);
550 FLAC__metadata_object_delete(block);
551 printf("OK\n");
552
553
554 printf("testing PADDING\n");
555
556 printf("testing FLAC__metadata_object_new()... ");
557 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
558 if(0 == block) {
559 printf("FAILED, returned NULL\n");
560 return false;
561 }
562 expected_length = 0;
563 if(block->length != expected_length) {
564 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
565 return false;
566 }
567 printf("OK\n");
568
569 printf("testing FLAC__metadata_object_clone()... ");
570 blockcopy = FLAC__metadata_object_clone(block);
571 if(0 == blockcopy) {
572 printf("FAILED, returned NULL\n");
573 return false;
574 }
575 if(!mutils__compare_block(block, blockcopy))
576 return false;
577 printf("OK\n");
578
579 printf("testing FLAC__metadata_object_delete()... ");
580 FLAC__metadata_object_delete(blockcopy);
581 FLAC__metadata_object_delete(block);
582 printf("OK\n");
583
584
585 printf("testing APPLICATION\n");
586
587 printf("testing FLAC__metadata_object_new()... ");
588 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION);
589 if(0 == block) {
590 printf("FAILED, returned NULL\n");
591 return false;
592 }
593 expected_length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
594 if(block->length != expected_length) {
595 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
596 return false;
597 }
598 printf("OK\n");
599
600 printf("testing FLAC__metadata_object_clone()... ");
601 blockcopy = FLAC__metadata_object_clone(block);
602 if(0 == blockcopy) {
603 printf("FAILED, returned NULL\n");
604 return false;
605 }
606 if(!mutils__compare_block(block, blockcopy))
607 return false;
608 printf("OK\n");
609
610 printf("testing FLAC__metadata_object_delete()... ");
611 FLAC__metadata_object_delete(blockcopy);
612 printf("OK\n");
613
614 printf("testing FLAC__metadata_object_application_set_data(copy)... ");
615 if(!FLAC__metadata_object_application_set_data(block, dummydata, sizeof(dummydata), true/*copy*/)) {
616 printf("FAILED, returned false\n");
617 return false;
618 }
619 expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
620 if(block->length != expected_length) {
621 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
622 return false;
623 }
624 if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
625 printf("FAILED, data mismatch\n");
626 return false;
627 }
628 printf("OK\n");
629
630 printf("testing FLAC__metadata_object_clone()... ");
631 blockcopy = FLAC__metadata_object_clone(block);
632 if(0 == blockcopy) {
633 printf("FAILED, returned NULL\n");
634 return false;
635 }
636 if(!mutils__compare_block(block, blockcopy))
637 return false;
638 printf("OK\n");
639
640 printf("testing FLAC__metadata_object_delete()... ");
641 FLAC__metadata_object_delete(blockcopy);
642 printf("OK\n");
643
644 printf("testing FLAC__metadata_object_application_set_data(own)... ");
645 if(!FLAC__metadata_object_application_set_data(block, make_dummydata_(dummydata, sizeof(dummydata)), sizeof(dummydata), false/*own*/)) {
646 printf("FAILED, returned false\n");
647 return false;
648 }
649 expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
650 if(block->length != expected_length) {
651 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
652 return false;
653 }
654 if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
655 printf("FAILED, data mismatch\n");
656 return false;
657 }
658 printf("OK\n");
659
660 printf("testing FLAC__metadata_object_clone()... ");
661 blockcopy = FLAC__metadata_object_clone(block);
662 if(0 == blockcopy) {
663 printf("FAILED, returned NULL\n");
664 return false;
665 }
666 if(!mutils__compare_block(block, blockcopy))
667 return false;
668 printf("OK\n");
669
670 printf("testing FLAC__metadata_object_delete()... ");
671 FLAC__metadata_object_delete(blockcopy);
672 FLAC__metadata_object_delete(block);
673 printf("OK\n");
674
675
676 printf("testing SEEKTABLE\n");
677
678 for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
679 seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
680 seekpoint_array[i].stream_offset = 0;
681 seekpoint_array[i].frame_samples = 0;
682 }
683
684 seekpoints = 0;
685 printf("testing FLAC__metadata_object_new()... ");
686 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
687 if(0 == block) {
688 printf("FAILED, returned NULL\n");
689 return false;
690 }
691 if(!check_seektable_(block, seekpoints, 0))
692 return false;
693
694 printf("testing FLAC__metadata_object_clone()... ");
695 blockcopy = FLAC__metadata_object_clone(block);
696 if(0 == blockcopy) {
697 printf("FAILED, returned NULL\n");
698 return false;
699 }
700 if(!mutils__compare_block(block, blockcopy))
701 return false;
702 printf("OK\n");
703
704 printf("testing FLAC__metadata_object_delete()... ");
705 FLAC__metadata_object_delete(blockcopy);
706 printf("OK\n");
707
708 seekpoints = 2;
709 printf("testing FLAC__metadata_object_seektable_resize_points(grow to %u)...", seekpoints);
710 if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
711 printf("FAILED, returned false\n");
712 return false;
713 }
714 if(!check_seektable_(block, seekpoints, seekpoint_array))
715 return false;
716
717 seekpoints = 1;
718 printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
719 if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
720 printf("FAILED, returned false\n");
721 return false;
722 }
723 if(!check_seektable_(block, seekpoints, seekpoint_array))
724 return false;
725
726 printf("testing FLAC__metadata_object_seektable_is_legal()...");
727 if(!FLAC__metadata_object_seektable_is_legal(block)) {
728 printf("FAILED, returned false\n");
729 return false;
730 }
731 printf("OK\n");
732
733 seekpoints = 0;
734 printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
735 if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
736 printf("FAILED, returned false\n");
737 return false;
738 }
739 if(!check_seektable_(block, seekpoints, 0))
740 return false;
741
742 seekpoints++;
743 printf("testing FLAC__metadata_object_seektable_insert_point() on empty array...");
744 if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
745 printf("FAILED, returned false\n");
746 return false;
747 }
748 if(!check_seektable_(block, seekpoints, seekpoint_array))
749 return false;
750
751 seekpoint_array[0].sample_number = 1;
752 seekpoints++;
753 printf("testing FLAC__metadata_object_seektable_insert_point() on beginning of non-empty array...");
754 if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
755 printf("FAILED, returned false\n");
756 return false;
757 }
758 if(!check_seektable_(block, seekpoints, seekpoint_array))
759 return false;
760
761 seekpoint_array[1].sample_number = 2;
762 seekpoints++;
763 printf("testing FLAC__metadata_object_seektable_insert_point() on middle of non-empty array...");
764 if(!FLAC__metadata_object_seektable_insert_point(block, 1, seekpoint_array[1])) {
765 printf("FAILED, returned false\n");
766 return false;
767 }
768 if(!check_seektable_(block, seekpoints, seekpoint_array))
769 return false;
770
771 seekpoint_array[3].sample_number = 3;
772 seekpoints++;
773 printf("testing FLAC__metadata_object_seektable_insert_point() on end of non-empty array...");
774 if(!FLAC__metadata_object_seektable_insert_point(block, 3, seekpoint_array[3])) {
775 printf("FAILED, returned false\n");
776 return false;
777 }
778 if(!check_seektable_(block, seekpoints, seekpoint_array))
779 return false;
780
781 printf("testing FLAC__metadata_object_clone()... ");
782 blockcopy = FLAC__metadata_object_clone(block);
783 if(0 == blockcopy) {
784 printf("FAILED, returned NULL\n");
785 return false;
786 }
787 if(!mutils__compare_block(block, blockcopy))
788 return false;
789 printf("OK\n");
790
791 printf("testing FLAC__metadata_object_delete()... ");
792 FLAC__metadata_object_delete(blockcopy);
793 printf("OK\n");
794
795 seekpoint_array[2].sample_number = seekpoint_array[3].sample_number;
796 seekpoints--;
797 printf("testing FLAC__metadata_object_seektable_delete_point() on middle of array...");
798 if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
799 printf("FAILED, returned false\n");
800 return false;
801 }
802 if(!check_seektable_(block, seekpoints, seekpoint_array))
803 return false;
804
805 seekpoints--;
806 printf("testing FLAC__metadata_object_seektable_delete_point() on end of array...");
807 if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
808 printf("FAILED, returned false\n");
809 return false;
810 }
811 if(!check_seektable_(block, seekpoints, seekpoint_array))
812 return false;
813
814 seekpoints--;
815 printf("testing FLAC__metadata_object_seektable_delete_point() on beginning of array...");
816 if(!FLAC__metadata_object_seektable_delete_point(block, 0)) {
817 printf("FAILED, returned false\n");
818 return false;
819 }
820 if(!check_seektable_(block, seekpoints, seekpoint_array+1))
821 return false;
822
823 printf("testing FLAC__metadata_object_seektable_set_point()...");
824 FLAC__metadata_object_seektable_set_point(block, 0, seekpoint_array[0]);
825 if(!check_seektable_(block, seekpoints, seekpoint_array))
826 return false;
827
828 printf("testing FLAC__metadata_object_delete()... ");
829 FLAC__metadata_object_delete(block);
830 printf("OK\n");
831
832 /* seektable template functions */
833
834 for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
835 seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
836 seekpoint_array[i].stream_offset = 0;
837 seekpoint_array[i].frame_samples = 0;
838 }
839
840 seekpoints = 0;
841 printf("testing FLAC__metadata_object_new()... ");
842 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
843 if(0 == block) {
844 printf("FAILED, returned NULL\n");
845 return false;
846 }
847 if(!check_seektable_(block, seekpoints, 0))
848 return false;
849
850 seekpoints += 2;
851 printf("testing FLAC__metadata_object_seekpoint_template_append_placeholders()... ");
852 if(!FLAC__metadata_object_seektable_template_append_placeholders(block, 2)) {
853 printf("FAILED, returned false\n");
854 return false;
855 }
856 if(!check_seektable_(block, seekpoints, seekpoint_array))
857 return false;
858
859 seekpoint_array[seekpoints++].sample_number = 7;
860 printf("testing FLAC__metadata_object_seekpoint_template_append_point()... ");
861 if(!FLAC__metadata_object_seektable_template_append_point(block, 7)) {
862 printf("FAILED, returned false\n");
863 return false;
864 }
865 if(!check_seektable_(block, seekpoints, seekpoint_array))
866 return false;
867
868 {
869 FLAC__uint64 nums[2] = { 3, 7 };
870 seekpoint_array[seekpoints++].sample_number = nums[0];
871 seekpoint_array[seekpoints++].sample_number = nums[1];
872 printf("testing FLAC__metadata_object_seekpoint_template_append_points()... ");
873 if(!FLAC__metadata_object_seektable_template_append_points(block, nums, sizeof(nums)/sizeof(FLAC__uint64))) {
874 printf("FAILED, returned false\n");
875 return false;
876 }
877 if(!check_seektable_(block, seekpoints, seekpoint_array))
878 return false;
879 }
880
881 seekpoint_array[seekpoints++].sample_number = 0;
882 seekpoint_array[seekpoints++].sample_number = 10;
883 seekpoint_array[seekpoints++].sample_number = 20;
884 printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points()... ");
885 if(!FLAC__metadata_object_seektable_template_append_spaced_points(block, 3, 30)) {
886 printf("FAILED, returned false\n");
887 return false;
888 }
889 if(!check_seektable_(block, seekpoints, seekpoint_array))
890 return false;
891
892 seekpoints--;
893 seekpoint_array[0].sample_number = 0;
894 seekpoint_array[1].sample_number = 3;
895 seekpoint_array[2].sample_number = 7;
896 seekpoint_array[3].sample_number = 10;
897 seekpoint_array[4].sample_number = 20;
898 seekpoint_array[5].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
899 seekpoint_array[6].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
900 printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=true)... ");
901 if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/true)) {
902 printf("FAILED, returned false\n");
903 return false;
904 }
905 if(!FLAC__metadata_object_seektable_is_legal(block)) {
906 printf("FAILED, seek table is illegal\n");
907 return false;
908 }
909 if(!check_seektable_(block, seekpoints, seekpoint_array))
910 return false;
911
912 printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=false)... ");
913 if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/false)) {
914 printf("FAILED, returned false\n");
915 return false;
916 }
917 if(!FLAC__metadata_object_seektable_is_legal(block)) {
918 printf("FAILED, seek table is illegal\n");
919 return false;
920 }
921 if(!check_seektable_(block, seekpoints, seekpoint_array))
922 return false;
923
924 seekpoint_array[seekpoints++].sample_number = 0;
925 seekpoint_array[seekpoints++].sample_number = 10;
926 seekpoint_array[seekpoints++].sample_number = 20;
927 printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points_by_samples()... ");
928 if(!FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(block, 10, 30)) {
929 printf("FAILED, returned false\n");
930 return false;
931 }
932 if(!check_seektable_(block, seekpoints, seekpoint_array))
933 return false;
934
935 seekpoint_array[seekpoints++].sample_number = 0;
936 seekpoint_array[seekpoints++].sample_number = 11;
937 seekpoint_array[seekpoints++].sample_number = 22;
938 printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points_by_samples()... ");
939 if(!FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(block, 11, 30)) {
940 printf("FAILED, returned false\n");
941 return false;
942 }
943 if(!check_seektable_(block, seekpoints, seekpoint_array))
944 return false;
945
946 printf("testing FLAC__metadata_object_delete()... ");
947 FLAC__metadata_object_delete(block);
948 printf("OK\n");
949
950
951 printf("testing VORBIS_COMMENT\n");
952
953 {
954 FLAC__StreamMetadata_VorbisComment_Entry entry_;
955 char *field_name, *field_value;
956
957 printf("testing FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair()... ");
958 if(!FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry_, "name", "value")) {
959 printf("FAILED, returned false\n");
960 return false;
961 }
962 if(strcmp((const char *)entry_.entry, "name=value")) {
963 printf("FAILED, field mismatch\n");
964 return false;
965 }
966 printf("OK\n");
967
968 printf("testing FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair()... ");
969 if(!FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(entry_, &field_name, &field_value)) {
970 printf("FAILED, returned false\n");
971 return false;
972 }
973 if(strcmp(field_name, "name")) {
974 printf("FAILED, field name mismatch\n");
975 return false;
976 }
977 if(strcmp(field_value, "value")) {
978 printf("FAILED, field value mismatch\n");
979 return false;
980 }
981 printf("OK\n");
982
983 printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... ");
984 if(!FLAC__metadata_object_vorbiscomment_entry_matches(entry_, field_name, strlen(field_name))) {
985 printf("FAILED, expected true, returned false\n");
986 return false;
987 }
988 printf("OK\n");
989
990 printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... ");
991 if(FLAC__metadata_object_vorbiscomment_entry_matches(entry_, "blah", strlen("blah"))) {
992 printf("FAILED, expected false, returned true\n");
993 return false;
994 }
995 printf("OK\n");
996
997 free(entry_.entry);
998 free(field_name);
999 free(field_value);
1000 }
1001
1002 printf("testing FLAC__metadata_object_new()... ");
1003 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
1004 if(0 == block) {
1005 printf("FAILED, returned NULL\n");
1006 return false;
1007 }
1008 expected_length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + strlen(FLAC__VENDOR_STRING) + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN/8);
1009 if(block->length != expected_length) {
1010 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
1011 return false;
1012 }
1013 printf("OK\n");
1014
1015 printf("testing FLAC__metadata_object_clone()... ");
1016 vorbiscomment = FLAC__metadata_object_clone(block);
1017 if(0 == vorbiscomment) {
1018 printf("FAILED, returned NULL\n");
1019 return false;
1020 }
1021 if(!mutils__compare_block(vorbiscomment, block))
1022 return false;
1023 printf("OK\n");
1024
1025 vc_resize_(vorbiscomment, 2);
1026 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(grow to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
1027 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
1028 printf("FAILED, returned false\n");
1029 return false;
1030 }
1031 if(!mutils__compare_block(vorbiscomment, block))
1032 return false;
1033 printf("OK\n");
1034
1035 vc_resize_(vorbiscomment, 1);
1036 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
1037 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
1038 printf("FAILED, returned false\n");
1039 return false;
1040 }
1041 if(!mutils__compare_block(vorbiscomment, block))
1042 return false;
1043 printf("OK\n");
1044
1045 vc_resize_(vorbiscomment, 0);
1046 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
1047 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
1048 printf("FAILED, returned false\n");
1049 return false;
1050 }
1051 if(!mutils__compare_block(vorbiscomment, block))
1052 return false;
1053 printf("OK\n");
1054
1055 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on empty array...");
1056 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
1057 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
1058 printf("FAILED, returned false\n");
1059 return false;
1060 }
1061 if(!mutils__compare_block(vorbiscomment, block))
1062 return false;
1063 printf("OK\n");
1064
1065 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
1066 vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2");
1067 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
1068 printf("FAILED, returned false\n");
1069 return false;
1070 }
1071 if(!mutils__compare_block(vorbiscomment, block))
1072 return false;
1073 printf("OK\n");
1074
1075 vc_resize_(vorbiscomment, 0);
1076 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
1077 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
1078 printf("FAILED, returned false\n");
1079 return false;
1080 }
1081 if(!mutils__compare_block(vorbiscomment, block))
1082 return false;
1083 printf("OK\n");
1084
1085 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on empty array...");
1086 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
1087 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
1088 printf("FAILED, returned false\n");
1089 return false;
1090 }
1091 if(!mutils__compare_block(vorbiscomment, block))
1092 return false;
1093 printf("OK\n");
1094
1095 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on beginning of non-empty array...");
1096 vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
1097 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
1098 printf("FAILED, returned false\n");
1099 return false;
1100 }
1101 if(!mutils__compare_block(vorbiscomment, block))
1102 return false;
1103 printf("OK\n");
1104
1105 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on middle of non-empty array...");
1106 vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
1107 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/true)) {
1108 printf("FAILED, returned false\n");
1109 return false;
1110 }
1111 if(!mutils__compare_block(vorbiscomment, block))
1112 return false;
1113 printf("OK\n");
1114
1115 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
1116 vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
1117 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/true)) {
1118 printf("FAILED, returned false\n");
1119 return false;
1120 }
1121 if(!mutils__compare_block(vorbiscomment, block))
1122 return false;
1123 printf("OK\n");
1124
1125 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
1126 vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1");
1127 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/true)) {
1128 printf("FAILED, returned false\n");
1129 return false;
1130 }
1131 if(!mutils__compare_block(vorbiscomment, block))
1132 return false;
1133 printf("OK\n");
1134
1135 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
1136 vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1");
1137 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/true)) {
1138 printf("FAILED, returned false\n");
1139 return false;
1140 }
1141 if(!mutils__compare_block(vorbiscomment, block))
1142 return false;
1143 printf("OK\n");
1144
1145 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
1146 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name3")) != 1) {
1147 printf("FAILED, expected 1, got %d\n", j);
1148 return false;
1149 }
1150 printf("OK\n");
1151
1152 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
1153 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 4) {
1154 printf("FAILED, expected 4, got %d\n", j);
1155 return false;
1156 }
1157 printf("OK\n");
1158
1159 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
1160 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 5) {
1161 printf("FAILED, expected 5, got %d\n", j);
1162 return false;
1163 }
1164 printf("OK\n");
1165
1166 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
1167 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name2")) != 0) {
1168 printf("FAILED, expected 0, got %d\n", j);
1169 return false;
1170 }
1171 printf("OK\n");
1172
1173 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
1174 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name2")) != -1) {
1175 printf("FAILED, expected -1, got %d\n", j);
1176 return false;
1177 }
1178 printf("OK\n");
1179
1180 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
1181 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "blah")) != -1) {
1182 printf("FAILED, expected -1, got %d\n", j);
1183 return false;
1184 }
1185 printf("OK\n");
1186
1187 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, copy)...");
1188 vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false);
1189 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/true)) {
1190 printf("FAILED, returned false\n");
1191 return false;
1192 }
1193 if(!mutils__compare_block(vorbiscomment, block))
1194 return false;
1195 if(block->data.vorbis_comment.num_comments != 6) {
1196 printf("FAILED, expected 6 comments, got %u\n", block->data.vorbis_comment.num_comments);
1197 return false;
1198 }
1199 printf("OK\n");
1200
1201 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, copy)...");
1202 vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true);
1203 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/true)) {
1204 printf("FAILED, returned false\n");
1205 return false;
1206 }
1207 if(!mutils__compare_block(vorbiscomment, block))
1208 return false;
1209 if(block->data.vorbis_comment.num_comments != 4) {
1210 printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments);
1211 return false;
1212 }
1213 printf("OK\n");
1214
1215 printf("testing FLAC__metadata_object_clone()... ");
1216 blockcopy = FLAC__metadata_object_clone(block);
1217 if(0 == blockcopy) {
1218 printf("FAILED, returned NULL\n");
1219 return false;
1220 }
1221 if(!mutils__compare_block(block, blockcopy))
1222 return false;
1223 printf("OK\n");
1224
1225 printf("testing FLAC__metadata_object_delete()... ");
1226 FLAC__metadata_object_delete(blockcopy);
1227 printf("OK\n");
1228
1229 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
1230 vc_delete_(vorbiscomment, 2);
1231 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
1232 printf("FAILED, returned false\n");
1233 return false;
1234 }
1235 if(!mutils__compare_block(vorbiscomment, block))
1236 return false;
1237 printf("OK\n");
1238
1239 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
1240 vc_delete_(vorbiscomment, 2);
1241 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
1242 printf("FAILED, returned false\n");
1243 return false;
1244 }
1245 if(!mutils__compare_block(vorbiscomment, block))
1246 return false;
1247 printf("OK\n");
1248
1249 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
1250 vc_delete_(vorbiscomment, 0);
1251 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
1252 printf("FAILED, returned false\n");
1253 return false;
1254 }
1255 if(!mutils__compare_block(vorbiscomment, block))
1256 return false;
1257 printf("OK\n");
1258
1259 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
1260 vc_insert_new_(&entry, vorbiscomment, 1, "rem0=val0");
1261 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
1262 printf("FAILED, returned false\n");
1263 return false;
1264 }
1265 if(!mutils__compare_block(vorbiscomment, block))
1266 return false;
1267 printf("OK\n");
1268
1269 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
1270 vc_insert_new_(&entry, vorbiscomment, 2, "rem0=val1");
1271 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
1272 printf("FAILED, returned false\n");
1273 return false;
1274 }
1275 if(!mutils__compare_block(vorbiscomment, block))
1276 return false;
1277 printf("OK\n");
1278
1279 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
1280 vc_insert_new_(&entry, vorbiscomment, 3, "rem0=val2");
1281 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
1282 printf("FAILED, returned false\n");
1283 return false;
1284 }
1285 if(!mutils__compare_block(vorbiscomment, block))
1286 return false;
1287 printf("OK\n");
1288
1289 printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching(\"blah\")...");
1290 if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "blah")) != 0) {
1291 printf("FAILED, expected 0, got %d\n", j);
1292 return false;
1293 }
1294 if(block->data.vorbis_comment.num_comments != 4) {
1295 printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments);
1296 return false;
1297 }
1298 if(!mutils__compare_block(vorbiscomment, block))
1299 return false;
1300 printf("OK\n");
1301
1302 printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching(\"rem0\")...");
1303 vc_delete_(vorbiscomment, 1);
1304 if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "rem0")) != 1) {
1305 printf("FAILED, expected 1, got %d\n", j);
1306 return false;
1307 }
1308 if(block->data.vorbis_comment.num_comments != 3) {
1309 printf("FAILED, expected 3 comments, got %u\n", block->data.vorbis_comment.num_comments);
1310 return false;
1311 }
1312 if(!mutils__compare_block(vorbiscomment, block))
1313 return false;
1314 printf("OK\n");
1315
1316 printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching(\"blah\")...");
1317 if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "blah")) != 0) {
1318 printf("FAILED, expected 0, got %d\n", j);
1319 return false;
1320 }
1321 if(block->data.vorbis_comment.num_comments != 3) {
1322 printf("FAILED, expected 3 comments, got %u\n", block->data.vorbis_comment.num_comments);
1323 return false;
1324 }
1325 if(!mutils__compare_block(vorbiscomment, block))
1326 return false;
1327 printf("OK\n");
1328
1329 printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching(\"rem0\")...");
1330 vc_delete_(vorbiscomment, 1);
1331 vc_delete_(vorbiscomment, 1);
1332 if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "rem0")) != 2) {
1333 printf("FAILED, expected 2, got %d\n", j);
1334 return false;
1335 }
1336 if(block->data.vorbis_comment.num_comments != 1) {
1337 printf("FAILED, expected 1 comments, got %u\n", block->data.vorbis_comment.num_comments);
1338 return false;
1339 }
1340 if(!mutils__compare_block(vorbiscomment, block))
1341 return false;
1342 printf("OK\n");
1343
1344 printf("testing FLAC__metadata_object_vorbiscomment_set_comment(copy)...");
1345 vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
1346 FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/true);
1347 if(!mutils__compare_block(vorbiscomment, block))
1348 return false;
1349 printf("OK\n");
1350
1351 printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(copy)...");
1352 vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
1353 FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/true);
1354 if(!mutils__compare_block(vorbiscomment, block))
1355 return false;
1356 printf("OK\n");
1357
1358 printf("testing FLAC__metadata_object_delete()... ");
1359 FLAC__metadata_object_delete(vorbiscomment);
1360 FLAC__metadata_object_delete(block);
1361 printf("OK\n");
1362
1363
1364 printf("testing FLAC__metadata_object_new()... ");
1365 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
1366 if(0 == block) {
1367 printf("FAILED, returned NULL\n");
1368 return false;
1369 }
1370 printf("OK\n");
1371
1372 printf("testing FLAC__metadata_object_clone()... ");
1373 vorbiscomment = FLAC__metadata_object_clone(block);
1374 if(0 == vorbiscomment) {
1375 printf("FAILED, returned NULL\n");
1376 return false;
1377 }
1378 if(!mutils__compare_block(vorbiscomment, block))
1379 return false;
1380 printf("OK\n");
1381
1382 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on empty array...");
1383 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
1384 entry_clone_(&entry);
1385 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) {
1386 printf("FAILED, returned false\n");
1387 return false;
1388 }
1389 if(!mutils__compare_block(vorbiscomment, block))
1390 return false;
1391 printf("OK\n");
1392
1393 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on non-empty array...");
1394 vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2");
1395 entry_clone_(&entry);
1396 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) {
1397 printf("FAILED, returned false\n");
1398 return false;
1399 }
1400 if(!mutils__compare_block(vorbiscomment, block))
1401 return false;
1402 printf("OK\n");
1403
1404 printf("testing FLAC__metadata_object_delete()... ");
1405 FLAC__metadata_object_delete(vorbiscomment);
1406 FLAC__metadata_object_delete(block);
1407 printf("OK\n");
1408
1409 printf("testing FLAC__metadata_object_new()... ");
1410 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
1411 if(0 == block) {
1412 printf("FAILED, returned NULL\n");
1413 return false;
1414 }
1415 printf("OK\n");
1416
1417 printf("testing FLAC__metadata_object_clone()... ");
1418 vorbiscomment = FLAC__metadata_object_clone(block);
1419 if(0 == vorbiscomment) {
1420 printf("FAILED, returned NULL\n");
1421 return false;
1422 }
1423 if(!mutils__compare_block(vorbiscomment, block))
1424 return false;
1425 printf("OK\n");
1426
1427 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on empty array...");
1428 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
1429 entry_clone_(&entry);
1430 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
1431 printf("FAILED, returned false\n");
1432 return false;
1433 }
1434 if(!mutils__compare_block(vorbiscomment, block))
1435 return false;
1436 printf("OK\n");
1437
1438 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on beginning of non-empty array...");
1439 vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
1440 entry_clone_(&entry);
1441 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
1442 printf("FAILED, returned false\n");
1443 return false;
1444 }
1445 if(!mutils__compare_block(vorbiscomment, block))
1446 return false;
1447 printf("OK\n");
1448
1449 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on middle of non-empty array...");
1450 vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
1451 entry_clone_(&entry);
1452 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/false)) {
1453 printf("FAILED, returned false\n");
1454 return false;
1455 }
1456 if(!mutils__compare_block(vorbiscomment, block))
1457 return false;
1458 printf("OK\n");
1459
1460 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
1461 vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
1462 entry_clone_(&entry);
1463 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/false)) {
1464 printf("FAILED, returned false\n");
1465 return false;
1466 }
1467 if(!mutils__compare_block(vorbiscomment, block))
1468 return false;
1469 printf("OK\n");
1470
1471 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
1472 vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1");
1473 entry_clone_(&entry);
1474 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/false)) {
1475 printf("FAILED, returned false\n");
1476 return false;
1477 }
1478 if(!mutils__compare_block(vorbiscomment, block))
1479 return false;
1480 printf("OK\n");
1481
1482 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
1483 vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1");
1484 entry_clone_(&entry);
1485 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/false)) {
1486 printf("FAILED, returned false\n");
1487 return false;
1488 }
1489 if(!mutils__compare_block(vorbiscomment, block))
1490 return false;
1491 printf("OK\n");
1492
1493 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, own)...");
1494 vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false);
1495 entry_clone_(&entry);
1496 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/false)) {
1497 printf("FAILED, returned false\n");
1498 return false;
1499 }
1500 if(!mutils__compare_block(vorbiscomment, block))
1501 return false;
1502 if(block->data.vorbis_comment.num_comments != 6) {
1503 printf("FAILED, expected 6 comments, got %u\n", block->data.vorbis_comment.num_comments);
1504 return false;
1505 }
1506 printf("OK\n");
1507
1508 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, own)...");
1509 vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true);
1510 entry_clone_(&entry);
1511 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/false)) {
1512 printf("FAILED, returned false\n");
1513 return false;
1514 }
1515 if(!mutils__compare_block(vorbiscomment, block))
1516 return false;
1517 if(block->data.vorbis_comment.num_comments != 4) {
1518 printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments);
1519 return false;
1520 }
1521 printf("OK\n");
1522
1523 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
1524 vc_delete_(vorbiscomment, 2);
1525 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
1526 printf("FAILED, returned false\n");
1527 return false;
1528 }
1529 if(!mutils__compare_block(vorbiscomment, block))
1530 return false;
1531 printf("OK\n");
1532
1533 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
1534 vc_delete_(vorbiscomment, 2);
1535 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
1536 printf("FAILED, returned false\n");
1537 return false;
1538 }
1539 if(!mutils__compare_block(vorbiscomment, block))
1540 return false;
1541 printf("OK\n");
1542
1543 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
1544 vc_delete_(vorbiscomment, 0);
1545 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
1546 printf("FAILED, returned false\n");
1547 return false;
1548 }
1549 if(!mutils__compare_block(vorbiscomment, block))
1550 return false;
1551 printf("OK\n");
1552
1553 printf("testing FLAC__metadata_object_vorbiscomment_set_comment(own)...");
1554 vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
1555 entry_clone_(&entry);
1556 FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/false);
1557 if(!mutils__compare_block(vorbiscomment, block))
1558 return false;
1559 printf("OK\n");
1560
1561 printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(own)...");
1562 vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
1563 entry_clone_(&entry);
1564 FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/false);
1565 if(!mutils__compare_block(vorbiscomment, block))
1566 return false;
1567 printf("OK\n");
1568
1569 printf("testing FLAC__metadata_object_delete()... ");
1570 FLAC__metadata_object_delete(vorbiscomment);
1571 FLAC__metadata_object_delete(block);
1572 printf("OK\n");
1573
1574
1575 printf("testing CUESHEET\n");
1576
1577 {
1578 FLAC__StreamMetadata_CueSheet_Track *track_, *trackcopy_;
1579
1580 printf("testing FLAC__metadata_object_cuesheet_track_new()... ");
1581 track_ = FLAC__metadata_object_cuesheet_track_new();
1582 if(0 == track_) {
1583 printf("FAILED, returned NULL\n");
1584 return false;
1585 }
1586 printf("OK\n");
1587
1588 printf("testing FLAC__metadata_object_cuesheet_track_clone()... ");
1589 trackcopy_ = FLAC__metadata_object_cuesheet_track_clone(track_);
1590 if(0 == trackcopy_) {
1591 printf("FAILED, returned NULL\n");
1592 return false;
1593 }
1594 if(!compare_track_(trackcopy_, track_))
1595 return false;
1596 printf("OK\n");
1597
1598 printf("testing FLAC__metadata_object_cuesheet_track_delete()... ");
1599 FLAC__metadata_object_cuesheet_track_delete(trackcopy_);
1600 FLAC__metadata_object_cuesheet_track_delete(track_);
1601 printf("OK\n");
1602 }
1603
1604
1605 printf("testing FLAC__metadata_object_new()... ");
1606 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
1607 if(0 == block) {
1608 printf("FAILED, returned NULL\n");
1609 return false;
1610 }
1611 expected_length = (
1612 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
1613 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
1614 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
1615 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
1616 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
1617 ) / 8;
1618 if(block->length != expected_length) {
1619 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
1620 return false;
1621 }
1622 printf("OK\n");
1623
1624 printf("testing FLAC__metadata_object_clone()... ");
1625 cuesheet = FLAC__metadata_object_clone(block);
1626 if(0 == cuesheet) {
1627 printf("FAILED, returned NULL\n");
1628 return false;
1629 }
1630 if(!mutils__compare_block(cuesheet, block))
1631 return false;
1632 printf("OK\n");
1633
1634 cs_resize_(cuesheet, 2);
1635 printf("testing FLAC__metadata_object_cuesheet_resize_tracks(grow to %u)...", cuesheet->data.cue_sheet.num_tracks);
1636 if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
1637 printf("FAILED, returned false\n");
1638 return false;
1639 }
1640 if(!mutils__compare_block(cuesheet, block))
1641 return false;
1642 printf("OK\n");
1643
1644 cs_resize_(cuesheet, 1);
1645 printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
1646 if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
1647 printf("FAILED, returned false\n");
1648 return false;
1649 }
1650 if(!mutils__compare_block(cuesheet, block))
1651 return false;
1652 printf("OK\n");
1653
1654 cs_resize_(cuesheet, 0);
1655 printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
1656 if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
1657 printf("FAILED, returned false\n");
1658 return false;
1659 }
1660 if(!mutils__compare_block(cuesheet, block))
1661 return false;
1662 printf("OK\n");
1663
1664 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on empty array...");
1665 cs_insert_new_(&track, cuesheet, 0, 0, 1, "ABCDE1234567", false, false);
1666 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
1667 printf("FAILED, returned false\n");
1668 return false;
1669 }
1670 if(!mutils__compare_block(cuesheet, block))
1671 return false;
1672 printf("OK\n");
1673
1674 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on beginning of non-empty array...");
1675 cs_insert_new_(&track, cuesheet, 0, 10, 2, "BBCDE1234567", false, false);
1676 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
1677 printf("FAILED, returned false\n");
1678 return false;
1679 }
1680 if(!mutils__compare_block(cuesheet, block))
1681 return false;
1682 printf("OK\n");
1683
1684 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on middle of non-empty array...");
1685 cs_insert_new_(&track, cuesheet, 1, 20, 3, "CBCDE1234567", false, false);
1686 if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/true)) {
1687 printf("FAILED, returned false\n");
1688 return false;
1689 }
1690 if(!mutils__compare_block(cuesheet, block))
1691 return false;
1692 printf("OK\n");
1693
1694 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on end of non-empty array...");
1695 cs_insert_new_(&track, cuesheet, 3, 30, 4, "DBCDE1234567", false, false);
1696 if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/true)) {
1697 printf("FAILED, returned false\n");
1698 return false;
1699 }
1700 if(!mutils__compare_block(cuesheet, block))
1701 return false;
1702 printf("OK\n");
1703
1704 printf("testing FLAC__metadata_object_cuesheet_insert_blank_track() on end of non-empty array...");
1705 cs_insert_new_(&track, cuesheet, 4, 0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0", false, false);
1706 if(!FLAC__metadata_object_cuesheet_insert_blank_track(block, 4)) {
1707 printf("FAILED, returned false\n");
1708 return false;
1709 }
1710 if(!mutils__compare_block(cuesheet, block))
1711 return false;
1712 printf("OK\n");
1713
1714 printf("testing FLAC__metadata_object_clone()... ");
1715 blockcopy = FLAC__metadata_object_clone(block);
1716 if(0 == blockcopy) {
1717 printf("FAILED, returned NULL\n");
1718 return false;
1719 }
1720 if(!mutils__compare_block(block, blockcopy))
1721 return false;
1722 printf("OK\n");
1723
1724 printf("testing FLAC__metadata_object_delete()... ");
1725 FLAC__metadata_object_delete(blockcopy);
1726 printf("OK\n");
1727
1728 printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
1729 cs_delete_(cuesheet, 4);
1730 if(!FLAC__metadata_object_cuesheet_delete_track(block, 4)) {
1731 printf("FAILED, returned false\n");
1732 return false;
1733 }
1734 if(!mutils__compare_block(cuesheet, block))
1735 return false;
1736 printf("OK\n");
1737
1738 printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
1739 cs_delete_(cuesheet, 2);
1740 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
1741 printf("FAILED, returned false\n");
1742 return false;
1743 }
1744 if(!mutils__compare_block(cuesheet, block))
1745 return false;
1746 printf("OK\n");
1747
1748 printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
1749 cs_delete_(cuesheet, 2);
1750 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
1751 printf("FAILED, returned false\n");
1752 return false;
1753 }
1754 if(!mutils__compare_block(cuesheet, block))
1755 return false;
1756 printf("OK\n");
1757
1758 printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
1759 cs_delete_(cuesheet, 0);
1760 if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
1761 printf("FAILED, returned false\n");
1762 return false;
1763 }
1764 if(!mutils__compare_block(cuesheet, block))
1765 return false;
1766 printf("OK\n");
1767
1768 printf("testing FLAC__metadata_object_cuesheet_set_track(copy)...");
1769 cs_set_new_(&track, cuesheet, 0, 40, 5, "EBCDE1234567", false, false);
1770 FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/true);
1771 if(!mutils__compare_block(cuesheet, block))
1772 return false;
1773 printf("OK\n");
1774
1775 tr_resize_(cuesheet, 0, 2);
1776 printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(grow to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
1777 if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
1778 printf("FAILED, returned false\n");
1779 return false;
1780 }
1781 if(!mutils__compare_block(cuesheet, block))
1782 return false;
1783 printf("OK\n");
1784
1785 tr_resize_(cuesheet, 0, 1);
1786 printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
1787 if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
1788 printf("FAILED, returned false\n");
1789 return false;
1790 }
1791 if(!mutils__compare_block(cuesheet, block))
1792 return false;
1793 printf("OK\n");
1794
1795 tr_resize_(cuesheet, 0, 0);
1796 printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
1797 if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
1798 printf("FAILED, returned false\n");
1799 return false;
1800 }
1801 if(!mutils__compare_block(cuesheet, block))
1802 return false;
1803 printf("OK\n");
1804
1805 indx.offset = 0;
1806 indx.number = 1;
1807 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on empty array...");
1808 tr_insert_new_(cuesheet, 0, 0, indx);
1809 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, indx)) {
1810 printf("FAILED, returned false\n");
1811 return false;
1812 }
1813 if(!mutils__compare_block(cuesheet, block))
1814 return false;
1815 printf("OK\n");
1816
1817 indx.offset = 10;
1818 indx.number = 2;
1819 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on beginning of non-empty array...");
1820 tr_insert_new_(cuesheet, 0, 0, indx);
1821 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, indx)) {
1822 printf("FAILED, returned false\n");
1823 return false;
1824 }
1825 if(!mutils__compare_block(cuesheet, block))
1826 return false;
1827 printf("OK\n");
1828
1829 indx.offset = 20;
1830 indx.number = 3;
1831 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on middle of non-empty array...");
1832 tr_insert_new_(cuesheet, 0, 1, indx);
1833 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 1, indx)) {
1834 printf("FAILED, returned false\n");
1835 return false;
1836 }
1837 if(!mutils__compare_block(cuesheet, block))
1838 return false;
1839 printf("OK\n");
1840
1841 indx.offset = 30;
1842 indx.number = 4;
1843 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on end of non-empty array...");
1844 tr_insert_new_(cuesheet, 0, 3, indx);
1845 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 3, indx)) {
1846 printf("FAILED, returned false\n");
1847 return false;
1848 }
1849 if(!mutils__compare_block(cuesheet, block))
1850 return false;
1851 printf("OK\n");
1852
1853 indx.offset = 0;
1854 indx.number = 0;
1855 printf("testing FLAC__metadata_object_cuesheet_track_insert_blank_index() on end of non-empty array...");
1856 tr_insert_new_(cuesheet, 0, 4, indx);
1857 if(!FLAC__metadata_object_cuesheet_track_insert_blank_index(block, 0, 4)) {
1858 printf("FAILED, returned false\n");
1859 return false;
1860 }
1861 if(!mutils__compare_block(cuesheet, block))
1862 return false;
1863 printf("OK\n");
1864
1865 printf("testing FLAC__metadata_object_clone()... ");
1866 blockcopy = FLAC__metadata_object_clone(block);
1867 if(0 == blockcopy) {
1868 printf("FAILED, returned NULL\n");
1869 return false;
1870 }
1871 if(!mutils__compare_block(block, blockcopy))
1872 return false;
1873 printf("OK\n");
1874
1875 printf("testing FLAC__metadata_object_delete()... ");
1876 FLAC__metadata_object_delete(blockcopy);
1877 printf("OK\n");
1878
1879 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array...");
1880 tr_delete_(cuesheet, 0, 4);
1881 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 4)) {
1882 printf("FAILED, returned false\n");
1883 return false;
1884 }
1885 if(!mutils__compare_block(cuesheet, block))
1886 return false;
1887 printf("OK\n");
1888
1889 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on middle of array...");
1890 tr_delete_(cuesheet, 0, 2);
1891 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
1892 printf("FAILED, returned false\n");
1893 return false;
1894 }
1895 if(!mutils__compare_block(cuesheet, block))
1896 return false;
1897 printf("OK\n");
1898
1899 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array...");
1900 tr_delete_(cuesheet, 0, 2);
1901 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
1902 printf("FAILED, returned false\n");
1903 return false;
1904 }
1905 if(!mutils__compare_block(cuesheet, block))
1906 return false;
1907 printf("OK\n");
1908
1909 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on beginning of array...");
1910 tr_delete_(cuesheet, 0, 0);
1911 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 0)) {
1912 printf("FAILED, returned false\n");
1913 return false;
1914 }
1915 if(!mutils__compare_block(cuesheet, block))
1916 return false;
1917 printf("OK\n");
1918
1919 printf("testing FLAC__metadata_object_delete()... ");
1920 FLAC__metadata_object_delete(cuesheet);
1921 FLAC__metadata_object_delete(block);
1922 printf("OK\n");
1923
1924
1925 printf("testing FLAC__metadata_object_new()... ");
1926 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
1927 if(0 == block) {
1928 printf("FAILED, returned NULL\n");
1929 return false;
1930 }
1931 printf("OK\n");
1932
1933 printf("testing FLAC__metadata_object_clone()... ");
1934 cuesheet = FLAC__metadata_object_clone(block);
1935 if(0 == cuesheet) {
1936 printf("FAILED, returned NULL\n");
1937 return false;
1938 }
1939 if(!mutils__compare_block(cuesheet, block))
1940 return false;
1941 printf("OK\n");
1942
1943 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on empty array...");
1944 cs_insert_new_(&track, cuesheet, 0, 60, 7, "GBCDE1234567", false, false);
1945 track_clone_(&track);
1946 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
1947 printf("FAILED, returned false\n");
1948 return false;
1949 }
1950 if(!mutils__compare_block(cuesheet, block))
1951 return false;
1952 printf("OK\n");
1953
1954 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on beginning of non-empty array...");
1955 cs_insert_new_(&track, cuesheet, 0, 70, 8, "HBCDE1234567", false, false);
1956 track_clone_(&track);
1957 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
1958 printf("FAILED, returned false\n");
1959 return false;
1960 }
1961 if(!mutils__compare_block(cuesheet, block))
1962 return false;
1963 printf("OK\n");
1964
1965 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on middle of non-empty array...");
1966 cs_insert_new_(&track, cuesheet, 1, 80, 9, "IBCDE1234567", false, false);
1967 track_clone_(&track);
1968 if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/false)) {
1969 printf("FAILED, returned false\n");
1970 return false;
1971 }
1972 if(!mutils__compare_block(cuesheet, block))
1973 return false;
1974 printf("OK\n");
1975
1976 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on end of non-empty array...");
1977 cs_insert_new_(&track, cuesheet, 3, 90, 10, "JBCDE1234567", false, false);
1978 track_clone_(&track);
1979 if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/false)) {
1980 printf("FAILED, returned false\n");
1981 return false;
1982 }
1983 if(!mutils__compare_block(cuesheet, block))
1984 return false;
1985 printf("OK\n");
1986
1987 printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
1988 cs_delete_(cuesheet, 2);
1989 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
1990 printf("FAILED, returned false\n");
1991 return false;
1992 }
1993 if(!mutils__compare_block(cuesheet, block))
1994 return false;
1995 printf("OK\n");
1996
1997 printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
1998 cs_delete_(cuesheet, 2);
1999 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
2000 printf("FAILED, returned false\n");
2001 return false;
2002 }
2003 if(!mutils__compare_block(cuesheet, block))
2004 return false;
2005 printf("OK\n");
2006
2007 printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
2008 cs_delete_(cuesheet, 0);
2009 if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
2010 printf("FAILED, returned false\n");
2011 return false;
2012 }
2013 if(!mutils__compare_block(cuesheet, block))
2014 return false;
2015 printf("OK\n");
2016
2017 printf("testing FLAC__metadata_object_cuesheet_set_track(own)...");
2018 cs_set_new_(&track, cuesheet, 0, 100, 11, "KBCDE1234567", false, false);
2019 track_clone_(&track);
2020 FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/false);
2021 if(!mutils__compare_block(cuesheet, block))
2022 return false;
2023 printf("OK\n");
2024
2025 printf("testing FLAC__metadata_object_cuesheet_is_legal()...");
2026 {
2027 const char *violation;
2028 if(FLAC__metadata_object_cuesheet_is_legal(block, /*check_cd_da_subset=*/true, &violation)) {
2029 printf("FAILED, returned true when expecting false\n");
2030 return false;
2031 }
2032 printf("returned false as expected, violation=\"%s\" OK\n", violation);
2033 }
2034
2035 printf("testing FLAC__metadata_object_delete()... ");
2036 FLAC__metadata_object_delete(cuesheet);
2037 FLAC__metadata_object_delete(block);
2038 printf("OK\n");
2039
2040
2041 printf("testing PICTURE\n");
2042
2043 printf("testing FLAC__metadata_object_new()... ");
2044 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE);
2045 if(0 == block) {
2046 printf("FAILED, returned NULL\n");
2047 return false;
2048 }
2049 expected_length = (
2050 FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
2051 FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN +
2052 FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN +
2053 FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
2054 FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
2055 FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
2056 FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
2057 FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN
2058 ) / 8;
2059 if(block->length != expected_length) {
2060 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
2061 return false;
2062 }
2063 printf("OK\n");
2064
2065 printf("testing FLAC__metadata_object_clone()... ");
2066 picture = FLAC__metadata_object_clone(block);
2067 if(0 == picture) {
2068 printf("FAILED, returned NULL\n");
2069 return false;
2070 }
2071 if(!mutils__compare_block(picture, block))
2072 return false;
2073 printf("OK\n");
2074
2075 pi_set_mime_type(picture, "image/png\t");
2076 printf("testing FLAC__metadata_object_picture_set_mime_type(copy)...");
2077 if(!FLAC__metadata_object_picture_set_mime_type(block, "image/png\t", /*copy=*/true)) {
2078 printf("FAILED, returned false\n");
2079 return false;
2080 }
2081 if(!mutils__compare_block(picture, block))
2082 return false;
2083 printf("OK\n");
2084
2085 printf("testing FLAC__metadata_object_picture_is_legal()...");
2086 {
2087 const char *violation;
2088 if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
2089 printf("FAILED, returned true when expecting false\n");
2090 return false;
2091 }
2092 printf("returned false as expected, violation=\"%s\" OK\n", violation);
2093 }
2094
2095 pi_set_mime_type(picture, "image/png");
2096 printf("testing FLAC__metadata_object_picture_set_mime_type(copy)...");
2097 if(!FLAC__metadata_object_picture_set_mime_type(block, "image/png", /*copy=*/true)) {
2098 printf("FAILED, returned false\n");
2099 return false;
2100 }
2101 if(!mutils__compare_block(picture, block))
2102 return false;
2103 printf("OK\n");
2104
2105 printf("testing FLAC__metadata_object_picture_is_legal()...");
2106 {
2107 const char *violation;
2108 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
2109 printf("FAILED, returned false, violation=\"%s\"\n", violation);
2110 return false;
2111 }
2112 printf("OK\n");
2113 }
2114
2115 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION\xff");
2116 printf("testing FLAC__metadata_object_picture_set_description(copy)...");
2117 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)"DESCRIPTION\xff", /*copy=*/true)) {
2118 printf("FAILED, returned false\n");
2119 return false;
2120 }
2121 if(!mutils__compare_block(picture, block))
2122 return false;
2123 printf("OK\n");
2124
2125 printf("testing FLAC__metadata_object_picture_is_legal()...");
2126 {
2127 const char *violation;
2128 if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
2129 printf("FAILED, returned true when expecting false\n");
2130 return false;
2131 }
2132 printf("returned false as expected, violation=\"%s\" OK\n", violation);
2133 }
2134
2135 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION");
2136 printf("testing FLAC__metadata_object_picture_set_description(copy)...");
2137 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)"DESCRIPTION", /*copy=*/true)) {
2138 printf("FAILED, returned false\n");
2139 return false;
2140 }
2141 if(!mutils__compare_block(picture, block))
2142 return false;
2143 printf("OK\n");
2144
2145 printf("testing FLAC__metadata_object_picture_is_legal()...");
2146 {
2147 const char *violation;
2148 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
2149 printf("FAILED, returned false, violation=\"%s\"\n", violation);
2150 return false;
2151 }
2152 printf("OK\n");
2153 }
2154
2155
2156 pi_set_data(picture, (const FLAC__byte*)"PNGDATA", strlen("PNGDATA"));
2157 printf("testing FLAC__metadata_object_picture_set_data(copy)...");
2158 if(!FLAC__metadata_object_picture_set_data(block, (FLAC__byte*)"PNGDATA", strlen("PNGDATA"), /*copy=*/true)) {
2159 printf("FAILED, returned false\n");
2160 return false;
2161 }
2162 if(!mutils__compare_block(picture, block))
2163 return false;
2164 printf("OK\n");
2165
2166 printf("testing FLAC__metadata_object_clone()... ");
2167 blockcopy = FLAC__metadata_object_clone(block);
2168 if(0 == blockcopy) {
2169 printf("FAILED, returned NULL\n");
2170 return false;
2171 }
2172 if(!mutils__compare_block(block, blockcopy))
2173 return false;
2174 printf("OK\n");
2175
2176 printf("testing FLAC__metadata_object_delete()... ");
2177 FLAC__metadata_object_delete(blockcopy);
2178 printf("OK\n");
2179
2180 pi_set_mime_type(picture, "image/png\t");
2181 printf("testing FLAC__metadata_object_picture_set_mime_type(own)...");
2182 if(!FLAC__metadata_object_picture_set_mime_type(block, strdup("image/png\t"), /*copy=*/false)) {
2183 printf("FAILED, returned false\n");
2184 return false;
2185 }
2186 if(!mutils__compare_block(picture, block))
2187 return false;
2188 printf("OK\n");
2189
2190 printf("testing FLAC__metadata_object_picture_is_legal()...");
2191 {
2192 const char *violation;
2193 if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
2194 printf("FAILED, returned true when expecting false\n");
2195 return false;
2196 }
2197 printf("returned false as expected, violation=\"%s\" OK\n", violation);
2198 }
2199
2200 pi_set_mime_type(picture, "image/png");
2201 printf("testing FLAC__metadata_object_picture_set_mime_type(own)...");
2202 if(!FLAC__metadata_object_picture_set_mime_type(block, strdup("image/png"), /*copy=*/false)) {
2203 printf("FAILED, returned false\n");
2204 return false;
2205 }
2206 if(!mutils__compare_block(picture, block))
2207 return false;
2208 printf("OK\n");
2209
2210 printf("testing FLAC__metadata_object_picture_is_legal()...");
2211 {
2212 const char *violation;
2213 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
2214 printf("FAILED, returned false, violation=\"%s\"\n", violation);
2215 return false;
2216 }
2217 printf("OK\n");
2218 }
2219
2220 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION\xff");
2221 printf("testing FLAC__metadata_object_picture_set_description(own)...");
2222 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)strdup("DESCRIPTION\xff"), /*copy=*/false)) {
2223 printf("FAILED, returned false\n");
2224 return false;
2225 }
2226 if(!mutils__compare_block(picture, block))
2227 return false;
2228 printf("OK\n");
2229
2230 printf("testing FLAC__metadata_object_picture_is_legal()...");
2231 {
2232 const char *violation;
2233 if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
2234 printf("FAILED, returned true when expecting false\n");
2235 return false;
2236 }
2237 printf("returned false as expected, violation=\"%s\" OK\n", violation);
2238 }
2239
2240 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION");
2241 printf("testing FLAC__metadata_object_picture_set_description(own)...");
2242 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)strdup("DESCRIPTION"), /*copy=*/false)) {
2243 printf("FAILED, returned false\n");
2244 return false;
2245 }
2246 if(!mutils__compare_block(picture, block))
2247 return false;
2248 printf("OK\n");
2249
2250 printf("testing FLAC__metadata_object_picture_is_legal()...");
2251 {
2252 const char *violation;
2253 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
2254 printf("FAILED, returned false, violation=\"%s\"\n", violation);
2255 return false;
2256 }
2257 printf("OK\n");
2258 }
2259
2260 pi_set_data(picture, (const FLAC__byte*)"PNGDATA", strlen("PNGDATA"));
2261 printf("testing FLAC__metadata_object_picture_set_data(own)...");
2262 if(!FLAC__metadata_object_picture_set_data(block, (FLAC__byte*)strdup("PNGDATA"), strlen("PNGDATA"), /*copy=*/false)) {
2263 printf("FAILED, returned false\n");
2264 return false;
2265 }
2266 if(!mutils__compare_block(picture, block))
2267 return false;
2268 printf("OK\n");
2269
2270 printf("testing FLAC__metadata_object_clone()... ");
2271 blockcopy = FLAC__metadata_object_clone(block);
2272 if(0 == blockcopy) {
2273 printf("FAILED, returned NULL\n");
2274 return false;
2275 }
2276 if(!mutils__compare_block(block, blockcopy))
2277 return false;
2278 printf("OK\n");
2279
2280 printf("testing FLAC__metadata_object_delete()... ");
2281 FLAC__metadata_object_delete(blockcopy);
2282 printf("OK\n");
2283
2284 printf("testing FLAC__metadata_object_delete()... ");
2285 FLAC__metadata_object_delete(picture);
2286 FLAC__metadata_object_delete(block);
2287 printf("OK\n");
2288
2289
2290 return true;
2291 }
2292