| /* test_libFLAC++ - Unit tester for libFLAC++ |
| * Copyright (C) 2002-2009 Josh Coalson |
| * Copyright (C) 2011-2016 Xiph.Org Foundation |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <stdio.h> |
| #include <stdlib.h> /* for malloc() */ |
| #include <string.h> /* for memcmp() */ |
| #include "FLAC/assert.h" |
| #include "FLAC++/metadata.h" |
| #include "share/safe_str.h" |
| |
| static ::FLAC__StreamMetadata streaminfo_, padding_, seektable_, application_, vorbiscomment_, cuesheet_, picture_; |
| |
| static bool die_(const char *msg) |
| { |
| printf("FAILED, %s\n", msg); |
| return false; |
| } |
| |
| static void *malloc_or_die_(size_t size) |
| { |
| void *x = malloc(size); |
| if(0 == x) { |
| fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (uint32_t)size); |
| exit(1); |
| } |
| return x; |
| } |
| |
| static char *strdup_or_die_(const char *s) |
| { |
| char *x = strdup(s); |
| if(0 == x) { |
| fprintf(stderr, "ERROR: out of memory copying string \"%s\"\n", s); |
| exit(1); |
| } |
| return x; |
| } |
| |
| static bool index_is_equal_(const ::FLAC__StreamMetadata_CueSheet_Index &indx, const ::FLAC__StreamMetadata_CueSheet_Index &indxcopy) |
| { |
| if(indxcopy.offset != indx.offset) |
| return false; |
| if(indxcopy.number != indx.number) |
| return false; |
| return true; |
| } |
| |
| static bool track_is_equal_(const ::FLAC__StreamMetadata_CueSheet_Track *track, const ::FLAC__StreamMetadata_CueSheet_Track *trackcopy) |
| { |
| uint32_t i; |
| |
| if(trackcopy->offset != track->offset) |
| return false; |
| if(trackcopy->number != track->number) |
| return false; |
| if(0 != strcmp(trackcopy->isrc, track->isrc)) |
| return false; |
| if(trackcopy->type != track->type) |
| return false; |
| if(trackcopy->pre_emphasis != track->pre_emphasis) |
| return false; |
| if(trackcopy->num_indices != track->num_indices) |
| return false; |
| if(0 == track->indices || 0 == trackcopy->indices) { |
| if(track->indices != trackcopy->indices) |
| return false; |
| } |
| else { |
| for(i = 0; i < track->num_indices; i++) { |
| if(!index_is_equal_(trackcopy->indices[i], track->indices[i])) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static void init_metadata_blocks_() |
| { |
| streaminfo_.is_last = false; |
| streaminfo_.type = ::FLAC__METADATA_TYPE_STREAMINFO; |
| streaminfo_.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; |
| streaminfo_.data.stream_info.min_blocksize = 576; |
| streaminfo_.data.stream_info.max_blocksize = 576; |
| streaminfo_.data.stream_info.min_framesize = 0; |
| streaminfo_.data.stream_info.max_framesize = 0; |
| streaminfo_.data.stream_info.sample_rate = 44100; |
| streaminfo_.data.stream_info.channels = 1; |
| streaminfo_.data.stream_info.bits_per_sample = 8; |
| streaminfo_.data.stream_info.total_samples = 0; |
| memset(streaminfo_.data.stream_info.md5sum, 0, 16); |
| |
| padding_.is_last = false; |
| padding_.type = ::FLAC__METADATA_TYPE_PADDING; |
| padding_.length = 1234; |
| |
| seektable_.is_last = false; |
| seektable_.type = ::FLAC__METADATA_TYPE_SEEKTABLE; |
| seektable_.data.seek_table.num_points = 2; |
| seektable_.length = seektable_.data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH; |
| seektable_.data.seek_table.points = (::FLAC__StreamMetadata_SeekPoint*)malloc_or_die_(seektable_.data.seek_table.num_points * sizeof(::FLAC__StreamMetadata_SeekPoint)); |
| seektable_.data.seek_table.points[0].sample_number = 0; |
| seektable_.data.seek_table.points[0].stream_offset = 0; |
| seektable_.data.seek_table.points[0].frame_samples = streaminfo_.data.stream_info.min_blocksize; |
| seektable_.data.seek_table.points[1].sample_number = ::FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; |
| seektable_.data.seek_table.points[1].stream_offset = 1000; |
| seektable_.data.seek_table.points[1].frame_samples = streaminfo_.data.stream_info.min_blocksize; |
| |
| application_.is_last = false; |
| application_.type = ::FLAC__METADATA_TYPE_APPLICATION; |
| application_.length = 8; |
| memcpy(application_.data.application.id, "\xfe\xdc\xba\x98", 4); |
| application_.data.application.data = (FLAC__byte*)malloc_or_die_(4); |
| memcpy(application_.data.application.data, "\xf0\xe1\xd2\xc3", 4); |
| |
| vorbiscomment_.is_last = false; |
| vorbiscomment_.type = ::FLAC__METADATA_TYPE_VORBIS_COMMENT; |
| vorbiscomment_.length = (4 + 5) + 4 + (4 + 12) + (4 + 12); |
| vorbiscomment_.data.vorbis_comment.vendor_string.length = 5; |
| vorbiscomment_.data.vorbis_comment.vendor_string.entry = (FLAC__byte*)malloc_or_die_(5+1); |
| memcpy(vorbiscomment_.data.vorbis_comment.vendor_string.entry, "name0", 5+1); |
| vorbiscomment_.data.vorbis_comment.num_comments = 2; |
| vorbiscomment_.data.vorbis_comment.comments = (::FLAC__StreamMetadata_VorbisComment_Entry*)malloc_or_die_(vorbiscomment_.data.vorbis_comment.num_comments * sizeof(::FLAC__StreamMetadata_VorbisComment_Entry)); |
| vorbiscomment_.data.vorbis_comment.comments[0].length = 12; |
| vorbiscomment_.data.vorbis_comment.comments[0].entry = (FLAC__byte*)malloc_or_die_(12+1); |
| memcpy(vorbiscomment_.data.vorbis_comment.comments[0].entry, "name2=value2", 12+1); |
| vorbiscomment_.data.vorbis_comment.comments[1].length = 12; |
| vorbiscomment_.data.vorbis_comment.comments[1].entry = (FLAC__byte*)malloc_or_die_(12+1); |
| memcpy(vorbiscomment_.data.vorbis_comment.comments[1].entry, "name3=value3", 12+1); |
| |
| cuesheet_.is_last = false; |
| cuesheet_.type = ::FLAC__METADATA_TYPE_CUESHEET; |
| cuesheet_.length = |
| /* cuesheet guts */ |
| ( |
| FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN |
| ) / 8 + |
| /* 2 tracks */ |
| 2 * ( |
| FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN |
| ) / 8 + |
| /* 3 index points */ |
| 3 * ( |
| FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN |
| ) / 8 |
| ; |
| memset(cuesheet_.data.cue_sheet.media_catalog_number, 0, sizeof(cuesheet_.data.cue_sheet.media_catalog_number)); |
| cuesheet_.data.cue_sheet.media_catalog_number[0] = 'j'; |
| cuesheet_.data.cue_sheet.media_catalog_number[1] = 'C'; |
| cuesheet_.data.cue_sheet.lead_in = 159; |
| cuesheet_.data.cue_sheet.is_cd = true; |
| cuesheet_.data.cue_sheet.num_tracks = 2; |
| cuesheet_.data.cue_sheet.tracks = (FLAC__StreamMetadata_CueSheet_Track*)malloc_or_die_(cuesheet_.data.cue_sheet.num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track)); |
| cuesheet_.data.cue_sheet.tracks[0].offset = 1; |
| cuesheet_.data.cue_sheet.tracks[0].number = 1; |
| memcpy(cuesheet_.data.cue_sheet.tracks[0].isrc, "ACBDE1234567", sizeof(cuesheet_.data.cue_sheet.tracks[0].isrc)); |
| cuesheet_.data.cue_sheet.tracks[0].type = 0; |
| cuesheet_.data.cue_sheet.tracks[0].pre_emphasis = 1; |
| cuesheet_.data.cue_sheet.tracks[0].num_indices = 2; |
| 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)); |
| cuesheet_.data.cue_sheet.tracks[0].indices[0].offset = 0; |
| cuesheet_.data.cue_sheet.tracks[0].indices[0].number = 0; |
| cuesheet_.data.cue_sheet.tracks[0].indices[1].offset = 1234567890; |
| cuesheet_.data.cue_sheet.tracks[0].indices[1].number = 1; |
| cuesheet_.data.cue_sheet.tracks[1].offset = 2345678901u; |
| cuesheet_.data.cue_sheet.tracks[1].number = 2; |
| memcpy(cuesheet_.data.cue_sheet.tracks[1].isrc, "ACBDE7654321", sizeof(cuesheet_.data.cue_sheet.tracks[1].isrc)); |
| cuesheet_.data.cue_sheet.tracks[1].type = 1; |
| cuesheet_.data.cue_sheet.tracks[1].pre_emphasis = 0; |
| cuesheet_.data.cue_sheet.tracks[1].num_indices = 1; |
| 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)); |
| cuesheet_.data.cue_sheet.tracks[1].indices[0].offset = 0; |
| cuesheet_.data.cue_sheet.tracks[1].indices[0].number = 1; |
| |
| picture_.is_last = true; |
| picture_.type = FLAC__METADATA_TYPE_PICTURE; |
| picture_.length = |
| ( |
| FLAC__STREAM_METADATA_PICTURE_TYPE_LEN + |
| FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + /* will add the length for the string later */ |
| FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + /* will add the length for the string later */ |
| FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN + |
| FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN + |
| FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN + |
| FLAC__STREAM_METADATA_PICTURE_COLORS_LEN + |
| FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN /* will add the length for the data later */ |
| ) / 8 |
| ; |
| picture_.data.picture.type = FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER; |
| picture_.data.picture.mime_type = strdup_or_die_("image/jpeg"); |
| picture_.length += strlen(picture_.data.picture.mime_type); |
| picture_.data.picture.description = (FLAC__byte*)strdup_or_die_("desc"); |
| picture_.length += strlen((const char *)picture_.data.picture.description); |
| picture_.data.picture.width = 300; |
| picture_.data.picture.height = 300; |
| picture_.data.picture.depth = 24; |
| picture_.data.picture.colors = 0; |
| picture_.data.picture.data = (FLAC__byte*)strdup_or_die_("SOMEJPEGDATA"); |
| picture_.data.picture.data_length = strlen((const char *)picture_.data.picture.data); |
| picture_.length += picture_.data.picture.data_length; |
| } |
| |
| static void free_metadata_blocks_() |
| { |
| free(seektable_.data.seek_table.points); |
| free(application_.data.application.data); |
| free(vorbiscomment_.data.vorbis_comment.vendor_string.entry); |
| free(vorbiscomment_.data.vorbis_comment.comments[0].entry); |
| free(vorbiscomment_.data.vorbis_comment.comments[1].entry); |
| free(vorbiscomment_.data.vorbis_comment.comments); |
| free(cuesheet_.data.cue_sheet.tracks[0].indices); |
| free(cuesheet_.data.cue_sheet.tracks[1].indices); |
| free(cuesheet_.data.cue_sheet.tracks); |
| free(picture_.data.picture.mime_type); |
| free(picture_.data.picture.description); |
| free(picture_.data.picture.data); |
| } |
| |
| bool test_metadata_object_streaminfo() |
| { |
| uint32_t expected_length; |
| |
| printf("testing class FLAC::Metadata::StreamInfo\n"); |
| |
| printf("testing StreamInfo::StreamInfo()... "); |
| FLAC::Metadata::StreamInfo block; |
| if(!block.is_valid()) |
| return die_("!block.is_valid()"); |
| expected_length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; |
| if(block.get_length() != expected_length) { |
| printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length()); |
| return false; |
| } |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::StreamInfo(const StreamInfo &)... +\n"); |
| printf(" StreamInfo::operator!=(const StreamInfo &)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy(block); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != block) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::~StreamInfo()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" StreamInfo::operator!=(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy(streaminfo_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != streaminfo_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy(&streaminfo_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != streaminfo_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy(&streaminfo_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != streaminfo_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::StreamInfo(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&streaminfo_); |
| FLAC::Metadata::StreamInfo blockcopy(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != streaminfo_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy; |
| blockcopy.assign(&streaminfo_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != streaminfo_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" StreamInfo::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&streaminfo_); |
| FLAC::Metadata::StreamInfo blockcopy; |
| blockcopy.assign(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != streaminfo_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::operator=(const StreamInfo &)... +\n"); |
| printf(" StreamInfo::operator==(const StreamInfo &)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy = block; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == block)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::operator=(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" StreamInfo::operator==(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy = streaminfo_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == streaminfo_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::operator=(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" StreamInfo::operator==(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::StreamInfo blockcopy = &streaminfo_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == streaminfo_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing StreamInfo::set_min_blocksize()... "); |
| block.set_min_blocksize(streaminfo_.data.stream_info.min_blocksize); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_max_blocksize()... "); |
| block.set_max_blocksize(streaminfo_.data.stream_info.max_blocksize); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_min_framesize()... "); |
| block.set_min_framesize(streaminfo_.data.stream_info.min_framesize); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_max_framesize()... "); |
| block.set_max_framesize(streaminfo_.data.stream_info.max_framesize); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_sample_rate()... "); |
| block.set_sample_rate(streaminfo_.data.stream_info.sample_rate); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_channels()... "); |
| block.set_channels(streaminfo_.data.stream_info.channels); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_bits_per_sample()... "); |
| block.set_bits_per_sample(streaminfo_.data.stream_info.bits_per_sample); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_total_samples()... "); |
| block.set_total_samples(streaminfo_.data.stream_info.total_samples); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::set_md5sum()... "); |
| block.set_md5sum(streaminfo_.data.stream_info.md5sum); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_min_blocksize()... "); |
| if(block.get_min_blocksize() != streaminfo_.data.stream_info.min_blocksize) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_max_blocksize()... "); |
| if(block.get_max_blocksize() != streaminfo_.data.stream_info.max_blocksize) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_min_framesize()... "); |
| if(block.get_min_framesize() != streaminfo_.data.stream_info.min_framesize) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_max_framesize()... "); |
| if(block.get_max_framesize() != streaminfo_.data.stream_info.max_framesize) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_sample_rate()... "); |
| if(block.get_sample_rate() != streaminfo_.data.stream_info.sample_rate) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_channels()... "); |
| if(block.get_channels() != streaminfo_.data.stream_info.channels) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_bits_per_sample()... "); |
| if(block.get_bits_per_sample() != streaminfo_.data.stream_info.bits_per_sample) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_total_samples()... "); |
| if(block.get_total_samples() != streaminfo_.data.stream_info.total_samples) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing StreamInfo::get_md5sum()... "); |
| if(0 != memcmp(block.get_md5sum(), streaminfo_.data.stream_info.md5sum, 16)) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... "); |
| FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block); |
| if(0 == clone_) |
| return die_("returned NULL"); |
| if(0 == dynamic_cast<FLAC::Metadata::StreamInfo *>(clone_)) |
| return die_("downcast is NULL"); |
| if(*dynamic_cast<FLAC::Metadata::StreamInfo *>(clone_) != block) |
| return die_("clone is not identical"); |
| printf("OK\n"); |
| printf("testing StreamInfo::~StreamInfo()... "); |
| delete clone_; |
| printf("OK\n"); |
| |
| |
| printf("PASSED\n\n"); |
| return true; |
| } |
| |
| bool test_metadata_object_padding() |
| { |
| uint32_t expected_length; |
| |
| printf("testing class FLAC::Metadata::Padding\n"); |
| |
| printf("testing Padding::Padding()... "); |
| FLAC::Metadata::Padding block; |
| if(!block.is_valid()) |
| return die_("!block.is_valid()"); |
| expected_length = 0; |
| if(block.get_length() != expected_length) { |
| printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length()); |
| return false; |
| } |
| printf("OK\n"); |
| |
| printf("testing Padding::Padding(const Padding &)... +\n"); |
| printf(" Padding::operator!=(const Padding &)... "); |
| { |
| FLAC::Metadata::Padding blockcopy(block); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != block) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| |
| printf("testing Padding::~Padding()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing Padding::Padding(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" Padding::operator!=(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::Padding blockcopy(padding_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != padding_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::Padding(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" Padding::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Padding blockcopy(&padding_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != padding_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::Padding(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" Padding::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Padding blockcopy(&padding_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != padding_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::Padding(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" Padding::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&padding_); |
| FLAC::Metadata::Padding blockcopy(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != padding_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" Padding::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Padding blockcopy; |
| blockcopy.assign(&padding_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != padding_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" Padding::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&padding_); |
| FLAC::Metadata::Padding blockcopy; |
| blockcopy.assign(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != padding_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::operator=(const Padding &)... +\n"); |
| printf(" Padding::operator==(const Padding &)... "); |
| { |
| FLAC::Metadata::Padding blockcopy = block; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == block)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::operator=(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" Padding::operator==(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::Padding blockcopy = padding_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == padding_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::operator=(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" Padding::operator==(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Padding blockcopy = &padding_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == padding_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Padding::set_length()... "); |
| block.set_length(padding_.length); |
| printf("OK\n"); |
| |
| printf("testing Prototype::get_length()... "); |
| if(block.get_length() != padding_.length) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... "); |
| FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block); |
| if(0 == clone_) |
| return die_("returned NULL"); |
| if(0 == dynamic_cast<FLAC::Metadata::Padding *>(clone_)) |
| return die_("downcast is NULL"); |
| if(*dynamic_cast<FLAC::Metadata::Padding *>(clone_) != block) |
| return die_("clone is not identical"); |
| printf("OK\n"); |
| printf("testing Padding::~Padding()... "); |
| delete clone_; |
| printf("OK\n"); |
| |
| |
| printf("PASSED\n\n"); |
| return true; |
| } |
| |
| bool test_metadata_object_application() |
| { |
| uint32_t expected_length; |
| |
| printf("testing class FLAC::Metadata::Application\n"); |
| |
| printf("testing Application::Application()... "); |
| FLAC::Metadata::Application block; |
| if(!block.is_valid()) |
| return die_("!block.is_valid()"); |
| expected_length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8; |
| if(block.get_length() != expected_length) { |
| printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length()); |
| return false; |
| } |
| printf("OK\n"); |
| |
| printf("testing Application::Application(const Application &)... +\n"); |
| printf(" Application::operator!=(const Application &)... "); |
| { |
| FLAC::Metadata::Application blockcopy(block); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != block) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| |
| printf("testing Application::~Application()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing Application::Application(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" Application::operator!=(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::Application blockcopy(application_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != application_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::Application(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" Application::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Application blockcopy(&application_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != application_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::Application(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" Application::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Application blockcopy(&application_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != application_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::Application(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" Application::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&application_); |
| FLAC::Metadata::Application blockcopy(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != application_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" Application::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Application blockcopy; |
| blockcopy.assign(&application_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != application_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" Application::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&application_); |
| FLAC::Metadata::Application blockcopy; |
| blockcopy.assign(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != application_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::operator=(const Application &)... +\n"); |
| printf(" Application::operator==(const Application &)... "); |
| { |
| FLAC::Metadata::Application blockcopy = block; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == block)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::operator=(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" Application::operator==(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::Application blockcopy = application_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == application_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::operator=(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" Application::operator==(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Application blockcopy = &application_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == application_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Application::set_id()... "); |
| block.set_id(application_.data.application.id); |
| printf("OK\n"); |
| |
| printf("testing Application::set_data()... "); |
| block.set_data(application_.data.application.data, application_.length - sizeof(application_.data.application.id), /*copy=*/true); |
| printf("OK\n"); |
| |
| printf("testing Application::get_id()... "); |
| if(0 != memcmp(block.get_id(), application_.data.application.id, sizeof(application_.data.application.id))) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing Application::get_data()... "); |
| if(0 != memcmp(block.get_data(), application_.data.application.data, application_.length - sizeof(application_.data.application.id))) |
| return die_("value mismatch, doesn't match previously set value"); |
| printf("OK\n"); |
| |
| printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... "); |
| FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block); |
| if(0 == clone_) |
| return die_("returned NULL"); |
| if(0 == dynamic_cast<FLAC::Metadata::Application *>(clone_)) |
| return die_("downcast is NULL"); |
| if(*dynamic_cast<FLAC::Metadata::Application *>(clone_) != block) |
| return die_("clone is not identical"); |
| printf("OK\n"); |
| printf("testing Application::~Application()... "); |
| delete clone_; |
| printf("OK\n"); |
| |
| |
| printf("PASSED\n\n"); |
| return true; |
| } |
| |
| bool test_metadata_object_seektable() |
| { |
| uint32_t expected_length; |
| |
| printf("testing class FLAC::Metadata::SeekTable\n"); |
| |
| printf("testing SeekTable::SeekTable()... "); |
| FLAC::Metadata::SeekTable block; |
| if(!block.is_valid()) |
| return die_("!block.is_valid()"); |
| expected_length = 0; |
| if(block.get_length() != expected_length) { |
| printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length()); |
| return false; |
| } |
| printf("OK\n"); |
| |
| printf("testing SeekTable::SeekTable(const SeekTable &)... +\n"); |
| printf(" SeekTable::operator!=(const SeekTable &)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy(block); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != block) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::~SeekTable()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" SeekTable::operator!=(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy(seektable_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != seektable_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" SeekTable::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy(&seektable_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != seektable_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" SeekTable::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy(&seektable_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != seektable_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::SeekTable(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" SeekTable::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&seektable_); |
| FLAC::Metadata::SeekTable blockcopy(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != seektable_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" SeekTable::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy; |
| blockcopy.assign(&seektable_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != seektable_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" SeekTable::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&seektable_); |
| FLAC::Metadata::SeekTable blockcopy; |
| blockcopy.assign(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != seektable_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::operator=(const SeekTable &)... +\n"); |
| printf(" SeekTable::operator==(const SeekTable &)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy = block; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == block)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::operator=(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" SeekTable::operator==(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy = seektable_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == seektable_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::operator=(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" SeekTable::operator==(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::SeekTable blockcopy = &seektable_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == seektable_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing SeekTable::insert_point() x 3... "); |
| if(!block.insert_point(0, seektable_.data.seek_table.points[1])) |
| return die_("returned false"); |
| if(!block.insert_point(0, seektable_.data.seek_table.points[1])) |
| return die_("returned false"); |
| if(!block.insert_point(1, seektable_.data.seek_table.points[0])) |
| return die_("returned false"); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::is_legal()... "); |
| if(block.is_legal()) |
| return die_("returned true"); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::set_point()... "); |
| block.set_point(0, seektable_.data.seek_table.points[0]); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::delete_point()... "); |
| if(!block.delete_point(0)) |
| return die_("returned false"); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::is_legal()... "); |
| if(!block.is_legal()) |
| return die_("returned false"); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::get_num_points()... "); |
| if(block.get_num_points() != seektable_.data.seek_table.num_points) |
| return die_("number mismatch"); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::operator!=(const ::FLAC__StreamMetadata &)... "); |
| if(block != seektable_) |
| return die_("data mismatch"); |
| printf("OK\n"); |
| |
| printf("testing SeekTable::get_point()... "); |
| if( |
| block.get_point(1).sample_number != seektable_.data.seek_table.points[1].sample_number || |
| block.get_point(1).stream_offset != seektable_.data.seek_table.points[1].stream_offset || |
| block.get_point(1).frame_samples != seektable_.data.seek_table.points[1].frame_samples |
| ) |
| return die_("point mismatch"); |
| printf("OK\n"); |
| |
| printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... "); |
| FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block); |
| if(0 == clone_) |
| return die_("returned NULL"); |
| if(0 == dynamic_cast<FLAC::Metadata::SeekTable *>(clone_)) |
| return die_("downcast is NULL"); |
| if(*dynamic_cast<FLAC::Metadata::SeekTable *>(clone_) != block) |
| return die_("clone is not identical"); |
| printf("OK\n"); |
| printf("testing SeekTable::~SeekTable()... "); |
| delete clone_; |
| printf("OK\n"); |
| |
| |
| printf("PASSED\n\n"); |
| return true; |
| } |
| |
| bool test_metadata_object_vorbiscomment() |
| { |
| uint32_t expected_length; |
| |
| printf("testing class FLAC::Metadata::VorbisComment::Entry\n"); |
| |
| printf("testing Entry::Entry()... "); |
| { |
| FLAC::Metadata::VorbisComment::Entry entry1; |
| if(!entry1.is_valid()) |
| return die_("!is_valid()"); |
| printf("OK\n"); |
| |
| printf("testing Entry::~Entry()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing Entry::Entry(const char *field, uint32_t field_length)... "); |
| FLAC::Metadata::VorbisComment::Entry entry2("name2=value2", strlen("name2=value2")); |
| if(!entry2.is_valid()) |
| return die_("!is_valid()"); |
| printf("OK\n"); |
| |
| { |
| printf("testing Entry::Entry(const char *field)... "); |
| FLAC::Metadata::VorbisComment::Entry entry2z("name2=value2"); |
| if(!entry2z.is_valid()) |
| return die_("!is_valid()"); |
| if(strcmp(entry2.get_field(), entry2z.get_field())) |
| return die_("bad value"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Entry::Entry(const char *field_name, const char *field_value, uint32_t field_value_length)... "); |
| FLAC::Metadata::VorbisComment::Entry entry3("name3", "value3", strlen("value3")); |
| if(!entry3.is_valid()) |
| return die_("!is_valid()"); |
| printf("OK\n"); |
| |
| { |
| printf("testing Entry::Entry(const char *field_name, const char *field_value)... "); |
| FLAC::Metadata::VorbisComment::Entry entry3z("name3", "value3"); |
| if(!entry3z.is_valid()) |
| return die_("!is_valid()"); |
| if(strcmp(entry3.get_field(), entry3z.get_field())) |
| return die_("bad value"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Entry::Entry(const Entry &entry)... "); |
| { |
| FLAC::Metadata::VorbisComment::Entry entry2copy(entry2); |
| if(!entry2copy.is_valid()) |
| return die_("!is_valid()"); |
| printf("OK\n"); |
| |
| printf("testing Entry::~Entry()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing Entry::operator=(const Entry &entry)... "); |
| FLAC::Metadata::VorbisComment::Entry entry1 = entry2; |
| if(!entry2.is_valid()) |
| return die_("!is_valid()"); |
| printf("OK\n"); |
| |
| printf("testing Entry::get_field_length()... "); |
| if(entry1.get_field_length() != strlen("name2=value2")) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::get_field_name_length()... "); |
| if(entry1.get_field_name_length() != strlen("name2")) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::get_field_value_length()... "); |
| if(entry1.get_field_value_length() != strlen("value2")) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::get_entry()... "); |
| { |
| ::FLAC__StreamMetadata_VorbisComment_Entry entry = entry1.get_entry(); |
| if(entry.length != strlen("name2=value2")) |
| return die_("entry length mismatch"); |
| if(0 != memcmp(entry.entry, "name2=value2", entry.length)) |
| return die_("entry value mismatch"); |
| } |
| printf("OK\n"); |
| |
| printf("testing Entry::get_field()... "); |
| if(0 != memcmp(entry1.get_field(), "name2=value2", strlen("name2=value2"))) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::get_field_name()... "); |
| if(0 != memcmp(entry1.get_field_name(), "name2", strlen("name2"))) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::get_field_value()... "); |
| if(0 != memcmp(entry1.get_field_value(), "value2", strlen("value2"))) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::set_field_name()... "); |
| if(!entry1.set_field_name("name1")) |
| return die_("returned false"); |
| if(0 != memcmp(entry1.get_field_name(), "name1", strlen("name1"))) |
| return die_("value mismatch"); |
| if(0 != memcmp(entry1.get_field(), "name1=value2", strlen("name1=value2"))) |
| return die_("entry mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::set_field_value(const char *field_value, uint32_t field_value_length)... "); |
| if(!entry1.set_field_value("value1", strlen("value1"))) |
| return die_("returned false"); |
| if(0 != memcmp(entry1.get_field_value(), "value1", strlen("value1"))) |
| return die_("value mismatch"); |
| if(0 != memcmp(entry1.get_field(), "name1=value1", strlen("name1=value1"))) |
| return die_("entry mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::set_field_value(const char *field_value)... "); |
| if(!entry1.set_field_value("value1")) |
| return die_("returned false"); |
| if(0 != memcmp(entry1.get_field_value(), "value1", strlen("value1"))) |
| return die_("value mismatch"); |
| if(0 != memcmp(entry1.get_field(), "name1=value1", strlen("name1=value1"))) |
| return die_("entry mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::set_field(const char *field, uint32_t field_length)... "); |
| if(!entry1.set_field("name0=value0", strlen("name0=value0"))) |
| return die_("returned false"); |
| if(0 != memcmp(entry1.get_field_name(), "name0", strlen("name0"))) |
| return die_("value mismatch"); |
| if(0 != memcmp(entry1.get_field_value(), "value0", strlen("value0"))) |
| return die_("value mismatch"); |
| if(0 != memcmp(entry1.get_field(), "name0=value0", strlen("name0=value0"))) |
| return die_("entry mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Entry::set_field(const char *field)... "); |
| if(!entry1.set_field("name0=value0")) |
| return die_("returned false"); |
| if(0 != memcmp(entry1.get_field_name(), "name0", strlen("name0"))) |
| return die_("value mismatch"); |
| if(0 != memcmp(entry1.get_field_value(), "value0", strlen("value0"))) |
| return die_("value mismatch"); |
| if(0 != memcmp(entry1.get_field(), "name0=value0", strlen("name0=value0"))) |
| return die_("entry mismatch"); |
| printf("OK\n"); |
| |
| printf("PASSED\n\n"); |
| |
| |
| printf("testing class FLAC::Metadata::VorbisComment\n"); |
| |
| printf("testing VorbisComment::VorbisComment()... "); |
| FLAC::Metadata::VorbisComment block; |
| if(!block.is_valid()) |
| return die_("!block.is_valid()"); |
| expected_length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + strlen(::FLAC__VENDOR_STRING) + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN/8); |
| if(block.get_length() != expected_length) { |
| printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length()); |
| return false; |
| } |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::VorbisComment(const VorbisComment &)... +\n"); |
| printf(" VorbisComment::operator!=(const VorbisComment &)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy(block); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != block) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::~VorbisComment()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" VorbisComment::operator!=(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy(vorbiscomment_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != vorbiscomment_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy(&vorbiscomment_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != vorbiscomment_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy(&vorbiscomment_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != vorbiscomment_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::VorbisComment(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&vorbiscomment_); |
| FLAC::Metadata::VorbisComment blockcopy(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != vorbiscomment_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy; |
| blockcopy.assign(&vorbiscomment_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != vorbiscomment_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" VorbisComment::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&vorbiscomment_); |
| FLAC::Metadata::VorbisComment blockcopy; |
| blockcopy.assign(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != vorbiscomment_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::operator=(const VorbisComment &)... +\n"); |
| printf(" VorbisComment::operator==(const VorbisComment &)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy = block; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == block)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::operator=(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" VorbisComment::operator==(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy = vorbiscomment_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == vorbiscomment_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::operator=(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" VorbisComment::operator==(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::VorbisComment blockcopy = &vorbiscomment_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == vorbiscomment_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing VorbisComment::get_num_comments()... "); |
| if(block.get_num_comments() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::set_vendor_string()... "); |
| if(!block.set_vendor_string((const FLAC__byte *)"mame0")) |
| return die_("returned false"); |
| printf("OK\n"); |
| vorbiscomment_.data.vorbis_comment.vendor_string.entry[0] = 'm'; |
| |
| printf("testing VorbisComment::get_vendor_string()... "); |
| if(strlen((const char *)block.get_vendor_string()) != vorbiscomment_.data.vorbis_comment.vendor_string.length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_vendor_string(), vorbiscomment_.data.vorbis_comment.vendor_string.entry, vorbiscomment_.data.vorbis_comment.vendor_string.length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::append_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.append_comment(entry3)) |
| return die_("returned false"); |
| if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::append_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.append_comment(entry2)) |
| return die_("returned false"); |
| if(block.get_comment(1).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_comment(1).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::delete_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.delete_comment(0)) |
| return die_("returned false"); |
| if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length) |
| return die_("length[0] mismatch"); |
| if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length)) |
| return die_("value[0] mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::delete_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.delete_comment(0)) |
| return die_("returned false"); |
| if(block.get_num_comments() != 0) |
| return die_("block mismatch, expected num_comments = 0"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::insert_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.insert_comment(0, entry3)) |
| return die_("returned false"); |
| if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::insert_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.insert_comment(0, entry3)) |
| return die_("returned false"); |
| if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::insert_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.insert_comment(1, entry2)) |
| return die_("returned false"); |
| if(block.get_comment(1).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_comment(1).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::set_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.set_comment(0, entry2)) |
| return die_("returned false"); |
| if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing VorbisComment::delete_comment()... +\n"); |
| printf(" VorbisComment::get_comment()... "); |
| if(!block.delete_comment(0)) |
| return die_("returned false"); |
| if(block.get_comment(0).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[0].length) |
| return die_("length[0] mismatch"); |
| if(0 != memcmp(block.get_comment(0).get_field(), vorbiscomment_.data.vorbis_comment.comments[0].entry, vorbiscomment_.data.vorbis_comment.comments[0].length)) |
| return die_("value[0] mismatch"); |
| if(block.get_comment(1).get_field_length() != vorbiscomment_.data.vorbis_comment.comments[1].length) |
| return die_("length[1] mismatch"); |
| if(0 != memcmp(block.get_comment(1).get_field(), vorbiscomment_.data.vorbis_comment.comments[1].entry, vorbiscomment_.data.vorbis_comment.comments[1].length)) |
| return die_("value[0] mismatch"); |
| printf("OK\n"); |
| |
| printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... "); |
| FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block); |
| if(0 == clone_) |
| return die_("returned NULL"); |
| if(0 == dynamic_cast<FLAC::Metadata::VorbisComment *>(clone_)) |
| return die_("downcast is NULL"); |
| if(*dynamic_cast<FLAC::Metadata::VorbisComment *>(clone_) != block) |
| return die_("clone is not identical"); |
| printf("OK\n"); |
| printf("testing VorbisComment::~VorbisComment()... "); |
| delete clone_; |
| printf("OK\n"); |
| |
| |
| printf("PASSED\n\n"); |
| return true; |
| } |
| |
| bool test_metadata_object_cuesheet() |
| { |
| uint32_t expected_length; |
| |
| printf("testing class FLAC::Metadata::CueSheet::Track\n"); |
| |
| printf("testing Track::Track()... "); |
| FLAC::Metadata::CueSheet::Track track0; |
| if(!track0.is_valid()) |
| return die_("!is_valid()"); |
| printf("OK\n"); |
| |
| { |
| printf("testing Track::get_track()... "); |
| const ::FLAC__StreamMetadata_CueSheet_Track *trackp = track0.get_track(); |
| if(0 == trackp) |
| return die_("returned pointer is NULL"); |
| printf("OK\n"); |
| |
| printf("testing Track::Track(const ::FLAC__StreamMetadata_CueSheet_Track*)... "); |
| FLAC::Metadata::CueSheet::Track track2(trackp); |
| if(!track2.is_valid()) |
| return die_("!is_valid()"); |
| if(!track_is_equal_(track2.get_track(), trackp)) |
| return die_("copy is not equal"); |
| printf("OK\n"); |
| |
| printf("testing Track::~Track()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing Track::Track(const Track &track)... "); |
| { |
| FLAC::Metadata::CueSheet::Track track0copy(track0); |
| if(!track0copy.is_valid()) |
| return die_("!is_valid()"); |
| if(!track_is_equal_(track0copy.get_track(), track0.get_track())) |
| return die_("copy is not equal"); |
| printf("OK\n"); |
| |
| printf("testing Track::~Track()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing Track::operator=(const Track &track)... "); |
| FLAC::Metadata::CueSheet::Track track1 = track0; |
| if(!track0.is_valid()) |
| return die_("!is_valid()"); |
| if(!track_is_equal_(track1.get_track(), track0.get_track())) |
| return die_("copy is not equal"); |
| printf("OK\n"); |
| |
| printf("testing Track::get_offset()... "); |
| if(track1.get_offset() != 0) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::get_number()... "); |
| if(track1.get_number() != 0) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::get_isrc()... "); |
| if(0 != memcmp(track1.get_isrc(), "\0\0\0\0\0\0\0\0\0\0\0\0\0", 13)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::get_type()... "); |
| if(track1.get_type() != 0) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::get_pre_emphasis()... "); |
| if(track1.get_pre_emphasis() != 0) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::get_num_indices()... "); |
| if(track1.get_num_indices() != 0) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::set_offset()... "); |
| track1.set_offset(588); |
| if(track1.get_offset() != 588) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::set_number()... "); |
| track1.set_number(1); |
| if(track1.get_number() != 1) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::set_isrc()... "); |
| track1.set_isrc("ABCDE1234567"); |
| if(0 != memcmp(track1.get_isrc(), "ABCDE1234567", 13)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::set_type()... "); |
| track1.set_type(1); |
| if(track1.get_type() != 1) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Track::set_pre_emphasis()... "); |
| track1.set_pre_emphasis(1); |
| if(track1.get_pre_emphasis() != 1) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("PASSED\n\n"); |
| |
| printf("testing class FLAC::Metadata::CueSheet\n"); |
| |
| printf("testing CueSheet::CueSheet()... "); |
| FLAC::Metadata::CueSheet block; |
| if(!block.is_valid()) |
| return die_("!block.is_valid()"); |
| expected_length = ( |
| FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN + |
| FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN |
| ) / 8; |
| if(block.get_length() != expected_length) { |
| printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length()); |
| return false; |
| } |
| printf("OK\n"); |
| |
| printf("testing CueSheet::CueSheet(const CueSheet &)... +\n"); |
| printf(" CueSheet::operator!=(const CueSheet &)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy(block); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != block) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::~CueSheet()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" CueSheet::operator!=(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy(cuesheet_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != cuesheet_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" CueSheet::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy(&cuesheet_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != cuesheet_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" CueSheet::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy(&cuesheet_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != cuesheet_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::CueSheet(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" CueSheet::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&cuesheet_); |
| FLAC::Metadata::CueSheet blockcopy(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != cuesheet_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" CueSheet::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy; |
| blockcopy.assign(&cuesheet_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != cuesheet_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" CueSheet::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&cuesheet_); |
| FLAC::Metadata::CueSheet blockcopy; |
| blockcopy.assign(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != cuesheet_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::operator=(const CueSheet &)... +\n"); |
| printf(" CueSheet::operator==(const CueSheet &)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy = block; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == block)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::operator=(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" CueSheet::operator==(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy = cuesheet_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == cuesheet_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::operator=(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" CueSheet::operator==(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::CueSheet blockcopy = &cuesheet_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == cuesheet_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing CueSheet::get_media_catalog_number()... "); |
| if(0 != strcmp(block.get_media_catalog_number(), "")) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::get_lead_in()... "); |
| if(block.get_lead_in() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::get_is_cd()... "); |
| if(block.get_is_cd()) |
| return die_("value mismatch, expected false"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::get_num_tracks()... "); |
| if(block.get_num_tracks() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::set_media_catalog_number()... "); |
| { |
| char mcn[129]; |
| memset(mcn, 0, sizeof(mcn)); |
| safe_strncpy(mcn, "1234567890123", sizeof(mcn)); |
| block.set_media_catalog_number(mcn); |
| if(0 != memcmp(block.get_media_catalog_number(), mcn, sizeof(mcn))) |
| return die_("value mismatch"); |
| } |
| printf("OK\n"); |
| |
| printf("testing CueSheet::set_lead_in()... "); |
| block.set_lead_in(588); |
| if(block.get_lead_in() != 588) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::set_is_cd()... "); |
| block.set_is_cd(true); |
| if(!block.get_is_cd()) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::insert_track()... +\n"); |
| printf(" CueSheet::get_track()... "); |
| if(!block.insert_track(0, track0)) |
| return die_("returned false"); |
| if(!track_is_equal_(block.get_track(0).get_track(), track0.get_track())) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::insert_track()... +\n"); |
| printf(" CueSheet::get_track()... "); |
| if(!block.insert_track(1, track1)) |
| return die_("returned false"); |
| if(!track_is_equal_(block.get_track(1).get_track(), track1.get_track())) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| ::FLAC__StreamMetadata_CueSheet_Index index0; |
| index0.offset = 588*4; |
| index0.number = 1; |
| |
| printf("testing CueSheet::insert_index(0)... +\n"); |
| printf(" CueSheet::get_track()... +\n"); |
| printf(" CueSheet::Track::get_index()... "); |
| if(!block.insert_index(0, 0, index0)) |
| return die_("returned false"); |
| if(!index_is_equal_(block.get_track(0).get_index(0), index0)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| index0.offset = 588*5; |
| printf("testing CueSheet::Track::set_index()... "); |
| { |
| FLAC::Metadata::CueSheet::Track track_ = block.get_track(0); |
| track_.set_index(0, index0); |
| if(!index_is_equal_(track_.get_index(0), index0)) |
| return die_("value mismatch"); |
| } |
| printf("OK\n"); |
| |
| index0.offset = 588*6; |
| printf("testing CueSheet::set_index()... "); |
| block.set_index(0, 0, index0); |
| if(!index_is_equal_(block.get_track(0).get_index(0), index0)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::delete_index()... "); |
| if(!block.delete_index(0, 0)) |
| return die_("returned false"); |
| if(block.get_track(0).get_num_indices() != 0) |
| return die_("num_indices mismatch"); |
| printf("OK\n"); |
| |
| |
| printf("testing CueSheet::set_track()... +\n"); |
| printf(" CueSheet::get_track()... "); |
| if(!block.set_track(0, track1)) |
| return die_("returned false"); |
| if(!track_is_equal_(block.get_track(0).get_track(), track1.get_track())) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing CueSheet::delete_track()... "); |
| if(!block.delete_track(0)) |
| return die_("returned false"); |
| if(block.get_num_tracks() != 1) |
| return die_("num_tracks mismatch"); |
| printf("OK\n"); |
| |
| printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... "); |
| FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block); |
| if(0 == clone_) |
| return die_("returned NULL"); |
| if(0 == dynamic_cast<FLAC::Metadata::CueSheet *>(clone_)) |
| return die_("downcast is NULL"); |
| if(*dynamic_cast<FLAC::Metadata::CueSheet *>(clone_) != block) |
| return die_("clone is not identical"); |
| printf("OK\n"); |
| printf("testing CueSheet::~CueSheet()... "); |
| delete clone_; |
| printf("OK\n"); |
| |
| printf("PASSED\n\n"); |
| return true; |
| } |
| |
| bool test_metadata_object_picture() |
| { |
| uint32_t expected_length; |
| |
| printf("testing class FLAC::Metadata::Picture\n"); |
| |
| printf("testing Picture::Picture()... "); |
| FLAC::Metadata::Picture block; |
| if(!block.is_valid()) |
| return die_("!block.is_valid()"); |
| expected_length = ( |
| FLAC__STREAM_METADATA_PICTURE_TYPE_LEN + |
| FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + |
| FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + |
| FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN + |
| FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN + |
| FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN + |
| FLAC__STREAM_METADATA_PICTURE_COLORS_LEN + |
| FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN |
| ) / 8; |
| if(block.get_length() != expected_length) { |
| printf("FAILED, bad length, expected %u, got %u\n", expected_length, block.get_length()); |
| return false; |
| } |
| printf("OK\n"); |
| |
| printf("testing Picture::Picture(const Picture &)... +\n"); |
| printf(" Picture::operator!=(const Picture &)... "); |
| { |
| FLAC::Metadata::Picture blockcopy(block); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != block) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| |
| printf("testing Picture::~Picture()... "); |
| } |
| printf("OK\n"); |
| |
| printf("testing Picture::Picture(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" Picture::operator!=(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::Picture blockcopy(picture_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != picture_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::Picture(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" Picture::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Picture blockcopy(&picture_); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != picture_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::Picture(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" Picture::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Picture blockcopy(&picture_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != picture_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::Picture(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" Picture::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&picture_); |
| FLAC::Metadata::Picture blockcopy(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != picture_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::assign(const ::FLAC__StreamMetadata *, copy=true)... +\n"); |
| printf(" Picture::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Picture blockcopy; |
| blockcopy.assign(&picture_, /*copy=*/true); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != picture_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::assign(const ::FLAC__StreamMetadata *, copy=false)... +\n"); |
| printf(" Picture::operator!=(const ::FLAC__StreamMetadata *)... "); |
| { |
| ::FLAC__StreamMetadata *copy = ::FLAC__metadata_object_clone(&picture_); |
| FLAC::Metadata::Picture blockcopy; |
| blockcopy.assign(copy, /*copy=*/false); |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(blockcopy != picture_) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::operator=(const Picture &)... +\n"); |
| printf(" Picture::operator==(const Picture &)... "); |
| { |
| FLAC::Metadata::Picture blockcopy = block; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == block)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::operator=(const ::FLAC__StreamMetadata &)... +\n"); |
| printf(" Picture::operator==(const ::FLAC__StreamMetadata &)... "); |
| { |
| FLAC::Metadata::Picture blockcopy = picture_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == picture_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::operator=(const ::FLAC__StreamMetadata *)... +\n"); |
| printf(" Picture::operator==(const ::FLAC__StreamMetadata *)... "); |
| { |
| FLAC::Metadata::Picture blockcopy = &picture_; |
| if(!blockcopy.is_valid()) |
| return die_("!blockcopy.is_valid()"); |
| if(!(blockcopy == picture_)) |
| return die_("copy is not identical to original"); |
| printf("OK\n"); |
| } |
| |
| printf("testing Picture::get_type()... "); |
| if(block.get_type() != ::FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER) |
| return die_("value mismatch, expected ::FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_type()... +\n"); |
| printf(" Picture::get_type()... "); |
| block.set_type(::FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA); |
| if(block.get_type() != ::FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA) |
| return die_("value mismatch, expected ::FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_mime_type()... "); |
| if(!block.set_mime_type("qmage/jpeg")) |
| return die_("returned false"); |
| printf("OK\n"); |
| picture_.data.picture.mime_type[0] = 'q'; |
| |
| printf("testing Picture::get_mime_type()... "); |
| if(0 != strcmp(block.get_mime_type(), picture_.data.picture.mime_type)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_description()... "); |
| if(!block.set_description((const FLAC__byte*)"qesc")) |
| return die_("returned false"); |
| printf("OK\n"); |
| picture_.data.picture.description[0] = 'q'; |
| |
| printf("testing Picture::get_description()... "); |
| if(0 != strcmp((const char *)block.get_description(), (const char *)picture_.data.picture.description)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing Picture::get_width()... "); |
| if(block.get_width() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_width()... +\n"); |
| printf(" Picture::get_width()... "); |
| block.set_width(400); |
| if(block.get_width() != 400) |
| return die_("value mismatch, expected 400"); |
| printf("OK\n"); |
| |
| printf("testing Picture::get_height()... "); |
| if(block.get_height() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_height()... +\n"); |
| printf(" Picture::get_height()... "); |
| block.set_height(200); |
| if(block.get_height() != 200) |
| return die_("value mismatch, expected 200"); |
| printf("OK\n"); |
| |
| printf("testing Picture::get_depth()... "); |
| if(block.get_depth() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_depth()... +\n"); |
| printf(" Picture::get_depth()... "); |
| block.set_depth(16); |
| if(block.get_depth() != 16) |
| return die_("value mismatch, expected 16"); |
| printf("OK\n"); |
| |
| printf("testing Picture::get_colors()... "); |
| if(block.get_colors() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_colors()... +\n"); |
| printf(" Picture::get_colors()... "); |
| block.set_colors(1u>16); |
| if(block.get_colors() != (1u>16)) |
| return die_("value mismatch, expected 2^16"); |
| printf("OK\n"); |
| |
| printf("testing Picture::get_data_length()... "); |
| if(block.get_data_length() != 0) |
| return die_("value mismatch, expected 0"); |
| printf("OK\n"); |
| |
| printf("testing Picture::set_data()... "); |
| if(!block.set_data((const FLAC__byte*)"qOMEJPEGDATA", strlen("qOMEJPEGDATA"))) |
| return die_("returned false"); |
| printf("OK\n"); |
| picture_.data.picture.data[0] = 'q'; |
| |
| printf("testing Picture::get_data()... "); |
| if(block.get_data_length() != picture_.data.picture.data_length) |
| return die_("length mismatch"); |
| if(0 != memcmp(block.get_data(), picture_.data.picture.data, picture_.data.picture.data_length)) |
| return die_("value mismatch"); |
| printf("OK\n"); |
| |
| printf("testing FLAC::Metadata::clone(const FLAC::Metadata::Prototype *)... "); |
| FLAC::Metadata::Prototype *clone_ = FLAC::Metadata::clone(&block); |
| if(0 == clone_) |
| return die_("returned NULL"); |
| if(0 == dynamic_cast<FLAC::Metadata::Picture *>(clone_)) |
| return die_("downcast is NULL"); |
| if(*dynamic_cast<FLAC::Metadata::Picture *>(clone_) != block) |
| return die_("clone is not identical"); |
| printf("OK\n"); |
| printf("testing Picture::~Picture()... "); |
| delete clone_; |
| printf("OK\n"); |
| |
| |
| printf("PASSED\n\n"); |
| return true; |
| } |
| |
| bool test_metadata_object() |
| { |
| printf("\n+++ libFLAC++ unit test: metadata objects\n\n"); |
| |
| init_metadata_blocks_(); |
| |
| if(!test_metadata_object_streaminfo()) |
| return false; |
| |
| if(!test_metadata_object_padding()) |
| return false; |
| |
| if(!test_metadata_object_application()) |
| return false; |
| |
| if(!test_metadata_object_seektable()) |
| return false; |
| |
| if(!test_metadata_object_vorbiscomment()) |
| return false; |
| |
| if(!test_metadata_object_cuesheet()) |
| return false; |
| |
| if(!test_metadata_object_picture()) |
| return false; |
| |
| free_metadata_blocks_(); |
| |
| return true; |
| } |