src/test_libFLAC/metadata_object.c

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