src/test_libFLAC++/metadata_object.cpp

   1 /* test_libFLAC++ - Unit tester for libFLAC++
   2  * Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009  Josh Coalson
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h> /* for malloc() */
  21 #include <string.h> /* for memcmp() */
  22 #include "FLAC/assert.h"
  23 #include "FLAC++/metadata.h"
  24 #include "share/safe_str.h"
  25
  26 static ::FLAC__StreamMetadata streaminfo_, padding_, seektable_, application_, vorbiscomment_, cuesheet_, picture_;
  27
  28 static bool die_(const char *msg)
  29 {
  30         printf("FAILED, %s\n", msg);
  31         return false;
  32 }
  33
  34 static void *malloc_or_die_(size_t size)
  35 {
  36         void *x = malloc(size);
  37         if(0 == x) {
  38                 fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)size);
  39                 exit(1);
  40         }
  41         return x;
  42 }
  43
  44 static char *strdup_or_die_(const char *s)
  45 {
  46         char *x = strdup(s);
  47         if(0 == x) {
  48                 fprintf(stderr, "ERROR: out of memory copying string \"%s\"\n", s);
  49                 exit(1);
  50         }
  51         return x;
  52 }
  53
  54 static bool index_is_equal_(const ::FLAC__StreamMetadata_CueSheet_Index &indx, const ::FLAC__StreamMetadata_CueSheet_Index &indxcopy)
  55 {
  56         if(indxcopy.offset != indx.offset)
  57                 return false;
  58         if(indxcopy.number != indx.number)
  59                 return false;
  60         return true;
  61 }
  62
  63 static bool track_is_equal_(const ::FLAC__StreamMetadata_CueSheet_Track *track, const ::FLAC__StreamMetadata_CueSheet_Track *trackcopy)
  64 {
  65         unsigned i;
  66
  67         if(trackcopy->offset != track->offset)
  68                 return false;
  69         if(trackcopy->number != track->number)
  70                 return false;
  71         if(0 != strcmp(trackcopy->isrc, track->isrc))
  72                 return false;
  73         if(trackcopy->type != track->type)
  74                 return false;
  75         if(trackcopy->pre_emphasis != track->pre_emphasis)
  76                 return false;
  77         if(trackcopy->num_indices != track->num_indices)
  78                 return false;
  79         if(0 == track->indices || 0 == trackcopy->indices) {
  80                 if(track->indices != trackcopy->indices)
  81                         return false;
  82         }
  83         else {
  84                 for(i = 0; i < track->num_indices; i++) {
  85                         if(!index_is_equal_(trackcopy->indices[i], track->indices[i]))
  86                                 return false;
  87                 }
  88         }
  89         return true;
  90 }
  91
  92 static void init_metadata_blocks_()
  93 {
  94         streaminfo_.is_last = false;
  95         streaminfo_.type = ::FLAC__METADATA_TYPE_STREAMINFO;
  96         streaminfo_.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
  97         streaminfo_.data.stream_info.min_blocksize = 576;
  98         streaminfo_.data.stream_info.max_blocksize = 576;
  99         streaminfo_.data.stream_info.min_framesize = 0;
 100         streaminfo_.data.stream_info.max_framesize = 0;
 101         streaminfo_.data.stream_info.sample_rate = 44100;
 102         streaminfo_.data.stream_info.channels = 1;
 103         streaminfo_.data.stream_info.bits_per_sample = 8;
 104         streaminfo_.data.stream_info.total_samples = 0;
 105         memset(streaminfo_.data.stream_info.md5sum, 0, 16);
 106
 107         padding_.is_last = false;
 108         padding_.type = ::FLAC__METADATA_TYPE_PADDING;
 109         padding_.length = 1234;
 110
 111         seektable_.is_last = false;
 112         seektable_.type = ::FLAC__METADATA_TYPE_SEEKTABLE;
 113         seektable_.data.seek_table.num_points = 2;
 114         seektable_.length = seektable_.data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
 115         seektable_.data.seek_table.points = (::FLAC__StreamMetadata_SeekPoint*)malloc_or_die_(seektable_.data.seek_table.num_points * sizeof(::FLAC__StreamMetadata_SeekPoint));
 116         seektable_.data.seek_table.points[0].sample_number = 0;
 117         seektable_.data.seek_table.points[0].stream_offset = 0;
 118         seektable_.data.seek_table.points[0].frame_samples = streaminfo_.data.stream_info.min_blocksize;
 119         seektable_.data.seek_table.points[1].sample_number = ::FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 120         seektable_.data.seek_table.points[1].stream_offset = 1000;
 121         seektable_.data.seek_table.points[1].frame_samples = streaminfo_.data.stream_info.min_blocksize;
 122
 123         application_.is_last = false;
 124         application_.type = ::FLAC__METADATA_TYPE_APPLICATION;
 125         application_.length = 8;
 126         memcpy(application_.data.application.id, "\xfe\xdc\xba\x98", 4);
 127         application_.data.application.data = (FLAC__byte*)malloc_or_die_(4);
 128         memcpy(application_.data.application.data, "\xf0\xe1\xd2\xc3", 4);
 129
 130         vorbiscomment_.is_last = false;
 131         vorbiscomment_.type = ::FLAC__METADATA_TYPE_VORBIS_COMMENT;
 132         vorbiscomment_.length = (4 + 5) + 4 + (4 + 12) + (4 + 12);
 133         vorbiscomment_.data.vorbis_comment.vendor_string.length = 5;
 134         vorbiscomment_.data.vorbis_comment.vendor_string.entry = (FLAC__byte*)malloc_or_die_(5+1);
 135         memcpy(vorbiscomment_.data.vorbis_comment.vendor_string.entry, "name0", 5+1);
 136         vorbiscomment_.data.vorbis_comment.num_comments = 2;
 137         vorbiscomment_.data.vorbis_comment.comments = (::FLAC__StreamMetadata_VorbisComment_Entry*)malloc_or_die_(vorbiscomment_.data.vorbis_comment.num_comments * sizeof(::FLAC__StreamMetadata_VorbisComment_Entry));
 138         vorbiscomment_.data.vorbis_comment.comments[0].length = 12;
 139         vorbiscomment_.data.vorbis_comment.comments[0].entry = (FLAC__byte*)malloc_or_die_(12+1);
 140         memcpy(vorbiscomment_.data.vorbis_comment.comments[0].entry, "name2=value2", 12+1);
 141         vorbiscomment_.data.vorbis_comment.comments[1].length = 12;
 142         vorbiscomment_.data.vorbis_comment.comments[1].entry = (FLAC__byte*)malloc_or_die_(12+1);
 143         memcpy(vorbiscomment_.data.vorbis_comment.comments[1].entry, "name3=value3", 12+1);
 144
 145         cuesheet_.is_last = false;
 146         cuesheet_.type = ::FLAC__METADATA_TYPE_CUESHEET;
 147         cuesheet_.length =
 148                 /* cuesheet guts */
 149                 (
 150                         FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
 151                         FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
 152                         FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
 153                         FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
 154                         FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
 155                 ) / 8 +
 156                 /* 2 tracks */
 157                 2 * (
 158                         FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
 159                         FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
 160                         FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
 161                         FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
 162                         FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
 163                         FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
 164                         FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
 165                 ) / 8 +
 166                 /* 3 index points */
 167                 3 * (
 168                         FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
 169                         FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
 170                         FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
 171                 ) / 8
 172         ;
 173         memset(cuesheet_.data.cue_sheet.media_catalog_number, 0, sizeof(cuesheet_.data.cue_sheet.media_catalog_number));
 174         cuesheet_.data.cue_sheet.media_catalog_number[0] = 'j';
 175         cuesheet_.data.cue_sheet.media_catalog_number[1] = 'C';
 176         cuesheet_.data.cue_sheet.lead_in = 159;
 177         cuesheet_.data.cue_sheet.is_cd = true;
 178         cuesheet_.data.cue_sheet.num_tracks = 2;
 179         cuesheet_.data.cue_sheet.tracks = (FLAC__StreamMetadata_CueSheet_Track*)malloc_or_die_(cuesheet_.data.cue_sheet.num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track));
 180         cuesheet_.data.cue_sheet.tracks[0].offset = 1;
 181         cuesheet_.data.cue_sheet.tracks[0].number = 1;
 182         memcpy(cuesheet_.data.cue_sheet.tracks[0].isrc, "ACBDE1234567", sizeof(cuesheet_.data.cue_sheet.tracks[0].isrc));
 183         cuesheet_.data.cue_sheet.tracks[0].type = 0;
 184         cuesheet_.data.cue_sheet.tracks[0].pre_emphasis = 1;
 185         cuesheet_.data.cue_sheet.tracks[0].num_indices = 2;
 186         cuesheet_.data.cue_sheet.tracks[0].indices = (FLAC__StreamMetadata_CueSheet_Index*)malloc_or_die_(cuesheet_.data.cue_sheet.tracks[0].num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
 187         cuesheet_.data.cue_sheet.tracks[0].indices[0].offset = 0;
 188         cuesheet_.data.cue_sheet.tracks[0].indices[0].number = 0;
 189         cuesheet_.data.cue_sheet.tracks[0].indices[1].offset = 1234567890;
 190         cuesheet_.data.cue_sheet.tracks[0].indices[1].number = 1;
 191         cuesheet_.data.cue_sheet.tracks[1].offset = 2345678901u;
 192         cuesheet_.data.cue_sheet.tracks[1].number = 2;
 193         memcpy(cuesheet_.data.cue_sheet.tracks[1].isrc, "ACBDE7654321", sizeof(cuesheet_.data.cue_sheet.tracks[1].isrc));
 194         cuesheet_.data.cue_sheet.tracks[1].type = 1;
 195         cuesheet_.data.cue_sheet.tracks[1].pre_emphasis = 0;
 196         cuesheet_.data.cue_sheet.tracks[1].num_indices = 1;
 197         cuesheet_.data.cue_sheet.tracks[1].indices = (FLAC__StreamMetadata_CueSheet_Index*)malloc_or_die_(cuesheet_.data.cue_sheet.tracks[1].num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
 198         cuesheet_.data.cue_sheet.tracks[1].indices[0].offset = 0;
 199         cuesheet_.data.cue_sheet.tracks[1].indices[0].number = 1;
 200
 201         picture_.is_last = true;
 202         picture_.type = FLAC__METADATA_TYPE_PICTURE;
 203         picture_.length =
 204                 (
 205                         FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
 206                         FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + /* will add the length for the string later */
 207                         FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + /* will add the length for the string later */
 208                         FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
 209                         FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
 210                         FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
 211                         FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
 212                         FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN /* will add the length for the data later */
 213                 ) / 8
 214         ;
 215         picture_.data.picture.type = FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER;
 216         picture_.data.picture.mime_type = strdup_or_die_("image/jpeg");
 217         picture_.length += strlen(picture_.data.picture.mime_type);
 218         picture_.data.picture.description = (FLAC__byte*)strdup_or_die_("desc");
 219         picture_.length += strlen((const char *)picture_.data.picture.description);
 220         picture_.data.picture.width = 300;
 221         picture_.data.picture.height = 300;
 222         picture_.data.picture.depth = 24;
 223         picture_.data.picture.colors = 0;
 224         picture_.data.picture.data = (FLAC__byte*)strdup_or_die_("SOMEJPEGDATA");
 225         picture_.data.picture.data_length = strlen((const char *)picture_.data.picture.data);
 226         picture_.length += picture_.data.picture.data_length;
 227 }
 228
 229 static void free_metadata_blocks_()
 230 {
 231         free(seektable_.data.seek_table.points);
 232         free(application_.data.application.data);
 233         free(vorbiscomment_.data.vorbis_comment.vendor_string.entry);
 234         free(vorbiscomment_.data.vorbis_comment.comments[0].entry);
 235         free(vorbiscomment_.data.vorbis_comment.comments[1].entry);
 236         free(vorbiscomment_.data.vorbis_comment.comments);
 237         free(cuesheet_.data.cue_sheet.tracks[0].indices);
 238         free(cuesheet_.data.cue_sheet.tracks[1].indices);
 239         free(cuesheet_.data.cue_sheet.tracks);
 240         free(picture_.data.picture.mime_type);
 241         free(picture_.data.picture.description);
 242         free(picture_.data.picture.data);
 243 }
 244
 245 bool test_metadata_object_streaminfo()
 246 {
 247         unsigned expected_length;
 248
 249         printf("testing class FLAC::Metadata::StreamInfo\n");
 250
 251         printf("testing StreamInfo::StreamInfo()... ");
 252         FLAC::Metadata::StreamInfo block;
 253         if(!block.is_valid())
 254                 return die_("!block.is_valid()");
 255         expected_length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
 256         if(block.get_length() != expected_length) {
 257                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length());
 258                 return false;
 259         }
 260         printf("OK\n");
 261
 262         printf("testing StreamInfo::StreamInfo(const StreamInfo &)... +\n");
 263         printf("        StreamInfo::operator!=(const StreamInfo &)... ");
 264         {
 265                 FLAC::Metadata::StreamInfo blockcopy(block);
 266                 if(!blockcopy.is_valid())
 267                         return die_("!blockcopy.is_valid()");
 268                 if(blockcopy != block)
 269                         return die_("copy is not identical to original");
 270                 printf("OK\n");
 271
 272                 printf("testing StreamInfo::~StreamInfo()... ");
 273         }
 274         printf("OK\n");
 275
 276         printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata &)... +\n");
 277         printf("        StreamInfo::operator!=(const ::FLAC__StreamMetadata &)... ");
 278         {
 279                 FLAC::Metadata::StreamInfo blockcopy(streaminfo_);
 280                 if(!blockcopy.is_valid())
 281                         return die_("!blockcopy.is_valid()");
 282                 if(blockcopy != streaminfo_)
 283                         return die_("copy is not identical to original");
 284                 printf("OK\n");
 285         }
 286
 287         printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata *)... +\n");
 288         printf("        StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... ");
 289         {
 290                 FLAC::Metadata::StreamInfo blockcopy(&streaminfo_);
 291                 if(!blockcopy.is_valid())
 292                         return die_("!blockcopy.is_valid()");
 293                 if(blockcopy != streaminfo_)
 294                         return die_("copy is not identical to original");
 295                 printf("OK\n");
 296         }
 297
 298         printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 299         printf("        StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... ");
 300         {
 301                 FLAC::Metadata::StreamInfo blockcopy(&streaminfo_, /*copy=*/true);
 302                 if(!blockcopy.is_valid())
 303                         return die_("!blockcopy.is_valid()");
 304                 if(blockcopy != streaminfo_)
 305                         return die_("copy is not identical to original");
 306                 printf("OK\n");
 307         }
 308
 309         printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 310         printf("        StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... ");
 311         {
 312                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&streaminfo_);
 313                 FLAC::Metadata::StreamInfo blockcopy(copy, /*copy=*/false);
 314                 if(!blockcopy.is_valid())
 315                         return die_("!blockcopy.is_valid()");
 316                 if(blockcopy != streaminfo_)
 317                         return die_("copy is not identical to original");
 318                 printf("OK\n");
 319         }
 320
 321         printf("testing StreamInfo::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 322         printf("        StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... ");
 323         {
 324                 FLAC::Metadata::StreamInfo blockcopy;
 325                 blockcopy.assign(&streaminfo_, /*copy=*/true);
 326                 if(!blockcopy.is_valid())
 327                         return die_("!blockcopy.is_valid()");
 328                 if(blockcopy != streaminfo_)
 329                         return die_("copy is not identical to original");
 330                 printf("OK\n");
 331         }
 332
 333         printf("testing StreamInfo::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 334         printf("        StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... ");
 335         {
 336                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&streaminfo_);
 337                 FLAC::Metadata::StreamInfo blockcopy;
 338                 blockcopy.assign(copy, /*copy=*/false);
 339                 if(!blockcopy.is_valid())
 340                         return die_("!blockcopy.is_valid()");
 341                 if(blockcopy != streaminfo_)
 342                         return die_("copy is not identical to original");
 343                 printf("OK\n");
 344         }
 345
 346         printf("testing StreamInfo::operator=(const StreamInfo &)... +\n");
 347         printf("        StreamInfo::operator==(const StreamInfo &)... ");
 348         {
 349                 FLAC::Metadata::StreamInfo blockcopy = block;
 350                 if(!blockcopy.is_valid())
 351                         return die_("!blockcopy.is_valid()");
 352                 if(!(blockcopy == block))
 353                         return die_("copy is not identical to original");
 354                 printf("OK\n");
 355         }
 356
 357         printf("testing StreamInfo::operator=(const ::FLAC__StreamMetadata &)... +\n");
 358         printf("        StreamInfo::operator==(const ::FLAC__StreamMetadata &)... ");
 359         {
 360                 FLAC::Metadata::StreamInfo blockcopy = streaminfo_;
 361                 if(!blockcopy.is_valid())
 362                         return die_("!blockcopy.is_valid()");
 363                 if(!(blockcopy == streaminfo_))
 364                         return die_("copy is not identical to original");
 365                 printf("OK\n");
 366         }
 367
 368         printf("testing StreamInfo::operator=(const ::FLAC__StreamMetadata *)... +\n");
 369         printf("        StreamInfo::operator==(const ::FLAC__StreamMetadata *)... ");
 370         {
 371                 FLAC::Metadata::StreamInfo blockcopy = &streaminfo_;
 372                 if(!blockcopy.is_valid())
 373                         return die_("!blockcopy.is_valid()");
 374                 if(!(blockcopy == streaminfo_))
 375                         return die_("copy is not identical to original");
 376                 printf("OK\n");
 377         }
 378
 379         printf("testing StreamInfo::set_min_blocksize()... ");
 380         block.set_min_blocksize(streaminfo_.data.stream_info.min_blocksize);
 381         printf("OK\n");
 382
 383         printf("testing StreamInfo::set_max_blocksize()... ");
 384         block.set_max_blocksize(streaminfo_.data.stream_info.max_blocksize);
 385         printf("OK\n");
 386
 387         printf("testing StreamInfo::set_min_framesize()... ");
 388         block.set_min_framesize(streaminfo_.data.stream_info.min_framesize);
 389         printf("OK\n");
 390
 391         printf("testing StreamInfo::set_max_framesize()... ");
 392         block.set_max_framesize(streaminfo_.data.stream_info.max_framesize);
 393         printf("OK\n");
 394
 395         printf("testing StreamInfo::set_sample_rate()... ");
 396         block.set_sample_rate(streaminfo_.data.stream_info.sample_rate);
 397         printf("OK\n");
 398
 399         printf("testing StreamInfo::set_channels()... ");
 400         block.set_channels(streaminfo_.data.stream_info.channels);
 401         printf("OK\n");
 402
 403         printf("testing StreamInfo::set_bits_per_sample()... ");
 404         block.set_bits_per_sample(streaminfo_.data.stream_info.bits_per_sample);
 405         printf("OK\n");
 406
 407         printf("testing StreamInfo::set_total_samples()... ");
 408         block.set_total_samples(streaminfo_.data.stream_info.total_samples);
 409         printf("OK\n");
 410
 411         printf("testing StreamInfo::set_md5sum()... ");
 412         block.set_md5sum(streaminfo_.data.stream_info.md5sum);
 413         printf("OK\n");
 414
 415         printf("testing StreamInfo::get_min_blocksize()... ");
 416         if(block.get_min_blocksize() != streaminfo_.data.stream_info.min_blocksize)
 417                 return die_("value mismatch, doesn't match previously set value");
 418         printf("OK\n");
 419
 420         printf("testing StreamInfo::get_max_blocksize()... ");
 421         if(block.get_max_blocksize() != streaminfo_.data.stream_info.max_blocksize)
 422                 return die_("value mismatch, doesn't match previously set value");
 423         printf("OK\n");
 424
 425         printf("testing StreamInfo::get_min_framesize()... ");
 426         if(block.get_min_framesize() != streaminfo_.data.stream_info.min_framesize)
 427                 return die_("value mismatch, doesn't match previously set value");
 428         printf("OK\n");
 429
 430         printf("testing StreamInfo::get_max_framesize()... ");
 431         if(block.get_max_framesize() != streaminfo_.data.stream_info.max_framesize)
 432                 return die_("value mismatch, doesn't match previously set value");
 433         printf("OK\n");
 434
 435         printf("testing StreamInfo::get_sample_rate()... ");
 436         if(block.get_sample_rate() != streaminfo_.data.stream_info.sample_rate)
 437                 return die_("value mismatch, doesn't match previously set value");
 438         printf("OK\n");
 439
 440         printf("testing StreamInfo::get_channels()... ");
 441         if(block.get_channels() != streaminfo_.data.stream_info.channels)
 442                 return die_("value mismatch, doesn't match previously set value");
 443         printf("OK\n");
 444
 445         printf("testing StreamInfo::get_bits_per_sample()... ");
 446         if(block.get_bits_per_sample() != streaminfo_.data.stream_info.bits_per_sample)
 447                 return die_("value mismatch, doesn't match previously set value");
 448         printf("OK\n");
 449
 450         printf("testing StreamInfo::get_total_samples()... ");
 451         if(block.get_total_samples() != streaminfo_.data.stream_info.total_samples)
 452                 return die_("value mismatch, doesn't match previously set value");
 453         printf("OK\n");
 454
 455         printf("testing StreamInfo::get_md5sum()... ");
 456         if(0 != memcmp(block.get_md5sum(), streaminfo_.data.stream_info.md5sum, 16))
 457                 return die_("value mismatch, doesn't match previously set value");
 458         printf("OK\n");
 459
 460         printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... ");
 461         FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block);
 462         if(0 == clone_)
 463                 return die_("returned NULL");
 464         if(0 == dynamic_cast<FLAC::Metadata::StreamInfo *>(clone_))
 465                 return die_("downcast is NULL");
 466         if(*dynamic_cast<FLAC::Metadata::StreamInfo *>(clone_) != block)
 467                 return die_("clone is not identical");
 468         printf("OK\n");
 469         printf("testing StreamInfo::~StreamInfo()... ");
 470         delete clone_;
 471         printf("OK\n");
 472
 473
 474         printf("PASSED\n\n");
 475         return true;
 476 }
 477
 478 bool test_metadata_object_padding()
 479 {
 480         unsigned expected_length;
 481
 482         printf("testing class FLAC::Metadata::Padding\n");
 483
 484         printf("testing Padding::Padding()... ");
 485         FLAC::Metadata::Padding block;
 486         if(!block.is_valid())
 487                 return die_("!block.is_valid()");
 488         expected_length = 0;
 489         if(block.get_length() != expected_length) {
 490                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length());
 491                 return false;
 492         }
 493         printf("OK\n");
 494
 495         printf("testing Padding::Padding(const Padding &)... +\n");
 496         printf("        Padding::operator!=(const Padding &)... ");
 497         {
 498                 FLAC::Metadata::Padding blockcopy(block);
 499                 if(!blockcopy.is_valid())
 500                         return die_("!blockcopy.is_valid()");
 501                 if(blockcopy != block)
 502                         return die_("copy is not identical to original");
 503                 printf("OK\n");
 504
 505                 printf("testing Padding::~Padding()... ");
 506         }
 507         printf("OK\n");
 508
 509         printf("testing Padding::Padding(const ::FLAC__StreamMetadata &)... +\n");
 510         printf("        Padding::operator!=(const ::FLAC__StreamMetadata &)... ");
 511         {
 512                 FLAC::Metadata::Padding blockcopy(padding_);
 513                 if(!blockcopy.is_valid())
 514                         return die_("!blockcopy.is_valid()");
 515                 if(blockcopy != padding_)
 516                         return die_("copy is not identical to original");
 517                 printf("OK\n");
 518         }
 519
 520         printf("testing Padding::Padding(const ::FLAC__StreamMetadata *)... +\n");
 521         printf("        Padding::operator!=(const ::FLAC__StreamMetadata *)... ");
 522         {
 523                 FLAC::Metadata::Padding blockcopy(&padding_);
 524                 if(!blockcopy.is_valid())
 525                         return die_("!blockcopy.is_valid()");
 526                 if(blockcopy != padding_)
 527                         return die_("copy is not identical to original");
 528                 printf("OK\n");
 529         }
 530
 531         printf("testing Padding::Padding(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 532         printf("        Padding::operator!=(const ::FLAC__StreamMetadata *)... ");
 533         {
 534                 FLAC::Metadata::Padding blockcopy(&padding_, /*copy=*/true);
 535                 if(!blockcopy.is_valid())
 536                         return die_("!blockcopy.is_valid()");
 537                 if(blockcopy != padding_)
 538                         return die_("copy is not identical to original");
 539                 printf("OK\n");
 540         }
 541
 542         printf("testing Padding::Padding(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 543         printf("        Padding::operator!=(const ::FLAC__StreamMetadata *)... ");
 544         {
 545                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&padding_);
 546                 FLAC::Metadata::Padding blockcopy(copy, /*copy=*/false);
 547                 if(!blockcopy.is_valid())
 548                         return die_("!blockcopy.is_valid()");
 549                 if(blockcopy != padding_)
 550                         return die_("copy is not identical to original");
 551                 printf("OK\n");
 552         }
 553
 554         printf("testing Padding::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 555         printf("        Padding::operator!=(const ::FLAC__StreamMetadata *)... ");
 556         {
 557                 FLAC::Metadata::Padding blockcopy;
 558                 blockcopy.assign(&padding_, /*copy=*/true);
 559                 if(!blockcopy.is_valid())
 560                         return die_("!blockcopy.is_valid()");
 561                 if(blockcopy != padding_)
 562                         return die_("copy is not identical to original");
 563                 printf("OK\n");
 564         }
 565
 566         printf("testing Padding::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 567         printf("        Padding::operator!=(const ::FLAC__StreamMetadata *)... ");
 568         {
 569                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&padding_);
 570                 FLAC::Metadata::Padding blockcopy;
 571                 blockcopy.assign(copy, /*copy=*/false);
 572                 if(!blockcopy.is_valid())
 573                         return die_("!blockcopy.is_valid()");
 574                 if(blockcopy != padding_)
 575                         return die_("copy is not identical to original");
 576                 printf("OK\n");
 577         }
 578
 579         printf("testing Padding::operator=(const Padding &)... +\n");
 580         printf("        Padding::operator==(const Padding &)... ");
 581         {
 582                 FLAC::Metadata::Padding blockcopy = block;
 583                 if(!blockcopy.is_valid())
 584                         return die_("!blockcopy.is_valid()");
 585                 if(!(blockcopy == block))
 586                         return die_("copy is not identical to original");
 587                 printf("OK\n");
 588         }
 589
 590         printf("testing Padding::operator=(const ::FLAC__StreamMetadata &)... +\n");
 591         printf("        Padding::operator==(const ::FLAC__StreamMetadata &)... ");
 592         {
 593                 FLAC::Metadata::Padding blockcopy = padding_;
 594                 if(!blockcopy.is_valid())
 595                         return die_("!blockcopy.is_valid()");
 596                 if(!(blockcopy == padding_))
 597                         return die_("copy is not identical to original");
 598                 printf("OK\n");
 599         }
 600
 601         printf("testing Padding::operator=(const ::FLAC__StreamMetadata *)... +\n");
 602         printf("        Padding::operator==(const ::FLAC__StreamMetadata *)... ");
 603         {
 604                 FLAC::Metadata::Padding blockcopy = &padding_;
 605                 if(!blockcopy.is_valid())
 606                         return die_("!blockcopy.is_valid()");
 607                 if(!(blockcopy == padding_))
 608                         return die_("copy is not identical to original");
 609                 printf("OK\n");
 610         }
 611
 612         printf("testing Padding::set_length()... ");
 613         block.set_length(padding_.length);
 614         printf("OK\n");
 615
 616         printf("testing Prototype::get_length()... ");
 617         if(block.get_length() != padding_.length)
 618                 return die_("value mismatch, doesn't match previously set value");
 619         printf("OK\n");
 620
 621         printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... ");
 622         FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block);
 623         if(0 == clone_)
 624                 return die_("returned NULL");
 625         if(0 == dynamic_cast<FLAC::Metadata::Padding *>(clone_))
 626                 return die_("downcast is NULL");
 627         if(*dynamic_cast<FLAC::Metadata::Padding *>(clone_) != block)
 628                 return die_("clone is not identical");
 629         printf("OK\n");
 630         printf("testing Padding::~Padding()... ");
 631         delete clone_;
 632         printf("OK\n");
 633
 634
 635         printf("PASSED\n\n");
 636         return true;
 637 }
 638
 639 bool test_metadata_object_application()
 640 {
 641         unsigned expected_length;
 642
 643         printf("testing class FLAC::Metadata::Application\n");
 644
 645         printf("testing Application::Application()... ");
 646         FLAC::Metadata::Application block;
 647         if(!block.is_valid())
 648                 return die_("!block.is_valid()");
 649         expected_length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
 650         if(block.get_length() != expected_length) {
 651                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length());
 652                 return false;
 653         }
 654         printf("OK\n");
 655
 656         printf("testing Application::Application(const Application &)... +\n");
 657         printf("        Application::operator!=(const Application &)... ");
 658         {
 659                 FLAC::Metadata::Application blockcopy(block);
 660                 if(!blockcopy.is_valid())
 661                         return die_("!blockcopy.is_valid()");
 662                 if(blockcopy != block)
 663                         return die_("copy is not identical to original");
 664                 printf("OK\n");
 665
 666                 printf("testing Application::~Application()... ");
 667         }
 668         printf("OK\n");
 669
 670         printf("testing Application::Application(const ::FLAC__StreamMetadata &)... +\n");
 671         printf("        Application::operator!=(const ::FLAC__StreamMetadata &)... ");
 672         {
 673                 FLAC::Metadata::Application blockcopy(application_);
 674                 if(!blockcopy.is_valid())
 675                         return die_("!blockcopy.is_valid()");
 676                 if(blockcopy != application_)
 677                         return die_("copy is not identical to original");
 678                 printf("OK\n");
 679         }
 680
 681         printf("testing Application::Application(const ::FLAC__StreamMetadata *)... +\n");
 682         printf("        Application::operator!=(const ::FLAC__StreamMetadata *)... ");
 683         {
 684                 FLAC::Metadata::Application blockcopy(&application_);
 685                 if(!blockcopy.is_valid())
 686                         return die_("!blockcopy.is_valid()");
 687                 if(blockcopy != application_)
 688                         return die_("copy is not identical to original");
 689                 printf("OK\n");
 690         }
 691
 692         printf("testing Application::Application(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 693         printf("        Application::operator!=(const ::FLAC__StreamMetadata *)... ");
 694         {
 695                 FLAC::Metadata::Application blockcopy(&application_, /*copy=*/true);
 696                 if(!blockcopy.is_valid())
 697                         return die_("!blockcopy.is_valid()");
 698                 if(blockcopy != application_)
 699                         return die_("copy is not identical to original");
 700                 printf("OK\n");
 701         }
 702
 703         printf("testing Application::Application(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 704         printf("        Application::operator!=(const ::FLAC__StreamMetadata *)... ");
 705         {
 706                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&application_);
 707                 FLAC::Metadata::Application blockcopy(copy, /*copy=*/false);
 708                 if(!blockcopy.is_valid())
 709                         return die_("!blockcopy.is_valid()");
 710                 if(blockcopy != application_)
 711                         return die_("copy is not identical to original");
 712                 printf("OK\n");
 713         }
 714
 715         printf("testing Application::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 716         printf("        Application::operator!=(const ::FLAC__StreamMetadata *)... ");
 717         {
 718                 FLAC::Metadata::Application blockcopy;
 719                 blockcopy.assign(&application_, /*copy=*/true);
 720                 if(!blockcopy.is_valid())
 721                         return die_("!blockcopy.is_valid()");
 722                 if(blockcopy != application_)
 723                         return die_("copy is not identical to original");
 724                 printf("OK\n");
 725         }
 726
 727         printf("testing Application::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 728         printf("        Application::operator!=(const ::FLAC__StreamMetadata *)... ");
 729         {
 730                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&application_);
 731                 FLAC::Metadata::Application blockcopy;
 732                 blockcopy.assign(copy, /*copy=*/false);
 733                 if(!blockcopy.is_valid())
 734                         return die_("!blockcopy.is_valid()");
 735                 if(blockcopy != application_)
 736                         return die_("copy is not identical to original");
 737                 printf("OK\n");
 738         }
 739
 740         printf("testing Application::operator=(const Application &)... +\n");
 741         printf("        Application::operator==(const Application &)... ");
 742         {
 743                 FLAC::Metadata::Application blockcopy = block;
 744                 if(!blockcopy.is_valid())
 745                         return die_("!blockcopy.is_valid()");
 746                 if(!(blockcopy == block))
 747                         return die_("copy is not identical to original");
 748                 printf("OK\n");
 749         }
 750
 751         printf("testing Application::operator=(const ::FLAC__StreamMetadata &)... +\n");
 752         printf("        Application::operator==(const ::FLAC__StreamMetadata &)... ");
 753         {
 754                 FLAC::Metadata::Application blockcopy = application_;
 755                 if(!blockcopy.is_valid())
 756                         return die_("!blockcopy.is_valid()");
 757                 if(!(blockcopy == application_))
 758                         return die_("copy is not identical to original");
 759                 printf("OK\n");
 760         }
 761
 762         printf("testing Application::operator=(const ::FLAC__StreamMetadata *)... +\n");
 763         printf("        Application::operator==(const ::FLAC__StreamMetadata *)... ");
 764         {
 765                 FLAC::Metadata::Application blockcopy = &application_;
 766                 if(!blockcopy.is_valid())
 767                         return die_("!blockcopy.is_valid()");
 768                 if(!(blockcopy == application_))
 769                         return die_("copy is not identical to original");
 770                 printf("OK\n");
 771         }
 772
 773         printf("testing Application::set_id()... ");
 774         block.set_id(application_.data.application.id);
 775         printf("OK\n");
 776
 777         printf("testing Application::set_data()... ");
 778         block.set_data(application_.data.application.data, application_.length - sizeof(application_.data.application.id), /*copy=*/true);
 779         printf("OK\n");
 780
 781         printf("testing Application::get_id()... ");
 782         if(0 != memcmp(block.get_id(), application_.data.application.id, sizeof(application_.data.application.id)))
 783                 return die_("value mismatch, doesn't match previously set value");
 784         printf("OK\n");
 785
 786         printf("testing Application::get_data()... ");
 787         if(0 != memcmp(block.get_data(), application_.data.application.data, application_.length - sizeof(application_.data.application.id)))
 788                 return die_("value mismatch, doesn't match previously set value");
 789         printf("OK\n");
 790
 791         printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... ");
 792         FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block);
 793         if(0 == clone_)
 794                 return die_("returned NULL");
 795         if(0 == dynamic_cast<FLAC::Metadata::Application *>(clone_))
 796                 return die_("downcast is NULL");
 797         if(*dynamic_cast<FLAC::Metadata::Application *>(clone_) != block)
 798                 return die_("clone is not identical");
 799         printf("OK\n");
 800         printf("testing Application::~Application()... ");
 801         delete clone_;
 802         printf("OK\n");
 803
 804
 805         printf("PASSED\n\n");
 806         return true;
 807 }
 808
 809 bool test_metadata_object_seektable()
 810 {
 811         unsigned expected_length;
 812
 813         printf("testing class FLAC::Metadata::SeekTable\n");
 814
 815         printf("testing SeekTable::SeekTable()... ");
 816         FLAC::Metadata::SeekTable block;
 817         if(!block.is_valid())
 818                 return die_("!block.is_valid()");
 819         expected_length = 0;
 820         if(block.get_length() != expected_length) {
 821                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length());
 822                 return false;
 823         }
 824         printf("OK\n");
 825
 826         printf("testing SeekTable::SeekTable(const SeekTable &)... +\n");
 827         printf("        SeekTable::operator!=(const SeekTable &)... ");
 828         {
 829                 FLAC::Metadata::SeekTable blockcopy(block);
 830                 if(!blockcopy.is_valid())
 831                         return die_("!blockcopy.is_valid()");
 832                 if(blockcopy != block)
 833                         return die_("copy is not identical to original");
 834                 printf("OK\n");
 835
 836                 printf("testing SeekTable::~SeekTable()... ");
 837         }
 838         printf("OK\n");
 839
 840         printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata &)... +\n");
 841         printf("        SeekTable::operator!=(const ::FLAC__StreamMetadata &)... ");
 842         {
 843                 FLAC::Metadata::SeekTable blockcopy(seektable_);
 844                 if(!blockcopy.is_valid())
 845                         return die_("!blockcopy.is_valid()");
 846                 if(blockcopy != seektable_)
 847                         return die_("copy is not identical to original");
 848                 printf("OK\n");
 849         }
 850
 851         printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata *)... +\n");
 852         printf("        SeekTable::operator!=(const ::FLAC__StreamMetadata *)... ");
 853         {
 854                 FLAC::Metadata::SeekTable blockcopy(&seektable_);
 855                 if(!blockcopy.is_valid())
 856                         return die_("!blockcopy.is_valid()");
 857                 if(blockcopy != seektable_)
 858                         return die_("copy is not identical to original");
 859                 printf("OK\n");
 860         }
 861
 862         printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 863         printf("        SeekTable::operator!=(const ::FLAC__StreamMetadata *)... ");
 864         {
 865                 FLAC::Metadata::SeekTable blockcopy(&seektable_, /*copy=*/true);
 866                 if(!blockcopy.is_valid())
 867                         return die_("!blockcopy.is_valid()");
 868                 if(blockcopy != seektable_)
 869                         return die_("copy is not identical to original");
 870                 printf("OK\n");
 871         }
 872
 873         printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 874         printf("        SeekTable::operator!=(const ::FLAC__StreamMetadata *)... ");
 875         {
 876                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&seektable_);
 877                 FLAC::Metadata::SeekTable blockcopy(copy, /*copy=*/false);
 878                 if(!blockcopy.is_valid())
 879                         return die_("!blockcopy.is_valid()");
 880                 if(blockcopy != seektable_)
 881                         return die_("copy is not identical to original");
 882                 printf("OK\n");
 883         }
 884
 885         printf("testing SeekTable::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n");
 886         printf("        SeekTable::operator!=(const ::FLAC__StreamMetadata *)... ");
 887         {
 888                 FLAC::Metadata::SeekTable blockcopy;
 889                 blockcopy.assign(&seektable_, /*copy=*/true);
 890                 if(!blockcopy.is_valid())
 891                         return die_("!blockcopy.is_valid()");
 892                 if(blockcopy != seektable_)
 893                         return die_("copy is not identical to original");
 894                 printf("OK\n");
 895         }
 896
 897         printf("testing SeekTable::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n");
 898         printf("        SeekTable::operator!=(const ::FLAC__StreamMetadata *)... ");
 899         {
 900                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&seektable_);
 901                 FLAC::Metadata::SeekTable blockcopy;
 902                 blockcopy.assign(copy, /*copy=*/false);
 903                 if(!blockcopy.is_valid())
 904                         return die_("!blockcopy.is_valid()");
 905                 if(blockcopy != seektable_)
 906                         return die_("copy is not identical to original");
 907                 printf("OK\n");
 908         }
 909
 910         printf("testing SeekTable::operator=(const SeekTable &)... +\n");
 911         printf("        SeekTable::operator==(const SeekTable &)... ");
 912         {
 913                 FLAC::Metadata::SeekTable blockcopy = block;
 914                 if(!blockcopy.is_valid())
 915                         return die_("!blockcopy.is_valid()");
 916                 if(!(blockcopy == block))
 917                         return die_("copy is not identical to original");
 918                 printf("OK\n");
 919         }
 920
 921         printf("testing SeekTable::operator=(const ::FLAC__StreamMetadata &)... +\n");
 922         printf("        SeekTable::operator==(const ::FLAC__StreamMetadata &)... ");
 923         {
 924                 FLAC::Metadata::SeekTable blockcopy = seektable_;
 925                 if(!blockcopy.is_valid())
 926                         return die_("!blockcopy.is_valid()");
 927                 if(!(blockcopy == seektable_))
 928                         return die_("copy is not identical to original");
 929                 printf("OK\n");
 930         }
 931
 932         printf("testing SeekTable::operator=(const ::FLAC__StreamMetadata *)... +\n");
 933         printf("        SeekTable::operator==(const ::FLAC__StreamMetadata *)... ");
 934         {
 935                 FLAC::Metadata::SeekTable blockcopy = &seektable_;
 936                 if(!blockcopy.is_valid())
 937                         return die_("!blockcopy.is_valid()");
 938                 if(!(blockcopy == seektable_))
 939                         return die_("copy is not identical to original");
 940                 printf("OK\n");
 941         }
 942
 943         printf("testing SeekTable::insert_point() x 3... ");
 944         if(!block.insert_point(0, seektable_.data.seek_table.points[1]))
 945                 return die_("returned false");
 946         if(!block.insert_point(0, seektable_.data.seek_table.points[1]))
 947                 return die_("returned false");
 948         if(!block.insert_point(1, seektable_.data.seek_table.points[0]))
 949                 return die_("returned false");
 950         printf("OK\n");
 951
 952         printf("testing SeekTable::is_legal()... ");
 953         if(block.is_legal())
 954                 return die_("returned true");
 955         printf("OK\n");
 956
 957         printf("testing SeekTable::set_point()... ");
 958         block.set_point(0, seektable_.data.seek_table.points[0]);
 959         printf("OK\n");
 960
 961         printf("testing SeekTable::delete_point()... ");
 962         if(!block.delete_point(0))
 963                 return die_("returned false");
 964         printf("OK\n");
 965
 966         printf("testing SeekTable::is_legal()... ");
 967         if(!block.is_legal())
 968                 return die_("returned false");
 969         printf("OK\n");
 970
 971         printf("testing SeekTable::get_num_points()... ");
 972         if(block.get_num_points() != seektable_.data.seek_table.num_points)
 973                 return die_("number mismatch");
 974         printf("OK\n");
 975
 976         printf("testing SeekTable::operator!=(const ::FLAC__StreamMetadata &)... ");
 977         if(block != seektable_)
 978                 return die_("data mismatch");
 979         printf("OK\n");
 980
 981         printf("testing SeekTable::get_point()... ");
 982         if(
 983                 block.get_point(1).sample_number != seektable_.data.seek_table.points[1].sample_number ||
 984                 block.get_point(1).stream_offset != seektable_.data.seek_table.points[1].stream_offset ||
 985                 block.get_point(1).frame_samples != seektable_.data.seek_table.points[1].frame_samples
 986         )
 987                 return die_("point mismatch");
 988         printf("OK\n");
 989
 990         printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... ");
 991         FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block);
 992         if(0 == clone_)
 993                 return die_("returned NULL");
 994         if(0 == dynamic_cast<FLAC::Metadata::SeekTable *>(clone_))
 995                 return die_("downcast is NULL");
 996         if(*dynamic_cast<FLAC::Metadata::SeekTable *>(clone_) != block)
 997                 return die_("clone is not identical");
 998         printf("OK\n");
 999         printf("testing SeekTable::~SeekTable()... ");
1000         delete clone_;
1001         printf("OK\n");
1002
1003
1004         printf("PASSED\n\n");
1005         return true;
1006 }
1007
1008 bool test_metadata_object_vorbiscomment()
1009 {
1010         unsigned expected_length;
1011
1012         printf("testing class FLAC::Metadata::VorbisComment::Entry\n");
1013
1014         printf("testing Entry::Entry()... ");
1015         {
1016                 FLAC::Metadata::VorbisComment::Entry entry1;
1017                 if(!entry1.is_valid())
1018                         return die_("!is_valid()");
1019                 printf("OK\n");
1020
1021                 printf("testing Entry::~Entry()... ");
1022         }
1023         printf("OK\n");
1024
1025         printf("testing Entry::Entry(const char *field, unsigned field_length)... ");
1026         FLAC::Metadata::VorbisComment::Entry entry2("name2=value2", strlen("name2=value2"));
1027         if(!entry2.is_valid())
1028                 return die_("!is_valid()");
1029         printf("OK\n");
1030
1031         {
1032                 printf("testing Entry::Entry(const char *field)... ");
1033                 FLAC::Metadata::VorbisComment::Entry entry2z("name2=value2");
1034                 if(!entry2z.is_valid())
1035                         return die_("!is_valid()");
1036                 if(strcmp(entry2.get_field(), entry2z.get_field()))
1037                         return die_("bad value");
1038                 printf("OK\n");
1039         }
1040
1041         printf("testing Entry::Entry(const char *field_name, const char *field_value, unsigned field_value_length)... ");
1042         FLAC::Metadata::VorbisComment::Entry entry3("name3", "value3", strlen("value3"));
1043         if(!entry3.is_valid())
1044                 return die_("!is_valid()");
1045         printf("OK\n");
1046
1047         {
1048                 printf("testing Entry::Entry(const char *field_name, const char *field_value)... ");
1049                 FLAC::Metadata::VorbisComment::Entry entry3z("name3", "value3");
1050                 if(!entry3z.is_valid())
1051                         return die_("!is_valid()");
1052                 if(strcmp(entry3.get_field(), entry3z.get_field()))
1053                         return die_("bad value");
1054                 printf("OK\n");
1055         }
1056
1057         printf("testing Entry::Entry(const Entry &entry)... ");
1058         {
1059                 FLAC::Metadata::VorbisComment::Entry entry2copy(entry2);
1060                 if(!entry2copy.is_valid())
1061                         return die_("!is_valid()");
1062                 printf("OK\n");
1063
1064                 printf("testing Entry::~Entry()... ");
1065         }
1066         printf("OK\n");
1067
1068         printf("testing Entry::operator=(const Entry &entry)... ");
1069         FLAC::Metadata::VorbisComment::Entry entry1 = entry2;
1070         if(!entry2.is_valid())
1071                 return die_("!is_valid()");
1072         printf("OK\n");
1073
1074         printf("testing Entry::get_field_length()... ");
1075         if(entry1.get_field_length() != strlen("name2=value2"))
1076                 return die_("value mismatch");
1077         printf("OK\n");
1078
1079         printf("testing Entry::get_field_name_length()... ");
1080         if(entry1.get_field_name_length() != strlen("name2"))
1081                 return die_("value mismatch");
1082         printf("OK\n");
1083
1084         printf("testing Entry::get_field_value_length()... ");
1085         if(entry1.get_field_value_length() != strlen("value2"))
1086                 return die_("value mismatch");
1087         printf("OK\n");
1088
1089         printf("testing Entry::get_entry()... ");
1090         {
1091                 ::FLAC__StreamMetadata_VorbisComment_Entry entry = entry1.get_entry();
1092                 if(entry.length != strlen("name2=value2"))
1093                         return die_("entry length mismatch");
1094                 if(0 != memcmp(entry.entry, "name2=value2", entry.length))
1095                         return die_("entry value mismatch");
1096         }
1097         printf("OK\n");
1098
1099         printf("testing Entry::get_field()... ");
1100         if(0 != memcmp(entry1.get_field(), "name2=value2", strlen("name2=value2")))
1101                 return die_("value mismatch");
1102         printf("OK\n");
1103
1104         printf("testing Entry::get_field_name()... ");
1105         if(0 != memcmp(entry1.get_field_name(), "name2", strlen("name2")))
1106                 return die_("value mismatch");
1107         printf("OK\n");
1108
1109         printf("testing Entry::get_field_value()... ");
1110         if(0 != memcmp(entry1.get_field_value(), "value2", strlen("value2")))
1111                 return die_("value mismatch");
1112         printf("OK\n");
1113
1114         printf("testing Entry::set_field_name()... ");
1115         if(!entry1.set_field_name("name1"))
1116                 return die_("returned false");
1117         if(0 != memcmp(entry1.get_field_name(), "name1", strlen("name1")))
1118                 return die_("value mismatch");
1119         if(0 != memcmp(entry1.get_field(), "name1=value2", strlen("name1=value2")))
1120                 return die_("entry mismatch");
1121         printf("OK\n");
1122
1123         printf("testing Entry::set_field_value(const char *field_value, unsigned field_value_length)... ");
1124         if(!entry1.set_field_value("value1", strlen("value1")))
1125                 return die_("returned false");
1126         if(0 != memcmp(entry1.get_field_value(), "value1", strlen("value1")))
1127                 return die_("value mismatch");
1128         if(0 != memcmp(entry1.get_field(), "name1=value1", strlen("name1=value1")))
1129                 return die_("entry mismatch");
1130         printf("OK\n");
1131
1132         printf("testing Entry::set_field_value(const char *field_value)... ");
1133         if(!entry1.set_field_value("value1"))
1134                 return die_("returned false");
1135         if(0 != memcmp(entry1.get_field_value(), "value1", strlen("value1")))
1136                 return die_("value mismatch");
1137         if(0 != memcmp(entry1.get_field(), "name1=value1", strlen("name1=value1")))
1138                 return die_("entry mismatch");
1139         printf("OK\n");
1140
1141         printf("testing Entry::set_field(const char *field, unsigned field_length)... ");
1142         if(!entry1.set_field("name0=value0", strlen("name0=value0")))
1143                 return die_("returned false");
1144         if(0 != memcmp(entry1.get_field_name(), "name0", strlen("name0")))
1145                 return die_("value mismatch");
1146         if(0 != memcmp(entry1.get_field_value(), "value0", strlen("value0")))
1147                 return die_("value mismatch");
1148         if(0 != memcmp(entry1.get_field(), "name0=value0", strlen("name0=value0")))
1149                 return die_("entry mismatch");
1150         printf("OK\n");
1151
1152         printf("testing Entry::set_field(const char *field)... ");
1153         if(!entry1.set_field("name0=value0"))
1154                 return die_("returned false");
1155         if(0 != memcmp(entry1.get_field_name(), "name0", strlen("name0")))
1156                 return die_("value mismatch");
1157         if(0 != memcmp(entry1.get_field_value(), "value0", strlen("value0")))
1158                 return die_("value mismatch");
1159         if(0 != memcmp(entry1.get_field(), "name0=value0", strlen("name0=value0")))
1160                 return die_("entry mismatch");
1161         printf("OK\n");
1162
1163         printf("PASSED\n\n");
1164
1165
1166         printf("testing class FLAC::Metadata::VorbisComment\n");
1167
1168         printf("testing VorbisComment::VorbisComment()... ");
1169         FLAC::Metadata::VorbisComment block;
1170         if(!block.is_valid())
1171                 return die_("!block.is_valid()");
1172         expected_length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + strlen(::FLAC__VENDOR_STRING) + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN/8);
1173         if(block.get_length() != expected_length) {
1174                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length());
1175                 return false;
1176         }
1177         printf("OK\n");
1178
1179         printf("testing VorbisComment::VorbisComment(const VorbisComment &)... +\n");
1180         printf("        VorbisComment::operator!=(const VorbisComment &)... ");
1181         {
1182                 FLAC::Metadata::VorbisComment blockcopy(block);
1183                 if(!blockcopy.is_valid())
1184                         return die_("!blockcopy.is_valid()");
1185                 if(blockcopy != block)
1186                         return die_("copy is not identical to original");
1187                 printf("OK\n");
1188
1189                 printf("testing VorbisComment::~VorbisComment()... ");
1190         }
1191         printf("OK\n");
1192
1193         printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata &)... +\n");
1194         printf("        VorbisComment::operator!=(const ::FLAC__StreamMetadata &)... ");
1195         {
1196                 FLAC::Metadata::VorbisComment blockcopy(vorbiscomment_);
1197                 if(!blockcopy.is_valid())
1198                         return die_("!blockcopy.is_valid()");
1199                 if(blockcopy != vorbiscomment_)
1200                         return die_("copy is not identical to original");
1201                 printf("OK\n");
1202         }
1203
1204         printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata *)... +\n");
1205         printf("        VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... ");
1206         {
1207                 FLAC::Metadata::VorbisComment blockcopy(&vorbiscomment_);
1208                 if(!blockcopy.is_valid())
1209                         return die_("!blockcopy.is_valid()");
1210                 if(blockcopy != vorbiscomment_)
1211                         return die_("copy is not identical to original");
1212                 printf("OK\n");
1213         }
1214
1215         printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata *, copy=true)... +\n");
1216         printf("        VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... ");
1217         {
1218                 FLAC::Metadata::VorbisComment blockcopy(&vorbiscomment_, /*copy=*/true);
1219                 if(!blockcopy.is_valid())
1220                         return die_("!blockcopy.is_valid()");
1221                 if(blockcopy != vorbiscomment_)
1222                         return die_("copy is not identical to original");
1223                 printf("OK\n");
1224         }
1225
1226         printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata *, copy=false)... +\n");
1227         printf("        VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... ");
1228         {
1229                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&vorbiscomment_);
1230                 FLAC::Metadata::VorbisComment blockcopy(copy, /*copy=*/false);
1231                 if(!blockcopy.is_valid())
1232                         return die_("!blockcopy.is_valid()");
1233                 if(blockcopy != vorbiscomment_)
1234                         return die_("copy is not identical to original");
1235                 printf("OK\n");
1236         }
1237
1238         printf("testing VorbisComment::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n");
1239         printf("        VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... ");
1240         {
1241                 FLAC::Metadata::VorbisComment blockcopy;
1242                 blockcopy.assign(&vorbiscomment_, /*copy=*/true);
1243                 if(!blockcopy.is_valid())
1244                         return die_("!blockcopy.is_valid()");
1245                 if(blockcopy != vorbiscomment_)
1246                         return die_("copy is not identical to original");
1247                 printf("OK\n");
1248         }
1249
1250         printf("testing VorbisComment::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n");
1251         printf("        VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... ");
1252         {
1253                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&vorbiscomment_);
1254                 FLAC::Metadata::VorbisComment blockcopy;
1255                 blockcopy.assign(copy, /*copy=*/false);
1256                 if(!blockcopy.is_valid())
1257                         return die_("!blockcopy.is_valid()");
1258                 if(blockcopy != vorbiscomment_)
1259                         return die_("copy is not identical to original");
1260                 printf("OK\n");
1261         }
1262
1263         printf("testing VorbisComment::operator=(const VorbisComment &)... +\n");
1264         printf("        VorbisComment::operator==(const VorbisComment &)... ");
1265         {
1266                 FLAC::Metadata::VorbisComment blockcopy = block;
1267                 if(!blockcopy.is_valid())
1268                         return die_("!blockcopy.is_valid()");
1269                 if(!(blockcopy == block))
1270                         return die_("copy is not identical to original");
1271                 printf("OK\n");
1272         }
1273
1274         printf("testing VorbisComment::operator=(const ::FLAC__StreamMetadata &)... +\n");
1275         printf("        VorbisComment::operator==(const ::FLAC__StreamMetadata &)... ");
1276         {
1277                 FLAC::Metadata::VorbisComment blockcopy = vorbiscomment_;
1278                 if(!blockcopy.is_valid())
1279                         return die_("!blockcopy.is_valid()");
1280                 if(!(blockcopy == vorbiscomment_))
1281                         return die_("copy is not identical to original");
1282                 printf("OK\n");
1283         }
1284
1285         printf("testing VorbisComment::operator=(const ::FLAC__StreamMetadata *)... +\n");
1286         printf("        VorbisComment::operator==(const ::FLAC__StreamMetadata *)... ");
1287         {
1288                 FLAC::Metadata::VorbisComment blockcopy = &vorbiscomment_;
1289                 if(!blockcopy.is_valid())
1290                         return die_("!blockcopy.is_valid()");
1291                 if(!(blockcopy == vorbiscomment_))
1292                         return die_("copy is not identical to original");
1293                 printf("OK\n");
1294         }
1295
1296         printf("testing VorbisComment::get_num_comments()... ");
1297         if(block.get_num_comments() != 0)
1298                 return die_("value mismatch, expected 0");
1299         printf("OK\n");
1300
1301         printf("testing VorbisComment::set_vendor_string()... ");
1302         if(!block.set_vendor_string((const FLAC__byte *)"mame0"))
1303                 return die_("returned false");
1304         printf("OK\n");
1305         vorbiscomment_.data.vorbis_comment.vendor_string.entry[0] = 'm';
1306
1307         printf("testing VorbisComment::get_vendor_string()... ");
1308         if(strlen((const char *)block.get_vendor_string()) != vorbiscomment_.data.vorbis_comment.vendor_string.length)
1309                 return die_("length mismatch");
1310         if(0 != memcmp(block.get_vendor_string(), vorbiscomment_.data.vorbis_comment.vendor_string.entry, vorbiscomment_.data.vorbis_comment.vendor_string.length))
1311                 return die_("value mismatch");
1312         printf("OK\n");
1313
1314         printf("testing VorbisComment::append_comment()... +\n");
1315         printf("        VorbisComment::get_comment()... ");
1316         if(!block.append_comment(entry3))
1317                 return die_("returned false");
1318         if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length)
1319                 return die_("length mismatch");
1320         if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length))
1321                 return die_("value mismatch");
1322         printf("OK\n");
1323
1324         printf("testing VorbisComment::append_comment()... +\n");
1325         printf("        VorbisComment::get_comment()... ");
1326         if(!block.append_comment(entry2))
1327                 return die_("returned false");
1328         if(block.get_comment(1).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length)
1329                 return die_("length mismatch");
1330         if(0 != memcmp(block.get_comment(1).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length))
1331                 return die_("value mismatch");
1332         printf("OK\n");
1333
1334         printf("testing VorbisComment::delete_comment()... +\n");
1335         printf("        VorbisComment::get_comment()... ");
1336         if(!block.delete_comment(0))
1337                 return die_("returned false");
1338         if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length)
1339                 return die_("length[0] mismatch");
1340         if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length))
1341                 return die_("value[0] mismatch");
1342         printf("OK\n");
1343
1344         printf("testing VorbisComment::delete_comment()... +\n");
1345         printf("        VorbisComment::get_comment()... ");
1346         if(!block.delete_comment(0))
1347                 return die_("returned false");
1348         if(block.get_num_comments() != 0)
1349                 return die_("block mismatch, expected num_comments = 0");
1350         printf("OK\n");
1351
1352         printf("testing VorbisComment::insert_comment()... +\n");
1353         printf("        VorbisComment::get_comment()... ");
1354         if(!block.insert_comment(0, entry3))
1355                 return die_("returned false");
1356         if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length)
1357                 return die_("length mismatch");
1358         if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length))
1359                 return die_("value mismatch");
1360         printf("OK\n");
1361
1362         printf("testing VorbisComment::insert_comment()... +\n");
1363         printf("        VorbisComment::get_comment()... ");
1364         if(!block.insert_comment(0, entry3))
1365                 return die_("returned false");
1366         if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length)
1367                 return die_("length mismatch");
1368         if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length))
1369                 return die_("value mismatch");
1370         printf("OK\n");
1371
1372         printf("testing VorbisComment::insert_comment()... +\n");
1373         printf("        VorbisComment::get_comment()... ");
1374         if(!block.insert_comment(1, entry2))
1375                 return die_("returned false");
1376         if(block.get_comment(1).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length)
1377                 return die_("length mismatch");
1378         if(0 != memcmp(block.get_comment(1).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length))
1379                 return die_("value mismatch");
1380         printf("OK\n");
1381
1382         printf("testing VorbisComment::set_comment()... +\n");
1383         printf("        VorbisComment::get_comment()... ");
1384         if(!block.set_comment(0, entry2))
1385                 return die_("returned false");
1386         if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length)
1387                 return die_("length mismatch");
1388         if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length))
1389                 return die_("value mismatch");
1390         printf("OK\n");
1391
1392         printf("testing VorbisComment::delete_comment()... +\n");
1393         printf("        VorbisComment::get_comment()... ");
1394         if(!block.delete_comment(0))
1395                 return die_("returned false");
1396         if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length)
1397                 return die_("length[0] mismatch");
1398         if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length))
1399                 return die_("value[0] mismatch");
1400         if(block.get_comment(1).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length)
1401                 return die_("length[1] mismatch");
1402         if(0 != memcmp(block.get_comment(1).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length))
1403                 return die_("value[0] mismatch");
1404         printf("OK\n");
1405
1406         printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... ");
1407         FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block);
1408         if(0 == clone_)
1409                 return die_("returned NULL");
1410         if(0 == dynamic_cast<FLAC::Metadata::VorbisComment *>(clone_))
1411                 return die_("downcast is NULL");
1412         if(*dynamic_cast<FLAC::Metadata::VorbisComment *>(clone_) != block)
1413                 return die_("clone is not identical");
1414         printf("OK\n");
1415         printf("testing VorbisComment::~VorbisComment()... ");
1416         delete clone_;
1417         printf("OK\n");
1418
1419
1420         printf("PASSED\n\n");
1421         return true;
1422 }
1423
1424 bool test_metadata_object_cuesheet()
1425 {
1426         unsigned expected_length;
1427
1428         printf("testing class FLAC::Metadata::CueSheet::Track\n");
1429
1430         printf("testing Track::Track()... ");
1431         FLAC::Metadata::CueSheet::Track track0;
1432         if(!track0.is_valid())
1433                 return die_("!is_valid()");
1434         printf("OK\n");
1435
1436         {
1437                 printf("testing Track::get_track()... ");
1438                 const ::FLAC__StreamMetadata_CueSheet_Track *trackp = track0.get_track();
1439                 if(0 == trackp)
1440                         return die_("returned pointer is NULL");
1441                 printf("OK\n");
1442
1443                 printf("testing Track::Track(const ::FLAC__StreamMetadata_CueSheet_Track*)... ");
1444                 FLAC::Metadata::CueSheet::Track track2(trackp);
1445                 if(!track2.is_valid())
1446                         return die_("!is_valid()");
1447                 if(!track_is_equal_(track2.get_track(), trackp))
1448                         return die_("copy is not equal");
1449                 printf("OK\n");
1450
1451                 printf("testing Track::~Track()... ");
1452         }
1453         printf("OK\n");
1454
1455         printf("testing Track::Track(const Track &track)... ");
1456         {
1457                 FLAC::Metadata::CueSheet::Track track0copy(track0);
1458                 if(!track0copy.is_valid())
1459                         return die_("!is_valid()");
1460                 if(!track_is_equal_(track0copy.get_track(), track0.get_track()))
1461                         return die_("copy is not equal");
1462                 printf("OK\n");
1463
1464                 printf("testing Track::~Track()... ");
1465         }
1466         printf("OK\n");
1467
1468         printf("testing Track::operator=(const Track &track)... ");
1469         FLAC::Metadata::CueSheet::Track track1 = track0;
1470         if(!track0.is_valid())
1471                 return die_("!is_valid()");
1472         if(!track_is_equal_(track1.get_track(), track0.get_track()))
1473                 return die_("copy is not equal");
1474         printf("OK\n");
1475
1476         printf("testing Track::get_offset()... ");
1477         if(track1.get_offset() != 0)
1478                 return die_("value mismatch");
1479         printf("OK\n");
1480
1481         printf("testing Track::get_number()... ");
1482         if(track1.get_number() != 0)
1483                 return die_("value mismatch");
1484         printf("OK\n");
1485
1486         printf("testing Track::get_isrc()... ");
1487         if(0 != memcmp(track1.get_isrc(), "\0\0\0\0\0\0\0\0\0\0\0\0\0", 13))
1488                 return die_("value mismatch");
1489         printf("OK\n");
1490
1491         printf("testing Track::get_type()... ");
1492         if(track1.get_type() != 0)
1493                 return die_("value mismatch");
1494         printf("OK\n");
1495
1496         printf("testing Track::get_pre_emphasis()... ");
1497         if(track1.get_pre_emphasis() != 0)
1498                 return die_("value mismatch");
1499         printf("OK\n");
1500
1501         printf("testing Track::get_num_indices()... ");
1502         if(track1.get_num_indices() != 0)
1503                 return die_("value mismatch");
1504         printf("OK\n");
1505
1506         printf("testing Track::set_offset()... ");
1507         track1.set_offset(588);
1508         if(track1.get_offset() != 588)
1509                 return die_("value mismatch");
1510         printf("OK\n");
1511
1512         printf("testing Track::set_number()... ");
1513         track1.set_number(1);
1514         if(track1.get_number() != 1)
1515                 return die_("value mismatch");
1516         printf("OK\n");
1517
1518         printf("testing Track::set_isrc()... ");
1519         track1.set_isrc("ABCDE1234567");
1520         if(0 != memcmp(track1.get_isrc(), "ABCDE1234567", 13))
1521                 return die_("value mismatch");
1522         printf("OK\n");
1523
1524         printf("testing Track::set_type()... ");
1525         track1.set_type(1);
1526         if(track1.get_type() != 1)
1527                 return die_("value mismatch");
1528         printf("OK\n");
1529
1530         printf("testing Track::set_pre_emphasis()... ");
1531         track1.set_pre_emphasis(1);
1532         if(track1.get_pre_emphasis() != 1)
1533                 return die_("value mismatch");
1534         printf("OK\n");
1535
1536         printf("PASSED\n\n");
1537
1538         printf("testing class FLAC::Metadata::CueSheet\n");
1539
1540         printf("testing CueSheet::CueSheet()... ");
1541         FLAC::Metadata::CueSheet block;
1542         if(!block.is_valid())
1543                 return die_("!block.is_valid()");
1544         expected_length = (
1545                 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
1546                 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
1547                 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
1548                 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
1549                 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
1550         ) / 8;
1551         if(block.get_length() != expected_length) {
1552                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length());
1553                 return false;
1554         }
1555         printf("OK\n");
1556
1557         printf("testing CueSheet::CueSheet(const CueSheet &)... +\n");
1558         printf("        CueSheet::operator!=(const CueSheet &)... ");
1559         {
1560                 FLAC::Metadata::CueSheet blockcopy(block);
1561                 if(!blockcopy.is_valid())
1562                         return die_("!blockcopy.is_valid()");
1563                 if(blockcopy != block)
1564                         return die_("copy is not identical to original");
1565                 printf("OK\n");
1566
1567                 printf("testing CueSheet::~CueSheet()... ");
1568         }
1569         printf("OK\n");
1570
1571         printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata &)... +\n");
1572         printf("        CueSheet::operator!=(const ::FLAC__StreamMetadata &)... ");
1573         {
1574                 FLAC::Metadata::CueSheet blockcopy(cuesheet_);
1575                 if(!blockcopy.is_valid())
1576                         return die_("!blockcopy.is_valid()");
1577                 if(blockcopy != cuesheet_)
1578                         return die_("copy is not identical to original");
1579                 printf("OK\n");
1580         }
1581
1582         printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata *)... +\n");
1583         printf("        CueSheet::operator!=(const ::FLAC__StreamMetadata *)... ");
1584         {
1585                 FLAC::Metadata::CueSheet blockcopy(&cuesheet_);
1586                 if(!blockcopy.is_valid())
1587                         return die_("!blockcopy.is_valid()");
1588                 if(blockcopy != cuesheet_)
1589                         return die_("copy is not identical to original");
1590                 printf("OK\n");
1591         }
1592
1593         printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata *, copy=true)... +\n");
1594         printf("        CueSheet::operator!=(const ::FLAC__StreamMetadata *)... ");
1595         {
1596                 FLAC::Metadata::CueSheet blockcopy(&cuesheet_, /*copy=*/true);
1597                 if(!blockcopy.is_valid())
1598                         return die_("!blockcopy.is_valid()");
1599                 if(blockcopy != cuesheet_)
1600                         return die_("copy is not identical to original");
1601                 printf("OK\n");
1602         }
1603
1604         printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata *, copy=false)... +\n");
1605         printf("        CueSheet::operator!=(const ::FLAC__StreamMetadata *)... ");
1606         {
1607                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&cuesheet_);
1608                 FLAC::Metadata::CueSheet blockcopy(copy, /*copy=*/false);
1609                 if(!blockcopy.is_valid())
1610                         return die_("!blockcopy.is_valid()");
1611                 if(blockcopy != cuesheet_)
1612                         return die_("copy is not identical to original");
1613                 printf("OK\n");
1614         }
1615
1616         printf("testing CueSheet::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n");
1617         printf("        CueSheet::operator!=(const ::FLAC__StreamMetadata *)... ");
1618         {
1619                 FLAC::Metadata::CueSheet blockcopy;
1620                 blockcopy.assign(&cuesheet_, /*copy=*/true);
1621                 if(!blockcopy.is_valid())
1622                         return die_("!blockcopy.is_valid()");
1623                 if(blockcopy != cuesheet_)
1624                         return die_("copy is not identical to original");
1625                 printf("OK\n");
1626         }
1627
1628         printf("testing CueSheet::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n");
1629         printf("        CueSheet::operator!=(const ::FLAC__StreamMetadata *)... ");
1630         {
1631                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&cuesheet_);
1632                 FLAC::Metadata::CueSheet blockcopy;
1633                 blockcopy.assign(copy, /*copy=*/false);
1634                 if(!blockcopy.is_valid())
1635                         return die_("!blockcopy.is_valid()");
1636                 if(blockcopy != cuesheet_)
1637                         return die_("copy is not identical to original");
1638                 printf("OK\n");
1639         }
1640
1641         printf("testing CueSheet::operator=(const CueSheet &)... +\n");
1642         printf("        CueSheet::operator==(const CueSheet &)... ");
1643         {
1644                 FLAC::Metadata::CueSheet blockcopy = block;
1645                 if(!blockcopy.is_valid())
1646                         return die_("!blockcopy.is_valid()");
1647                 if(!(blockcopy == block))
1648                         return die_("copy is not identical to original");
1649                 printf("OK\n");
1650         }
1651
1652         printf("testing CueSheet::operator=(const ::FLAC__StreamMetadata &)... +\n");
1653         printf("        CueSheet::operator==(const ::FLAC__StreamMetadata &)... ");
1654         {
1655                 FLAC::Metadata::CueSheet blockcopy = cuesheet_;
1656                 if(!blockcopy.is_valid())
1657                         return die_("!blockcopy.is_valid()");
1658                 if(!(blockcopy == cuesheet_))
1659                         return die_("copy is not identical to original");
1660                 printf("OK\n");
1661         }
1662
1663         printf("testing CueSheet::operator=(const ::FLAC__StreamMetadata *)... +\n");
1664         printf("        CueSheet::operator==(const ::FLAC__StreamMetadata *)... ");
1665         {
1666                 FLAC::Metadata::CueSheet blockcopy = &cuesheet_;
1667                 if(!blockcopy.is_valid())
1668                         return die_("!blockcopy.is_valid()");
1669                 if(!(blockcopy == cuesheet_))
1670                         return die_("copy is not identical to original");
1671                 printf("OK\n");
1672         }
1673
1674         printf("testing CueSheet::get_media_catalog_number()... ");
1675         if(0 != strcmp(block.get_media_catalog_number(), ""))
1676                 return die_("value mismatch");
1677         printf("OK\n");
1678
1679         printf("testing CueSheet::get_lead_in()... ");
1680         if(block.get_lead_in() != 0)
1681                 return die_("value mismatch, expected 0");
1682         printf("OK\n");
1683
1684         printf("testing CueSheet::get_is_cd()... ");
1685         if(block.get_is_cd())
1686                 return die_("value mismatch, expected false");
1687         printf("OK\n");
1688
1689         printf("testing CueSheet::get_num_tracks()... ");
1690         if(block.get_num_tracks() != 0)
1691                 return die_("value mismatch, expected 0");
1692         printf("OK\n");
1693
1694         printf("testing CueSheet::set_media_catalog_number()... ");
1695         {
1696                 char mcn[129];
1697                 memset(mcn, 0, sizeof(mcn));
1698                 safe_strncpy(mcn, "1234567890123", sizeof(mcn));
1699                 block.set_media_catalog_number(mcn);
1700                 if(0 != memcmp(block.get_media_catalog_number(), mcn, sizeof(mcn)))
1701                         return die_("value mismatch");
1702         }
1703         printf("OK\n");
1704
1705         printf("testing CueSheet::set_lead_in()... ");
1706         block.set_lead_in(588);
1707         if(block.get_lead_in() != 588)
1708                 return die_("value mismatch");
1709         printf("OK\n");
1710
1711         printf("testing CueSheet::set_is_cd()... ");
1712         block.set_is_cd(true);
1713         if(!block.get_is_cd())
1714                 return die_("value mismatch");
1715         printf("OK\n");
1716
1717         printf("testing CueSheet::insert_track()... +\n");
1718         printf("        CueSheet::get_track()... ");
1719         if(!block.insert_track(0, track0))
1720                 return die_("returned false");
1721         if(!track_is_equal_(block.get_track(0).get_track(), track0.get_track()))
1722                 return die_("value mismatch");
1723         printf("OK\n");
1724
1725         printf("testing CueSheet::insert_track()... +\n");
1726         printf("        CueSheet::get_track()... ");
1727         if(!block.insert_track(1, track1))
1728                 return die_("returned false");
1729         if(!track_is_equal_(block.get_track(1).get_track(), track1.get_track()))
1730                 return die_("value mismatch");
1731         printf("OK\n");
1732
1733         ::FLAC__StreamMetadata_CueSheet_Index index0;
1734         index0.offset = 588*4;
1735         index0.number = 1;
1736
1737         printf("testing CueSheet::insert_index(0)... +\n");
1738         printf("        CueSheet::get_track()... +\n");
1739         printf("        CueSheet::Track::get_index()... ");
1740         if(!block.insert_index(0, 0, index0))
1741                 return die_("returned false");
1742         if(!index_is_equal_(block.get_track(0).get_index(0), index0))
1743                 return die_("value mismatch");
1744         printf("OK\n");
1745
1746         index0.offset = 588*5;
1747         printf("testing CueSheet::Track::set_index()... ");
1748         {
1749                 FLAC::Metadata::CueSheet::Track track_ = block.get_track(0);
1750                 track_.set_index(0, index0);
1751                 if(!index_is_equal_(track_.get_index(0), index0))
1752                         return die_("value mismatch");
1753         }
1754         printf("OK\n");
1755
1756         index0.offset = 588*6;
1757         printf("testing CueSheet::set_index()... ");
1758         block.set_index(0, 0, index0);
1759         if(!index_is_equal_(block.get_track(0).get_index(0), index0))
1760                 return die_("value mismatch");
1761         printf("OK\n");
1762
1763         printf("testing CueSheet::delete_index()... ");
1764         if(!block.delete_index(0, 0))
1765                 return die_("returned false");
1766         if(block.get_track(0).get_num_indices() != 0)
1767                 return die_("num_indices mismatch");
1768         printf("OK\n");
1769
1770
1771         printf("testing CueSheet::set_track()... +\n");
1772         printf("        CueSheet::get_track()... ");
1773         if(!block.set_track(0, track1))
1774                 return die_("returned false");
1775         if(!track_is_equal_(block.get_track(0).get_track(), track1.get_track()))
1776                 return die_("value mismatch");
1777         printf("OK\n");
1778
1779         printf("testing CueSheet::delete_track()... ");
1780         if(!block.delete_track(0))
1781                 return die_("returned false");
1782         if(block.get_num_tracks() != 1)
1783                 return die_("num_tracks mismatch");
1784         printf("OK\n");
1785
1786         printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... ");
1787         FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block);
1788         if(0 == clone_)
1789                 return die_("returned NULL");
1790         if(0 == dynamic_cast<FLAC::Metadata::CueSheet *>(clone_))
1791                 return die_("downcast is NULL");
1792         if(*dynamic_cast<FLAC::Metadata::CueSheet *>(clone_) != block)
1793                 return die_("clone is not identical");
1794         printf("OK\n");
1795         printf("testing CueSheet::~CueSheet()... ");
1796         delete clone_;
1797         printf("OK\n");
1798
1799         printf("PASSED\n\n");
1800         return true;
1801 }
1802
1803 bool test_metadata_object_picture()
1804 {
1805         unsigned expected_length;
1806
1807         printf("testing class FLAC::Metadata::Picture\n");
1808
1809         printf("testing Picture::Picture()... ");
1810         FLAC::Metadata::Picture block;
1811         if(!block.is_valid())
1812                 return die_("!block.is_valid()");
1813         expected_length = (
1814                 FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
1815                 FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN +
1816                 FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN +
1817                 FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
1818                 FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
1819                 FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
1820                 FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
1821                 FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN
1822         ) / 8;
1823         if(block.get_length() != expected_length) {
1824                 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length());
1825                 return false;
1826         }
1827         printf("OK\n");
1828
1829         printf("testing Picture::Picture(const Picture &)... +\n");
1830         printf("        Picture::operator!=(const Picture &)... ");
1831         {
1832                 FLAC::Metadata::Picture blockcopy(block);
1833                 if(!blockcopy.is_valid())
1834                         return die_("!blockcopy.is_valid()");
1835                 if(blockcopy != block)
1836                         return die_("copy is not identical to original");
1837                 printf("OK\n");
1838
1839                 printf("testing Picture::~Picture()... ");
1840         }
1841         printf("OK\n");
1842
1843         printf("testing Picture::Picture(const ::FLAC__StreamMetadata &)... +\n");
1844         printf("        Picture::operator!=(const ::FLAC__StreamMetadata &)... ");
1845         {
1846                 FLAC::Metadata::Picture blockcopy(picture_);
1847                 if(!blockcopy.is_valid())
1848                         return die_("!blockcopy.is_valid()");
1849                 if(blockcopy != picture_)
1850                         return die_("copy is not identical to original");
1851                 printf("OK\n");
1852         }
1853
1854         printf("testing Picture::Picture(const ::FLAC__StreamMetadata *)... +\n");
1855         printf("        Picture::operator!=(const ::FLAC__StreamMetadata *)... ");
1856         {
1857                 FLAC::Metadata::Picture blockcopy(&picture_);
1858                 if(!blockcopy.is_valid())
1859                         return die_("!blockcopy.is_valid()");
1860                 if(blockcopy != picture_)
1861                         return die_("copy is not identical to original");
1862                 printf("OK\n");
1863         }
1864
1865         printf("testing Picture::Picture(const ::FLAC__StreamMetadata *, copy=true)... +\n");
1866         printf("        Picture::operator!=(const ::FLAC__StreamMetadata *)... ");
1867         {
1868                 FLAC::Metadata::Picture blockcopy(&picture_, /*copy=*/true);
1869                 if(!blockcopy.is_valid())
1870                         return die_("!blockcopy.is_valid()");
1871                 if(blockcopy != picture_)
1872                         return die_("copy is not identical to original");
1873                 printf("OK\n");
1874         }
1875
1876         printf("testing Picture::Picture(const ::FLAC__StreamMetadata *, copy=false)... +\n");
1877         printf("        Picture::operator!=(const ::FLAC__StreamMetadata *)... ");
1878         {
1879                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&picture_);
1880                 FLAC::Metadata::Picture blockcopy(copy, /*copy=*/false);
1881                 if(!blockcopy.is_valid())
1882                         return die_("!blockcopy.is_valid()");
1883                 if(blockcopy != picture_)
1884                         return die_("copy is not identical to original");
1885                 printf("OK\n");
1886         }
1887
1888         printf("testing Picture::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n");
1889         printf("        Picture::operator!=(const ::FLAC__StreamMetadata *)... ");
1890         {
1891                 FLAC::Metadata::Picture blockcopy;
1892                 blockcopy.assign(&picture_, /*copy=*/true);
1893                 if(!blockcopy.is_valid())
1894                         return die_("!blockcopy.is_valid()");
1895                 if(blockcopy != picture_)
1896                         return die_("copy is not identical to original");
1897                 printf("OK\n");
1898         }
1899
1900         printf("testing Picture::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n");
1901         printf("        Picture::operator!=(const ::FLAC__StreamMetadata *)... ");
1902         {
1903                 ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&picture_);
1904                 FLAC::Metadata::Picture blockcopy;
1905                 blockcopy.assign(copy, /*copy=*/false);
1906                 if(!blockcopy.is_valid())
1907                         return die_("!blockcopy.is_valid()");
1908                 if(blockcopy != picture_)
1909                         return die_("copy is not identical to original");
1910                 printf("OK\n");
1911         }
1912
1913         printf("testing Picture::operator=(const Picture &)... +\n");
1914         printf("        Picture::operator==(const Picture &)... ");
1915         {
1916                 FLAC::Metadata::Picture blockcopy = block;
1917                 if(!blockcopy.is_valid())
1918                         return die_("!blockcopy.is_valid()");
1919                 if(!(blockcopy == block))
1920                         return die_("copy is not identical to original");
1921                 printf("OK\n");
1922         }
1923
1924         printf("testing Picture::operator=(const ::FLAC__StreamMetadata &)... +\n");
1925         printf("        Picture::operator==(const ::FLAC__StreamMetadata &)... ");
1926         {
1927                 FLAC::Metadata::Picture blockcopy = picture_;
1928                 if(!blockcopy.is_valid())
1929                         return die_("!blockcopy.is_valid()");
1930                 if(!(blockcopy == picture_))
1931                         return die_("copy is not identical to original");
1932                 printf("OK\n");
1933         }
1934
1935         printf("testing Picture::operator=(const ::FLAC__StreamMetadata *)... +\n");
1936         printf("        Picture::operator==(const ::FLAC__StreamMetadata *)... ");
1937         {
1938                 FLAC::Metadata::Picture blockcopy = &picture_;
1939                 if(!blockcopy.is_valid())
1940                         return die_("!blockcopy.is_valid()");
1941                 if(!(blockcopy == picture_))
1942                         return die_("copy is not identical to original");
1943                 printf("OK\n");
1944         }
1945
1946         printf("testing Picture::get_type()... ");
1947         if(block.get_type() != ::FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER)
1948                 return die_("value mismatch, expected ::FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER");
1949         printf("OK\n");
1950
1951         printf("testing Picture::set_type()... +\n");
1952         printf("        Picture::get_type()... ");
1953         block.set_type(::FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA);
1954         if(block.get_type() != ::FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA)
1955                 return die_("value mismatch, expected ::FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA");
1956         printf("OK\n");
1957
1958         printf("testing Picture::set_mime_type()... ");
1959         if(!block.set_mime_type("qmage/jpeg"))
1960                 return die_("returned false");
1961         printf("OK\n");
1962         picture_.data.picture.mime_type[0] = 'q';
1963
1964         printf("testing Picture::get_mime_type()... ");
1965         if(0 != strcmp(block.get_mime_type(), picture_.data.picture.mime_type))
1966                 return die_("value mismatch");
1967         printf("OK\n");
1968
1969         printf("testing Picture::set_description()... ");
1970         if(!block.set_description((const FLAC__byte*)"qesc"))
1971                 return die_("returned false");
1972         printf("OK\n");
1973         picture_.data.picture.description[0] = 'q';
1974
1975         printf("testing Picture::get_description()... ");
1976         if(0 != strcmp((const char *)block.get_description(), (const char *)picture_.data.picture.description))
1977                 return die_("value mismatch");
1978         printf("OK\n");
1979
1980         printf("testing Picture::get_width()... ");
1981         if(block.get_width() != 0)
1982                 return die_("value mismatch, expected 0");
1983         printf("OK\n");
1984
1985         printf("testing Picture::set_width()... +\n");
1986         printf("        Picture::get_width()... ");
1987         block.set_width(400);
1988         if(block.get_width() != 400)
1989                 return die_("value mismatch, expected 400");
1990         printf("OK\n");
1991
1992         printf("testing Picture::get_height()... ");
1993         if(block.get_height() != 0)
1994                 return die_("value mismatch, expected 0");
1995         printf("OK\n");
1996
1997         printf("testing Picture::set_height()... +\n");
1998         printf("        Picture::get_height()... ");
1999         block.set_height(200);
2000         if(block.get_height() != 200)
2001                 return die_("value mismatch, expected 200");
2002         printf("OK\n");
2003
2004         printf("testing Picture::get_depth()... ");
2005         if(block.get_depth() != 0)
2006                 return die_("value mismatch, expected 0");
2007         printf("OK\n");
2008
2009         printf("testing Picture::set_depth()... +\n");
2010         printf("        Picture::get_depth()... ");
2011         block.set_depth(16);
2012         if(block.get_depth() != 16)
2013                 return die_("value mismatch, expected 16");
2014         printf("OK\n");
2015
2016         printf("testing Picture::get_colors()... ");
2017         if(block.get_colors() != 0)
2018                 return die_("value mismatch, expected 0");
2019         printf("OK\n");
2020
2021         printf("testing Picture::set_colors()... +\n");
2022         printf("        Picture::get_colors()... ");
2023         block.set_colors(1u>16);
2024         if(block.get_colors() != (1u>16))
2025                 return die_("value mismatch, expected 2^16");
2026         printf("OK\n");
2027
2028         printf("testing Picture::get_data_length()... ");
2029         if(block.get_data_length() != 0)
2030                 return die_("value mismatch, expected 0");
2031         printf("OK\n");
2032
2033         printf("testing Picture::set_data()... ");
2034         if(!block.set_data((const FLAC__byte*)"qOMEJPEGDATA", strlen("qOMEJPEGDATA")))
2035                 return die_("returned false");
2036         printf("OK\n");
2037         picture_.data.picture.data[0] = 'q';
2038
2039         printf("testing Picture::get_data()... ");
2040         if(block.get_data_length() != picture_.data.picture.data_length)
2041                 return die_("length mismatch");
2042         if(0 != memcmp(block.get_data(), picture_.data.picture.data, picture_.data.picture.data_length))
2043                 return die_("value mismatch");
2044         printf("OK\n");
2045
2046         printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... ");
2047         FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block);
2048         if(0 == clone_)
2049                 return die_("returned NULL");
2050         if(0 == dynamic_cast<FLAC::Metadata::Picture *>(clone_))
2051                 return die_("downcast is NULL");
2052         if(*dynamic_cast<FLAC::Metadata::Picture *>(clone_) != block)
2053                 return die_("clone is not identical");
2054         printf("OK\n");
2055         printf("testing Picture::~Picture()... ");
2056         delete clone_;
2057         printf("OK\n");
2058
2059
2060         printf("PASSED\n\n");
2061         return true;
2062 }
2063
2064 bool test_metadata_object()
2065 {
2066         printf("\n+++ libFLAC++ unit test: metadata objects\n\n");
2067
2068         init_metadata_blocks_();
2069
2070         if(!test_metadata_object_streaminfo())
2071                 return false;
2072
2073         if(!test_metadata_object_padding())
2074                 return false;
2075
2076         if(!test_metadata_object_application())
2077                 return false;
2078
2079         if(!test_metadata_object_seektable())
2080                 return false;
2081
2082         if(!test_metadata_object_vorbiscomment())
2083                 return false;
2084
2085         if(!test_metadata_object_cuesheet())
2086                 return false;
2087
2088         if(!test_metadata_object_picture())
2089                 return false;
2090
2091         free_metadata_blocks_();
2092
2093         return true;
2094 }