src/test_libFLAC++/metadata_object.cpp

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