metadata_object.c
上传用户:wstnjxml
上传日期:2014-04-03
资源大小:7248k
文件大小:67k
源码类别:

Windows CE

开发平台:

C/C++

  1. /* test_libFLAC - Unit tester for libFLAC
  2.  * Copyright (C) 2002,2003,2004,2005  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. #include "FLAC/assert.h"
  19. #include "FLAC/metadata.h"
  20. #include "metadata_utils.h"
  21. #include <stdio.h>
  22. #include <stdlib.h> /* for malloc() */
  23. #include <string.h> /* for memcmp() */
  24. static FLAC__byte *make_dummydata_(FLAC__byte *dummydata, unsigned len)
  25. {
  26. FLAC__byte *ret;
  27. if(0 == (ret = (FLAC__byte*)malloc(len))) {
  28. printf("FAILED, malloc errorn");
  29. exit(1);
  30. }
  31. else
  32. memcpy(ret, dummydata, len);
  33. return ret;
  34. }
  35. static FLAC__bool compare_track_(const FLAC__StreamMetadata_CueSheet_Track *from, const FLAC__StreamMetadata_CueSheet_Track *to)
  36. {
  37. unsigned i;
  38. if(from->offset != to->offset) {
  39. printf("FAILED, track offset mismatch, expected %llu, got %llun", to->offset, from->offset);
  40. return false;
  41. }
  42. if(from->number != to->number) {
  43. printf("FAILED, track number mismatch, expected %u, got %un", (unsigned)to->number, (unsigned)from->number);
  44. return false;
  45. }
  46. if(0 != strcmp(from->isrc, to->isrc)) {
  47. printf("FAILED, track number mismatch, expected %s, got %sn", to->isrc, from->isrc);
  48. return false;
  49. }
  50. if(from->type != to->type) {
  51. printf("FAILED, track type mismatch, expected %u, got %un", (unsigned)to->type, (unsigned)from->type);
  52. return false;
  53. }
  54. if(from->pre_emphasis != to->pre_emphasis) {
  55. printf("FAILED, track pre_emphasis mismatch, expected %u, got %un", (unsigned)to->pre_emphasis, (unsigned)from->pre_emphasis);
  56. return false;
  57. }
  58. if(from->num_indices != to->num_indices) {
  59. printf("FAILED, track num_indices mismatch, expected %u, got %un", (unsigned)to->num_indices, (unsigned)from->num_indices);
  60. return false;
  61. }
  62. if(0 == to->indices || 0 == from->indices) {
  63. if(to->indices != from->indices) {
  64. printf("FAILED, track indices mismatchn");
  65. return false;
  66. }
  67. }
  68. else {
  69. for(i = 0; i < to->num_indices; i++) {
  70. if(from->indices[i].offset != to->indices[i].offset) {
  71. printf("FAILED, track indices[%u].offset mismatch, expected %llu, got %llun", i, to->indices[i].offset, from->indices[i].offset);
  72. return false;
  73. }
  74. if(from->indices[i].number != to->indices[i].number) {
  75. printf("FAILED, track indices[%u].number mismatch, expected %u, got %un", i, (unsigned)to->indices[i].number, (unsigned)from->indices[i].number);
  76. return false;
  77. }
  78. }
  79. }
  80. return true;
  81. }
  82. static FLAC__bool compare_seekpoint_array_(const FLAC__StreamMetadata_SeekPoint *from, const FLAC__StreamMetadata_SeekPoint *to, unsigned n)
  83. {
  84. unsigned i;
  85. FLAC__ASSERT(0 != from);
  86. FLAC__ASSERT(0 != to);
  87. for(i = 0; i < n; i++) {
  88. if(from[i].sample_number != to[i].sample_number) {
  89. printf("FAILED, point[%u].sample_number mismatch, expected %llu, got %llun", i, to[i].sample_number, from[i].sample_number);
  90. return false;
  91. }
  92. if(from[i].stream_offset != to[i].stream_offset) {
  93. printf("FAILED, point[%u].stream_offset mismatch, expected %llu, got %llun", i, to[i].stream_offset, from[i].stream_offset);
  94. return false;
  95. }
  96. if(from[i].frame_samples != to[i].frame_samples) {
  97. printf("FAILED, point[%u].frame_samples mismatch, expected %u, got %un", i, to[i].frame_samples, from[i].frame_samples);
  98. return false;
  99. }
  100. }
  101. return true;
  102. }
  103. static FLAC__bool check_seektable_(const FLAC__StreamMetadata *block, unsigned num_points, const FLAC__StreamMetadata_SeekPoint *array)
  104. {
  105. const unsigned expected_length = num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
  106. if(block->length != expected_length) {
  107. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  108. return false;
  109. }
  110. if(block->data.seek_table.num_points != num_points) {
  111. printf("FAILED, expected %u point, got %un", num_points, block->data.seek_table.num_points);
  112. return false;
  113. }
  114. if(0 == array) {
  115. if(0 != block->data.seek_table.points) {
  116. printf("FAILED, 'points' pointer is not nulln");
  117. return false;
  118. }
  119. }
  120. else {
  121. if(!compare_seekpoint_array_(block->data.seek_table.points, array, num_points))
  122. return false;
  123. }
  124. printf("OKn");
  125. return true;
  126. }
  127. static void entry_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field)
  128. {
  129. entry->length = strlen(field);
  130. entry->entry = (FLAC__byte*)malloc(entry->length+1);
  131. FLAC__ASSERT(0 != entry->entry);
  132. memcpy(entry->entry, field, entry->length);
  133. entry->entry[entry->length] = '';
  134. }
  135. static void entry_clone_(FLAC__StreamMetadata_VorbisComment_Entry *entry)
  136. {
  137. FLAC__byte *x = (FLAC__byte*)malloc(entry->length+1);
  138. FLAC__ASSERT(0 != x);
  139. memcpy(x, entry->entry, entry->length);
  140. x[entry->length] = '';
  141. entry->entry = x;
  142. }
  143. static void vc_calc_len_(FLAC__StreamMetadata *block)
  144. {
  145. const FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
  146. unsigned i;
  147. block->length = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
  148. block->length += vc->vendor_string.length;
  149. block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
  150. for(i = 0; i < vc->num_comments; i++) {
  151. block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
  152. block->length += vc->comments[i].length;
  153. }
  154. }
  155. static void vc_resize_(FLAC__StreamMetadata *block, unsigned num)
  156. {
  157. FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
  158. if(vc->num_comments != 0) {
  159. FLAC__ASSERT(0 != vc->comments);
  160. if(num < vc->num_comments) {
  161. unsigned i;
  162. for(i = num; i < vc->num_comments; i++) {
  163. if(0 != vc->comments[i].entry)
  164. free(vc->comments[i].entry);
  165. }
  166. }
  167. }
  168. if(num == 0) {
  169. if(0 != vc->comments) {
  170. free(vc->comments);
  171. vc->comments = 0;
  172. }
  173. }
  174. else {
  175. vc->comments = (FLAC__StreamMetadata_VorbisComment_Entry*)realloc(vc->comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*num);
  176. FLAC__ASSERT(0 != vc->comments);
  177. if(num > vc->num_comments)
  178. memset(vc->comments+vc->num_comments, 0, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(num-vc->num_comments));
  179. }
  180. vc->num_comments = num;
  181. vc_calc_len_(block);
  182. }
  183. static int vc_find_from_(FLAC__StreamMetadata *block, const char *name, unsigned start)
  184. {
  185. const unsigned n = strlen(name);
  186. unsigned i;
  187. for(i = start; i < block->data.vorbis_comment.num_comments; i++) {
  188. const FLAC__StreamMetadata_VorbisComment_Entry *entry = &block->data.vorbis_comment.comments[i];
  189. if(entry->length > n && 0 == strncmp(entry->entry, name, n) && entry->entry[n] == '=')
  190. return (int)i;
  191. }
  192. return -1;
  193. }
  194. static void vc_set_vs_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field)
  195. {
  196. if(0 != block->data.vorbis_comment.vendor_string.entry)
  197. free(block->data.vorbis_comment.vendor_string.entry);
  198. entry_new_(entry, field);
  199. block->data.vorbis_comment.vendor_string = *entry;
  200. vc_calc_len_(block);
  201. }
  202. static void vc_set_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field)
  203. {
  204. if(0 != block->data.vorbis_comment.comments[pos].entry)
  205. free(block->data.vorbis_comment.comments[pos].entry);
  206. entry_new_(entry, field);
  207. block->data.vorbis_comment.comments[pos] = *entry;
  208. vc_calc_len_(block);
  209. }
  210. static void vc_insert_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field)
  211. {
  212. vc_resize_(block, block->data.vorbis_comment.num_comments+1);
  213. 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));
  214. memset(&block->data.vorbis_comment.comments[pos], 0, sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
  215. vc_set_new_(entry, block, pos, field);
  216. vc_calc_len_(block);
  217. }
  218. static void vc_delete_(FLAC__StreamMetadata *block, unsigned pos)
  219. {
  220. if(0 != block->data.vorbis_comment.comments[pos].entry)
  221. free(block->data.vorbis_comment.comments[pos].entry);
  222. 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));
  223. block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].entry = 0;
  224. block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].length = 0;
  225. vc_resize_(block, block->data.vorbis_comment.num_comments-1);
  226. vc_calc_len_(block);
  227. }
  228. static void vc_replace_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field, FLAC__bool all)
  229. {
  230. int index;
  231. char field_name[256];
  232. const char *eq = strchr(field, '=');
  233. FLAC__ASSERT(eq>field && (unsigned)(eq-field) < sizeof(field_name));
  234. memcpy(field_name, field, eq-field);
  235. field_name[eq-field]='';
  236. index = vc_find_from_(block, field_name, 0);
  237. if(index < 0)
  238. vc_insert_new_(entry, block, block->data.vorbis_comment.num_comments, field);
  239. else {
  240. vc_set_new_(entry, block, (unsigned)index, field);
  241. if(all) {
  242. for(index = index+1; index >= 0 && (unsigned)index < block->data.vorbis_comment.num_comments; )
  243. if((index = vc_find_from_(block, field_name, (unsigned)index)) >= 0)
  244. vc_delete_(block, (unsigned)index);
  245. }
  246. }
  247. vc_calc_len_(block);
  248. }
  249. static void track_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em)
  250. {
  251. track->offset = offset;
  252. track->number = number;
  253. memcpy(track->isrc, isrc, sizeof(track->isrc));
  254. track->type = data;
  255. track->pre_emphasis = pre_em;
  256. track->num_indices = 0;
  257. track->indices = 0;
  258. }
  259. static void track_clone_(FLAC__StreamMetadata_CueSheet_Track *track)
  260. {
  261. if(track->num_indices > 0) {
  262. size_t bytes = sizeof(FLAC__StreamMetadata_CueSheet_Index) * track->num_indices;
  263. FLAC__StreamMetadata_CueSheet_Index *x = (FLAC__StreamMetadata_CueSheet_Index*)malloc(bytes);
  264. FLAC__ASSERT(0 != x);
  265. memcpy(x, track->indices, bytes);
  266. track->indices = x;
  267. }
  268. }
  269. static void cs_calc_len_(FLAC__StreamMetadata *block)
  270. {
  271. const FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
  272. unsigned i;
  273. block->length = (
  274. FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
  275. FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
  276. FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
  277. FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
  278. FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
  279. ) / 8;
  280. block->length += cs->num_tracks * (
  281. FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
  282. FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
  283. FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
  284. FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
  285. FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
  286. FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
  287. FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
  288. ) / 8;
  289. for(i = 0; i < cs->num_tracks; i++) {
  290. block->length += cs->tracks[i].num_indices * (
  291. FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
  292. FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
  293. FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
  294. ) / 8;
  295. }
  296. }
  297. static void tr_resize_(FLAC__StreamMetadata *block, unsigned track_num, unsigned num)
  298. {
  299. FLAC__StreamMetadata_CueSheet_Track *tr;
  300. FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
  301. tr = &block->data.cue_sheet.tracks[track_num];
  302. if(tr->num_indices != 0) {
  303. FLAC__ASSERT(0 != tr->indices);
  304. }
  305. if(num == 0) {
  306. if(0 != tr->indices) {
  307. free(tr->indices);
  308. tr->indices = 0;
  309. }
  310. }
  311. else {
  312. tr->indices = (FLAC__StreamMetadata_CueSheet_Index*)realloc(tr->indices, sizeof(FLAC__StreamMetadata_CueSheet_Index)*num);
  313. FLAC__ASSERT(0 != tr->indices);
  314. if(num > tr->num_indices)
  315. memset(tr->indices+tr->num_indices, 0, sizeof(FLAC__StreamMetadata_CueSheet_Index)*(num-tr->num_indices));
  316. }
  317. tr->num_indices = num;
  318. cs_calc_len_(block);
  319. }
  320. static void tr_set_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index)
  321. {
  322. FLAC__StreamMetadata_CueSheet_Track *tr;
  323. FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
  324. tr = &block->data.cue_sheet.tracks[track_num];
  325. FLAC__ASSERT(pos < tr->num_indices);
  326. tr->indices[pos] = index;
  327. cs_calc_len_(block);
  328. }
  329. static void tr_insert_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index)
  330. {
  331. FLAC__StreamMetadata_CueSheet_Track *tr;
  332. FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
  333. tr = &block->data.cue_sheet.tracks[track_num];
  334. FLAC__ASSERT(pos <= tr->num_indices);
  335. tr_resize_(block, track_num, tr->num_indices+1);
  336. memmove(&tr->indices[pos+1], &tr->indices[pos], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-1-pos));
  337. tr_set_new_(block, track_num, pos, index);
  338. cs_calc_len_(block);
  339. }
  340. static void tr_delete_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos)
  341. {
  342. FLAC__StreamMetadata_CueSheet_Track *tr;
  343. FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
  344. tr = &block->data.cue_sheet.tracks[track_num];
  345. FLAC__ASSERT(pos <= tr->num_indices);
  346. memmove(&tr->indices[pos], &tr->indices[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-pos-1));
  347. tr_resize_(block, track_num, tr->num_indices-1);
  348. cs_calc_len_(block);
  349. }
  350. static void cs_resize_(FLAC__StreamMetadata *block, unsigned num)
  351. {
  352. FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
  353. if(cs->num_tracks != 0) {
  354. FLAC__ASSERT(0 != cs->tracks);
  355. if(num < cs->num_tracks) {
  356. unsigned i;
  357. for(i = num; i < cs->num_tracks; i++) {
  358. if(0 != cs->tracks[i].indices)
  359. free(cs->tracks[i].indices);
  360. }
  361. }
  362. }
  363. if(num == 0) {
  364. if(0 != cs->tracks) {
  365. free(cs->tracks);
  366. cs->tracks = 0;
  367. }
  368. }
  369. else {
  370. cs->tracks = (FLAC__StreamMetadata_CueSheet_Track*)realloc(cs->tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track)*num);
  371. FLAC__ASSERT(0 != cs->tracks);
  372. if(num > cs->num_tracks)
  373. memset(cs->tracks+cs->num_tracks, 0, sizeof(FLAC__StreamMetadata_CueSheet_Track)*(num-cs->num_tracks));
  374. }
  375. cs->num_tracks = num;
  376. cs_calc_len_(block);
  377. }
  378. static 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)
  379. {
  380. track_new_(track, offset, number, isrc, data, pre_em);
  381. block->data.cue_sheet.tracks[pos] = *track;
  382. cs_calc_len_(block);
  383. }
  384. static 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)
  385. {
  386. cs_resize_(block, block->data.cue_sheet.num_tracks+1);
  387. 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));
  388. cs_set_new_(track, block, pos, offset, number, isrc, data, pre_em);
  389. cs_calc_len_(block);
  390. }
  391. static void cs_delete_(FLAC__StreamMetadata *block, unsigned pos)
  392. {
  393. if(0 != block->data.cue_sheet.tracks[pos].indices)
  394. free(block->data.cue_sheet.tracks[pos].indices);
  395. 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));
  396. block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].indices = 0;
  397. block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].num_indices = 0;
  398. cs_resize_(block, block->data.cue_sheet.num_tracks-1);
  399. cs_calc_len_(block);
  400. }
  401. FLAC__bool test_metadata_object()
  402. {
  403. FLAC__StreamMetadata *block, *blockcopy, *vorbiscomment, *cuesheet;
  404. FLAC__StreamMetadata_SeekPoint seekpoint_array[8];
  405. FLAC__StreamMetadata_VorbisComment_Entry entry;
  406. FLAC__StreamMetadata_CueSheet_Index index;
  407. FLAC__StreamMetadata_CueSheet_Track track;
  408. unsigned i, expected_length, seekpoints;
  409. int j;
  410. static FLAC__byte dummydata[4] = { 'a', 'b', 'c', 'd' };
  411. printf("n+++ libFLAC unit test: metadata objectsnn");
  412. printf("testing STREAMINFOn");
  413. printf("testing FLAC__metadata_object_new()... ");
  414. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_STREAMINFO);
  415. if(0 == block) {
  416. printf("FAILED, returned NULLn");
  417. return false;
  418. }
  419. expected_length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
  420. if(block->length != expected_length) {
  421. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  422. return false;
  423. }
  424. printf("OKn");
  425. printf("testing FLAC__metadata_object_clone()... ");
  426. blockcopy = FLAC__metadata_object_clone(block);
  427. if(0 == blockcopy) {
  428. printf("FAILED, returned NULLn");
  429. return false;
  430. }
  431. if(!mutils__compare_block(block, blockcopy))
  432. return false;
  433. printf("OKn");
  434. printf("testing FLAC__metadata_object_delete()... ");
  435. FLAC__metadata_object_delete(blockcopy);
  436. FLAC__metadata_object_delete(block);
  437. printf("OKn");
  438. printf("testing PADDINGn");
  439. printf("testing FLAC__metadata_object_new()... ");
  440. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
  441. if(0 == block) {
  442. printf("FAILED, returned NULLn");
  443. return false;
  444. }
  445. expected_length = 0;
  446. if(block->length != expected_length) {
  447. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  448. return false;
  449. }
  450. printf("OKn");
  451. printf("testing FLAC__metadata_object_clone()... ");
  452. blockcopy = FLAC__metadata_object_clone(block);
  453. if(0 == blockcopy) {
  454. printf("FAILED, returned NULLn");
  455. return false;
  456. }
  457. if(!mutils__compare_block(block, blockcopy))
  458. return false;
  459. printf("OKn");
  460. printf("testing FLAC__metadata_object_delete()... ");
  461. FLAC__metadata_object_delete(blockcopy);
  462. FLAC__metadata_object_delete(block);
  463. printf("OKn");
  464. printf("testing APPLICATIONn");
  465. printf("testing FLAC__metadata_object_new()... ");
  466. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION);
  467. if(0 == block) {
  468. printf("FAILED, returned NULLn");
  469. return false;
  470. }
  471. expected_length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
  472. if(block->length != expected_length) {
  473. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  474. return false;
  475. }
  476. printf("OKn");
  477. printf("testing FLAC__metadata_object_clone()... ");
  478. blockcopy = FLAC__metadata_object_clone(block);
  479. if(0 == blockcopy) {
  480. printf("FAILED, returned NULLn");
  481. return false;
  482. }
  483. if(!mutils__compare_block(block, blockcopy))
  484. return false;
  485. printf("OKn");
  486. printf("testing FLAC__metadata_object_delete()... ");
  487. FLAC__metadata_object_delete(blockcopy);
  488. printf("OKn");
  489. printf("testing FLAC__metadata_object_application_set_data(copy)... ");
  490. if(!FLAC__metadata_object_application_set_data(block, dummydata, sizeof(dummydata), true/*copy*/)) {
  491. printf("FAILED, returned falsen");
  492. return false;
  493. }
  494. expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
  495. if(block->length != expected_length) {
  496. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  497. return false;
  498. }
  499. if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
  500. printf("FAILED, data mismatchn");
  501. return false;
  502. }
  503. printf("OKn");
  504. printf("testing FLAC__metadata_object_clone()... ");
  505. blockcopy = FLAC__metadata_object_clone(block);
  506. if(0 == blockcopy) {
  507. printf("FAILED, returned NULLn");
  508. return false;
  509. }
  510. if(!mutils__compare_block(block, blockcopy))
  511. return false;
  512. printf("OKn");
  513. printf("testing FLAC__metadata_object_delete()... ");
  514. FLAC__metadata_object_delete(blockcopy);
  515. printf("OKn");
  516. printf("testing FLAC__metadata_object_application_set_data(own)... ");
  517. if(!FLAC__metadata_object_application_set_data(block, make_dummydata_(dummydata, sizeof(dummydata)), sizeof(dummydata), false/*own*/)) {
  518. printf("FAILED, returned falsen");
  519. return false;
  520. }
  521. expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
  522. if(block->length != expected_length) {
  523. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  524. return false;
  525. }
  526. if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
  527. printf("FAILED, data mismatchn");
  528. return false;
  529. }
  530. printf("OKn");
  531. printf("testing FLAC__metadata_object_clone()... ");
  532. blockcopy = FLAC__metadata_object_clone(block);
  533. if(0 == blockcopy) {
  534. printf("FAILED, returned NULLn");
  535. return false;
  536. }
  537. if(!mutils__compare_block(block, blockcopy))
  538. return false;
  539. printf("OKn");
  540. printf("testing FLAC__metadata_object_delete()... ");
  541. FLAC__metadata_object_delete(blockcopy);
  542. FLAC__metadata_object_delete(block);
  543. printf("OKn");
  544. printf("testing SEEKTABLEn");
  545. for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
  546. seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
  547. seekpoint_array[i].stream_offset = 0;
  548. seekpoint_array[i].frame_samples = 0;
  549. }
  550. seekpoints = 0;
  551. printf("testing FLAC__metadata_object_new()... ");
  552. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
  553. if(0 == block) {
  554. printf("FAILED, returned NULLn");
  555. return false;
  556. }
  557. if(!check_seektable_(block, seekpoints, 0))
  558. return false;
  559. printf("testing FLAC__metadata_object_clone()... ");
  560. blockcopy = FLAC__metadata_object_clone(block);
  561. if(0 == blockcopy) {
  562. printf("FAILED, returned NULLn");
  563. return false;
  564. }
  565. if(!mutils__compare_block(block, blockcopy))
  566. return false;
  567. printf("OKn");
  568. printf("testing FLAC__metadata_object_delete()... ");
  569. FLAC__metadata_object_delete(blockcopy);
  570. printf("OKn");
  571. seekpoints = 2;
  572. printf("testing FLAC__metadata_object_seektable_resize_points(grow to %u)...", seekpoints);
  573. if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
  574. printf("FAILED, returned falsen");
  575. return false;
  576. }
  577. if(!check_seektable_(block, seekpoints, seekpoint_array))
  578. return false;
  579. seekpoints = 1;
  580. printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
  581. if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
  582. printf("FAILED, returned falsen");
  583. return false;
  584. }
  585. if(!check_seektable_(block, seekpoints, seekpoint_array))
  586. return false;
  587. printf("testing FLAC__metadata_object_seektable_is_legal()...");
  588. if(!FLAC__metadata_object_seektable_is_legal(block)) {
  589. printf("FAILED, returned falsen");
  590. return false;
  591. }
  592. printf("OKn");
  593. seekpoints = 0;
  594. printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
  595. if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
  596. printf("FAILED, returned falsen");
  597. return false;
  598. }
  599. if(!check_seektable_(block, seekpoints, 0))
  600. return false;
  601. seekpoints++;
  602. printf("testing FLAC__metadata_object_seektable_insert_point() on empty array...");
  603. if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
  604. printf("FAILED, returned falsen");
  605. return false;
  606. }
  607. if(!check_seektable_(block, seekpoints, seekpoint_array))
  608. return false;
  609. seekpoint_array[0].sample_number = 1;
  610. seekpoints++;
  611. printf("testing FLAC__metadata_object_seektable_insert_point() on beginning of non-empty array...");
  612. if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
  613. printf("FAILED, returned falsen");
  614. return false;
  615. }
  616. if(!check_seektable_(block, seekpoints, seekpoint_array))
  617. return false;
  618. seekpoint_array[1].sample_number = 2;
  619. seekpoints++;
  620. printf("testing FLAC__metadata_object_seektable_insert_point() on middle of non-empty array...");
  621. if(!FLAC__metadata_object_seektable_insert_point(block, 1, seekpoint_array[1])) {
  622. printf("FAILED, returned falsen");
  623. return false;
  624. }
  625. if(!check_seektable_(block, seekpoints, seekpoint_array))
  626. return false;
  627. seekpoint_array[3].sample_number = 3;
  628. seekpoints++;
  629. printf("testing FLAC__metadata_object_seektable_insert_point() on end of non-empty array...");
  630. if(!FLAC__metadata_object_seektable_insert_point(block, 3, seekpoint_array[3])) {
  631. printf("FAILED, returned falsen");
  632. return false;
  633. }
  634. if(!check_seektable_(block, seekpoints, seekpoint_array))
  635. return false;
  636. printf("testing FLAC__metadata_object_clone()... ");
  637. blockcopy = FLAC__metadata_object_clone(block);
  638. if(0 == blockcopy) {
  639. printf("FAILED, returned NULLn");
  640. return false;
  641. }
  642. if(!mutils__compare_block(block, blockcopy))
  643. return false;
  644. printf("OKn");
  645. printf("testing FLAC__metadata_object_delete()... ");
  646. FLAC__metadata_object_delete(blockcopy);
  647. printf("OKn");
  648. seekpoint_array[2].sample_number = seekpoint_array[3].sample_number;
  649. seekpoints--;
  650. printf("testing FLAC__metadata_object_seektable_delete_point() on middle of array...");
  651. if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
  652. printf("FAILED, returned falsen");
  653. return false;
  654. }
  655. if(!check_seektable_(block, seekpoints, seekpoint_array))
  656. return false;
  657. seekpoints--;
  658. printf("testing FLAC__metadata_object_seektable_delete_point() on end of array...");
  659. if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
  660. printf("FAILED, returned falsen");
  661. return false;
  662. }
  663. if(!check_seektable_(block, seekpoints, seekpoint_array))
  664. return false;
  665. seekpoints--;
  666. printf("testing FLAC__metadata_object_seektable_delete_point() on beginning of array...");
  667. if(!FLAC__metadata_object_seektable_delete_point(block, 0)) {
  668. printf("FAILED, returned falsen");
  669. return false;
  670. }
  671. if(!check_seektable_(block, seekpoints, seekpoint_array+1))
  672. return false;
  673. printf("testing FLAC__metadata_object_seektable_set_point()...");
  674. FLAC__metadata_object_seektable_set_point(block, 0, seekpoint_array[0]);
  675. if(!check_seektable_(block, seekpoints, seekpoint_array))
  676. return false;
  677. printf("testing FLAC__metadata_object_delete()... ");
  678. FLAC__metadata_object_delete(block);
  679. printf("OKn");
  680. /* seektable template functions */
  681. for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
  682. seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
  683. seekpoint_array[i].stream_offset = 0;
  684. seekpoint_array[i].frame_samples = 0;
  685. }
  686. seekpoints = 0;
  687. printf("testing FLAC__metadata_object_new()... ");
  688. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
  689. if(0 == block) {
  690. printf("FAILED, returned NULLn");
  691. return false;
  692. }
  693. if(!check_seektable_(block, seekpoints, 0))
  694. return false;
  695. seekpoints += 2;
  696. printf("testing FLAC__metadata_object_seekpoint_template_append_placeholders()... ");
  697. if(!FLAC__metadata_object_seektable_template_append_placeholders(block, 2)) {
  698. printf("FAILED, returned falsen");
  699. return false;
  700. }
  701. if(!check_seektable_(block, seekpoints, seekpoint_array))
  702. return false;
  703. seekpoint_array[seekpoints++].sample_number = 7;
  704. printf("testing FLAC__metadata_object_seekpoint_template_append_point()... ");
  705. if(!FLAC__metadata_object_seektable_template_append_point(block, 7)) {
  706. printf("FAILED, returned falsen");
  707. return false;
  708. }
  709. if(!check_seektable_(block, seekpoints, seekpoint_array))
  710. return false;
  711. {
  712. FLAC__uint64 nums[2] = { 3, 7 };
  713. seekpoint_array[seekpoints++].sample_number = nums[0];
  714. seekpoint_array[seekpoints++].sample_number = nums[1];
  715. printf("testing FLAC__metadata_object_seekpoint_template_append_points()... ");
  716. if(!FLAC__metadata_object_seektable_template_append_points(block, nums, sizeof(nums)/sizeof(FLAC__uint64))) {
  717. printf("FAILED, returned falsen");
  718. return false;
  719. }
  720. if(!check_seektable_(block, seekpoints, seekpoint_array))
  721. return false;
  722. }
  723. seekpoint_array[seekpoints++].sample_number = 0;
  724. seekpoint_array[seekpoints++].sample_number = 10;
  725. seekpoint_array[seekpoints++].sample_number = 20;
  726. printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points()... ");
  727. if(!FLAC__metadata_object_seektable_template_append_spaced_points(block, 3, 30)) {
  728. printf("FAILED, returned falsen");
  729. return false;
  730. }
  731. if(!check_seektable_(block, seekpoints, seekpoint_array))
  732. return false;
  733. seekpoints--;
  734. seekpoint_array[0].sample_number = 0;
  735. seekpoint_array[1].sample_number = 3;
  736. seekpoint_array[2].sample_number = 7;
  737. seekpoint_array[3].sample_number = 10;
  738. seekpoint_array[4].sample_number = 20;
  739. seekpoint_array[5].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
  740. seekpoint_array[6].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
  741. printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=true)... ");
  742. if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/true)) {
  743. printf("FAILED, returned falsen");
  744. return false;
  745. }
  746. if(!FLAC__metadata_object_seektable_is_legal(block)) {
  747. printf("FAILED, seek table is illegaln");
  748. return false;
  749. }
  750. if(!check_seektable_(block, seekpoints, seekpoint_array))
  751. return false;
  752. printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=false)... ");
  753. if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/false)) {
  754. printf("FAILED, returned falsen");
  755. return false;
  756. }
  757. if(!FLAC__metadata_object_seektable_is_legal(block)) {
  758. printf("FAILED, seek table is illegaln");
  759. return false;
  760. }
  761. if(!check_seektable_(block, seekpoints, seekpoint_array))
  762. return false;
  763. printf("testing FLAC__metadata_object_delete()... ");
  764. FLAC__metadata_object_delete(block);
  765. printf("OKn");
  766. printf("testing VORBIS_COMMENTn");
  767. {
  768. FLAC__StreamMetadata_VorbisComment_Entry entry_;
  769. char *field_name, *field_value;
  770. printf("testing FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair()... ");
  771. if(!FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry_, "name", "value")) {
  772. printf("FAILED, returned falsen");
  773. return false;
  774. }
  775. if(strcmp(entry_.entry, "name=value")) {
  776. printf("FAILED, field mismatchn");
  777. return false;
  778. }
  779. printf("OKn");
  780. printf("testing FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair()... ");
  781. if(!FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(entry_, &field_name, &field_value)) {
  782. printf("FAILED, returned falsen");
  783. return false;
  784. }
  785. if(strcmp(field_name, "name")) {
  786. printf("FAILED, field name mismatchn");
  787. return false;
  788. }
  789. if(strcmp(field_value, "value")) {
  790. printf("FAILED, field value mismatchn");
  791. return false;
  792. }
  793. printf("OKn");
  794. printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... ");
  795. if(!FLAC__metadata_object_vorbiscomment_entry_matches(entry_, field_name, strlen(field_name))) {
  796. printf("FAILED, expected true, returned falsen");
  797. return false;
  798. }
  799. printf("OKn");
  800. printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... ");
  801. if(FLAC__metadata_object_vorbiscomment_entry_matches(entry_, "blah", strlen("blah"))) {
  802. printf("FAILED, expected false, returned truen");
  803. return false;
  804. }
  805. printf("OKn");
  806. free(entry_.entry);
  807. free(field_name);
  808. free(field_value);
  809. }
  810. printf("testing FLAC__metadata_object_new()... ");
  811. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
  812. if(0 == block) {
  813. printf("FAILED, returned NULLn");
  814. return false;
  815. }
  816. expected_length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + strlen(FLAC__VENDOR_STRING) + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN/8);
  817. if(block->length != expected_length) {
  818. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  819. return false;
  820. }
  821. printf("OKn");
  822. printf("testing FLAC__metadata_object_clone()... ");
  823. vorbiscomment = FLAC__metadata_object_clone(block);
  824. if(0 == vorbiscomment) {
  825. printf("FAILED, returned NULLn");
  826. return false;
  827. }
  828. if(!mutils__compare_block(vorbiscomment, block))
  829. return false;
  830. printf("OKn");
  831. vc_resize_(vorbiscomment, 2);
  832. printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(grow to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
  833. if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
  834. printf("FAILED, returned falsen");
  835. return false;
  836. }
  837. if(!mutils__compare_block(vorbiscomment, block))
  838. return false;
  839. printf("OKn");
  840. vc_resize_(vorbiscomment, 1);
  841. printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
  842. if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
  843. printf("FAILED, returned falsen");
  844. return false;
  845. }
  846. if(!mutils__compare_block(vorbiscomment, block))
  847. return false;
  848. printf("OKn");
  849. vc_resize_(vorbiscomment, 0);
  850. printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
  851. if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
  852. printf("FAILED, returned falsen");
  853. return false;
  854. }
  855. if(!mutils__compare_block(vorbiscomment, block))
  856. return false;
  857. printf("OKn");
  858. printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on empty array...");
  859. vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
  860. if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
  861. printf("FAILED, returned falsen");
  862. return false;
  863. }
  864. if(!mutils__compare_block(vorbiscomment, block))
  865. return false;
  866. printf("OKn");
  867. printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
  868. vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2");
  869. if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
  870. printf("FAILED, returned falsen");
  871. return false;
  872. }
  873. if(!mutils__compare_block(vorbiscomment, block))
  874. return false;
  875. printf("OKn");
  876. vc_resize_(vorbiscomment, 0);
  877. printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
  878. if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
  879. printf("FAILED, returned falsen");
  880. return false;
  881. }
  882. if(!mutils__compare_block(vorbiscomment, block))
  883. return false;
  884. printf("OKn");
  885. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on empty array...");
  886. vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
  887. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
  888. printf("FAILED, returned falsen");
  889. return false;
  890. }
  891. if(!mutils__compare_block(vorbiscomment, block))
  892. return false;
  893. printf("OKn");
  894. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on beginning of non-empty array...");
  895. vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
  896. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
  897. printf("FAILED, returned falsen");
  898. return false;
  899. }
  900. if(!mutils__compare_block(vorbiscomment, block))
  901. return false;
  902. printf("OKn");
  903. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on middle of non-empty array...");
  904. vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
  905. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/true)) {
  906. printf("FAILED, returned falsen");
  907. return false;
  908. }
  909. if(!mutils__compare_block(vorbiscomment, block))
  910. return false;
  911. printf("OKn");
  912. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
  913. vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
  914. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/true)) {
  915. printf("FAILED, returned falsen");
  916. return false;
  917. }
  918. if(!mutils__compare_block(vorbiscomment, block))
  919. return false;
  920. printf("OKn");
  921. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
  922. vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1");
  923. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/true)) {
  924. printf("FAILED, returned falsen");
  925. return false;
  926. }
  927. if(!mutils__compare_block(vorbiscomment, block))
  928. return false;
  929. printf("OKn");
  930. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
  931. vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1");
  932. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/true)) {
  933. printf("FAILED, returned falsen");
  934. return false;
  935. }
  936. if(!mutils__compare_block(vorbiscomment, block))
  937. return false;
  938. printf("OKn");
  939. printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
  940. if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name3")) != 1) {
  941. printf("FAILED, expected 1, got %dn", j);
  942. return false;
  943. }
  944. printf("OKn");
  945. printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
  946. if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 4) {
  947. printf("FAILED, expected 4, got %dn", j);
  948. return false;
  949. }
  950. printf("OKn");
  951. printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
  952. if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 5) {
  953. printf("FAILED, expected 5, got %dn", j);
  954. return false;
  955. }
  956. printf("OKn");
  957. printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
  958. if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name2")) != 0) {
  959. printf("FAILED, expected 0, got %dn", j);
  960. return false;
  961. }
  962. printf("OKn");
  963. printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
  964. if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name2")) != -1) {
  965. printf("FAILED, expected -1, got %dn", j);
  966. return false;
  967. }
  968. printf("OKn");
  969. printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
  970. if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "blah")) != -1) {
  971. printf("FAILED, expected -1, got %dn", j);
  972. return false;
  973. }
  974. printf("OKn");
  975. printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, copy)...");
  976. vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false);
  977. if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/true)) {
  978. printf("FAILED, returned falsen");
  979. return false;
  980. }
  981. if(!mutils__compare_block(vorbiscomment, block))
  982. return false;
  983. if(block->data.vorbis_comment.num_comments != 6) {
  984. printf("FAILED, expected 6 comments, got %un", block->data.vorbis_comment.num_comments);
  985. return false;
  986. }
  987. printf("OKn");
  988. printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, copy)...");
  989. vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true);
  990. if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/true)) {
  991. printf("FAILED, returned falsen");
  992. return false;
  993. }
  994. if(!mutils__compare_block(vorbiscomment, block))
  995. return false;
  996. if(block->data.vorbis_comment.num_comments != 4) {
  997. printf("FAILED, expected 4 comments, got %un", block->data.vorbis_comment.num_comments);
  998. return false;
  999. }
  1000. printf("OKn");
  1001. printf("testing FLAC__metadata_object_clone()... ");
  1002. blockcopy = FLAC__metadata_object_clone(block);
  1003. if(0 == blockcopy) {
  1004. printf("FAILED, returned NULLn");
  1005. return false;
  1006. }
  1007. if(!mutils__compare_block(block, blockcopy))
  1008. return false;
  1009. printf("OKn");
  1010. printf("testing FLAC__metadata_object_delete()... ");
  1011. FLAC__metadata_object_delete(blockcopy);
  1012. printf("OKn");
  1013. printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
  1014. vc_delete_(vorbiscomment, 2);
  1015. if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
  1016. printf("FAILED, returned falsen");
  1017. return false;
  1018. }
  1019. if(!mutils__compare_block(vorbiscomment, block))
  1020. return false;
  1021. printf("OKn");
  1022. printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
  1023. vc_delete_(vorbiscomment, 2);
  1024. if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
  1025. printf("FAILED, returned falsen");
  1026. return false;
  1027. }
  1028. if(!mutils__compare_block(vorbiscomment, block))
  1029. return false;
  1030. printf("OKn");
  1031. printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
  1032. vc_delete_(vorbiscomment, 0);
  1033. if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
  1034. printf("FAILED, returned falsen");
  1035. return false;
  1036. }
  1037. if(!mutils__compare_block(vorbiscomment, block))
  1038. return false;
  1039. printf("OKn");
  1040. printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
  1041. vc_insert_new_(&entry, vorbiscomment, 1, "rem0=val0");
  1042. if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
  1043. printf("FAILED, returned falsen");
  1044. return false;
  1045. }
  1046. if(!mutils__compare_block(vorbiscomment, block))
  1047. return false;
  1048. printf("OKn");
  1049. printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
  1050. vc_insert_new_(&entry, vorbiscomment, 2, "rem0=val1");
  1051. if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
  1052. printf("FAILED, returned falsen");
  1053. return false;
  1054. }
  1055. if(!mutils__compare_block(vorbiscomment, block))
  1056. return false;
  1057. printf("OKn");
  1058. printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
  1059. vc_insert_new_(&entry, vorbiscomment, 3, "rem0=val2");
  1060. if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
  1061. printf("FAILED, returned falsen");
  1062. return false;
  1063. }
  1064. if(!mutils__compare_block(vorbiscomment, block))
  1065. return false;
  1066. printf("OKn");
  1067. printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching("blah")...");
  1068. if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "blah")) != 0) {
  1069. printf("FAILED, expected 0, got %dn", j);
  1070. return false;
  1071. }
  1072. if(block->data.vorbis_comment.num_comments != 4) {
  1073. printf("FAILED, expected 4 comments, got %un", block->data.vorbis_comment.num_comments);
  1074. return false;
  1075. }
  1076. if(!mutils__compare_block(vorbiscomment, block))
  1077. return false;
  1078. printf("OKn");
  1079. printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching("rem0")...");
  1080. vc_delete_(vorbiscomment, 1);
  1081. if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "rem0")) != 1) {
  1082. printf("FAILED, expected 1, got %dn", j);
  1083. return false;
  1084. }
  1085. if(block->data.vorbis_comment.num_comments != 3) {
  1086. printf("FAILED, expected 3 comments, got %un", block->data.vorbis_comment.num_comments);
  1087. return false;
  1088. }
  1089. if(!mutils__compare_block(vorbiscomment, block))
  1090. return false;
  1091. printf("OKn");
  1092. printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching("blah")...");
  1093. if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "blah")) != 0) {
  1094. printf("FAILED, expected 0, got %dn", j);
  1095. return false;
  1096. }
  1097. if(block->data.vorbis_comment.num_comments != 3) {
  1098. printf("FAILED, expected 3 comments, got %un", block->data.vorbis_comment.num_comments);
  1099. return false;
  1100. }
  1101. if(!mutils__compare_block(vorbiscomment, block))
  1102. return false;
  1103. printf("OKn");
  1104. printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching("rem0")...");
  1105. vc_delete_(vorbiscomment, 1);
  1106. vc_delete_(vorbiscomment, 1);
  1107. if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "rem0")) != 2) {
  1108. printf("FAILED, expected 2, got %dn", j);
  1109. return false;
  1110. }
  1111. if(block->data.vorbis_comment.num_comments != 1) {
  1112. printf("FAILED, expected 1 comments, got %un", block->data.vorbis_comment.num_comments);
  1113. return false;
  1114. }
  1115. if(!mutils__compare_block(vorbiscomment, block))
  1116. return false;
  1117. printf("OKn");
  1118. printf("testing FLAC__metadata_object_vorbiscomment_set_comment(copy)...");
  1119. vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
  1120. FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/true);
  1121. if(!mutils__compare_block(vorbiscomment, block))
  1122. return false;
  1123. printf("OKn");
  1124. printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(copy)...");
  1125. vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
  1126. FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/true);
  1127. if(!mutils__compare_block(vorbiscomment, block))
  1128. return false;
  1129. printf("OKn");
  1130. printf("testing FLAC__metadata_object_delete()... ");
  1131. FLAC__metadata_object_delete(vorbiscomment);
  1132. FLAC__metadata_object_delete(block);
  1133. printf("OKn");
  1134. printf("testing FLAC__metadata_object_new()... ");
  1135. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
  1136. if(0 == block) {
  1137. printf("FAILED, returned NULLn");
  1138. return false;
  1139. }
  1140. printf("OKn");
  1141. printf("testing FLAC__metadata_object_clone()... ");
  1142. vorbiscomment = FLAC__metadata_object_clone(block);
  1143. if(0 == vorbiscomment) {
  1144. printf("FAILED, returned NULLn");
  1145. return false;
  1146. }
  1147. if(!mutils__compare_block(vorbiscomment, block))
  1148. return false;
  1149. printf("OKn");
  1150. printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on empty array...");
  1151. vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
  1152. entry_clone_(&entry);
  1153. if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) {
  1154. printf("FAILED, returned falsen");
  1155. return false;
  1156. }
  1157. if(!mutils__compare_block(vorbiscomment, block))
  1158. return false;
  1159. printf("OKn");
  1160. printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on non-empty array...");
  1161. vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2");
  1162. entry_clone_(&entry);
  1163. if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) {
  1164. printf("FAILED, returned falsen");
  1165. return false;
  1166. }
  1167. if(!mutils__compare_block(vorbiscomment, block))
  1168. return false;
  1169. printf("OKn");
  1170. printf("testing FLAC__metadata_object_delete()... ");
  1171. FLAC__metadata_object_delete(vorbiscomment);
  1172. FLAC__metadata_object_delete(block);
  1173. printf("OKn");
  1174. printf("testing FLAC__metadata_object_new()... ");
  1175. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
  1176. if(0 == block) {
  1177. printf("FAILED, returned NULLn");
  1178. return false;
  1179. }
  1180. printf("OKn");
  1181. printf("testing FLAC__metadata_object_clone()... ");
  1182. vorbiscomment = FLAC__metadata_object_clone(block);
  1183. if(0 == vorbiscomment) {
  1184. printf("FAILED, returned NULLn");
  1185. return false;
  1186. }
  1187. if(!mutils__compare_block(vorbiscomment, block))
  1188. return false;
  1189. printf("OKn");
  1190. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on empty array...");
  1191. vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
  1192. entry_clone_(&entry);
  1193. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
  1194. printf("FAILED, returned falsen");
  1195. return false;
  1196. }
  1197. if(!mutils__compare_block(vorbiscomment, block))
  1198. return false;
  1199. printf("OKn");
  1200. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on beginning of non-empty array...");
  1201. vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
  1202. entry_clone_(&entry);
  1203. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
  1204. printf("FAILED, returned falsen");
  1205. return false;
  1206. }
  1207. if(!mutils__compare_block(vorbiscomment, block))
  1208. return false;
  1209. printf("OKn");
  1210. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on middle of non-empty array...");
  1211. vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
  1212. entry_clone_(&entry);
  1213. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/false)) {
  1214. printf("FAILED, returned falsen");
  1215. return false;
  1216. }
  1217. if(!mutils__compare_block(vorbiscomment, block))
  1218. return false;
  1219. printf("OKn");
  1220. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
  1221. vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
  1222. entry_clone_(&entry);
  1223. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/false)) {
  1224. printf("FAILED, returned falsen");
  1225. return false;
  1226. }
  1227. if(!mutils__compare_block(vorbiscomment, block))
  1228. return false;
  1229. printf("OKn");
  1230. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
  1231. vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1");
  1232. entry_clone_(&entry);
  1233. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/false)) {
  1234. printf("FAILED, returned falsen");
  1235. return false;
  1236. }
  1237. if(!mutils__compare_block(vorbiscomment, block))
  1238. return false;
  1239. printf("OKn");
  1240. printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
  1241. vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1");
  1242. entry_clone_(&entry);
  1243. if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/false)) {
  1244. printf("FAILED, returned falsen");
  1245. return false;
  1246. }
  1247. if(!mutils__compare_block(vorbiscomment, block))
  1248. return false;
  1249. printf("OKn");
  1250. printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, own)...");
  1251. vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false);
  1252. entry_clone_(&entry);
  1253. if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/false)) {
  1254. printf("FAILED, returned falsen");
  1255. return false;
  1256. }
  1257. if(!mutils__compare_block(vorbiscomment, block))
  1258. return false;
  1259. if(block->data.vorbis_comment.num_comments != 6) {
  1260. printf("FAILED, expected 6 comments, got %un", block->data.vorbis_comment.num_comments);
  1261. return false;
  1262. }
  1263. printf("OKn");
  1264. printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, own)...");
  1265. vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true);
  1266. entry_clone_(&entry);
  1267. if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/false)) {
  1268. printf("FAILED, returned falsen");
  1269. return false;
  1270. }
  1271. if(!mutils__compare_block(vorbiscomment, block))
  1272. return false;
  1273. if(block->data.vorbis_comment.num_comments != 4) {
  1274. printf("FAILED, expected 4 comments, got %un", block->data.vorbis_comment.num_comments);
  1275. return false;
  1276. }
  1277. printf("OKn");
  1278. printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
  1279. vc_delete_(vorbiscomment, 2);
  1280. if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
  1281. printf("FAILED, returned falsen");
  1282. return false;
  1283. }
  1284. if(!mutils__compare_block(vorbiscomment, block))
  1285. return false;
  1286. printf("OKn");
  1287. printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
  1288. vc_delete_(vorbiscomment, 2);
  1289. if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
  1290. printf("FAILED, returned falsen");
  1291. return false;
  1292. }
  1293. if(!mutils__compare_block(vorbiscomment, block))
  1294. return false;
  1295. printf("OKn");
  1296. printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
  1297. vc_delete_(vorbiscomment, 0);
  1298. if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
  1299. printf("FAILED, returned falsen");
  1300. return false;
  1301. }
  1302. if(!mutils__compare_block(vorbiscomment, block))
  1303. return false;
  1304. printf("OKn");
  1305. printf("testing FLAC__metadata_object_vorbiscomment_set_comment(own)...");
  1306. vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
  1307. entry_clone_(&entry);
  1308. FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/false);
  1309. if(!mutils__compare_block(vorbiscomment, block))
  1310. return false;
  1311. printf("OKn");
  1312. printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(own)...");
  1313. vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
  1314. entry_clone_(&entry);
  1315. FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/false);
  1316. if(!mutils__compare_block(vorbiscomment, block))
  1317. return false;
  1318. printf("OKn");
  1319. printf("testing FLAC__metadata_object_delete()... ");
  1320. FLAC__metadata_object_delete(vorbiscomment);
  1321. FLAC__metadata_object_delete(block);
  1322. printf("OKn");
  1323. printf("testing CUESHEETn");
  1324. {
  1325. FLAC__StreamMetadata_CueSheet_Track *track_, *trackcopy_;
  1326. printf("testing FLAC__metadata_object_cuesheet_track_new()... ");
  1327. track_ = FLAC__metadata_object_cuesheet_track_new();
  1328. if(0 == track_) {
  1329. printf("FAILED, returned NULLn");
  1330. return false;
  1331. }
  1332. printf("OKn");
  1333. printf("testing FLAC__metadata_object_cuesheet_track_clone()... ");
  1334. trackcopy_ = FLAC__metadata_object_cuesheet_track_clone(track_);
  1335. if(0 == trackcopy_) {
  1336. printf("FAILED, returned NULLn");
  1337. return false;
  1338. }
  1339. if(!compare_track_(trackcopy_, track_))
  1340. return false;
  1341. printf("OKn");
  1342. printf("testing FLAC__metadata_object_cuesheet_track_delete()... ");
  1343. FLAC__metadata_object_cuesheet_track_delete(trackcopy_);
  1344. FLAC__metadata_object_cuesheet_track_delete(track_);
  1345. printf("OKn");
  1346. }
  1347. printf("testing FLAC__metadata_object_new()... ");
  1348. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
  1349. if(0 == block) {
  1350. printf("FAILED, returned NULLn");
  1351. return false;
  1352. }
  1353. expected_length = (
  1354. FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
  1355. FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
  1356. FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
  1357. FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
  1358. FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
  1359. ) / 8;
  1360. if(block->length != expected_length) {
  1361. printf("FAILED, bad length, expected %u, got %un", expected_length, block->length);
  1362. return false;
  1363. }
  1364. printf("OKn");
  1365. printf("testing FLAC__metadata_object_clone()... ");
  1366. cuesheet = FLAC__metadata_object_clone(block);
  1367. if(0 == cuesheet) {
  1368. printf("FAILED, returned NULLn");
  1369. return false;
  1370. }
  1371. if(!mutils__compare_block(cuesheet, block))
  1372. return false;
  1373. printf("OKn");
  1374. cs_resize_(cuesheet, 2);
  1375. printf("testing FLAC__metadata_object_cuesheet_resize_tracks(grow to %u)...", cuesheet->data.cue_sheet.num_tracks);
  1376. if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
  1377. printf("FAILED, returned falsen");
  1378. return false;
  1379. }
  1380. if(!mutils__compare_block(cuesheet, block))
  1381. return false;
  1382. printf("OKn");
  1383. cs_resize_(cuesheet, 1);
  1384. printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
  1385. if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
  1386. printf("FAILED, returned falsen");
  1387. return false;
  1388. }
  1389. if(!mutils__compare_block(cuesheet, block))
  1390. return false;
  1391. printf("OKn");
  1392. cs_resize_(cuesheet, 0);
  1393. printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
  1394. if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
  1395. printf("FAILED, returned falsen");
  1396. return false;
  1397. }
  1398. if(!mutils__compare_block(cuesheet, block))
  1399. return false;
  1400. printf("OKn");
  1401. printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on empty array...");
  1402. cs_insert_new_(&track, cuesheet, 0, 0, 1, "ABCDE1234567", false, false);
  1403. if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
  1404. printf("FAILED, returned falsen");
  1405. return false;
  1406. }
  1407. if(!mutils__compare_block(cuesheet, block))
  1408. return false;
  1409. printf("OKn");
  1410. printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on beginning of non-empty array...");
  1411. cs_insert_new_(&track, cuesheet, 0, 10, 2, "BBCDE1234567", false, false);
  1412. if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
  1413. printf("FAILED, returned falsen");
  1414. return false;
  1415. }
  1416. if(!mutils__compare_block(cuesheet, block))
  1417. return false;
  1418. printf("OKn");
  1419. printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on middle of non-empty array...");
  1420. cs_insert_new_(&track, cuesheet, 1, 20, 3, "CBCDE1234567", false, false);
  1421. if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/true)) {
  1422. printf("FAILED, returned falsen");
  1423. return false;
  1424. }
  1425. if(!mutils__compare_block(cuesheet, block))
  1426. return false;
  1427. printf("OKn");
  1428. printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on end of non-empty array...");
  1429. cs_insert_new_(&track, cuesheet, 3, 30, 4, "DBCDE1234567", false, false);
  1430. if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/true)) {
  1431. printf("FAILED, returned falsen");
  1432. return false;
  1433. }
  1434. if(!mutils__compare_block(cuesheet, block))
  1435. return false;
  1436. printf("OKn");
  1437. printf("testing FLAC__metadata_object_cuesheet_insert_blank_track() on end of non-empty array...");
  1438. cs_insert_new_(&track, cuesheet, 4, 0, 0, "", false, false);
  1439. if(!FLAC__metadata_object_cuesheet_insert_blank_track(block, 4)) {
  1440. printf("FAILED, returned falsen");
  1441. return false;
  1442. }
  1443. if(!mutils__compare_block(cuesheet, block))
  1444. return false;
  1445. printf("OKn");
  1446. printf("testing FLAC__metadata_object_clone()... ");
  1447. blockcopy = FLAC__metadata_object_clone(block);
  1448. if(0 == blockcopy) {
  1449. printf("FAILED, returned NULLn");
  1450. return false;
  1451. }
  1452. if(!mutils__compare_block(block, blockcopy))
  1453. return false;
  1454. printf("OKn");
  1455. printf("testing FLAC__metadata_object_delete()... ");
  1456. FLAC__metadata_object_delete(blockcopy);
  1457. printf("OKn");
  1458. printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
  1459. cs_delete_(cuesheet, 4);
  1460. if(!FLAC__metadata_object_cuesheet_delete_track(block, 4)) {
  1461. printf("FAILED, returned falsen");
  1462. return false;
  1463. }
  1464. if(!mutils__compare_block(cuesheet, block))
  1465. return false;
  1466. printf("OKn");
  1467. printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
  1468. cs_delete_(cuesheet, 2);
  1469. if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
  1470. printf("FAILED, returned falsen");
  1471. return false;
  1472. }
  1473. if(!mutils__compare_block(cuesheet, block))
  1474. return false;
  1475. printf("OKn");
  1476. printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
  1477. cs_delete_(cuesheet, 2);
  1478. if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
  1479. printf("FAILED, returned falsen");
  1480. return false;
  1481. }
  1482. if(!mutils__compare_block(cuesheet, block))
  1483. return false;
  1484. printf("OKn");
  1485. printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
  1486. cs_delete_(cuesheet, 0);
  1487. if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
  1488. printf("FAILED, returned falsen");
  1489. return false;
  1490. }
  1491. if(!mutils__compare_block(cuesheet, block))
  1492. return false;
  1493. printf("OKn");
  1494. printf("testing FLAC__metadata_object_cuesheet_set_track(copy)...");
  1495. cs_set_new_(&track, cuesheet, 0, 40, 5, "EBCDE1234567", false, false);
  1496. FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/true);
  1497. if(!mutils__compare_block(cuesheet, block))
  1498. return false;
  1499. printf("OKn");
  1500. tr_resize_(cuesheet, 0, 2);
  1501. printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(grow to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
  1502. if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
  1503. printf("FAILED, returned falsen");
  1504. return false;
  1505. }
  1506. if(!mutils__compare_block(cuesheet, block))
  1507. return false;
  1508. printf("OKn");
  1509. tr_resize_(cuesheet, 0, 1);
  1510. printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
  1511. if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
  1512. printf("FAILED, returned falsen");
  1513. return false;
  1514. }
  1515. if(!mutils__compare_block(cuesheet, block))
  1516. return false;
  1517. printf("OKn");
  1518. tr_resize_(cuesheet, 0, 0);
  1519. printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
  1520. if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
  1521. printf("FAILED, returned falsen");
  1522. return false;
  1523. }
  1524. if(!mutils__compare_block(cuesheet, block))
  1525. return false;
  1526. printf("OKn");
  1527. index.offset = 0;
  1528. index.number = 1;
  1529. printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on empty array...");
  1530. tr_insert_new_(cuesheet, 0, 0, index);
  1531. if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) {
  1532. printf("FAILED, returned falsen");
  1533. return false;
  1534. }
  1535. if(!mutils__compare_block(cuesheet, block))
  1536. return false;
  1537. printf("OKn");
  1538. index.offset = 10;
  1539. index.number = 2;
  1540. printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on beginning of non-empty array...");
  1541. tr_insert_new_(cuesheet, 0, 0, index);
  1542. if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) {
  1543. printf("FAILED, returned falsen");
  1544. return false;
  1545. }
  1546. if(!mutils__compare_block(cuesheet, block))
  1547. return false;
  1548. printf("OKn");
  1549. index.offset = 20;
  1550. index.number = 3;
  1551. printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on middle of non-empty array...");
  1552. tr_insert_new_(cuesheet, 0, 1, index);
  1553. if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 1, index)) {
  1554. printf("FAILED, returned falsen");
  1555. return false;
  1556. }
  1557. if(!mutils__compare_block(cuesheet, block))
  1558. return false;
  1559. printf("OKn");
  1560. index.offset = 30;
  1561. index.number = 4;
  1562. printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on end of non-empty array...");
  1563. tr_insert_new_(cuesheet, 0, 3, index);
  1564. if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 3, index)) {
  1565. printf("FAILED, returned falsen");
  1566. return false;
  1567. }
  1568. if(!mutils__compare_block(cuesheet, block))
  1569. return false;
  1570. printf("OKn");
  1571. index.offset = 0;
  1572. index.number = 0;
  1573. printf("testing FLAC__metadata_object_cuesheet_track_insert_blank_index() on end of non-empty array...");
  1574. tr_insert_new_(cuesheet, 0, 4, index);
  1575. if(!FLAC__metadata_object_cuesheet_track_insert_blank_index(block, 0, 4)) {
  1576. printf("FAILED, returned falsen");
  1577. return false;
  1578. }
  1579. if(!mutils__compare_block(cuesheet, block))
  1580. return false;
  1581. printf("OKn");
  1582. printf("testing FLAC__metadata_object_clone()... ");
  1583. blockcopy = FLAC__metadata_object_clone(block);
  1584. if(0 == blockcopy) {
  1585. printf("FAILED, returned NULLn");
  1586. return false;
  1587. }
  1588. if(!mutils__compare_block(block, blockcopy))
  1589. return false;
  1590. printf("OKn");
  1591. printf("testing FLAC__metadata_object_delete()... ");
  1592. FLAC__metadata_object_delete(blockcopy);
  1593. printf("OKn");
  1594. printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array...");
  1595. tr_delete_(cuesheet, 0, 4);
  1596. if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 4)) {
  1597. printf("FAILED, returned falsen");
  1598. return false;
  1599. }
  1600. if(!mutils__compare_block(cuesheet, block))
  1601. return false;
  1602. printf("OKn");
  1603. printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on middle of array...");
  1604. tr_delete_(cuesheet, 0, 2);
  1605. if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
  1606. printf("FAILED, returned falsen");
  1607. return false;
  1608. }
  1609. if(!mutils__compare_block(cuesheet, block))
  1610. return false;
  1611. printf("OKn");
  1612. printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array...");
  1613. tr_delete_(cuesheet, 0, 2);
  1614. if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
  1615. printf("FAILED, returned falsen");
  1616. return false;
  1617. }
  1618. if(!mutils__compare_block(cuesheet, block))
  1619. return false;
  1620. printf("OKn");
  1621. printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on beginning of array...");
  1622. tr_delete_(cuesheet, 0, 0);
  1623. if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 0)) {
  1624. printf("FAILED, returned falsen");
  1625. return false;
  1626. }
  1627. if(!mutils__compare_block(cuesheet, block))
  1628. return false;
  1629. printf("OKn");
  1630. printf("testing FLAC__metadata_object_delete()... ");
  1631. FLAC__metadata_object_delete(cuesheet);
  1632. FLAC__metadata_object_delete(block);
  1633. printf("OKn");
  1634. printf("testing FLAC__metadata_object_new()... ");
  1635. block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
  1636. if(0 == block) {
  1637. printf("FAILED, returned NULLn");
  1638. return false;
  1639. }
  1640. printf("OKn");
  1641. printf("testing FLAC__metadata_object_clone()... ");
  1642. cuesheet = FLAC__metadata_object_clone(block);
  1643. if(0 == cuesheet) {
  1644. printf("FAILED, returned NULLn");
  1645. return false;
  1646. }
  1647. if(!mutils__compare_block(cuesheet, block))
  1648. return false;
  1649. printf("OKn");
  1650. printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on empty array...");
  1651. cs_insert_new_(&track, cuesheet, 0, 60, 7, "GBCDE1234567", false, false);
  1652. track_clone_(&track);
  1653. if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
  1654. printf("FAILED, returned falsen");
  1655. return false;
  1656. }
  1657. if(!mutils__compare_block(cuesheet, block))
  1658. return false;
  1659. printf("OKn");
  1660. printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on beginning of non-empty array...");
  1661. cs_insert_new_(&track, cuesheet, 0, 70, 8, "HBCDE1234567", false, false);
  1662. track_clone_(&track);
  1663. if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
  1664. printf("FAILED, returned falsen");
  1665. return false;
  1666. }
  1667. if(!mutils__compare_block(cuesheet, block))
  1668. return false;
  1669. printf("OKn");
  1670. printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on middle of non-empty array...");
  1671. cs_insert_new_(&track, cuesheet, 1, 80, 9, "IBCDE1234567", false, false);
  1672. track_clone_(&track);
  1673. if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/false)) {
  1674. printf("FAILED, returned falsen");
  1675. return false;
  1676. }
  1677. if(!mutils__compare_block(cuesheet, block))
  1678. return false;
  1679. printf("OKn");
  1680. printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on end of non-empty array...");
  1681. cs_insert_new_(&track, cuesheet, 3, 90, 10, "JBCDE1234567", false, false);
  1682. track_clone_(&track);
  1683. if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/false)) {
  1684. printf("FAILED, returned falsen");
  1685. return false;
  1686. }
  1687. if(!mutils__compare_block(cuesheet, block))
  1688. return false;
  1689. printf("OKn");
  1690. printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
  1691. cs_delete_(cuesheet, 2);
  1692. if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
  1693. printf("FAILED, returned falsen");
  1694. return false;
  1695. }
  1696. if(!mutils__compare_block(cuesheet, block))
  1697. return false;
  1698. printf("OKn");
  1699. printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
  1700. cs_delete_(cuesheet, 2);
  1701. if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
  1702. printf("FAILED, returned falsen");
  1703. return false;
  1704. }
  1705. if(!mutils__compare_block(cuesheet, block))
  1706. return false;
  1707. printf("OKn");
  1708. printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
  1709. cs_delete_(cuesheet, 0);
  1710. if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
  1711. printf("FAILED, returned falsen");
  1712. return false;
  1713. }
  1714. if(!mutils__compare_block(cuesheet, block))
  1715. return false;
  1716. printf("OKn");
  1717. printf("testing FLAC__metadata_object_cuesheet_set_track(own)...");
  1718. cs_set_new_(&track, cuesheet, 0, 100, 11, "KBCDE1234567", false, false);
  1719. track_clone_(&track);
  1720. FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/false);
  1721. if(!mutils__compare_block(cuesheet, block))
  1722. return false;
  1723. printf("OKn");
  1724. printf("testing FLAC__metadata_object_cuesheet_is_legal()...");
  1725. {
  1726. const char *violation;
  1727. if(FLAC__metadata_object_cuesheet_is_legal(block, /*check_cd_da_subset=*/true, &violation)) {
  1728. printf("FAILED, returned true when expecting falsen");
  1729. return false;
  1730. }
  1731. printf("returned false as expected, violation="%s" OKn", violation);
  1732. }
  1733. printf("testing FLAC__metadata_object_delete()... ");
  1734. FLAC__metadata_object_delete(cuesheet);
  1735. FLAC__metadata_object_delete(block);
  1736. printf("OKn");
  1737. return true;
  1738. }