gemba 0.1.1 → 0.2.0

data/vendor/rcheevos/test/rhash/test_cdreader.c

@@ -0,0 +1,920 @@
+#include "rc_hash.h"
+
+#include "../rc_compat.h"
+#include "../src/rhash/rc_hash_internal.h"
+#include "../test_framework.h"
+#include "data.h"
+#include "mock_filereader.h"
+
+#include <stdlib.h>
+
+static const uint8_t sync_pattern[] = {
+  0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00
+};
+
+static char cue_single_track[] =
+  "FILE \"game.bin\" BINARY\n"
+  "  TRACK 01 MODE2/2352\n"
+  "    INDEX 01 00:00:00\n";
+
+static char cue_single_bin_multiple_data[] =
+  "FILE \"game.bin\" BINARY\n"
+  "  TRACK 01 AUDIO\n"
+  "    INDEX 01 00:00:00\n"
+  "  TRACK 02 MODE1/2352\n"
+  "    PREGAP 00:03:00\n"
+  "    INDEX 01 00:55:45\n"
+  "  TRACK 03 MODE1/2352\n"
+  "    INDEX 01 11:30:74\n"
+  "  TRACK 04 MODE1/2352\n"
+  "    INDEX 01 13:31:51\n"
+  "  TRACK 05 MODE1/2352\n"
+  "    INDEX 01 13:48:56\n"
+  "  TRACK 06 MODE1/2352\n"
+  "    INDEX 01 34:48:19\n"
+  "  TRACK 07 MODE1/2352\n"
+  "    INDEX 01 50:42:74\n"
+  "  TRACK 08 MODE1/2352\n"
+  "    INDEX 01 55:20:74\n"
+  "  TRACK 09 MODE1/2352\n"
+  "    INDEX 01 56:25:67\n"
+  "  TRACK 10 MODE1/2352\n"
+  "    INDEX 01 59:04:08\n"
+  "  TRACK 11 MODE1/2352\n"
+  "    INDEX 01 61:17:18\n"
+  "  TRACK 12 MODE1/2352\n"
+  "    INDEX 01 62:44:33\n"
+  "  TRACK 13 AUDIO\n"
+  "    PREGAP 00:02:00\n"
+  "    INDEX 01 66:24:37\n";
+
+static char cue_multiple_bin_multiple_data[] =
+  "FILE \"track1.bin\" BINARY\n"
+  "  TRACK 01 AUDIO\n"
+  "    INDEX 01 00:00:00\n"
+  "FILE \"track2.bin\" BINARY\n"
+  "  TRACK 02 MODE1/2352\n"
+  "    INDEX 00 00:00:00\n"
+  "    INDEX 01 00:03:00\n"
+  "FILE \"track3.bin\" BINARY\n"
+  "  TRACK 03 MODE1/2352\n"
+  "    INDEX 00 00:00:00\n"
+  "    INDEX 01 00:02:00\n"
+  "FILE \"track4.bin\" BINARY\n"
+  "  TRACK 04 AUDIO\n"
+  "    INDEX 00 00:00:00\n";
+
+static char gdi_three_tracks[] =
+  "3\n"
+  "1 0 4 2352 track01.bin 0\n"
+  "2 600 0 2352 track02.raw 0\n"
+  "3 45000 4 2352 track03.bin 0";
+
+static char gdi_many_tracks[] =
+  "26\n"
+  "1 0 4 2352 track01.bin 0\n"
+  "2 450 0 2352 track02.raw 0\n"
+  "3 45000 4 2352 track03.bin 0\n"
+  "4 370673 0 2352 track04.raw 0\n"
+  "5 371347 0 2352 track05.raw 0\n"
+  "6 372014 0 2352 track06.raw 0\n"
+  "7 372915 0 2352 track07.raw 0\n"
+  "8 373626 0 2352 track08.raw 0\n"
+  "9 379011 0 2352 track09.raw 0\n"
+  "10 384738 0 2352 track10.raw 0\n"
+  "11 390481 0 2352 track11.raw 0\n"
+  "12 395473 0 2352 track12.raw 0\n"
+  "13 398926 0 2352 track13.raw 0\n"
+  "14 404448 0 2352 track14.raw 0\n"
+  "15 425246 0 2352 track15.raw 0\n"
+  "16 445520 0 2352 track16.raw 0\n"
+  "17 466032 0 2352 track17.raw 0\n"
+  "18 474231 0 2352 track18.raw 0\n"
+  "19 485598 0 2352 track19.raw 0\n"
+  "20 486386 0 2352 track20.raw 0\n"
+  "21 487098 0 2352 track21.raw 0\n"
+  "22 487822 0 2352 track22.raw 0\n"
+  "23 498356 0 2352 track23.raw 0\n"
+  "24 508297 0 2352 track24.raw 0\n"
+  "25 527383 0 2352 track25.raw 0\n"
+  "26 548106 4 2352 track26.bin 0\n";
+
+static void initialize_iterator(rc_hash_iterator_t* iterator)
+{
+  memset(iterator, 0, sizeof(*iterator));
+  rc_hash_get_default_cdreader(&iterator->callbacks.cdreader);
+  get_mock_filereader(&iterator->callbacks.filereader);
+}
+
+static rc_hash_cdrom_track_t* open_track(rc_hash_iterator_t* iterator, const char* path, uint32_t index)
+{
+  return (rc_hash_cdrom_track_t*)iterator->callbacks.cdreader.open_track_iterator(path, index, iterator);
+}
+
+static void close_track(rc_hash_iterator_t* iterator, rc_hash_cdrom_track_t* track_handle)
+{
+  iterator->callbacks.cdreader.close_track(track_handle);
+}
+
+static void test_open_cue_track_2()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_bin_multiple_data);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  track_handle = open_track(&iterator, "game.cue", 2);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 9807840); /* track 2: 0x95A7E0 */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_12()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_bin_multiple_data);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  track_handle = open_track(&iterator, "game.cue", 12);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 664047216); /* track 12: 0x27948E70 */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_14()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_bin_multiple_data);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  /* only 13 tracks */
+  track_handle = open_track(&iterator, "game.cue", 14);
+  ASSERT_PTR_NULL(track_handle);
+}
+
+static void test_open_cue_track_missing_bin()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_bin_multiple_data);
+
+  track_handle = open_track(&iterator, "game.cue", 2);
+  ASSERT_PTR_NULL(track_handle);
+}
+
+static void test_open_gdi_track_3()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.gdi", gdi_three_tracks);
+  mock_empty_file(1, "track03.bin", 1185760800);
+
+  track_handle = open_track(&iterator, "game.gdi", 3);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "track03.bin");
+  ASSERT_NUM64_EQUALS(track_handle->track_pregap_sectors, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_first_sector, 45000);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_gdi_track_3_quoted()
+{
+  const char gdi_contents[] =
+	  "3\n"
+	  "1 0 4 2352 \"track 01.bin\" 0\n"
+	  "2 600 0 2352 \"track 02.raw\" 0\n"
+	  "3 45000 4 2352 \"track 03.bin\" 0";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.gdi", gdi_contents);
+  mock_empty_file(1, "track 03.bin", 1185760800);
+
+  track_handle = open_track(&iterator, "game.gdi", 3);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "track 03.bin");
+  ASSERT_NUM64_EQUALS(track_handle->track_pregap_sectors, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_first_sector, 45000);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_gdi_track_3_extra_whitespace()
+{
+  const char gdi_contents[] =
+	  "3\n\n"
+	  "  1       0   4   2352   \"track 01.bin\"   0\n\n"
+	  "  2     600   0   2352   \"track 02.raw\"   0\n\n"
+	  "  3   45000   4   2352   \"track 03.bin\"   0\n\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.gdi", gdi_contents);
+  mock_empty_file(1, "track 03.bin", 1185760800);
+
+  track_handle = open_track(&iterator, "game.gdi", 3);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "track 03.bin");
+  ASSERT_NUM64_EQUALS(track_handle->track_pregap_sectors, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_first_sector, 45000);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_gdi_track_last()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.gdi", gdi_many_tracks);
+  mock_empty_file(1, "track26.bin", 2457600);
+
+  track_handle = open_track(&iterator, "game.gdi", RC_HASH_CDTRACK_LAST);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "track26.bin");
+  ASSERT_NUM64_EQUALS(track_handle->track_pregap_sectors, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_first_sector, 548106);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_bin_multiple_data);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  track_handle = open_track(&iterator, "game.cue", RC_HASH_CDTRACK_LARGEST);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 146190912); /* track 5: 0x8B6B240 */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data_multiple_bin()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_multiple_bin_multiple_data);
+  mock_empty_file(1, "track2.bin", 406423248);
+  mock_empty_file(2, "track3.bin", 11553024);
+
+  track_handle = open_track(&iterator, "game.cue", RC_HASH_CDTRACK_LARGEST);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "track2.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 225); /* INDEX 01 00:03:00 */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data_backwards_compatibility()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_bin_multiple_data);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  /* before defining the enum, 0 meant largest */
+  track_handle = open_track(&iterator, "game.cue", 0);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 146190912); /* track 5: 0x8B6B240 */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data_last_track()
+{
+  const char cue[] =
+	  "FILE \"game.bin\" BINARY\n"
+	  "  TRACK 01 AUDIO\n"
+	  "    INDEX 01 00:00:00\n"
+	  "  TRACK 02 MODE1/2352\n"
+	  "    PREGAP 00:03:00\n"
+	  "    INDEX 01 00:55:45\n"
+	  "  TRACK 03 MODE1/2352\n"
+	  "    INDEX 01 11:30:74\n"
+	  "  TRACK 04 MODE1/2352\n"
+	  "    INDEX 01 13:31:51\n"
+	  "  TRACK 05 MODE1/2352\n"
+	  "    INDEX 01 13:48:56\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  track_handle = open_track(&iterator, "game.cue", RC_HASH_CDTRACK_LARGEST);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 146190912); /* track 5: 0x8B6B240 (13:48:56) */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data_index0s()
+{
+  const char cue[] =
+	  "FILE \"game.bin\" BINARY\n"
+	  "  TRACK 01 AUDIO\n"
+	  "    INDEX 01 00:00:00\n"
+	  "  TRACK 02 MODE1/2352\n"
+	  "    INDEX 00 00:44:65\n"
+	  "    INDEX 01 00:47:65\n"
+	  "  TRACK 03 AUDIO\n"
+	  "    INDEX 00 01:19:52\n"
+	  "    INDEX 01 01:21:52\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  track_handle = open_track(&iterator, "game.cue", RC_HASH_CDTRACK_LARGEST);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 7914480); /* track 2: 0x78C3F0 (00:44:65) */
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 225);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data_index2()
+{
+  const char cue[] =
+	  "FILE \"game.bin\" BINARY\n"
+	  "  TRACK 01 AUDIO\n"
+	  "    INDEX 01 00:00:00\n"
+	  "  TRACK 02 MODE1/2352\n"
+	  "    INDEX 00 00:00:00\n"
+	  "    INDEX 01 00:02:00\n"
+	  "    INDEX 02 00:08:64\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  track_handle = open_track(&iterator, "game.cue", RC_HASH_CDTRACK_LARGEST);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 150); /* 00:02:00 = 150 frames in */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data_multiple_bins()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_multiple_bin_multiple_data);
+  mock_empty_file(1, "track1.bin", 4132464);
+  mock_empty_file(2, "track2.bin", 30080102);
+  mock_empty_file(3, "track3.bin", 40343152);
+  mock_empty_file(4, "track4.bin", 47277552);
+
+  track_handle = open_track(&iterator, "game.cue", 0);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "track3.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 150); /* 00:02:00 = 150 frames in */
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_open_cue_track_largest_data_only_audio()
+{
+  const char cue[] =
+    "FILE \"track1.bin\" BINARY\n"
+    "  TRACK 01 AUDIO\n"
+    "    INDEX 01 00:00:00\n"
+    "FILE \"track2.bin\" BINARY\n"
+    "  TRACK 02 AUDIO\n"
+    "    INDEX 00 00:00:00\n"
+    "    INDEX 01 00:03:00\n"
+    "FILE \"track3.bin\" BINARY\n"
+    "  TRACK 03 AUDIO\n"
+    "    INDEX 00 00:00:00\n"
+    "    INDEX 01 00:02:00\n"
+    "FILE \"track4.bin\" BINARY\n"
+    "  TRACK 04 AUDIO\n"
+    "    INDEX 00 00:00:00\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue);
+  mock_empty_file(1, "track1.bin", 4132464);
+  mock_empty_file(2, "track2.bin", 30080102);
+  mock_empty_file(3, "track3.bin", 40343152);
+  mock_empty_file(4, "track4.bin", 47277552);
+
+  track_handle = open_track(&iterator, "game.cue", 0);
+  ASSERT_PTR_NULL(track_handle);
+}
+
+static void test_open_cue_track_first_data()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_bin_multiple_data);
+  mock_empty_file(1, "game.bin", 718310208);
+
+  track_handle = open_track(&iterator, "game.cue", RC_HASH_CDTRACK_FIRST_DATA);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 9807840); /* track 2: 0x0095a7e0 (00:55:45) */
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 0);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_determine_sector_size_sync(int sector_size)
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+
+  const size_t image_size = (size_t)sector_size * 32;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_track);
+  mock_file(1, "game.bin", image, image_size);
+
+  memset(image, 0, image_size);
+  memcpy(&image[sector_size * 16], sync_pattern, sizeof(sync_pattern));
+
+  track_handle = open_track(&iterator, "game.cue", 1);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, sector_size);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+static void test_determine_sector_size_sync_primary_volume_descriptor(int sector_size)
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+
+  const size_t image_size = (size_t)sector_size * 32;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_track);
+  mock_file(1, "game.bin", image, image_size);
+
+  memset(image, 0, image_size);
+  memcpy(&image[sector_size * 16], sync_pattern, sizeof(sync_pattern));
+  memcpy(&image[sector_size * 16 + 25], "CD001", 5);
+
+  track_handle = open_track(&iterator, "game.cue", 1);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, sector_size);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 24);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+static void test_determine_sector_size_sync_primary_volume_descriptor_index0(int sector_size)
+{
+  char cue[] =
+    "FILE \"game.bin\" BINARY\n"
+    "  TRACK 01 MODE2/2352\n"
+    "    INDEX 00 00:00:00\n"
+    "    INDEX 01 00:02:00\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+
+  const size_t image_size = (size_t)sector_size * 200;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue);
+  mock_file(1, "game.bin", image, image_size);
+
+  char sector_size_str[16];
+  snprintf(sector_size_str, sizeof(sector_size_str), "%d", sector_size);
+  memcpy(&cue[40], sector_size_str, 4);
+
+  memset(image, 0, image_size);
+  memcpy(&image[sector_size * (150 + 16)], sync_pattern, sizeof(sync_pattern));
+  memcpy(&image[sector_size * (150 + 16) + 25], "CD001", 5);
+
+  track_handle = open_track(&iterator, "game.cue", 1);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 150);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, sector_size);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 24);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+static void test_determine_sector_size_sync_2048()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  const int sector_size = 2048;
+  const size_t image_size = (size_t)sector_size * 32;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_track);
+  mock_file(1, "game.bin", image, image_size);
+
+  memset(image, 0, image_size);
+
+  /* 2048 byte sectors don't have a sync pattern - will use mode specified in header */
+  track_handle = open_track(&iterator, "game.cue", 1);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 24);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+static void test_determine_sector_size_sync_primary_volume_descriptor_2048()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  const int sector_size = 2048;
+  const size_t image_size = (size_t)sector_size * 32;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_track);
+  mock_file(1, "game.bin", image, image_size);
+
+  memset(image, 0, image_size);
+  memcpy(&image[sector_size * 16 + 1], "CD001", 5);
+
+  track_handle = open_track(&iterator, "game.cue", 1);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, sector_size);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 0);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+static void test_determine_sector_size_sync_primary_volume_descriptor_index0_2048()
+{
+  char cue[] =
+    "FILE \"game.bin\" BINARY\n"
+    "  TRACK 01 MODE1/2048\n"
+    "    INDEX 00 00:00:00\n"
+    "    INDEX 01 00:02:00\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+
+  const int sector_size = 2048;
+  const size_t image_size = (size_t)sector_size * 200;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue);
+  mock_file(1, "game.bin", image, image_size);
+
+  char sector_size_str[16];
+  snprintf(sector_size_str, sizeof(sector_size_str), "%d", sector_size);
+  memcpy(&cue[40], sector_size_str, 4);
+
+  memset(image, 0, image_size);
+  memcpy(&image[sector_size * (150 + 16) + 1], "CD001", 5);
+
+  track_handle = open_track(&iterator, "game.cue", 1);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->file_track_offset, 0);
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 150);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, sector_size);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 0);
+  ASSERT_NUM_EQUALS(track_handle->raw_data_size, 2048);
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+static void test_absolute_sector_to_track_sector_cue_pregap()
+{
+  const char cue[] =
+    "FILE \"game1.bin\" BINARY\n"/* file contains 500 sectors of data [1176000 bytes] */
+    "  TRACK 01 MODE2/2352\n"
+    "    INDEX 00 00:00:00\n"    /* 150 pre-gap sectors */
+    "    INDEX 01 00:02:00\n"    /* 350 sectors of data */
+    "FILE \"game2.bin\" BINARY\n"
+	  "  TRACK 02 MODE2/2352\n"
+	  "    INDEX 00 00:00:00\n"    /* 150 pre-gap sectors */
+	  "    INDEX 01 00:02:00\n";
+
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+
+  const size_t image_size = (size_t)60 * 200;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue);
+  mock_file(1, "game1.bin", NULL, (size_t)500 * 2352);
+  mock_file(2, "game2.bin", image, image_size);
+
+  track_handle = open_track(&iterator, "game.cue", 2);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game2.bin");
+
+  /* pregap of second track starts at sector 500 */
+  ASSERT_NUM_EQUALS(track_handle->track_first_sector, 500);
+  ASSERT_NUM_EQUALS(track_handle->track_pregap_sectors, 150);
+
+  /* data for second track starts at sector 650 */
+  ASSERT_NUM_EQUALS(iterator.callbacks.cdreader.first_track_sector(track_handle), 650);
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+static void test_absolute_sector_to_track_sector_gdi()
+{
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.gdi", gdi_many_tracks);
+  mock_file(1, "track26.bin", NULL, 1234567);
+
+  track_handle = open_track(&iterator, "game.gdi", 26);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "track26.bin");
+  ASSERT_NUM_EQUALS(track_handle->track_first_sector, 548106);
+
+  ASSERT_NUM_EQUALS(iterator.callbacks.cdreader.first_track_sector(track_handle), 548106);
+
+  close_track(&iterator, track_handle);
+}
+
+static void test_read_sector()
+{
+  char buffer[4096];
+  rc_hash_cdrom_track_t* track_handle;
+  rc_hash_iterator_t iterator;
+  const size_t image_size = (size_t)2352 * 32;
+  uint8_t* image = (uint8_t*)malloc(image_size);
+  int offset, i;
+  ASSERT_PTR_NOT_NULL(image);
+
+  initialize_iterator(&iterator);
+
+  mock_file_text(0, "game.cue", cue_single_track);
+  mock_file(1, "game.bin", image, image_size);
+
+  memset(image, 0, image_size);
+  memcpy(&image[2352 * 16], sync_pattern, sizeof(sync_pattern));
+  image[2352 * 16 + 12] = 0;
+  image[2352 * 16 + 13] = 2;
+  image[2352 * 16 + 14] = 0x16;
+  image[2352 * 16 + 15] = 2;
+
+  offset = 2352 * 1 + 16;
+  for (i = 0; i < 26; i++)
+  {
+	memset(&image[offset], i + 'A', 256);
+	offset += 256;
+
+	if ((i % 8) == 7)
+      offset += (2352 - 2048);
+  }
+
+  track_handle = open_track(&iterator, "game.cue", 1);
+  ASSERT_PTR_NOT_NULL(track_handle);
+
+  ASSERT_PTR_NOT_NULL(track_handle->file_handle);
+  ASSERT_STR_EQUALS(get_mock_filename(track_handle->file_handle), "game.bin");
+  ASSERT_NUM64_EQUALS(track_handle->track_pregap_sectors, 0);
+  ASSERT_NUM_EQUALS(track_handle->sector_size, 2352);
+  ASSERT_NUM_EQUALS(track_handle->sector_header_size, 16);
+
+  /* read across multiple sectors */
+  ASSERT_NUM_EQUALS(iterator.callbacks.cdreader.read_sector(track_handle, 1, buffer, sizeof(buffer)), 4096);
+
+  ASSERT_NUM_EQUALS(buffer[0], 'A');
+  ASSERT_NUM_EQUALS(buffer[255], 'A');
+  ASSERT_NUM_EQUALS(buffer[256], 'B');
+  ASSERT_NUM_EQUALS(buffer[2047], 'H');
+  ASSERT_NUM_EQUALS(buffer[2048], 'I');
+  ASSERT_NUM_EQUALS(buffer[4095], 'P');
+
+  /* read of partial sector */
+  ASSERT_NUM_EQUALS(iterator.callbacks.cdreader.read_sector(track_handle, 2, buffer, 10), 10);
+  ASSERT_NUM_EQUALS(buffer[0], 'I');
+  ASSERT_NUM_EQUALS(buffer[9], 'I');
+  ASSERT_NUM_EQUALS(buffer[10], 'A');
+
+  close_track(&iterator, track_handle);
+  free(image);
+}
+
+/* ========================================================================= */
+
+void test_cdreader(void) {
+  TEST_SUITE_BEGIN();
+
+  init_mock_filereader();
+  rc_hash_init_default_cdreader();
+  
+  TEST(test_open_cue_track_2);
+  TEST(test_open_cue_track_12);
+  TEST(test_open_cue_track_14);
+  TEST(test_open_cue_track_missing_bin);
+
+  TEST(test_open_gdi_track_3);
+  TEST(test_open_gdi_track_3_quoted);
+  TEST(test_open_gdi_track_3_extra_whitespace);
+  TEST(test_open_gdi_track_last);
+
+  TEST(test_open_cue_track_largest_data);
+  TEST(test_open_cue_track_largest_data_multiple_bin);
+  TEST(test_open_cue_track_largest_data_backwards_compatibility);
+  TEST(test_open_cue_track_largest_data_last_track);
+  TEST(test_open_cue_track_largest_data_index0s);
+  TEST(test_open_cue_track_largest_data_index2);
+  TEST(test_open_cue_track_largest_data_multiple_bins);
+  TEST(test_open_cue_track_largest_data_only_audio);
+
+  TEST(test_open_cue_track_first_data);
+
+  TEST_PARAMS1(test_determine_sector_size_sync, 2352);
+  TEST_PARAMS1(test_determine_sector_size_sync_primary_volume_descriptor, 2352);
+  TEST_PARAMS1(test_determine_sector_size_sync_primary_volume_descriptor_index0, 2352);
+
+  TEST_PARAMS1(test_determine_sector_size_sync, 2336);
+  TEST_PARAMS1(test_determine_sector_size_sync_primary_volume_descriptor, 2336);
+  TEST_PARAMS1(test_determine_sector_size_sync_primary_volume_descriptor_index0, 2336);
+
+  TEST(test_determine_sector_size_sync_2048);
+  TEST(test_determine_sector_size_sync_primary_volume_descriptor_2048);
+  TEST(test_determine_sector_size_sync_primary_volume_descriptor_index0_2048);
+
+  TEST(test_absolute_sector_to_track_sector_cue_pregap);
+  TEST(test_absolute_sector_to_track_sector_gdi);
+
+  TEST(test_read_sector);
+
+  TEST_SUITE_END();
+}