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