src/test_libFLAC/metadata_object.c

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