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