src/test_libFLAC/metadata_object.c

   1 /* test_libFLAC - Unit tester for libFLAC
   2  * Copyright (C) 2002  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);
 146         FLAC__ASSERT(0 != entry->entry);
 147         memcpy(entry->entry, field, entry->length);
 148 }
 149
 150 static void entry_clone_(FLAC__StreamMetadata_VorbisComment_Entry *entry)
 151 {
 152         FLAC__byte *x = (FLAC__byte*)malloc(entry->length);
 153         FLAC__ASSERT(0 != x);
 154         memcpy(x, entry->entry, entry->length);
 155         entry->entry = x;
 156 }
 157
 158 static void vc_calc_len_(FLAC__StreamMetadata *block)
 159 {
 160         const FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
 161         unsigned i;
 162
 163         block->length = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
 164         block->length += vc->vendor_string.length;
 165         block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
 166         for(i = 0; i < vc->num_comments; i++) {
 167                 block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
 168                 block->length += vc->comments[i].length;
 169         }
 170 }
 171
 172 static void vc_resize_(FLAC__StreamMetadata *block, unsigned num)
 173 {
 174         FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
 175
 176         if(vc->num_comments != 0) {
 177                 FLAC__ASSERT(0 != vc->comments);
 178                 if(num < vc->num_comments) {
 179                         unsigned i;
 180                         for(i = num; i < vc->num_comments; i++) {
 181                                 if(0 != vc->comments[i].entry)
 182                                         free(vc->comments[i].entry);
 183                         }
 184                 }
 185         }
 186         if(num == 0) {
 187                 if(0 != vc->comments) {
 188                         free(vc->comments);
 189                         vc->comments = 0;
 190                 }
 191         }
 192         else {
 193                 vc->comments = (FLAC__StreamMetadata_VorbisComment_Entry*)realloc(vc->comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*num);
 194                 FLAC__ASSERT(0 != vc->comments);
 195                 if(num > vc->num_comments)
 196                         memset(vc->comments+vc->num_comments, 0, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(num-vc->num_comments));
 197         }
 198
 199         vc->num_comments = num;
 200         vc_calc_len_(block);
 201 }
 202
 203 static void vc_set_vs_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field)
 204 {
 205         entry_new_(entry, field);
 206         block->data.vorbis_comment.vendor_string = *entry;
 207         vc_calc_len_(block);
 208 }
 209
 210 static void vc_set_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field)
 211 {
 212         entry_new_(entry, field);
 213         block->data.vorbis_comment.comments[pos] = *entry;
 214         vc_calc_len_(block);
 215 }
 216
 217 static void vc_insert_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field)
 218 {
 219         vc_resize_(block, block->data.vorbis_comment.num_comments+1);
 220         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));
 221         vc_set_new_(entry, block, pos, field);
 222         vc_calc_len_(block);
 223 }
 224
 225 static void vc_delete_(FLAC__StreamMetadata *block, unsigned pos)
 226 {
 227         if(0 != block->data.vorbis_comment.comments[pos].entry)
 228                 free(block->data.vorbis_comment.comments[pos].entry);
 229         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));
 230         block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].entry = 0;
 231         block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].length = 0;
 232         vc_resize_(block, block->data.vorbis_comment.num_comments-1);
 233         vc_calc_len_(block);
 234 }
 235
 236 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)
 237 {
 238         track->offset = offset;
 239         track->number = number;
 240         memcpy(track->isrc, isrc, sizeof(track->isrc));
 241         track->type = data;
 242         track->pre_emphasis = pre_em;
 243         track->num_indices = 0;
 244         track->indices = 0;
 245 }
 246
 247 static void track_clone_(FLAC__StreamMetadata_CueSheet_Track *track)
 248 {
 249         if(track->num_indices > 0) {
 250                 size_t bytes = sizeof(FLAC__StreamMetadata_CueSheet_Index) * track->num_indices;
 251                 FLAC__StreamMetadata_CueSheet_Index *x = (FLAC__StreamMetadata_CueSheet_Index*)malloc(bytes);
 252                 FLAC__ASSERT(0 != x);
 253                 memcpy(x, track->indices, bytes);
 254                 track->indices = x;
 255         }
 256 }
 257
 258 static void cs_calc_len_(FLAC__StreamMetadata *block)
 259 {
 260         const FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
 261         unsigned i;
 262
 263         block->length = (
 264                 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
 265                 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
 266                 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
 267                 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
 268                 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
 269         ) / 8;
 270         block->length += cs->num_tracks * (
 271                 FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
 272                 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
 273                 FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
 274                 FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
 275                 FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
 276                 FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
 277                 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
 278         ) / 8;
 279         for(i = 0; i < cs->num_tracks; i++) {
 280                 block->length += cs->tracks[i].num_indices * (
 281                         FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
 282                         FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
 283                         FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
 284                 ) / 8;
 285         }
 286 }
 287
 288 static void tr_resize_(FLAC__StreamMetadata *block, unsigned track_num, unsigned num)
 289 {
 290         FLAC__StreamMetadata_CueSheet_Track *tr;
 291
 292         FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
 293
 294         tr = &block->data.cue_sheet.tracks[track_num];
 295
 296         if(tr->num_indices != 0) {
 297                 FLAC__ASSERT(0 != tr->indices);
 298         }
 299         if(num == 0) {
 300                 if(0 != tr->indices) {
 301                         free(tr->indices);
 302                         tr->indices = 0;
 303                 }
 304         }
 305         else {
 306                 tr->indices = (FLAC__StreamMetadata_CueSheet_Index*)realloc(tr->indices, sizeof(FLAC__StreamMetadata_CueSheet_Index)*num);
 307                 FLAC__ASSERT(0 != tr->indices);
 308                 if(num > tr->num_indices)
 309                         memset(tr->indices+tr->num_indices, 0, sizeof(FLAC__StreamMetadata_CueSheet_Index)*(num-tr->num_indices));
 310         }
 311
 312         tr->num_indices = num;
 313         cs_calc_len_(block);
 314 }
 315
 316 static void tr_set_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index)
 317 {
 318         FLAC__StreamMetadata_CueSheet_Track *tr;
 319
 320         FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
 321
 322         tr = &block->data.cue_sheet.tracks[track_num];
 323
 324         FLAC__ASSERT(pos < tr->num_indices);
 325
 326         tr->indices[pos] = index;
 327
 328         cs_calc_len_(block);
 329 }
 330
 331 static void tr_insert_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index)
 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         FLAC__ASSERT(pos <= tr->num_indices);
 340
 341         tr_resize_(block, track_num, tr->num_indices+1);
 342         memmove(&tr->indices[pos+1], &tr->indices[pos], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-1-pos));
 343         tr_set_new_(block, track_num, pos, index);
 344         cs_calc_len_(block);
 345 }
 346
 347 static void tr_delete_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos)
 348 {
 349         FLAC__StreamMetadata_CueSheet_Track *tr;
 350
 351         FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
 352
 353         tr = &block->data.cue_sheet.tracks[track_num];
 354
 355         FLAC__ASSERT(pos <= tr->num_indices);
 356
 357         memmove(&tr->indices[pos], &tr->indices[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-pos-1));
 358         tr_resize_(block, track_num, tr->num_indices-1);
 359         cs_calc_len_(block);
 360 }
 361
 362 static void cs_resize_(FLAC__StreamMetadata *block, unsigned num)
 363 {
 364         FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
 365
 366         if(cs->num_tracks != 0) {
 367                 FLAC__ASSERT(0 != cs->tracks);
 368                 if(num < cs->num_tracks) {
 369                         unsigned i;
 370                         for(i = num; i < cs->num_tracks; i++) {
 371                                 if(0 != cs->tracks[i].indices)
 372                                         free(cs->tracks[i].indices);
 373                         }
 374                 }
 375         }
 376         if(num == 0) {
 377                 if(0 != cs->tracks) {
 378                         free(cs->tracks);
 379                         cs->tracks = 0;
 380                 }
 381         }
 382         else {
 383                 cs->tracks = (FLAC__StreamMetadata_CueSheet_Track*)realloc(cs->tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track)*num);
 384                 FLAC__ASSERT(0 != cs->tracks);
 385                 if(num > cs->num_tracks)
 386                         memset(cs->tracks+cs->num_tracks, 0, sizeof(FLAC__StreamMetadata_CueSheet_Track)*(num-cs->num_tracks));
 387         }
 388
 389         cs->num_tracks = num;
 390         cs_calc_len_(block);
 391 }
 392
 393 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)
 394 {
 395         track_new_(track, offset, number, isrc, data, pre_em);
 396         block->data.cue_sheet.tracks[pos] = *track;
 397         cs_calc_len_(block);
 398 }
 399
 400 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)
 401 {
 402         cs_resize_(block, block->data.cue_sheet.num_tracks+1);
 403         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));
 404         cs_set_new_(track, block, pos, offset, number, isrc, data, pre_em);
 405         cs_calc_len_(block);
 406 }
 407
 408 static void cs_delete_(FLAC__StreamMetadata *block, unsigned pos)
 409 {
 410         if(0 != block->data.cue_sheet.tracks[pos].indices)
 411                 free(block->data.cue_sheet.tracks[pos].indices);
 412         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));
 413         block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].indices = 0;
 414         block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].num_indices = 0;
 415         cs_resize_(block, block->data.cue_sheet.num_tracks-1);
 416         cs_calc_len_(block);
 417 }
 418
 419
 420 FLAC__bool test_metadata_object()
 421 {
 422         FLAC__StreamMetadata *block, *blockcopy, *vorbiscomment, *cuesheet;
 423         FLAC__StreamMetadata_SeekPoint seekpoint_array[8];
 424         FLAC__StreamMetadata_VorbisComment_Entry entry;
 425         FLAC__StreamMetadata_CueSheet_Index index;
 426         FLAC__StreamMetadata_CueSheet_Track track;
 427         unsigned i, expected_length, seekpoints;
 428         static FLAC__byte dummydata[4] = { 'a', 'b', 'c', 'd' };
 429
 430         printf("\n+++ libFLAC unit test: metadata objects\n\n");
 431
 432
 433         printf("testing STREAMINFO\n");
 434
 435         printf("testing FLAC__metadata_object_new()... ");
 436         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_STREAMINFO);
 437         if(0 == block) {
 438                 printf("FAILED, returned NULL\n");
 439                 return false;
 440         }
 441         expected_length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
 442         if(block->length != expected_length) {
 443                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
 444                 return false;
 445         }
 446         printf("OK\n");
 447
 448         printf("testing FLAC__metadata_object_clone()... ");
 449         blockcopy = FLAC__metadata_object_clone(block);
 450         if(0 == blockcopy) {
 451                 printf("FAILED, returned NULL\n");
 452                 return false;
 453         }
 454         if(!compare_block_(block, blockcopy))
 455                 return false;
 456         printf("OK\n");
 457
 458         printf("testing FLAC__metadata_object_delete()... ");
 459         FLAC__metadata_object_delete(blockcopy);
 460         FLAC__metadata_object_delete(block);
 461         printf("OK\n");
 462
 463
 464         printf("testing PADDING\n");
 465
 466         printf("testing FLAC__metadata_object_new()... ");
 467         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
 468         if(0 == block) {
 469                 printf("FAILED, returned NULL\n");
 470                 return false;
 471         }
 472         expected_length = 0;
 473         if(block->length != expected_length) {
 474                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
 475                 return false;
 476         }
 477         printf("OK\n");
 478
 479         printf("testing FLAC__metadata_object_clone()... ");
 480         blockcopy = FLAC__metadata_object_clone(block);
 481         if(0 == blockcopy) {
 482                 printf("FAILED, returned NULL\n");
 483                 return false;
 484         }
 485         if(!compare_block_(block, blockcopy))
 486                 return false;
 487         printf("OK\n");
 488
 489         printf("testing FLAC__metadata_object_delete()... ");
 490         FLAC__metadata_object_delete(blockcopy);
 491         FLAC__metadata_object_delete(block);
 492         printf("OK\n");
 493
 494
 495         printf("testing APPLICATION\n");
 496
 497         printf("testing FLAC__metadata_object_new()... ");
 498         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION);
 499         if(0 == block) {
 500                 printf("FAILED, returned NULL\n");
 501                 return false;
 502         }
 503         expected_length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
 504         if(block->length != expected_length) {
 505                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
 506                 return false;
 507         }
 508         printf("OK\n");
 509
 510         printf("testing FLAC__metadata_object_clone()... ");
 511         blockcopy = FLAC__metadata_object_clone(block);
 512         if(0 == blockcopy) {
 513                 printf("FAILED, returned NULL\n");
 514                 return false;
 515         }
 516         if(!compare_block_(block, blockcopy))
 517                 return false;
 518         printf("OK\n");
 519
 520         printf("testing FLAC__metadata_object_delete()... ");
 521         FLAC__metadata_object_delete(blockcopy);
 522         printf("OK\n");
 523
 524         printf("testing FLAC__metadata_object_application_set_data(copy)... ");
 525         if(!FLAC__metadata_object_application_set_data(block, dummydata, sizeof(dummydata), true/*copy*/)) {
 526                 printf("FAILED, returned false\n");
 527                 return false;
 528         }
 529         expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
 530         if(block->length != expected_length) {
 531                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
 532                 return false;
 533         }
 534         if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
 535                 printf("FAILED, data mismatch\n");
 536                 return false;
 537         }
 538         printf("OK\n");
 539
 540         printf("testing FLAC__metadata_object_clone()... ");
 541         blockcopy = FLAC__metadata_object_clone(block);
 542         if(0 == blockcopy) {
 543                 printf("FAILED, returned NULL\n");
 544                 return false;
 545         }
 546         if(!compare_block_(block, blockcopy))
 547                 return false;
 548         printf("OK\n");
 549
 550         printf("testing FLAC__metadata_object_delete()... ");
 551         FLAC__metadata_object_delete(blockcopy);
 552         printf("OK\n");
 553
 554         printf("testing FLAC__metadata_object_application_set_data(own)... ");
 555         if(!FLAC__metadata_object_application_set_data(block, make_dummydata_(dummydata, sizeof(dummydata)), sizeof(dummydata), false/*own*/)) {
 556                 printf("FAILED, returned false\n");
 557                 return false;
 558         }
 559         expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
 560         if(block->length != expected_length) {
 561                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
 562                 return false;
 563         }
 564         if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
 565                 printf("FAILED, data mismatch\n");
 566                 return false;
 567         }
 568         printf("OK\n");
 569
 570         printf("testing FLAC__metadata_object_clone()... ");
 571         blockcopy = FLAC__metadata_object_clone(block);
 572         if(0 == blockcopy) {
 573                 printf("FAILED, returned NULL\n");
 574                 return false;
 575         }
 576         if(!compare_block_(block, blockcopy))
 577                 return false;
 578         printf("OK\n");
 579
 580         printf("testing FLAC__metadata_object_delete()... ");
 581         FLAC__metadata_object_delete(blockcopy);
 582         FLAC__metadata_object_delete(block);
 583         printf("OK\n");
 584
 585
 586         printf("testing SEEKTABLE\n");
 587
 588         for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
 589                 seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 590                 seekpoint_array[i].stream_offset = 0;
 591                 seekpoint_array[i].frame_samples = 0;
 592         }
 593
 594         seekpoints = 0;
 595         printf("testing FLAC__metadata_object_new()... ");
 596         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
 597         if(0 == block) {
 598                 printf("FAILED, returned NULL\n");
 599                 return false;
 600         }
 601         if(!check_seektable_(block, seekpoints, 0))
 602                 return false;
 603
 604         printf("testing FLAC__metadata_object_clone()... ");
 605         blockcopy = FLAC__metadata_object_clone(block);
 606         if(0 == blockcopy) {
 607                 printf("FAILED, returned NULL\n");
 608                 return false;
 609         }
 610         if(!compare_block_(block, blockcopy))
 611                 return false;
 612         printf("OK\n");
 613
 614         printf("testing FLAC__metadata_object_delete()... ");
 615         FLAC__metadata_object_delete(blockcopy);
 616         printf("OK\n");
 617
 618         seekpoints = 2;
 619         printf("testing FLAC__metadata_object_seektable_resize_points(grow to %u)...", seekpoints);
 620         if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
 621                 printf("FAILED, returned false\n");
 622                 return false;
 623         }
 624         if(!check_seektable_(block, seekpoints, seekpoint_array))
 625                 return false;
 626
 627         seekpoints = 1;
 628         printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
 629         if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
 630                 printf("FAILED, returned false\n");
 631                 return false;
 632         }
 633         if(!check_seektable_(block, seekpoints, seekpoint_array))
 634                 return false;
 635
 636         printf("testing FLAC__metadata_object_seektable_is_legal()...");
 637         if(!FLAC__metadata_object_seektable_is_legal(block)) {
 638                 printf("FAILED, returned false\n");
 639                 return false;
 640         }
 641         printf("OK\n");
 642
 643         seekpoints = 0;
 644         printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
 645         if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
 646                 printf("FAILED, returned false\n");
 647                 return false;
 648         }
 649         if(!check_seektable_(block, seekpoints, 0))
 650                 return false;
 651
 652         seekpoints++;
 653         printf("testing FLAC__metadata_object_seektable_insert_point() on empty array...");
 654         if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
 655                 printf("FAILED, returned false\n");
 656                 return false;
 657         }
 658         if(!check_seektable_(block, seekpoints, seekpoint_array))
 659                 return false;
 660
 661         seekpoint_array[0].sample_number = 1;
 662         seekpoints++;
 663         printf("testing FLAC__metadata_object_seektable_insert_point() on beginning of non-empty array...");
 664         if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
 665                 printf("FAILED, returned false\n");
 666                 return false;
 667         }
 668         if(!check_seektable_(block, seekpoints, seekpoint_array))
 669                 return false;
 670
 671         seekpoint_array[1].sample_number = 2;
 672         seekpoints++;
 673         printf("testing FLAC__metadata_object_seektable_insert_point() on middle of non-empty array...");
 674         if(!FLAC__metadata_object_seektable_insert_point(block, 1, seekpoint_array[1])) {
 675                 printf("FAILED, returned false\n");
 676                 return false;
 677         }
 678         if(!check_seektable_(block, seekpoints, seekpoint_array))
 679                 return false;
 680
 681         seekpoint_array[3].sample_number = 3;
 682         seekpoints++;
 683         printf("testing FLAC__metadata_object_seektable_insert_point() on end of non-empty array...");
 684         if(!FLAC__metadata_object_seektable_insert_point(block, 3, seekpoint_array[3])) {
 685                 printf("FAILED, returned false\n");
 686                 return false;
 687         }
 688         if(!check_seektable_(block, seekpoints, seekpoint_array))
 689                 return false;
 690
 691         printf("testing FLAC__metadata_object_clone()... ");
 692         blockcopy = FLAC__metadata_object_clone(block);
 693         if(0 == blockcopy) {
 694                 printf("FAILED, returned NULL\n");
 695                 return false;
 696         }
 697         if(!compare_block_(block, blockcopy))
 698                 return false;
 699         printf("OK\n");
 700
 701         printf("testing FLAC__metadata_object_delete()... ");
 702         FLAC__metadata_object_delete(blockcopy);
 703         printf("OK\n");
 704
 705         seekpoint_array[2].sample_number = seekpoint_array[3].sample_number;
 706         seekpoints--;
 707         printf("testing FLAC__metadata_object_seektable_delete_point() on middle of array...");
 708         if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
 709                 printf("FAILED, returned false\n");
 710                 return false;
 711         }
 712         if(!check_seektable_(block, seekpoints, seekpoint_array))
 713                 return false;
 714
 715         seekpoints--;
 716         printf("testing FLAC__metadata_object_seektable_delete_point() on end of array...");
 717         if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
 718                 printf("FAILED, returned false\n");
 719                 return false;
 720         }
 721         if(!check_seektable_(block, seekpoints, seekpoint_array))
 722                 return false;
 723
 724         seekpoints--;
 725         printf("testing FLAC__metadata_object_seektable_delete_point() on beginning of array...");
 726         if(!FLAC__metadata_object_seektable_delete_point(block, 0)) {
 727                 printf("FAILED, returned false\n");
 728                 return false;
 729         }
 730         if(!check_seektable_(block, seekpoints, seekpoint_array+1))
 731                 return false;
 732
 733         printf("testing FLAC__metadata_object_seektable_set_point()...");
 734         FLAC__metadata_object_seektable_set_point(block, 0, seekpoint_array[0]);
 735         if(!check_seektable_(block, seekpoints, seekpoint_array))
 736                 return false;
 737
 738         printf("testing FLAC__metadata_object_delete()... ");
 739         FLAC__metadata_object_delete(block);
 740         printf("OK\n");
 741
 742         /* seektable template functions */
 743
 744         for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
 745                 seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 746                 seekpoint_array[i].stream_offset = 0;
 747                 seekpoint_array[i].frame_samples = 0;
 748         }
 749
 750         seekpoints = 0;
 751         printf("testing FLAC__metadata_object_new()... ");
 752         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
 753         if(0 == block) {
 754                 printf("FAILED, returned NULL\n");
 755                 return false;
 756         }
 757         if(!check_seektable_(block, seekpoints, 0))
 758                 return false;
 759
 760         seekpoints += 2;
 761         printf("testing FLAC__metadata_object_seekpoint_template_append_placeholders()... ");
 762         if(!FLAC__metadata_object_seektable_template_append_placeholders(block, 2)) {
 763                 printf("FAILED, returned false\n");
 764                 return false;
 765         }
 766         if(!check_seektable_(block, seekpoints, seekpoint_array))
 767                 return false;
 768
 769         seekpoint_array[seekpoints++].sample_number = 7;
 770         printf("testing FLAC__metadata_object_seekpoint_template_append_point()... ");
 771         if(!FLAC__metadata_object_seektable_template_append_point(block, 7)) {
 772                 printf("FAILED, returned false\n");
 773                 return false;
 774         }
 775         if(!check_seektable_(block, seekpoints, seekpoint_array))
 776                 return false;
 777
 778         {
 779                 FLAC__uint64 nums[2] = { 3, 7 };
 780                 seekpoint_array[seekpoints++].sample_number = nums[0];
 781                 seekpoint_array[seekpoints++].sample_number = nums[1];
 782                 printf("testing FLAC__metadata_object_seekpoint_template_append_points()... ");
 783                 if(!FLAC__metadata_object_seektable_template_append_points(block, nums, sizeof(nums)/sizeof(FLAC__uint64))) {
 784                         printf("FAILED, returned false\n");
 785                         return false;
 786                 }
 787                 if(!check_seektable_(block, seekpoints, seekpoint_array))
 788                         return false;
 789         }
 790
 791         seekpoint_array[seekpoints++].sample_number = 0;
 792         seekpoint_array[seekpoints++].sample_number = 10;
 793         seekpoint_array[seekpoints++].sample_number = 20;
 794         printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points()... ");
 795         if(!FLAC__metadata_object_seektable_template_append_spaced_points(block, 3, 30)) {
 796                 printf("FAILED, returned false\n");
 797                 return false;
 798         }
 799         if(!check_seektable_(block, seekpoints, seekpoint_array))
 800                 return false;
 801
 802         seekpoints--;
 803         seekpoint_array[0].sample_number = 0;
 804         seekpoint_array[1].sample_number = 3;
 805         seekpoint_array[2].sample_number = 7;
 806         seekpoint_array[3].sample_number = 10;
 807         seekpoint_array[4].sample_number = 20;
 808         seekpoint_array[5].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 809         seekpoint_array[6].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 810         printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=true)... ");
 811         if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/true)) {
 812                 printf("FAILED, returned false\n");
 813                 return false;
 814         }
 815         if(!FLAC__metadata_object_seektable_is_legal(block)) {
 816                 printf("FAILED, seek table is illegal\n");
 817                 return false;
 818         }
 819         if(!check_seektable_(block, seekpoints, seekpoint_array))
 820                 return false;
 821
 822         printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=false)... ");
 823         if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/false)) {
 824                 printf("FAILED, returned false\n");
 825                 return false;
 826         }
 827         if(!FLAC__metadata_object_seektable_is_legal(block)) {
 828                 printf("FAILED, seek table is illegal\n");
 829                 return false;
 830         }
 831         if(!check_seektable_(block, seekpoints, seekpoint_array))
 832                 return false;
 833
 834         printf("testing FLAC__metadata_object_delete()... ");
 835         FLAC__metadata_object_delete(block);
 836         printf("OK\n");
 837
 838
 839         printf("testing VORBIS_COMMENT\n");
 840
 841         printf("testing FLAC__metadata_object_new()... ");
 842         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
 843         if(0 == block) {
 844                 printf("FAILED, returned NULL\n");
 845                 return false;
 846         }
 847         expected_length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + strlen(FLAC__VENDOR_STRING) + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN/8);
 848         if(block->length != expected_length) {
 849                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
 850                 return false;
 851         }
 852         printf("OK\n");
 853
 854         printf("testing FLAC__metadata_object_clone()... ");
 855         vorbiscomment = FLAC__metadata_object_clone(block);
 856         if(0 == vorbiscomment) {
 857                 printf("FAILED, returned NULL\n");
 858                 return false;
 859         }
 860         if(!compare_block_(vorbiscomment, block))
 861                 return false;
 862         printf("OK\n");
 863
 864         vc_resize_(vorbiscomment, 2);
 865         printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(grow to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
 866         if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
 867                 printf("FAILED, returned false\n");
 868                 return false;
 869         }
 870         if(!compare_block_(vorbiscomment, block))
 871                 return false;
 872         printf("OK\n");
 873
 874         vc_resize_(vorbiscomment, 1);
 875         printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
 876         if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
 877                 printf("FAILED, returned false\n");
 878                 return false;
 879         }
 880         if(!compare_block_(vorbiscomment, block))
 881                 return false;
 882         printf("OK\n");
 883
 884         vc_resize_(vorbiscomment, 0);
 885         printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
 886         if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
 887                 printf("FAILED, returned false\n");
 888                 return false;
 889         }
 890         if(!compare_block_(vorbiscomment, block))
 891                 return false;
 892         printf("OK\n");
 893
 894         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on empty array...");
 895         vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
 896         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
 897                 printf("FAILED, returned false\n");
 898                 return false;
 899         }
 900         if(!compare_block_(vorbiscomment, block))
 901                 return false;
 902         printf("OK\n");
 903
 904         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on beginning of non-empty array...");
 905         vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
 906         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
 907                 printf("FAILED, returned false\n");
 908                 return false;
 909         }
 910         if(!compare_block_(vorbiscomment, block))
 911                 return false;
 912         printf("OK\n");
 913
 914         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on middle of non-empty array...");
 915         vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
 916         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/true)) {
 917                 printf("FAILED, returned false\n");
 918                 return false;
 919         }
 920         if(!compare_block_(vorbiscomment, block))
 921                 return false;
 922         printf("OK\n");
 923
 924         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
 925         vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
 926         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/true)) {
 927                 printf("FAILED, returned false\n");
 928                 return false;
 929         }
 930         if(!compare_block_(vorbiscomment, block))
 931                 return false;
 932         printf("OK\n");
 933
 934         printf("testing FLAC__metadata_object_clone()... ");
 935         blockcopy = FLAC__metadata_object_clone(block);
 936         if(0 == blockcopy) {
 937                 printf("FAILED, returned NULL\n");
 938                 return false;
 939         }
 940         if(!compare_block_(block, blockcopy))
 941                 return false;
 942         printf("OK\n");
 943
 944         printf("testing FLAC__metadata_object_delete()... ");
 945         FLAC__metadata_object_delete(blockcopy);
 946         printf("OK\n");
 947
 948         printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
 949         vc_delete_(vorbiscomment, 2);
 950         if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
 951                 printf("FAILED, returned false\n");
 952                 return false;
 953         }
 954         if(!compare_block_(vorbiscomment, block))
 955                 return false;
 956         printf("OK\n");
 957
 958         printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
 959         vc_delete_(vorbiscomment, 2);
 960         if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
 961                 printf("FAILED, returned false\n");
 962                 return false;
 963         }
 964         if(!compare_block_(vorbiscomment, block))
 965                 return false;
 966         printf("OK\n");
 967
 968         printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
 969         vc_delete_(vorbiscomment, 0);
 970         if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
 971                 printf("FAILED, returned false\n");
 972                 return false;
 973         }
 974         if(!compare_block_(vorbiscomment, block))
 975                 return false;
 976         printf("OK\n");
 977
 978         printf("testing FLAC__metadata_object_vorbiscomment_set_comment(copy)...");
 979         vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
 980         FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/true);
 981         if(!compare_block_(vorbiscomment, block))
 982                 return false;
 983         printf("OK\n");
 984
 985         printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(copy)...");
 986         vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
 987         FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/true);
 988         if(!compare_block_(vorbiscomment, block))
 989                 return false;
 990         printf("OK\n");
 991
 992         printf("testing FLAC__metadata_object_delete()... ");
 993         FLAC__metadata_object_delete(vorbiscomment);
 994         FLAC__metadata_object_delete(block);
 995         printf("OK\n");
 996
 997
 998         printf("testing FLAC__metadata_object_new()... ");
 999         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
1000         if(0 == block) {
1001                 printf("FAILED, returned NULL\n");
1002                 return false;
1003         }
1004         printf("OK\n");
1005
1006         printf("testing FLAC__metadata_object_clone()... ");
1007         vorbiscomment = FLAC__metadata_object_clone(block);
1008         if(0 == vorbiscomment) {
1009                 printf("FAILED, returned NULL\n");
1010                 return false;
1011         }
1012         if(!compare_block_(vorbiscomment, block))
1013                 return false;
1014         printf("OK\n");
1015
1016         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on empty array...");
1017         vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
1018         entry_clone_(&entry);
1019         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
1020                 printf("FAILED, returned false\n");
1021                 return false;
1022         }
1023         if(!compare_block_(vorbiscomment, block))
1024                 return false;
1025         printf("OK\n");
1026
1027         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on beginning of non-empty array...");
1028         vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
1029         entry_clone_(&entry);
1030         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
1031                 printf("FAILED, returned false\n");
1032                 return false;
1033         }
1034         if(!compare_block_(vorbiscomment, block))
1035                 return false;
1036         printf("OK\n");
1037
1038         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on middle of non-empty array...");
1039         vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
1040         entry_clone_(&entry);
1041         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/false)) {
1042                 printf("FAILED, returned false\n");
1043                 return false;
1044         }
1045         if(!compare_block_(vorbiscomment, block))
1046                 return false;
1047         printf("OK\n");
1048
1049         printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
1050         vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
1051         entry_clone_(&entry);
1052         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/false)) {
1053                 printf("FAILED, returned false\n");
1054                 return false;
1055         }
1056         if(!compare_block_(vorbiscomment, block))
1057                 return false;
1058         printf("OK\n");
1059
1060         printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
1061         vc_delete_(vorbiscomment, 2);
1062         if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
1063                 printf("FAILED, returned false\n");
1064                 return false;
1065         }
1066         if(!compare_block_(vorbiscomment, block))
1067                 return false;
1068         printf("OK\n");
1069
1070         printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
1071         vc_delete_(vorbiscomment, 2);
1072         if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
1073                 printf("FAILED, returned false\n");
1074                 return false;
1075         }
1076         if(!compare_block_(vorbiscomment, block))
1077                 return false;
1078         printf("OK\n");
1079
1080         printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
1081         vc_delete_(vorbiscomment, 0);
1082         if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
1083                 printf("FAILED, returned false\n");
1084                 return false;
1085         }
1086         if(!compare_block_(vorbiscomment, block))
1087                 return false;
1088         printf("OK\n");
1089
1090         printf("testing FLAC__metadata_object_vorbiscomment_set_comment(own)...");
1091         vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
1092         entry_clone_(&entry);
1093         FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/false);
1094         if(!compare_block_(vorbiscomment, block))
1095                 return false;
1096         printf("OK\n");
1097
1098         printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(own)...");
1099         vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
1100         entry_clone_(&entry);
1101         FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/false);
1102         if(!compare_block_(vorbiscomment, block))
1103                 return false;
1104         printf("OK\n");
1105
1106         printf("testing FLAC__metadata_object_delete()... ");
1107         FLAC__metadata_object_delete(vorbiscomment);
1108         FLAC__metadata_object_delete(block);
1109         printf("OK\n");
1110
1111
1112
1113         printf("testing CUESHEET\n");
1114
1115         {
1116                 FLAC__StreamMetadata_CueSheet_Track *track_, *trackcopy_;
1117
1118                 printf("testing FLAC__metadata_object_cuesheet_track_new()... ");
1119                 track_ = FLAC__metadata_object_cuesheet_track_new();
1120                 if(0 == track_) {
1121                         printf("FAILED, returned NULL\n");
1122                         return false;
1123                 }
1124                 printf("OK\n");
1125
1126                 printf("testing FLAC__metadata_object_cuesheet_track_clone()... ");
1127                 trackcopy_ = FLAC__metadata_object_cuesheet_track_clone(track_);
1128                 if(0 == trackcopy_) {
1129                         printf("FAILED, returned NULL\n");
1130                         return false;
1131                 }
1132                 if(!compare_track_(trackcopy_, track_))
1133                         return false;
1134                 printf("OK\n");
1135
1136                 printf("testing FLAC__metadata_object_cuesheet_track_delete()... ");
1137                 FLAC__metadata_object_cuesheet_track_delete(trackcopy_);
1138                 FLAC__metadata_object_cuesheet_track_delete(track_);
1139                 printf("OK\n");
1140         }
1141
1142
1143         printf("testing FLAC__metadata_object_new()... ");
1144         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
1145         if(0 == block) {
1146                 printf("FAILED, returned NULL\n");
1147                 return false;
1148         }
1149         expected_length = (
1150                 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
1151                 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
1152                 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
1153                 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
1154                 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
1155         ) / 8;
1156         if(block->length != expected_length) {
1157                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
1158                 return false;
1159         }
1160         printf("OK\n");
1161
1162         printf("testing FLAC__metadata_object_clone()... ");
1163         cuesheet = FLAC__metadata_object_clone(block);
1164         if(0 == cuesheet) {
1165                 printf("FAILED, returned NULL\n");
1166                 return false;
1167         }
1168         if(!compare_block_(cuesheet, block))
1169                 return false;
1170         printf("OK\n");
1171
1172         cs_resize_(cuesheet, 2);
1173         printf("testing FLAC__metadata_object_cuesheet_resize_tracks(grow to %u)...", cuesheet->data.cue_sheet.num_tracks);
1174         if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
1175                 printf("FAILED, returned false\n");
1176                 return false;
1177         }
1178         if(!compare_block_(cuesheet, block))
1179                 return false;
1180         printf("OK\n");
1181
1182         cs_resize_(cuesheet, 1);
1183         printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
1184         if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
1185                 printf("FAILED, returned false\n");
1186                 return false;
1187         }
1188         if(!compare_block_(cuesheet, block))
1189                 return false;
1190         printf("OK\n");
1191
1192         cs_resize_(cuesheet, 0);
1193         printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
1194         if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
1195                 printf("FAILED, returned false\n");
1196                 return false;
1197         }
1198         if(!compare_block_(cuesheet, block))
1199                 return false;
1200         printf("OK\n");
1201
1202         printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on empty array...");
1203         cs_insert_new_(&track, cuesheet, 0, 0, 1, "ABCDE1234567", false, false);
1204         if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
1205                 printf("FAILED, returned false\n");
1206                 return false;
1207         }
1208         if(!compare_block_(cuesheet, block))
1209                 return false;
1210         printf("OK\n");
1211
1212         printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on beginning of non-empty array...");
1213         cs_insert_new_(&track, cuesheet, 0, 10, 2, "BBCDE1234567", false, false);
1214         if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
1215                 printf("FAILED, returned false\n");
1216                 return false;
1217         }
1218         if(!compare_block_(cuesheet, block))
1219                 return false;
1220         printf("OK\n");
1221
1222         printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on middle of non-empty array...");
1223         cs_insert_new_(&track, cuesheet, 1, 20, 3, "CBCDE1234567", false, false);
1224         if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/true)) {
1225                 printf("FAILED, returned false\n");
1226                 return false;
1227         }
1228         if(!compare_block_(cuesheet, block))
1229                 return false;
1230         printf("OK\n");
1231
1232         printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on end of non-empty array...");
1233         cs_insert_new_(&track, cuesheet, 3, 30, 4, "DBCDE1234567", false, false);
1234         if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/true)) {
1235                 printf("FAILED, returned false\n");
1236                 return false;
1237         }
1238         if(!compare_block_(cuesheet, block))
1239                 return false;
1240         printf("OK\n");
1241
1242         printf("testing FLAC__metadata_object_clone()... ");
1243         blockcopy = FLAC__metadata_object_clone(block);
1244         if(0 == blockcopy) {
1245                 printf("FAILED, returned NULL\n");
1246                 return false;
1247         }
1248         if(!compare_block_(block, blockcopy))
1249                 return false;
1250         printf("OK\n");
1251
1252         printf("testing FLAC__metadata_object_delete()... ");
1253         FLAC__metadata_object_delete(blockcopy);
1254         printf("OK\n");
1255
1256         printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
1257         cs_delete_(cuesheet, 2);
1258         if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
1259                 printf("FAILED, returned false\n");
1260                 return false;
1261         }
1262         if(!compare_block_(cuesheet, block))
1263                 return false;
1264         printf("OK\n");
1265
1266         printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
1267         cs_delete_(cuesheet, 2);
1268         if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
1269                 printf("FAILED, returned false\n");
1270                 return false;
1271         }
1272         if(!compare_block_(cuesheet, block))
1273                 return false;
1274         printf("OK\n");
1275
1276         printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
1277         cs_delete_(cuesheet, 0);
1278         if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
1279                 printf("FAILED, returned false\n");
1280                 return false;
1281         }
1282         if(!compare_block_(cuesheet, block))
1283                 return false;
1284         printf("OK\n");
1285
1286         printf("testing FLAC__metadata_object_cuesheet_set_track(copy)...");
1287         cs_set_new_(&track, cuesheet, 0, 40, 5, "EBCDE1234567", false, false);
1288         FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/true);
1289         if(!compare_block_(cuesheet, block))
1290                 return false;
1291         printf("OK\n");
1292
1293         tr_resize_(cuesheet, 0, 2);
1294         printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(grow to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
1295         if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
1296                 printf("FAILED, returned false\n");
1297                 return false;
1298         }
1299         if(!compare_block_(cuesheet, block))
1300                 return false;
1301         printf("OK\n");
1302
1303         tr_resize_(cuesheet, 0, 1);
1304         printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
1305         if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
1306                 printf("FAILED, returned false\n");
1307                 return false;
1308         }
1309         if(!compare_block_(cuesheet, block))
1310                 return false;
1311         printf("OK\n");
1312
1313         tr_resize_(cuesheet, 0, 0);
1314         printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
1315         if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
1316                 printf("FAILED, returned false\n");
1317                 return false;
1318         }
1319         if(!compare_block_(cuesheet, block))
1320                 return false;
1321         printf("OK\n");
1322
1323         index.offset = 0;
1324         index.number = 1;
1325         printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on empty array...");
1326         tr_insert_new_(cuesheet, 0, 0, index);
1327         if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) {
1328                 printf("FAILED, returned false\n");
1329                 return false;
1330         }
1331         if(!compare_block_(cuesheet, block))
1332                 return false;
1333         printf("OK\n");
1334
1335         index.offset = 10;
1336         index.number = 2;
1337         printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on beginning of non-empty array...");
1338         tr_insert_new_(cuesheet, 0, 0, index);
1339         if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) {
1340                 printf("FAILED, returned false\n");
1341                 return false;
1342         }
1343         if(!compare_block_(cuesheet, block))
1344                 return false;
1345         printf("OK\n");
1346
1347         index.offset = 20;
1348         index.number = 3;
1349         printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on middle of non-empty array...");
1350         tr_insert_new_(cuesheet, 0, 1, index);
1351         if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 1, index)) {
1352                 printf("FAILED, returned false\n");
1353                 return false;
1354         }
1355         if(!compare_block_(cuesheet, block))
1356                 return false;
1357         printf("OK\n");
1358
1359         index.offset = 30;
1360         index.number = 4;
1361         printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on end of non-empty array...");
1362         tr_insert_new_(cuesheet, 0, 3, index);
1363         if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 3, index)) {
1364                 printf("FAILED, returned false\n");
1365                 return false;
1366         }
1367         if(!compare_block_(cuesheet, block))
1368                 return false;
1369         printf("OK\n");
1370
1371         printf("testing FLAC__metadata_object_clone()... ");
1372         blockcopy = FLAC__metadata_object_clone(block);
1373         if(0 == blockcopy) {
1374                 printf("FAILED, returned NULL\n");
1375                 return false;
1376         }
1377         if(!compare_block_(block, blockcopy))
1378                 return false;
1379         printf("OK\n");
1380
1381         printf("testing FLAC__metadata_object_delete()... ");
1382         FLAC__metadata_object_delete(blockcopy);
1383         printf("OK\n");
1384
1385         printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on middle of array...");
1386         tr_delete_(cuesheet, 0, 2);
1387         if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
1388                 printf("FAILED, returned false\n");
1389                 return false;
1390         }
1391         if(!compare_block_(cuesheet, block))
1392                 return false;
1393         printf("OK\n");
1394
1395         printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array...");
1396         tr_delete_(cuesheet, 0, 2);
1397         if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
1398                 printf("FAILED, returned false\n");
1399                 return false;
1400         }
1401         if(!compare_block_(cuesheet, block))
1402                 return false;
1403         printf("OK\n");
1404
1405         printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on beginning of array...");
1406         tr_delete_(cuesheet, 0, 0);
1407         if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 0)) {
1408                 printf("FAILED, returned false\n");
1409                 return false;
1410         }
1411         if(!compare_block_(cuesheet, block))
1412                 return false;
1413         printf("OK\n");
1414
1415         printf("testing FLAC__metadata_object_delete()... ");
1416         FLAC__metadata_object_delete(cuesheet);
1417         FLAC__metadata_object_delete(block);
1418         printf("OK\n");
1419
1420
1421         printf("testing FLAC__metadata_object_new()... ");
1422         block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
1423         if(0 == block) {
1424                 printf("FAILED, returned NULL\n");
1425                 return false;
1426         }
1427         printf("OK\n");
1428
1429         printf("testing FLAC__metadata_object_clone()... ");
1430         cuesheet = FLAC__metadata_object_clone(block);
1431         if(0 == cuesheet) {
1432                 printf("FAILED, returned NULL\n");
1433                 return false;
1434         }
1435         if(!compare_block_(cuesheet, block))
1436                 return false;
1437         printf("OK\n");
1438
1439         printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on empty array...");
1440         cs_insert_new_(&track, cuesheet, 0, 60, 7, "GBCDE1234567", false, false);
1441         track_clone_(&track);
1442         if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
1443                 printf("FAILED, returned false\n");
1444                 return false;
1445         }
1446         if(!compare_block_(cuesheet, block))
1447                 return false;
1448         printf("OK\n");
1449
1450         printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on beginning of non-empty array...");
1451         cs_insert_new_(&track, cuesheet, 0, 70, 8, "HBCDE1234567", false, false);
1452         track_clone_(&track);
1453         if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
1454                 printf("FAILED, returned false\n");
1455                 return false;
1456         }
1457         if(!compare_block_(cuesheet, block))
1458                 return false;
1459         printf("OK\n");
1460
1461         printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on middle of non-empty array...");
1462         cs_insert_new_(&track, cuesheet, 1, 80, 9, "IBCDE1234567", false, false);
1463         track_clone_(&track);
1464         if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/false)) {
1465                 printf("FAILED, returned false\n");
1466                 return false;
1467         }
1468         if(!compare_block_(cuesheet, block))
1469                 return false;
1470         printf("OK\n");
1471
1472         printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on end of non-empty array...");
1473         cs_insert_new_(&track, cuesheet, 3, 90, 10, "JBCDE1234567", false, false);
1474         track_clone_(&track);
1475         if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/false)) {
1476                 printf("FAILED, returned false\n");
1477                 return false;
1478         }
1479         if(!compare_block_(cuesheet, block))
1480                 return false;
1481         printf("OK\n");
1482
1483         printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
1484         cs_delete_(cuesheet, 2);
1485         if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
1486                 printf("FAILED, returned false\n");
1487                 return false;
1488         }
1489         if(!compare_block_(cuesheet, block))
1490                 return false;
1491         printf("OK\n");
1492
1493         printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
1494         cs_delete_(cuesheet, 2);
1495         if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
1496                 printf("FAILED, returned false\n");
1497                 return false;
1498         }
1499         if(!compare_block_(cuesheet, block))
1500                 return false;
1501         printf("OK\n");
1502
1503         printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
1504         cs_delete_(cuesheet, 0);
1505         if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
1506                 printf("FAILED, returned false\n");
1507                 return false;
1508         }
1509         if(!compare_block_(cuesheet, block))
1510                 return false;
1511         printf("OK\n");
1512
1513         printf("testing FLAC__metadata_object_cuesheet_set_track(own)...");
1514         cs_set_new_(&track, cuesheet, 0, 100, 11, "KBCDE1234567", false, false);
1515         track_clone_(&track);
1516         FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/false);
1517         if(!compare_block_(cuesheet, block))
1518                 return false;
1519         printf("OK\n");
1520
1521         printf("testing FLAC__metadata_object_cuesheet_is_legal()...");
1522         {
1523                 const char *violation;
1524                 if(FLAC__metadata_object_cuesheet_is_legal(block, /*check_cd_da_subset=*/true, &violation)) {
1525                         printf("FAILED, returned true when expecting false\n");
1526                         return false;
1527                 }
1528                 printf("returned false as expected, violation=\"%s\" OK\n", violation);
1529         }
1530
1531         printf("testing FLAC__metadata_object_delete()... ");
1532         FLAC__metadata_object_delete(cuesheet);
1533         FLAC__metadata_object_delete(block);
1534         printf("OK\n");
1535
1536
1537         return true;
1538 }