开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
metadata_object.cpp
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：63k
源码类别：

Windows CE

开发平台：

C/C++

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