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#if HAVE_CONFIG_H 20# include <config.h> 21#endif 22 23#include "FLAC/assert.h" 24#include "FLAC/metadata.h" 25#include "test_libs_common/metadata_utils.h" 26#include "metadata.h" 27#include <stdio.h> 28#include <stdlib.h> /* for malloc() */ 29#include <string.h> /* for memcmp() */ 30 31static FLAC__byte *make_dummydata_(FLAC__byte *dummydata, unsigned len) 32{ 33 FLAC__byte *ret; 34 35 if(0 == (ret = (FLAC__byte*)malloc(len))) { 36 printf("FAILED, malloc error\n"); 37 exit(1); 38 } 39 else 40 memcpy(ret, dummydata, len); 41 42 return ret; 43} 44 45static FLAC__bool compare_track_(const FLAC__StreamMetadata_CueSheet_Track *from, const FLAC__StreamMetadata_CueSheet_Track *to) 46{ 47 unsigned i; 48 49 if(from->offset != to->offset) { 50#ifdef _MSC_VER 51 printf("FAILED, track offset mismatch, expected %I64u, got %I64u\n", to->offset, from->offset); 52#else 53 printf("FAILED, track offset mismatch, expected %llu, got %llu\n", (unsigned long long)to->offset, (unsigned long long)from->offset); 54#endif 55 return false; 56 } 57 if(from->number != to->number) { 58 printf("FAILED, track number mismatch, expected %u, got %u\n", (unsigned)to->number, (unsigned)from->number); 59 return false; 60 } 61 if(0 != strcmp(from->isrc, to->isrc)) { 62 printf("FAILED, track number mismatch, expected %s, got %s\n", to->isrc, from->isrc); 63 return false; 64 } 65 if(from->type != to->type) { 66 printf("FAILED, track type mismatch, expected %u, got %u\n", (unsigned)to->type, (unsigned)from->type); 67 return false; 68 } 69 if(from->pre_emphasis != to->pre_emphasis) { 70 printf("FAILED, track pre_emphasis mismatch, expected %u, got %u\n", (unsigned)to->pre_emphasis, (unsigned)from->pre_emphasis); 71 return false; 72 } 73 if(from->num_indices != to->num_indices) { 74 printf("FAILED, track num_indices mismatch, expected %u, got %u\n", (unsigned)to->num_indices, (unsigned)from->num_indices); 75 return false; 76 } 77 if(0 == to->indices || 0 == from->indices) { 78 if(to->indices != from->indices) { 79 printf("FAILED, track indices mismatch\n"); 80 return false; 81 } 82 } 83 else { 84 for(i = 0; i < to->num_indices; i++) { 85 if(from->indices[i].offset != to->indices[i].offset) { 86#ifdef _MSC_VER 87 printf("FAILED, track indices[%u].offset mismatch, expected %I64u, got %I64u\n", i, to->indices[i].offset, from->indices[i].offset); 88#else 89 printf("FAILED, track indices[%u].offset mismatch, expected %llu, got %llu\n", i, (unsigned long long)to->indices[i].offset, (unsigned long long)from->indices[i].offset); 90#endif 91 return false; 92 } 93 if(from->indices[i].number != to->indices[i].number) { 94 printf("FAILED, track indices[%u].number mismatch, expected %u, got %u\n", i, (unsigned)to->indices[i].number, (unsigned)from->indices[i].number); 95 return false; 96 } 97 } 98 } 99 100 return true; 101} 102 103static FLAC__bool compare_seekpoint_array_(const FLAC__StreamMetadata_SeekPoint *from, const FLAC__StreamMetadata_SeekPoint *to, unsigned n) 104{ 105 unsigned i; 106 107 FLAC__ASSERT(0 != from); 108 FLAC__ASSERT(0 != to); 109 110 for(i = 0; i < n; i++) { 111 if(from[i].sample_number != to[i].sample_number) { 112#ifdef _MSC_VER 113 printf("FAILED, point[%u].sample_number mismatch, expected %I64u, got %I64u\n", i, to[i].sample_number, from[i].sample_number); 114#else 115 printf("FAILED, point[%u].sample_number mismatch, expected %llu, got %llu\n", i, (unsigned long long)to[i].sample_number, (unsigned long long)from[i].sample_number); 116#endif 117 return false; 118 } 119 if(from[i].stream_offset != to[i].stream_offset) { 120#ifdef _MSC_VER 121 printf("FAILED, point[%u].stream_offset mismatch, expected %I64u, got %I64u\n", i, to[i].stream_offset, from[i].stream_offset); 122#else 123 printf("FAILED, point[%u].stream_offset mismatch, expected %llu, got %llu\n", i, (unsigned long long)to[i].stream_offset, (unsigned long long)from[i].stream_offset); 124#endif 125 return false; 126 } 127 if(from[i].frame_samples != to[i].frame_samples) { 128 printf("FAILED, point[%u].frame_samples mismatch, expected %u, got %u\n", i, to[i].frame_samples, from[i].frame_samples); 129 return false; 130 } 131 } 132 133 return true; 134} 135 136static FLAC__bool check_seektable_(const FLAC__StreamMetadata *block, unsigned num_points, const FLAC__StreamMetadata_SeekPoint *array) 137{ 138 const unsigned expected_length = num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH; 139 140 if(block->length != expected_length) { 141 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 142 return false; 143 } 144 if(block->data.seek_table.num_points != num_points) { 145 printf("FAILED, expected %u point, got %u\n", num_points, block->data.seek_table.num_points); 146 return false; 147 } 148 if(0 == array) { 149 if(0 != block->data.seek_table.points) { 150 printf("FAILED, 'points' pointer is not null\n"); 151 return false; 152 } 153 } 154 else { 155 if(!compare_seekpoint_array_(block->data.seek_table.points, array, num_points)) 156 return false; 157 } 158 printf("OK\n"); 159 160 return true; 161} 162 163static void entry_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field) 164{ 165 entry->length = strlen(field); 166 entry->entry = (FLAC__byte*)malloc(entry->length+1); 167 FLAC__ASSERT(0 != entry->entry); 168 memcpy(entry->entry, field, entry->length); 169 entry->entry[entry->length] = '\0'; 170} 171 172static void entry_clone_(FLAC__StreamMetadata_VorbisComment_Entry *entry) 173{ 174 FLAC__byte *x = (FLAC__byte*)malloc(entry->length+1); 175 FLAC__ASSERT(0 != x); 176 memcpy(x, entry->entry, entry->length); 177 x[entry->length] = '\0'; 178 entry->entry = x; 179} 180 181static void vc_calc_len_(FLAC__StreamMetadata *block) 182{ 183 const FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment; 184 unsigned i; 185 186 block->length = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8; 187 block->length += vc->vendor_string.length; 188 block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8; 189 for(i = 0; i < vc->num_comments; i++) { 190 block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8; 191 block->length += vc->comments[i].length; 192 } 193} 194 195static void vc_resize_(FLAC__StreamMetadata *block, unsigned num) 196{ 197 FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment; 198 199 if(vc->num_comments != 0) { 200 FLAC__ASSERT(0 != vc->comments); 201 if(num < vc->num_comments) { 202 unsigned i; 203 for(i = num; i < vc->num_comments; i++) { 204 if(0 != vc->comments[i].entry) 205 free(vc->comments[i].entry); 206 } 207 } 208 } 209 if(num == 0) { 210 if(0 != vc->comments) { 211 free(vc->comments); 212 vc->comments = 0; 213 } 214 } 215 else { 216 vc->comments = (FLAC__StreamMetadata_VorbisComment_Entry*)realloc(vc->comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*num); 217 FLAC__ASSERT(0 != vc->comments); 218 if(num > vc->num_comments) 219 memset(vc->comments+vc->num_comments, 0, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(num-vc->num_comments)); 220 } 221 222 vc->num_comments = num; 223 vc_calc_len_(block); 224} 225 226static int vc_find_from_(FLAC__StreamMetadata *block, const char *name, unsigned start) 227{ 228 const unsigned n = strlen(name); 229 unsigned i; 230 for(i = start; i < block->data.vorbis_comment.num_comments; i++) { 231 const FLAC__StreamMetadata_VorbisComment_Entry *entry = &block->data.vorbis_comment.comments[i]; 232 if(entry->length > n && 0 == strncmp((const char *)entry->entry, name, n) && entry->entry[n] == '=') 233 return (int)i; 234 } 235 return -1; 236} 237 238static void vc_set_vs_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field) 239{ 240 if(0 != block->data.vorbis_comment.vendor_string.entry) 241 free(block->data.vorbis_comment.vendor_string.entry); 242 entry_new_(entry, field); 243 block->data.vorbis_comment.vendor_string = *entry; 244 vc_calc_len_(block); 245} 246 247static void vc_set_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field) 248{ 249 if(0 != block->data.vorbis_comment.comments[pos].entry) 250 free(block->data.vorbis_comment.comments[pos].entry); 251 entry_new_(entry, field); 252 block->data.vorbis_comment.comments[pos] = *entry; 253 vc_calc_len_(block); 254} 255 256static void vc_insert_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field) 257{ 258 vc_resize_(block, block->data.vorbis_comment.num_comments+1); 259 memmove(&block->data.vorbis_comment.comments[pos+1], &block->data.vorbis_comment.comments[pos], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(block->data.vorbis_comment.num_comments-1-pos)); 260 memset(&block->data.vorbis_comment.comments[pos], 0, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)); 261 vc_set_new_(entry, block, pos, field); 262 vc_calc_len_(block); 263} 264 265static void vc_delete_(FLAC__StreamMetadata *block, unsigned pos) 266{ 267 if(0 != block->data.vorbis_comment.comments[pos].entry) 268 free(block->data.vorbis_comment.comments[pos].entry); 269 memmove(&block->data.vorbis_comment.comments[pos], &block->data.vorbis_comment.comments[pos+1], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(block->data.vorbis_comment.num_comments-pos-1)); 270 block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].entry = 0; 271 block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].length = 0; 272 vc_resize_(block, block->data.vorbis_comment.num_comments-1); 273 vc_calc_len_(block); 274} 275 276static void vc_replace_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field, FLAC__bool all) 277{ 278 int index; 279 char field_name[256]; 280 const char *eq = strchr(field, '='); 281 FLAC__ASSERT(eq>field && (unsigned)(eq-field) < sizeof(field_name)); 282 memcpy(field_name, field, eq-field); 283 field_name[eq-field]='\0'; 284 285 index = vc_find_from_(block, field_name, 0); 286 if(index < 0) 287 vc_insert_new_(entry, block, block->data.vorbis_comment.num_comments, field); 288 else { 289 vc_set_new_(entry, block, (unsigned)index, field); 290 if(all) { 291 for(index = index+1; index >= 0 && (unsigned)index < block->data.vorbis_comment.num_comments; ) 292 if((index = vc_find_from_(block, field_name, (unsigned)index)) >= 0) 293 vc_delete_(block, (unsigned)index); 294 } 295 } 296 297 vc_calc_len_(block); 298} 299 300static void track_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em) 301{ 302 track->offset = offset; 303 track->number = number; 304 memcpy(track->isrc, isrc, sizeof(track->isrc)); 305 track->type = data; 306 track->pre_emphasis = pre_em; 307 track->num_indices = 0; 308 track->indices = 0; 309} 310 311static void track_clone_(FLAC__StreamMetadata_CueSheet_Track *track) 312{ 313 if(track->num_indices > 0) { 314 size_t bytes = sizeof(FLAC__StreamMetadata_CueSheet_Index) * track->num_indices; 315 FLAC__StreamMetadata_CueSheet_Index *x = (FLAC__StreamMetadata_CueSheet_Index*)malloc(bytes); 316 FLAC__ASSERT(0 != x); 317 memcpy(x, track->indices, bytes); 318 track->indices = x; 319 } 320} 321 322static void cs_calc_len_(FLAC__StreamMetadata *block) 323{ 324 const FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet; 325 unsigned i; 326 327 block->length = ( 328 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN + 329 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN + 330 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + 331 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN + 332 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN 333 ) / 8; 334 block->length += cs->num_tracks * ( 335 FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN + 336 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN + 337 FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN + 338 FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + 339 FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + 340 FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN + 341 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN 342 ) / 8; 343 for(i = 0; i < cs->num_tracks; i++) { 344 block->length += cs->tracks[i].num_indices * ( 345 FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN + 346 FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN + 347 FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN 348 ) / 8; 349 } 350} 351 352static void tr_resize_(FLAC__StreamMetadata *block, unsigned track_num, unsigned num) 353{ 354 FLAC__StreamMetadata_CueSheet_Track *tr; 355 356 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks); 357 358 tr = &block->data.cue_sheet.tracks[track_num]; 359 360 if(tr->num_indices != 0) { 361 FLAC__ASSERT(0 != tr->indices); 362 } 363 if(num == 0) { 364 if(0 != tr->indices) { 365 free(tr->indices); 366 tr->indices = 0; 367 } 368 } 369 else { 370 tr->indices = (FLAC__StreamMetadata_CueSheet_Index*)realloc(tr->indices, sizeof(FLAC__StreamMetadata_CueSheet_Index)*num); 371 FLAC__ASSERT(0 != tr->indices); 372 if(num > tr->num_indices) 373 memset(tr->indices+tr->num_indices, 0, sizeof(FLAC__StreamMetadata_CueSheet_Index)*(num-tr->num_indices)); 374 } 375 376 tr->num_indices = num; 377 cs_calc_len_(block); 378} 379 380static void tr_set_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index) 381{ 382 FLAC__StreamMetadata_CueSheet_Track *tr; 383 384 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks); 385 386 tr = &block->data.cue_sheet.tracks[track_num]; 387 388 FLAC__ASSERT(pos < tr->num_indices); 389 390 tr->indices[pos] = index; 391 392 cs_calc_len_(block); 393} 394 395static void tr_insert_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index) 396{ 397 FLAC__StreamMetadata_CueSheet_Track *tr; 398 399 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks); 400 401 tr = &block->data.cue_sheet.tracks[track_num]; 402 403 FLAC__ASSERT(pos <= tr->num_indices); 404 405 tr_resize_(block, track_num, tr->num_indices+1); 406 memmove(&tr->indices[pos+1], &tr->indices[pos], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-1-pos)); 407 tr_set_new_(block, track_num, pos, index); 408 cs_calc_len_(block); 409} 410 411static void tr_delete_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos) 412{ 413 FLAC__StreamMetadata_CueSheet_Track *tr; 414 415 FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks); 416 417 tr = &block->data.cue_sheet.tracks[track_num]; 418 419 FLAC__ASSERT(pos <= tr->num_indices); 420 421 memmove(&tr->indices[pos], &tr->indices[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-pos-1)); 422 tr_resize_(block, track_num, tr->num_indices-1); 423 cs_calc_len_(block); 424} 425 426static void cs_resize_(FLAC__StreamMetadata *block, unsigned num) 427{ 428 FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet; 429 430 if(cs->num_tracks != 0) { 431 FLAC__ASSERT(0 != cs->tracks); 432 if(num < cs->num_tracks) { 433 unsigned i; 434 for(i = num; i < cs->num_tracks; i++) { 435 if(0 != cs->tracks[i].indices) 436 free(cs->tracks[i].indices); 437 } 438 } 439 } 440 if(num == 0) { 441 if(0 != cs->tracks) { 442 free(cs->tracks); 443 cs->tracks = 0; 444 } 445 } 446 else { 447 cs->tracks = (FLAC__StreamMetadata_CueSheet_Track*)realloc(cs->tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track)*num); 448 FLAC__ASSERT(0 != cs->tracks); 449 if(num > cs->num_tracks) 450 memset(cs->tracks+cs->num_tracks, 0, sizeof(FLAC__StreamMetadata_CueSheet_Track)*(num-cs->num_tracks)); 451 } 452 453 cs->num_tracks = num; 454 cs_calc_len_(block); 455} 456 457static void cs_set_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__StreamMetadata *block, unsigned pos, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em) 458{ 459 track_new_(track, offset, number, isrc, data, pre_em); 460 block->data.cue_sheet.tracks[pos] = *track; 461 cs_calc_len_(block); 462} 463 464static void cs_insert_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__StreamMetadata *block, unsigned pos, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em) 465{ 466 cs_resize_(block, block->data.cue_sheet.num_tracks+1); 467 memmove(&block->data.cue_sheet.tracks[pos+1], &block->data.cue_sheet.tracks[pos], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(block->data.cue_sheet.num_tracks-1-pos)); 468 cs_set_new_(track, block, pos, offset, number, isrc, data, pre_em); 469 cs_calc_len_(block); 470} 471 472static void cs_delete_(FLAC__StreamMetadata *block, unsigned pos) 473{ 474 if(0 != block->data.cue_sheet.tracks[pos].indices) 475 free(block->data.cue_sheet.tracks[pos].indices); 476 memmove(&block->data.cue_sheet.tracks[pos], &block->data.cue_sheet.tracks[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(block->data.cue_sheet.num_tracks-pos-1)); 477 block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].indices = 0; 478 block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].num_indices = 0; 479 cs_resize_(block, block->data.cue_sheet.num_tracks-1); 480 cs_calc_len_(block); 481} 482 483static void pi_set_mime_type(FLAC__StreamMetadata *block, const char *s) 484{ 485 if(block->data.picture.mime_type) { 486 block->length -= strlen(block->data.picture.mime_type); 487 free(block->data.picture.mime_type); 488 } 489 block->data.picture.mime_type = strdup(s); 490 FLAC__ASSERT(block->data.picture.mime_type); 491 block->length += strlen(block->data.picture.mime_type); 492} 493 494static void pi_set_description(FLAC__StreamMetadata *block, const FLAC__byte *s) 495{ 496 if(block->data.picture.description) { 497 block->length -= strlen((const char *)block->data.picture.description); 498 free(block->data.picture.description); 499 } 500 block->data.picture.description = (FLAC__byte*)strdup((const char *)s); 501 FLAC__ASSERT(block->data.picture.description); 502 block->length += strlen((const char *)block->data.picture.description); 503} 504 505static void pi_set_data(FLAC__StreamMetadata *block, const FLAC__byte *data, FLAC__uint32 len) 506{ 507 if(block->data.picture.data) { 508 block->length -= block->data.picture.data_length; 509 free(block->data.picture.data); 510 } 511 block->data.picture.data = (FLAC__byte*)strdup((const char *)data); 512 FLAC__ASSERT(block->data.picture.data); 513 block->data.picture.data_length = len; 514 block->length += len; 515} 516 517FLAC__bool test_metadata_object(void) 518{ 519 FLAC__StreamMetadata *block, *blockcopy, *vorbiscomment, *cuesheet, *picture; 520 FLAC__StreamMetadata_SeekPoint seekpoint_array[14]; 521 FLAC__StreamMetadata_VorbisComment_Entry entry; 522 FLAC__StreamMetadata_CueSheet_Index index; 523 FLAC__StreamMetadata_CueSheet_Track track; 524 unsigned i, expected_length, seekpoints; 525 int j; 526 static FLAC__byte dummydata[4] = { 'a', 'b', 'c', 'd' }; 527 528 printf("\n+++ libFLAC unit test: metadata objects\n\n"); 529 530 531 printf("testing STREAMINFO\n"); 532 533 printf("testing FLAC__metadata_object_new()... "); 534 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_STREAMINFO); 535 if(0 == block) { 536 printf("FAILED, returned NULL\n"); 537 return false; 538 } 539 expected_length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; 540 if(block->length != expected_length) { 541 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 542 return false; 543 } 544 printf("OK\n"); 545 546 printf("testing FLAC__metadata_object_clone()... "); 547 blockcopy = FLAC__metadata_object_clone(block); 548 if(0 == blockcopy) { 549 printf("FAILED, returned NULL\n"); 550 return false; 551 } 552 if(!mutils__compare_block(block, blockcopy)) 553 return false; 554 printf("OK\n"); 555 556 printf("testing FLAC__metadata_object_delete()... "); 557 FLAC__metadata_object_delete(blockcopy); 558 FLAC__metadata_object_delete(block); 559 printf("OK\n"); 560 561 562 printf("testing PADDING\n"); 563 564 printf("testing FLAC__metadata_object_new()... "); 565 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING); 566 if(0 == block) { 567 printf("FAILED, returned NULL\n"); 568 return false; 569 } 570 expected_length = 0; 571 if(block->length != expected_length) { 572 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 573 return false; 574 } 575 printf("OK\n"); 576 577 printf("testing FLAC__metadata_object_clone()... "); 578 blockcopy = FLAC__metadata_object_clone(block); 579 if(0 == blockcopy) { 580 printf("FAILED, returned NULL\n"); 581 return false; 582 } 583 if(!mutils__compare_block(block, blockcopy)) 584 return false; 585 printf("OK\n"); 586 587 printf("testing FLAC__metadata_object_delete()... "); 588 FLAC__metadata_object_delete(blockcopy); 589 FLAC__metadata_object_delete(block); 590 printf("OK\n"); 591 592 593 printf("testing APPLICATION\n"); 594 595 printf("testing FLAC__metadata_object_new()... "); 596 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION); 597 if(0 == block) { 598 printf("FAILED, returned NULL\n"); 599 return false; 600 } 601 expected_length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8; 602 if(block->length != expected_length) { 603 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 604 return false; 605 } 606 printf("OK\n"); 607 608 printf("testing FLAC__metadata_object_clone()... "); 609 blockcopy = FLAC__metadata_object_clone(block); 610 if(0 == blockcopy) { 611 printf("FAILED, returned NULL\n"); 612 return false; 613 } 614 if(!mutils__compare_block(block, blockcopy)) 615 return false; 616 printf("OK\n"); 617 618 printf("testing FLAC__metadata_object_delete()... "); 619 FLAC__metadata_object_delete(blockcopy); 620 printf("OK\n"); 621 622 printf("testing FLAC__metadata_object_application_set_data(copy)... "); 623 if(!FLAC__metadata_object_application_set_data(block, dummydata, sizeof(dummydata), true/*copy*/)) { 624 printf("FAILED, returned false\n"); 625 return false; 626 } 627 expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata); 628 if(block->length != expected_length) { 629 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 630 return false; 631 } 632 if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) { 633 printf("FAILED, data mismatch\n"); 634 return false; 635 } 636 printf("OK\n"); 637 638 printf("testing FLAC__metadata_object_clone()... "); 639 blockcopy = FLAC__metadata_object_clone(block); 640 if(0 == blockcopy) { 641 printf("FAILED, returned NULL\n"); 642 return false; 643 } 644 if(!mutils__compare_block(block, blockcopy)) 645 return false; 646 printf("OK\n"); 647 648 printf("testing FLAC__metadata_object_delete()... "); 649 FLAC__metadata_object_delete(blockcopy); 650 printf("OK\n"); 651 652 printf("testing FLAC__metadata_object_application_set_data(own)... "); 653 if(!FLAC__metadata_object_application_set_data(block, make_dummydata_(dummydata, sizeof(dummydata)), sizeof(dummydata), false/*own*/)) { 654 printf("FAILED, returned false\n"); 655 return false; 656 } 657 expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata); 658 if(block->length != expected_length) { 659 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 660 return false; 661 } 662 if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) { 663 printf("FAILED, data mismatch\n"); 664 return false; 665 } 666 printf("OK\n"); 667 668 printf("testing FLAC__metadata_object_clone()... "); 669 blockcopy = FLAC__metadata_object_clone(block); 670 if(0 == blockcopy) { 671 printf("FAILED, returned NULL\n"); 672 return false; 673 } 674 if(!mutils__compare_block(block, blockcopy)) 675 return false; 676 printf("OK\n"); 677 678 printf("testing FLAC__metadata_object_delete()... "); 679 FLAC__metadata_object_delete(blockcopy); 680 FLAC__metadata_object_delete(block); 681 printf("OK\n"); 682 683 684 printf("testing SEEKTABLE\n"); 685 686 for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) { 687 seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 688 seekpoint_array[i].stream_offset = 0; 689 seekpoint_array[i].frame_samples = 0; 690 } 691 692 seekpoints = 0; 693 printf("testing FLAC__metadata_object_new()... "); 694 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE); 695 if(0 == block) { 696 printf("FAILED, returned NULL\n"); 697 return false; 698 } 699 if(!check_seektable_(block, seekpoints, 0)) 700 return false; 701 702 printf("testing FLAC__metadata_object_clone()... "); 703 blockcopy = FLAC__metadata_object_clone(block); 704 if(0 == blockcopy) { 705 printf("FAILED, returned NULL\n"); 706 return false; 707 } 708 if(!mutils__compare_block(block, blockcopy)) 709 return false; 710 printf("OK\n"); 711 712 printf("testing FLAC__metadata_object_delete()... "); 713 FLAC__metadata_object_delete(blockcopy); 714 printf("OK\n"); 715 716 seekpoints = 2; 717 printf("testing FLAC__metadata_object_seektable_resize_points(grow to %u)...", seekpoints); 718 if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) { 719 printf("FAILED, returned false\n"); 720 return false; 721 } 722 if(!check_seektable_(block, seekpoints, seekpoint_array)) 723 return false; 724 725 seekpoints = 1; 726 printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints); 727 if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) { 728 printf("FAILED, returned false\n"); 729 return false; 730 } 731 if(!check_seektable_(block, seekpoints, seekpoint_array)) 732 return false; 733 734 printf("testing FLAC__metadata_object_seektable_is_legal()..."); 735 if(!FLAC__metadata_object_seektable_is_legal(block)) { 736 printf("FAILED, returned false\n"); 737 return false; 738 } 739 printf("OK\n"); 740 741 seekpoints = 0; 742 printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints); 743 if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) { 744 printf("FAILED, returned false\n"); 745 return false; 746 } 747 if(!check_seektable_(block, seekpoints, 0)) 748 return false; 749 750 seekpoints++; 751 printf("testing FLAC__metadata_object_seektable_insert_point() on empty array..."); 752 if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) { 753 printf("FAILED, returned false\n"); 754 return false; 755 } 756 if(!check_seektable_(block, seekpoints, seekpoint_array)) 757 return false; 758 759 seekpoint_array[0].sample_number = 1; 760 seekpoints++; 761 printf("testing FLAC__metadata_object_seektable_insert_point() on beginning of non-empty array..."); 762 if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) { 763 printf("FAILED, returned false\n"); 764 return false; 765 } 766 if(!check_seektable_(block, seekpoints, seekpoint_array)) 767 return false; 768 769 seekpoint_array[1].sample_number = 2; 770 seekpoints++; 771 printf("testing FLAC__metadata_object_seektable_insert_point() on middle of non-empty array..."); 772 if(!FLAC__metadata_object_seektable_insert_point(block, 1, seekpoint_array[1])) { 773 printf("FAILED, returned false\n"); 774 return false; 775 } 776 if(!check_seektable_(block, seekpoints, seekpoint_array)) 777 return false; 778 779 seekpoint_array[3].sample_number = 3; 780 seekpoints++; 781 printf("testing FLAC__metadata_object_seektable_insert_point() on end of non-empty array..."); 782 if(!FLAC__metadata_object_seektable_insert_point(block, 3, seekpoint_array[3])) { 783 printf("FAILED, returned false\n"); 784 return false; 785 } 786 if(!check_seektable_(block, seekpoints, seekpoint_array)) 787 return false; 788 789 printf("testing FLAC__metadata_object_clone()... "); 790 blockcopy = FLAC__metadata_object_clone(block); 791 if(0 == blockcopy) { 792 printf("FAILED, returned NULL\n"); 793 return false; 794 } 795 if(!mutils__compare_block(block, blockcopy)) 796 return false; 797 printf("OK\n"); 798 799 printf("testing FLAC__metadata_object_delete()... "); 800 FLAC__metadata_object_delete(blockcopy); 801 printf("OK\n"); 802 803 seekpoint_array[2].sample_number = seekpoint_array[3].sample_number; 804 seekpoints--; 805 printf("testing FLAC__metadata_object_seektable_delete_point() on middle of array..."); 806 if(!FLAC__metadata_object_seektable_delete_point(block, 2)) { 807 printf("FAILED, returned false\n"); 808 return false; 809 } 810 if(!check_seektable_(block, seekpoints, seekpoint_array)) 811 return false; 812 813 seekpoints--; 814 printf("testing FLAC__metadata_object_seektable_delete_point() on end of array..."); 815 if(!FLAC__metadata_object_seektable_delete_point(block, 2)) { 816 printf("FAILED, returned false\n"); 817 return false; 818 } 819 if(!check_seektable_(block, seekpoints, seekpoint_array)) 820 return false; 821 822 seekpoints--; 823 printf("testing FLAC__metadata_object_seektable_delete_point() on beginning of array..."); 824 if(!FLAC__metadata_object_seektable_delete_point(block, 0)) { 825 printf("FAILED, returned false\n"); 826 return false; 827 } 828 if(!check_seektable_(block, seekpoints, seekpoint_array+1)) 829 return false; 830 831 printf("testing FLAC__metadata_object_seektable_set_point()..."); 832 FLAC__metadata_object_seektable_set_point(block, 0, seekpoint_array[0]); 833 if(!check_seektable_(block, seekpoints, seekpoint_array)) 834 return false; 835 836 printf("testing FLAC__metadata_object_delete()... "); 837 FLAC__metadata_object_delete(block); 838 printf("OK\n"); 839 840 /* seektable template functions */ 841 842 for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) { 843 seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 844 seekpoint_array[i].stream_offset = 0; 845 seekpoint_array[i].frame_samples = 0; 846 } 847 848 seekpoints = 0; 849 printf("testing FLAC__metadata_object_new()... "); 850 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE); 851 if(0 == block) { 852 printf("FAILED, returned NULL\n"); 853 return false; 854 } 855 if(!check_seektable_(block, seekpoints, 0)) 856 return false; 857 858 seekpoints += 2; 859 printf("testing FLAC__metadata_object_seekpoint_template_append_placeholders()... "); 860 if(!FLAC__metadata_object_seektable_template_append_placeholders(block, 2)) { 861 printf("FAILED, returned false\n"); 862 return false; 863 } 864 if(!check_seektable_(block, seekpoints, seekpoint_array)) 865 return false; 866 867 seekpoint_array[seekpoints++].sample_number = 7; 868 printf("testing FLAC__metadata_object_seekpoint_template_append_point()... "); 869 if(!FLAC__metadata_object_seektable_template_append_point(block, 7)) { 870 printf("FAILED, returned false\n"); 871 return false; 872 } 873 if(!check_seektable_(block, seekpoints, seekpoint_array)) 874 return false; 875 876 { 877 FLAC__uint64 nums[2] = { 3, 7 }; 878 seekpoint_array[seekpoints++].sample_number = nums[0]; 879 seekpoint_array[seekpoints++].sample_number = nums[1]; 880 printf("testing FLAC__metadata_object_seekpoint_template_append_points()... "); 881 if(!FLAC__metadata_object_seektable_template_append_points(block, nums, sizeof(nums)/sizeof(FLAC__uint64))) { 882 printf("FAILED, returned false\n"); 883 return false; 884 } 885 if(!check_seektable_(block, seekpoints, seekpoint_array)) 886 return false; 887 } 888 889 seekpoint_array[seekpoints++].sample_number = 0; 890 seekpoint_array[seekpoints++].sample_number = 10; 891 seekpoint_array[seekpoints++].sample_number = 20; 892 printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points()... "); 893 if(!FLAC__metadata_object_seektable_template_append_spaced_points(block, 3, 30)) { 894 printf("FAILED, returned false\n"); 895 return false; 896 } 897 if(!check_seektable_(block, seekpoints, seekpoint_array)) 898 return false; 899 900 seekpoints--; 901 seekpoint_array[0].sample_number = 0; 902 seekpoint_array[1].sample_number = 3; 903 seekpoint_array[2].sample_number = 7; 904 seekpoint_array[3].sample_number = 10; 905 seekpoint_array[4].sample_number = 20; 906 seekpoint_array[5].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 907 seekpoint_array[6].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 908 printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=true)... "); 909 if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/true)) { 910 printf("FAILED, returned false\n"); 911 return false; 912 } 913 if(!FLAC__metadata_object_seektable_is_legal(block)) { 914 printf("FAILED, seek table is illegal\n"); 915 return false; 916 } 917 if(!check_seektable_(block, seekpoints, seekpoint_array)) 918 return false; 919 920 printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=false)... "); 921 if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/false)) { 922 printf("FAILED, returned false\n"); 923 return false; 924 } 925 if(!FLAC__metadata_object_seektable_is_legal(block)) { 926 printf("FAILED, seek table is illegal\n"); 927 return false; 928 } 929 if(!check_seektable_(block, seekpoints, seekpoint_array)) 930 return false; 931 932 seekpoint_array[seekpoints++].sample_number = 0; 933 seekpoint_array[seekpoints++].sample_number = 10; 934 seekpoint_array[seekpoints++].sample_number = 20; 935 printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points_by_samples()... "); 936 if(!FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(block, 10, 30)) { 937 printf("FAILED, returned false\n"); 938 return false; 939 } 940 if(!check_seektable_(block, seekpoints, seekpoint_array)) 941 return false; 942 943 seekpoint_array[seekpoints++].sample_number = 0; 944 seekpoint_array[seekpoints++].sample_number = 11; 945 seekpoint_array[seekpoints++].sample_number = 22; 946 printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points_by_samples()... "); 947 if(!FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(block, 11, 30)) { 948 printf("FAILED, returned false\n"); 949 return false; 950 } 951 if(!check_seektable_(block, seekpoints, seekpoint_array)) 952 return false; 953 954 printf("testing FLAC__metadata_object_delete()... "); 955 FLAC__metadata_object_delete(block); 956 printf("OK\n"); 957 958 959 printf("testing VORBIS_COMMENT\n"); 960 961 { 962 FLAC__StreamMetadata_VorbisComment_Entry entry_; 963 char *field_name, *field_value; 964 965 printf("testing FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair()... "); 966 if(!FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry_, "name", "value")) { 967 printf("FAILED, returned false\n"); 968 return false; 969 } 970 if(strcmp((const char *)entry_.entry, "name=value")) { 971 printf("FAILED, field mismatch\n"); 972 return false; 973 } 974 printf("OK\n"); 975 976 printf("testing FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair()... "); 977 if(!FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(entry_, &field_name, &field_value)) { 978 printf("FAILED, returned false\n"); 979 return false; 980 } 981 if(strcmp(field_name, "name")) { 982 printf("FAILED, field name mismatch\n"); 983 return false; 984 } 985 if(strcmp(field_value, "value")) { 986 printf("FAILED, field value mismatch\n"); 987 return false; 988 } 989 printf("OK\n"); 990 991 printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... "); 992 if(!FLAC__metadata_object_vorbiscomment_entry_matches(entry_, field_name, strlen(field_name))) { 993 printf("FAILED, expected true, returned false\n"); 994 return false; 995 } 996 printf("OK\n"); 997 998 printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... "); 999 if(FLAC__metadata_object_vorbiscomment_entry_matches(entry_, "blah", strlen("blah"))) { 1000 printf("FAILED, expected false, returned true\n"); 1001 return false; 1002 } 1003 printf("OK\n"); 1004 1005 free(entry_.entry); 1006 free(field_name); 1007 free(field_value); 1008 } 1009 1010 printf("testing FLAC__metadata_object_new()... "); 1011 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT); 1012 if(0 == block) { 1013 printf("FAILED, returned NULL\n"); 1014 return false; 1015 } 1016 expected_length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + strlen(FLAC__VENDOR_STRING) + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN/8); 1017 if(block->length != expected_length) { 1018 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 1019 return false; 1020 } 1021 printf("OK\n"); 1022 1023 printf("testing FLAC__metadata_object_clone()... "); 1024 vorbiscomment = FLAC__metadata_object_clone(block); 1025 if(0 == vorbiscomment) { 1026 printf("FAILED, returned NULL\n"); 1027 return false; 1028 } 1029 if(!mutils__compare_block(vorbiscomment, block)) 1030 return false; 1031 printf("OK\n"); 1032 1033 vc_resize_(vorbiscomment, 2); 1034 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(grow to %u)...", vorbiscomment->data.vorbis_comment.num_comments); 1035 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) { 1036 printf("FAILED, returned false\n"); 1037 return false; 1038 } 1039 if(!mutils__compare_block(vorbiscomment, block)) 1040 return false; 1041 printf("OK\n"); 1042 1043 vc_resize_(vorbiscomment, 1); 1044 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments); 1045 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) { 1046 printf("FAILED, returned false\n"); 1047 return false; 1048 } 1049 if(!mutils__compare_block(vorbiscomment, block)) 1050 return false; 1051 printf("OK\n"); 1052 1053 vc_resize_(vorbiscomment, 0); 1054 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments); 1055 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) { 1056 printf("FAILED, returned false\n"); 1057 return false; 1058 } 1059 if(!mutils__compare_block(vorbiscomment, block)) 1060 return false; 1061 printf("OK\n"); 1062 1063 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on empty array..."); 1064 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1"); 1065 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) { 1066 printf("FAILED, returned false\n"); 1067 return false; 1068 } 1069 if(!mutils__compare_block(vorbiscomment, block)) 1070 return false; 1071 printf("OK\n"); 1072 1073 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array..."); 1074 vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2"); 1075 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) { 1076 printf("FAILED, returned false\n"); 1077 return false; 1078 } 1079 if(!mutils__compare_block(vorbiscomment, block)) 1080 return false; 1081 printf("OK\n"); 1082 1083 vc_resize_(vorbiscomment, 0); 1084 printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments); 1085 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) { 1086 printf("FAILED, returned false\n"); 1087 return false; 1088 } 1089 if(!mutils__compare_block(vorbiscomment, block)) 1090 return false; 1091 printf("OK\n"); 1092 1093 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on empty array..."); 1094 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1"); 1095 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) { 1096 printf("FAILED, returned false\n"); 1097 return false; 1098 } 1099 if(!mutils__compare_block(vorbiscomment, block)) 1100 return false; 1101 printf("OK\n"); 1102 1103 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on beginning of non-empty array..."); 1104 vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2"); 1105 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) { 1106 printf("FAILED, returned false\n"); 1107 return false; 1108 } 1109 if(!mutils__compare_block(vorbiscomment, block)) 1110 return false; 1111 printf("OK\n"); 1112 1113 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on middle of non-empty array..."); 1114 vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3"); 1115 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/true)) { 1116 printf("FAILED, returned false\n"); 1117 return false; 1118 } 1119 if(!mutils__compare_block(vorbiscomment, block)) 1120 return false; 1121 printf("OK\n"); 1122 1123 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array..."); 1124 vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4"); 1125 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/true)) { 1126 printf("FAILED, returned false\n"); 1127 return false; 1128 } 1129 if(!mutils__compare_block(vorbiscomment, block)) 1130 return false; 1131 printf("OK\n"); 1132 1133 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array..."); 1134 vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1"); 1135 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/true)) { 1136 printf("FAILED, returned false\n"); 1137 return false; 1138 } 1139 if(!mutils__compare_block(vorbiscomment, block)) 1140 return false; 1141 printf("OK\n"); 1142 1143 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array..."); 1144 vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1"); 1145 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/true)) { 1146 printf("FAILED, returned false\n"); 1147 return false; 1148 } 1149 if(!mutils__compare_block(vorbiscomment, block)) 1150 return false; 1151 printf("OK\n"); 1152 1153 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()..."); 1154 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name3")) != 1) { 1155 printf("FAILED, expected 1, got %d\n", j); 1156 return false; 1157 } 1158 printf("OK\n"); 1159 1160 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()..."); 1161 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 4) { 1162 printf("FAILED, expected 4, got %d\n", j); 1163 return false; 1164 } 1165 printf("OK\n"); 1166 1167 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()..."); 1168 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 5) { 1169 printf("FAILED, expected 5, got %d\n", j); 1170 return false; 1171 } 1172 printf("OK\n"); 1173 1174 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()..."); 1175 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name2")) != 0) { 1176 printf("FAILED, expected 0, got %d\n", j); 1177 return false; 1178 } 1179 printf("OK\n"); 1180 1181 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()..."); 1182 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name2")) != -1) { 1183 printf("FAILED, expected -1, got %d\n", j); 1184 return false; 1185 } 1186 printf("OK\n"); 1187 1188 printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()..."); 1189 if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "blah")) != -1) { 1190 printf("FAILED, expected -1, got %d\n", j); 1191 return false; 1192 } 1193 printf("OK\n"); 1194 1195 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, copy)..."); 1196 vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false); 1197 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/true)) { 1198 printf("FAILED, returned false\n"); 1199 return false; 1200 } 1201 if(!mutils__compare_block(vorbiscomment, block)) 1202 return false; 1203 if(block->data.vorbis_comment.num_comments != 6) { 1204 printf("FAILED, expected 6 comments, got %u\n", block->data.vorbis_comment.num_comments); 1205 return false; 1206 } 1207 printf("OK\n"); 1208 1209 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, copy)..."); 1210 vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true); 1211 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/true)) { 1212 printf("FAILED, returned false\n"); 1213 return false; 1214 } 1215 if(!mutils__compare_block(vorbiscomment, block)) 1216 return false; 1217 if(block->data.vorbis_comment.num_comments != 4) { 1218 printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments); 1219 return false; 1220 } 1221 printf("OK\n"); 1222 1223 printf("testing FLAC__metadata_object_clone()... "); 1224 blockcopy = FLAC__metadata_object_clone(block); 1225 if(0 == blockcopy) { 1226 printf("FAILED, returned NULL\n"); 1227 return false; 1228 } 1229 if(!mutils__compare_block(block, blockcopy)) 1230 return false; 1231 printf("OK\n"); 1232 1233 printf("testing FLAC__metadata_object_delete()... "); 1234 FLAC__metadata_object_delete(blockcopy); 1235 printf("OK\n"); 1236 1237 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array..."); 1238 vc_delete_(vorbiscomment, 2); 1239 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) { 1240 printf("FAILED, returned false\n"); 1241 return false; 1242 } 1243 if(!mutils__compare_block(vorbiscomment, block)) 1244 return false; 1245 printf("OK\n"); 1246 1247 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array..."); 1248 vc_delete_(vorbiscomment, 2); 1249 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) { 1250 printf("FAILED, returned false\n"); 1251 return false; 1252 } 1253 if(!mutils__compare_block(vorbiscomment, block)) 1254 return false; 1255 printf("OK\n"); 1256 1257 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array..."); 1258 vc_delete_(vorbiscomment, 0); 1259 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) { 1260 printf("FAILED, returned false\n"); 1261 return false; 1262 } 1263 if(!mutils__compare_block(vorbiscomment, block)) 1264 return false; 1265 printf("OK\n"); 1266 1267 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array..."); 1268 vc_insert_new_(&entry, vorbiscomment, 1, "rem0=val0"); 1269 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) { 1270 printf("FAILED, returned false\n"); 1271 return false; 1272 } 1273 if(!mutils__compare_block(vorbiscomment, block)) 1274 return false; 1275 printf("OK\n"); 1276 1277 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array..."); 1278 vc_insert_new_(&entry, vorbiscomment, 2, "rem0=val1"); 1279 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) { 1280 printf("FAILED, returned false\n"); 1281 return false; 1282 } 1283 if(!mutils__compare_block(vorbiscomment, block)) 1284 return false; 1285 printf("OK\n"); 1286 1287 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array..."); 1288 vc_insert_new_(&entry, vorbiscomment, 3, "rem0=val2"); 1289 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) { 1290 printf("FAILED, returned false\n"); 1291 return false; 1292 } 1293 if(!mutils__compare_block(vorbiscomment, block)) 1294 return false; 1295 printf("OK\n"); 1296 1297 printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching(\"blah\")..."); 1298 if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "blah")) != 0) { 1299 printf("FAILED, expected 0, got %d\n", j); 1300 return false; 1301 } 1302 if(block->data.vorbis_comment.num_comments != 4) { 1303 printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments); 1304 return false; 1305 } 1306 if(!mutils__compare_block(vorbiscomment, block)) 1307 return false; 1308 printf("OK\n"); 1309 1310 printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching(\"rem0\")..."); 1311 vc_delete_(vorbiscomment, 1); 1312 if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "rem0")) != 1) { 1313 printf("FAILED, expected 1, got %d\n", j); 1314 return false; 1315 } 1316 if(block->data.vorbis_comment.num_comments != 3) { 1317 printf("FAILED, expected 3 comments, got %u\n", block->data.vorbis_comment.num_comments); 1318 return false; 1319 } 1320 if(!mutils__compare_block(vorbiscomment, block)) 1321 return false; 1322 printf("OK\n"); 1323 1324 printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching(\"blah\")..."); 1325 if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "blah")) != 0) { 1326 printf("FAILED, expected 0, got %d\n", j); 1327 return false; 1328 } 1329 if(block->data.vorbis_comment.num_comments != 3) { 1330 printf("FAILED, expected 3 comments, got %u\n", block->data.vorbis_comment.num_comments); 1331 return false; 1332 } 1333 if(!mutils__compare_block(vorbiscomment, block)) 1334 return false; 1335 printf("OK\n"); 1336 1337 printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching(\"rem0\")..."); 1338 vc_delete_(vorbiscomment, 1); 1339 vc_delete_(vorbiscomment, 1); 1340 if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "rem0")) != 2) { 1341 printf("FAILED, expected 2, got %d\n", j); 1342 return false; 1343 } 1344 if(block->data.vorbis_comment.num_comments != 1) { 1345 printf("FAILED, expected 1 comments, got %u\n", block->data.vorbis_comment.num_comments); 1346 return false; 1347 } 1348 if(!mutils__compare_block(vorbiscomment, block)) 1349 return false; 1350 printf("OK\n"); 1351 1352 printf("testing FLAC__metadata_object_vorbiscomment_set_comment(copy)..."); 1353 vc_set_new_(&entry, vorbiscomment, 0, "name5=field5"); 1354 FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/true); 1355 if(!mutils__compare_block(vorbiscomment, block)) 1356 return false; 1357 printf("OK\n"); 1358 1359 printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(copy)..."); 1360 vc_set_vs_new_(&entry, vorbiscomment, "name6=field6"); 1361 FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/true); 1362 if(!mutils__compare_block(vorbiscomment, block)) 1363 return false; 1364 printf("OK\n"); 1365 1366 printf("testing FLAC__metadata_object_delete()... "); 1367 FLAC__metadata_object_delete(vorbiscomment); 1368 FLAC__metadata_object_delete(block); 1369 printf("OK\n"); 1370 1371 1372 printf("testing FLAC__metadata_object_new()... "); 1373 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT); 1374 if(0 == block) { 1375 printf("FAILED, returned NULL\n"); 1376 return false; 1377 } 1378 printf("OK\n"); 1379 1380 printf("testing FLAC__metadata_object_clone()... "); 1381 vorbiscomment = FLAC__metadata_object_clone(block); 1382 if(0 == vorbiscomment) { 1383 printf("FAILED, returned NULL\n"); 1384 return false; 1385 } 1386 if(!mutils__compare_block(vorbiscomment, block)) 1387 return false; 1388 printf("OK\n"); 1389 1390 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on empty array..."); 1391 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1"); 1392 entry_clone_(&entry); 1393 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) { 1394 printf("FAILED, returned false\n"); 1395 return false; 1396 } 1397 if(!mutils__compare_block(vorbiscomment, block)) 1398 return false; 1399 printf("OK\n"); 1400 1401 printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on non-empty array..."); 1402 vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2"); 1403 entry_clone_(&entry); 1404 if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) { 1405 printf("FAILED, returned false\n"); 1406 return false; 1407 } 1408 if(!mutils__compare_block(vorbiscomment, block)) 1409 return false; 1410 printf("OK\n"); 1411 1412 printf("testing FLAC__metadata_object_delete()... "); 1413 FLAC__metadata_object_delete(vorbiscomment); 1414 FLAC__metadata_object_delete(block); 1415 printf("OK\n"); 1416 1417 printf("testing FLAC__metadata_object_new()... "); 1418 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT); 1419 if(0 == block) { 1420 printf("FAILED, returned NULL\n"); 1421 return false; 1422 } 1423 printf("OK\n"); 1424 1425 printf("testing FLAC__metadata_object_clone()... "); 1426 vorbiscomment = FLAC__metadata_object_clone(block); 1427 if(0 == vorbiscomment) { 1428 printf("FAILED, returned NULL\n"); 1429 return false; 1430 } 1431 if(!mutils__compare_block(vorbiscomment, block)) 1432 return false; 1433 printf("OK\n"); 1434 1435 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on empty array..."); 1436 vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1"); 1437 entry_clone_(&entry); 1438 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) { 1439 printf("FAILED, returned false\n"); 1440 return false; 1441 } 1442 if(!mutils__compare_block(vorbiscomment, block)) 1443 return false; 1444 printf("OK\n"); 1445 1446 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on beginning of non-empty array..."); 1447 vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2"); 1448 entry_clone_(&entry); 1449 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) { 1450 printf("FAILED, returned false\n"); 1451 return false; 1452 } 1453 if(!mutils__compare_block(vorbiscomment, block)) 1454 return false; 1455 printf("OK\n"); 1456 1457 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on middle of non-empty array..."); 1458 vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3"); 1459 entry_clone_(&entry); 1460 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/false)) { 1461 printf("FAILED, returned false\n"); 1462 return false; 1463 } 1464 if(!mutils__compare_block(vorbiscomment, block)) 1465 return false; 1466 printf("OK\n"); 1467 1468 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array..."); 1469 vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4"); 1470 entry_clone_(&entry); 1471 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/false)) { 1472 printf("FAILED, returned false\n"); 1473 return false; 1474 } 1475 if(!mutils__compare_block(vorbiscomment, block)) 1476 return false; 1477 printf("OK\n"); 1478 1479 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array..."); 1480 vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1"); 1481 entry_clone_(&entry); 1482 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/false)) { 1483 printf("FAILED, returned false\n"); 1484 return false; 1485 } 1486 if(!mutils__compare_block(vorbiscomment, block)) 1487 return false; 1488 printf("OK\n"); 1489 1490 printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array..."); 1491 vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1"); 1492 entry_clone_(&entry); 1493 if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/false)) { 1494 printf("FAILED, returned false\n"); 1495 return false; 1496 } 1497 if(!mutils__compare_block(vorbiscomment, block)) 1498 return false; 1499 printf("OK\n"); 1500 1501 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, own)..."); 1502 vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false); 1503 entry_clone_(&entry); 1504 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/false)) { 1505 printf("FAILED, returned false\n"); 1506 return false; 1507 } 1508 if(!mutils__compare_block(vorbiscomment, block)) 1509 return false; 1510 if(block->data.vorbis_comment.num_comments != 6) { 1511 printf("FAILED, expected 6 comments, got %u\n", block->data.vorbis_comment.num_comments); 1512 return false; 1513 } 1514 printf("OK\n"); 1515 1516 printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, own)..."); 1517 vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true); 1518 entry_clone_(&entry); 1519 if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/false)) { 1520 printf("FAILED, returned false\n"); 1521 return false; 1522 } 1523 if(!mutils__compare_block(vorbiscomment, block)) 1524 return false; 1525 if(block->data.vorbis_comment.num_comments != 4) { 1526 printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments); 1527 return false; 1528 } 1529 printf("OK\n"); 1530 1531 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array..."); 1532 vc_delete_(vorbiscomment, 2); 1533 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) { 1534 printf("FAILED, returned false\n"); 1535 return false; 1536 } 1537 if(!mutils__compare_block(vorbiscomment, block)) 1538 return false; 1539 printf("OK\n"); 1540 1541 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array..."); 1542 vc_delete_(vorbiscomment, 2); 1543 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) { 1544 printf("FAILED, returned false\n"); 1545 return false; 1546 } 1547 if(!mutils__compare_block(vorbiscomment, block)) 1548 return false; 1549 printf("OK\n"); 1550 1551 printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array..."); 1552 vc_delete_(vorbiscomment, 0); 1553 if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) { 1554 printf("FAILED, returned false\n"); 1555 return false; 1556 } 1557 if(!mutils__compare_block(vorbiscomment, block)) 1558 return false; 1559 printf("OK\n"); 1560 1561 printf("testing FLAC__metadata_object_vorbiscomment_set_comment(own)..."); 1562 vc_set_new_(&entry, vorbiscomment, 0, "name5=field5"); 1563 entry_clone_(&entry); 1564 FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/false); 1565 if(!mutils__compare_block(vorbiscomment, block)) 1566 return false; 1567 printf("OK\n"); 1568 1569 printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(own)..."); 1570 vc_set_vs_new_(&entry, vorbiscomment, "name6=field6"); 1571 entry_clone_(&entry); 1572 FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/false); 1573 if(!mutils__compare_block(vorbiscomment, block)) 1574 return false; 1575 printf("OK\n"); 1576 1577 printf("testing FLAC__metadata_object_delete()... "); 1578 FLAC__metadata_object_delete(vorbiscomment); 1579 FLAC__metadata_object_delete(block); 1580 printf("OK\n"); 1581 1582 1583 printf("testing CUESHEET\n"); 1584 1585 { 1586 FLAC__StreamMetadata_CueSheet_Track *track_, *trackcopy_; 1587 1588 printf("testing FLAC__metadata_object_cuesheet_track_new()... "); 1589 track_ = FLAC__metadata_object_cuesheet_track_new(); 1590 if(0 == track_) { 1591 printf("FAILED, returned NULL\n"); 1592 return false; 1593 } 1594 printf("OK\n"); 1595 1596 printf("testing FLAC__metadata_object_cuesheet_track_clone()... "); 1597 trackcopy_ = FLAC__metadata_object_cuesheet_track_clone(track_); 1598 if(0 == trackcopy_) { 1599 printf("FAILED, returned NULL\n"); 1600 return false; 1601 } 1602 if(!compare_track_(trackcopy_, track_)) 1603 return false; 1604 printf("OK\n"); 1605 1606 printf("testing FLAC__metadata_object_cuesheet_track_delete()... "); 1607 FLAC__metadata_object_cuesheet_track_delete(trackcopy_); 1608 FLAC__metadata_object_cuesheet_track_delete(track_); 1609 printf("OK\n"); 1610 } 1611 1612 1613 printf("testing FLAC__metadata_object_new()... "); 1614 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET); 1615 if(0 == block) { 1616 printf("FAILED, returned NULL\n"); 1617 return false; 1618 } 1619 expected_length = ( 1620 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN + 1621 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN + 1622 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + 1623 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN + 1624 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN 1625 ) / 8; 1626 if(block->length != expected_length) { 1627 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 1628 return false; 1629 } 1630 printf("OK\n"); 1631 1632 printf("testing FLAC__metadata_object_clone()... "); 1633 cuesheet = FLAC__metadata_object_clone(block); 1634 if(0 == cuesheet) { 1635 printf("FAILED, returned NULL\n"); 1636 return false; 1637 } 1638 if(!mutils__compare_block(cuesheet, block)) 1639 return false; 1640 printf("OK\n"); 1641 1642 cs_resize_(cuesheet, 2); 1643 printf("testing FLAC__metadata_object_cuesheet_resize_tracks(grow to %u)...", cuesheet->data.cue_sheet.num_tracks); 1644 if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) { 1645 printf("FAILED, returned false\n"); 1646 return false; 1647 } 1648 if(!mutils__compare_block(cuesheet, block)) 1649 return false; 1650 printf("OK\n"); 1651 1652 cs_resize_(cuesheet, 1); 1653 printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks); 1654 if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) { 1655 printf("FAILED, returned false\n"); 1656 return false; 1657 } 1658 if(!mutils__compare_block(cuesheet, block)) 1659 return false; 1660 printf("OK\n"); 1661 1662 cs_resize_(cuesheet, 0); 1663 printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks); 1664 if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) { 1665 printf("FAILED, returned false\n"); 1666 return false; 1667 } 1668 if(!mutils__compare_block(cuesheet, block)) 1669 return false; 1670 printf("OK\n"); 1671 1672 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on empty array..."); 1673 cs_insert_new_(&track, cuesheet, 0, 0, 1, "ABCDE1234567", false, false); 1674 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) { 1675 printf("FAILED, returned false\n"); 1676 return false; 1677 } 1678 if(!mutils__compare_block(cuesheet, block)) 1679 return false; 1680 printf("OK\n"); 1681 1682 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on beginning of non-empty array..."); 1683 cs_insert_new_(&track, cuesheet, 0, 10, 2, "BBCDE1234567", false, false); 1684 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) { 1685 printf("FAILED, returned false\n"); 1686 return false; 1687 } 1688 if(!mutils__compare_block(cuesheet, block)) 1689 return false; 1690 printf("OK\n"); 1691 1692 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on middle of non-empty array..."); 1693 cs_insert_new_(&track, cuesheet, 1, 20, 3, "CBCDE1234567", false, false); 1694 if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/true)) { 1695 printf("FAILED, returned false\n"); 1696 return false; 1697 } 1698 if(!mutils__compare_block(cuesheet, block)) 1699 return false; 1700 printf("OK\n"); 1701 1702 printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on end of non-empty array..."); 1703 cs_insert_new_(&track, cuesheet, 3, 30, 4, "DBCDE1234567", false, false); 1704 if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/true)) { 1705 printf("FAILED, returned false\n"); 1706 return false; 1707 } 1708 if(!mutils__compare_block(cuesheet, block)) 1709 return false; 1710 printf("OK\n"); 1711 1712 printf("testing FLAC__metadata_object_cuesheet_insert_blank_track() on end of non-empty array..."); 1713 cs_insert_new_(&track, cuesheet, 4, 0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0", false, false); 1714 if(!FLAC__metadata_object_cuesheet_insert_blank_track(block, 4)) { 1715 printf("FAILED, returned false\n"); 1716 return false; 1717 } 1718 if(!mutils__compare_block(cuesheet, block)) 1719 return false; 1720 printf("OK\n"); 1721 1722 printf("testing FLAC__metadata_object_clone()... "); 1723 blockcopy = FLAC__metadata_object_clone(block); 1724 if(0 == blockcopy) { 1725 printf("FAILED, returned NULL\n"); 1726 return false; 1727 } 1728 if(!mutils__compare_block(block, blockcopy)) 1729 return false; 1730 printf("OK\n"); 1731 1732 printf("testing FLAC__metadata_object_delete()... "); 1733 FLAC__metadata_object_delete(blockcopy); 1734 printf("OK\n"); 1735 1736 printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array..."); 1737 cs_delete_(cuesheet, 4); 1738 if(!FLAC__metadata_object_cuesheet_delete_track(block, 4)) { 1739 printf("FAILED, returned false\n"); 1740 return false; 1741 } 1742 if(!mutils__compare_block(cuesheet, block)) 1743 return false; 1744 printf("OK\n"); 1745 1746 printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array..."); 1747 cs_delete_(cuesheet, 2); 1748 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) { 1749 printf("FAILED, returned false\n"); 1750 return false; 1751 } 1752 if(!mutils__compare_block(cuesheet, block)) 1753 return false; 1754 printf("OK\n"); 1755 1756 printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array..."); 1757 cs_delete_(cuesheet, 2); 1758 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) { 1759 printf("FAILED, returned false\n"); 1760 return false; 1761 } 1762 if(!mutils__compare_block(cuesheet, block)) 1763 return false; 1764 printf("OK\n"); 1765 1766 printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array..."); 1767 cs_delete_(cuesheet, 0); 1768 if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) { 1769 printf("FAILED, returned false\n"); 1770 return false; 1771 } 1772 if(!mutils__compare_block(cuesheet, block)) 1773 return false; 1774 printf("OK\n"); 1775 1776 printf("testing FLAC__metadata_object_cuesheet_set_track(copy)..."); 1777 cs_set_new_(&track, cuesheet, 0, 40, 5, "EBCDE1234567", false, false); 1778 FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/true); 1779 if(!mutils__compare_block(cuesheet, block)) 1780 return false; 1781 printf("OK\n"); 1782 1783 tr_resize_(cuesheet, 0, 2); 1784 printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(grow to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices); 1785 if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) { 1786 printf("FAILED, returned false\n"); 1787 return false; 1788 } 1789 if(!mutils__compare_block(cuesheet, block)) 1790 return false; 1791 printf("OK\n"); 1792 1793 tr_resize_(cuesheet, 0, 1); 1794 printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices); 1795 if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) { 1796 printf("FAILED, returned false\n"); 1797 return false; 1798 } 1799 if(!mutils__compare_block(cuesheet, block)) 1800 return false; 1801 printf("OK\n"); 1802 1803 tr_resize_(cuesheet, 0, 0); 1804 printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices); 1805 if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) { 1806 printf("FAILED, returned false\n"); 1807 return false; 1808 } 1809 if(!mutils__compare_block(cuesheet, block)) 1810 return false; 1811 printf("OK\n"); 1812 1813 index.offset = 0; 1814 index.number = 1; 1815 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on empty array..."); 1816 tr_insert_new_(cuesheet, 0, 0, index); 1817 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) { 1818 printf("FAILED, returned false\n"); 1819 return false; 1820 } 1821 if(!mutils__compare_block(cuesheet, block)) 1822 return false; 1823 printf("OK\n"); 1824 1825 index.offset = 10; 1826 index.number = 2; 1827 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on beginning of non-empty array..."); 1828 tr_insert_new_(cuesheet, 0, 0, index); 1829 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) { 1830 printf("FAILED, returned false\n"); 1831 return false; 1832 } 1833 if(!mutils__compare_block(cuesheet, block)) 1834 return false; 1835 printf("OK\n"); 1836 1837 index.offset = 20; 1838 index.number = 3; 1839 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on middle of non-empty array..."); 1840 tr_insert_new_(cuesheet, 0, 1, index); 1841 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 1, index)) { 1842 printf("FAILED, returned false\n"); 1843 return false; 1844 } 1845 if(!mutils__compare_block(cuesheet, block)) 1846 return false; 1847 printf("OK\n"); 1848 1849 index.offset = 30; 1850 index.number = 4; 1851 printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on end of non-empty array..."); 1852 tr_insert_new_(cuesheet, 0, 3, index); 1853 if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 3, index)) { 1854 printf("FAILED, returned false\n"); 1855 return false; 1856 } 1857 if(!mutils__compare_block(cuesheet, block)) 1858 return false; 1859 printf("OK\n"); 1860 1861 index.offset = 0; 1862 index.number = 0; 1863 printf("testing FLAC__metadata_object_cuesheet_track_insert_blank_index() on end of non-empty array..."); 1864 tr_insert_new_(cuesheet, 0, 4, index); 1865 if(!FLAC__metadata_object_cuesheet_track_insert_blank_index(block, 0, 4)) { 1866 printf("FAILED, returned false\n"); 1867 return false; 1868 } 1869 if(!mutils__compare_block(cuesheet, block)) 1870 return false; 1871 printf("OK\n"); 1872 1873 printf("testing FLAC__metadata_object_clone()... "); 1874 blockcopy = FLAC__metadata_object_clone(block); 1875 if(0 == blockcopy) { 1876 printf("FAILED, returned NULL\n"); 1877 return false; 1878 } 1879 if(!mutils__compare_block(block, blockcopy)) 1880 return false; 1881 printf("OK\n"); 1882 1883 printf("testing FLAC__metadata_object_delete()... "); 1884 FLAC__metadata_object_delete(blockcopy); 1885 printf("OK\n"); 1886 1887 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array..."); 1888 tr_delete_(cuesheet, 0, 4); 1889 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 4)) { 1890 printf("FAILED, returned false\n"); 1891 return false; 1892 } 1893 if(!mutils__compare_block(cuesheet, block)) 1894 return false; 1895 printf("OK\n"); 1896 1897 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on middle of array..."); 1898 tr_delete_(cuesheet, 0, 2); 1899 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) { 1900 printf("FAILED, returned false\n"); 1901 return false; 1902 } 1903 if(!mutils__compare_block(cuesheet, block)) 1904 return false; 1905 printf("OK\n"); 1906 1907 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array..."); 1908 tr_delete_(cuesheet, 0, 2); 1909 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) { 1910 printf("FAILED, returned false\n"); 1911 return false; 1912 } 1913 if(!mutils__compare_block(cuesheet, block)) 1914 return false; 1915 printf("OK\n"); 1916 1917 printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on beginning of array..."); 1918 tr_delete_(cuesheet, 0, 0); 1919 if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 0)) { 1920 printf("FAILED, returned false\n"); 1921 return false; 1922 } 1923 if(!mutils__compare_block(cuesheet, block)) 1924 return false; 1925 printf("OK\n"); 1926 1927 printf("testing FLAC__metadata_object_delete()... "); 1928 FLAC__metadata_object_delete(cuesheet); 1929 FLAC__metadata_object_delete(block); 1930 printf("OK\n"); 1931 1932 1933 printf("testing FLAC__metadata_object_new()... "); 1934 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET); 1935 if(0 == block) { 1936 printf("FAILED, returned NULL\n"); 1937 return false; 1938 } 1939 printf("OK\n"); 1940 1941 printf("testing FLAC__metadata_object_clone()... "); 1942 cuesheet = FLAC__metadata_object_clone(block); 1943 if(0 == cuesheet) { 1944 printf("FAILED, returned NULL\n"); 1945 return false; 1946 } 1947 if(!mutils__compare_block(cuesheet, block)) 1948 return false; 1949 printf("OK\n"); 1950 1951 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on empty array..."); 1952 cs_insert_new_(&track, cuesheet, 0, 60, 7, "GBCDE1234567", false, false); 1953 track_clone_(&track); 1954 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) { 1955 printf("FAILED, returned false\n"); 1956 return false; 1957 } 1958 if(!mutils__compare_block(cuesheet, block)) 1959 return false; 1960 printf("OK\n"); 1961 1962 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on beginning of non-empty array..."); 1963 cs_insert_new_(&track, cuesheet, 0, 70, 8, "HBCDE1234567", false, false); 1964 track_clone_(&track); 1965 if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) { 1966 printf("FAILED, returned false\n"); 1967 return false; 1968 } 1969 if(!mutils__compare_block(cuesheet, block)) 1970 return false; 1971 printf("OK\n"); 1972 1973 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on middle of non-empty array..."); 1974 cs_insert_new_(&track, cuesheet, 1, 80, 9, "IBCDE1234567", false, false); 1975 track_clone_(&track); 1976 if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/false)) { 1977 printf("FAILED, returned false\n"); 1978 return false; 1979 } 1980 if(!mutils__compare_block(cuesheet, block)) 1981 return false; 1982 printf("OK\n"); 1983 1984 printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on end of non-empty array..."); 1985 cs_insert_new_(&track, cuesheet, 3, 90, 10, "JBCDE1234567", false, false); 1986 track_clone_(&track); 1987 if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/false)) { 1988 printf("FAILED, returned false\n"); 1989 return false; 1990 } 1991 if(!mutils__compare_block(cuesheet, block)) 1992 return false; 1993 printf("OK\n"); 1994 1995 printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array..."); 1996 cs_delete_(cuesheet, 2); 1997 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) { 1998 printf("FAILED, returned false\n"); 1999 return false; 2000 } 2001 if(!mutils__compare_block(cuesheet, block)) 2002 return false; 2003 printf("OK\n"); 2004 2005 printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array..."); 2006 cs_delete_(cuesheet, 2); 2007 if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) { 2008 printf("FAILED, returned false\n"); 2009 return false; 2010 } 2011 if(!mutils__compare_block(cuesheet, block)) 2012 return false; 2013 printf("OK\n"); 2014 2015 printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array..."); 2016 cs_delete_(cuesheet, 0); 2017 if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) { 2018 printf("FAILED, returned false\n"); 2019 return false; 2020 } 2021 if(!mutils__compare_block(cuesheet, block)) 2022 return false; 2023 printf("OK\n"); 2024 2025 printf("testing FLAC__metadata_object_cuesheet_set_track(own)..."); 2026 cs_set_new_(&track, cuesheet, 0, 100, 11, "KBCDE1234567", false, false); 2027 track_clone_(&track); 2028 FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/false); 2029 if(!mutils__compare_block(cuesheet, block)) 2030 return false; 2031 printf("OK\n"); 2032 2033 printf("testing FLAC__metadata_object_cuesheet_is_legal()..."); 2034 { 2035 const char *violation; 2036 if(FLAC__metadata_object_cuesheet_is_legal(block, /*check_cd_da_subset=*/true, &violation)) { 2037 printf("FAILED, returned true when expecting false\n"); 2038 return false; 2039 } 2040 printf("returned false as expected, violation=\"%s\" OK\n", violation); 2041 } 2042 2043 printf("testing FLAC__metadata_object_delete()... "); 2044 FLAC__metadata_object_delete(cuesheet); 2045 FLAC__metadata_object_delete(block); 2046 printf("OK\n"); 2047 2048 2049 printf("testing PICTURE\n"); 2050 2051 printf("testing FLAC__metadata_object_new()... "); 2052 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE); 2053 if(0 == block) { 2054 printf("FAILED, returned NULL\n"); 2055 return false; 2056 } 2057 expected_length = ( 2058 FLAC__STREAM_METADATA_PICTURE_TYPE_LEN + 2059 FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + 2060 FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + 2061 FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN + 2062 FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN + 2063 FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN + 2064 FLAC__STREAM_METADATA_PICTURE_COLORS_LEN + 2065 FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN 2066 ) / 8; 2067 if(block->length != expected_length) { 2068 printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length); 2069 return false; 2070 } 2071 printf("OK\n"); 2072 2073 printf("testing FLAC__metadata_object_clone()... "); 2074 picture = FLAC__metadata_object_clone(block); 2075 if(0 == picture) { 2076 printf("FAILED, returned NULL\n"); 2077 return false; 2078 } 2079 if(!mutils__compare_block(picture, block)) 2080 return false; 2081 printf("OK\n"); 2082 2083 pi_set_mime_type(picture, "image/png\t"); 2084 printf("testing FLAC__metadata_object_picture_set_mime_type(copy)..."); 2085 if(!FLAC__metadata_object_picture_set_mime_type(block, "image/png\t", /*copy=*/true)) { 2086 printf("FAILED, returned false\n"); 2087 return false; 2088 } 2089 if(!mutils__compare_block(picture, block)) 2090 return false; 2091 printf("OK\n"); 2092 2093 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2094 { 2095 const char *violation; 2096 if(FLAC__metadata_object_picture_is_legal(block, &violation)) { 2097 printf("FAILED, returned true when expecting false\n"); 2098 return false; 2099 } 2100 printf("returned false as expected, violation=\"%s\" OK\n", violation); 2101 } 2102 2103 pi_set_mime_type(picture, "image/png"); 2104 printf("testing FLAC__metadata_object_picture_set_mime_type(copy)..."); 2105 if(!FLAC__metadata_object_picture_set_mime_type(block, "image/png", /*copy=*/true)) { 2106 printf("FAILED, returned false\n"); 2107 return false; 2108 } 2109 if(!mutils__compare_block(picture, block)) 2110 return false; 2111 printf("OK\n"); 2112 2113 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2114 { 2115 const char *violation; 2116 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) { 2117 printf("FAILED, returned false, violation=\"%s\"\n", violation); 2118 return false; 2119 } 2120 printf("OK\n"); 2121 } 2122 2123 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION\xff"); 2124 printf("testing FLAC__metadata_object_picture_set_description(copy)..."); 2125 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)"DESCRIPTION\xff", /*copy=*/true)) { 2126 printf("FAILED, returned false\n"); 2127 return false; 2128 } 2129 if(!mutils__compare_block(picture, block)) 2130 return false; 2131 printf("OK\n"); 2132 2133 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2134 { 2135 const char *violation; 2136 if(FLAC__metadata_object_picture_is_legal(block, &violation)) { 2137 printf("FAILED, returned true when expecting false\n"); 2138 return false; 2139 } 2140 printf("returned false as expected, violation=\"%s\" OK\n", violation); 2141 } 2142 2143 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION"); 2144 printf("testing FLAC__metadata_object_picture_set_description(copy)..."); 2145 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)"DESCRIPTION", /*copy=*/true)) { 2146 printf("FAILED, returned false\n"); 2147 return false; 2148 } 2149 if(!mutils__compare_block(picture, block)) 2150 return false; 2151 printf("OK\n"); 2152 2153 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2154 { 2155 const char *violation; 2156 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) { 2157 printf("FAILED, returned false, violation=\"%s\"\n", violation); 2158 return false; 2159 } 2160 printf("OK\n"); 2161 } 2162 2163 2164 pi_set_data(picture, (const FLAC__byte*)"PNGDATA", strlen("PNGDATA")); 2165 printf("testing FLAC__metadata_object_picture_set_data(copy)..."); 2166 if(!FLAC__metadata_object_picture_set_data(block, (FLAC__byte*)"PNGDATA", strlen("PNGDATA"), /*copy=*/true)) { 2167 printf("FAILED, returned false\n"); 2168 return false; 2169 } 2170 if(!mutils__compare_block(picture, block)) 2171 return false; 2172 printf("OK\n"); 2173 2174 printf("testing FLAC__metadata_object_clone()... "); 2175 blockcopy = FLAC__metadata_object_clone(block); 2176 if(0 == blockcopy) { 2177 printf("FAILED, returned NULL\n"); 2178 return false; 2179 } 2180 if(!mutils__compare_block(block, blockcopy)) 2181 return false; 2182 printf("OK\n"); 2183 2184 printf("testing FLAC__metadata_object_delete()... "); 2185 FLAC__metadata_object_delete(blockcopy); 2186 printf("OK\n"); 2187 2188 pi_set_mime_type(picture, "image/png\t"); 2189 printf("testing FLAC__metadata_object_picture_set_mime_type(own)..."); 2190 if(!FLAC__metadata_object_picture_set_mime_type(block, strdup("image/png\t"), /*copy=*/false)) { 2191 printf("FAILED, returned false\n"); 2192 return false; 2193 } 2194 if(!mutils__compare_block(picture, block)) 2195 return false; 2196 printf("OK\n"); 2197 2198 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2199 { 2200 const char *violation; 2201 if(FLAC__metadata_object_picture_is_legal(block, &violation)) { 2202 printf("FAILED, returned true when expecting false\n"); 2203 return false; 2204 } 2205 printf("returned false as expected, violation=\"%s\" OK\n", violation); 2206 } 2207 2208 pi_set_mime_type(picture, "image/png"); 2209 printf("testing FLAC__metadata_object_picture_set_mime_type(own)..."); 2210 if(!FLAC__metadata_object_picture_set_mime_type(block, strdup("image/png"), /*copy=*/false)) { 2211 printf("FAILED, returned false\n"); 2212 return false; 2213 } 2214 if(!mutils__compare_block(picture, block)) 2215 return false; 2216 printf("OK\n"); 2217 2218 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2219 { 2220 const char *violation; 2221 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) { 2222 printf("FAILED, returned false, violation=\"%s\"\n", violation); 2223 return false; 2224 } 2225 printf("OK\n"); 2226 } 2227 2228 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION\xff"); 2229 printf("testing FLAC__metadata_object_picture_set_description(own)..."); 2230 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)strdup("DESCRIPTION\xff"), /*copy=*/false)) { 2231 printf("FAILED, returned false\n"); 2232 return false; 2233 } 2234 if(!mutils__compare_block(picture, block)) 2235 return false; 2236 printf("OK\n"); 2237 2238 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2239 { 2240 const char *violation; 2241 if(FLAC__metadata_object_picture_is_legal(block, &violation)) { 2242 printf("FAILED, returned true when expecting false\n"); 2243 return false; 2244 } 2245 printf("returned false as expected, violation=\"%s\" OK\n", violation); 2246 } 2247 2248 pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION"); 2249 printf("testing FLAC__metadata_object_picture_set_description(own)..."); 2250 if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)strdup("DESCRIPTION"), /*copy=*/false)) { 2251 printf("FAILED, returned false\n"); 2252 return false; 2253 } 2254 if(!mutils__compare_block(picture, block)) 2255 return false; 2256 printf("OK\n"); 2257 2258 printf("testing FLAC__metadata_object_picture_is_legal()..."); 2259 { 2260 const char *violation; 2261 if(!FLAC__metadata_object_picture_is_legal(block, &violation)) { 2262 printf("FAILED, returned false, violation=\"%s\"\n", violation); 2263 return false; 2264 } 2265 printf("OK\n"); 2266 } 2267 2268 pi_set_data(picture, (const FLAC__byte*)"PNGDATA", strlen("PNGDATA")); 2269 printf("testing FLAC__metadata_object_picture_set_data(own)..."); 2270 if(!FLAC__metadata_object_picture_set_data(block, (FLAC__byte*)strdup("PNGDATA"), strlen("PNGDATA"), /*copy=*/false)) { 2271 printf("FAILED, returned false\n"); 2272 return false; 2273 } 2274 if(!mutils__compare_block(picture, block)) 2275 return false; 2276 printf("OK\n"); 2277 2278 printf("testing FLAC__metadata_object_clone()... "); 2279 blockcopy = FLAC__metadata_object_clone(block); 2280 if(0 == blockcopy) { 2281 printf("FAILED, returned NULL\n"); 2282 return false; 2283 } 2284 if(!mutils__compare_block(block, blockcopy)) 2285 return false; 2286 printf("OK\n"); 2287 2288 printf("testing FLAC__metadata_object_delete()... "); 2289 FLAC__metadata_object_delete(blockcopy); 2290 printf("OK\n"); 2291 2292 printf("testing FLAC__metadata_object_delete()... "); 2293 FLAC__metadata_object_delete(picture); 2294 FLAC__metadata_object_delete(block); 2295 printf("OK\n"); 2296 2297 2298 return true; 2299} 2300