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