src/gb/test/rtc.c (view raw)
1/* Copyright (c) 2013-2016 Jeffrey Pfau
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6#include "util/test/suite.h"
7
8#include <mgba/core/core.h>
9#include <mgba/gb/core.h>
10#include <mgba/internal/gb/gb.h>
11#include <mgba/internal/gb/mbc.h>
12#include <mgba-util/vfs.h>
13
14struct GBRTCTest {
15 struct mRTCSource d;
16 struct mCore* core;
17 struct VFile* fakeSave;
18 time_t nextTime;
19};
20
21static void _sampleRtc(struct GB* gb) {
22 gb->memory.rtcLastLatch = 0;
23 GBStore8(gb->cpu, 0x6000, 0);
24 GBStore8(gb->cpu, 0x6000, 1);
25}
26
27static void _sampleRtcKeepLatch(struct GB* gb) {
28 GBStore8(gb->cpu, 0x6000, 0);
29 GBStore8(gb->cpu, 0x6000, 1);
30}
31
32static time_t _testTime(struct mRTCSource* source) {
33 struct GBRTCTest* test = (struct GBRTCTest*) source;
34 return test->nextTime;
35}
36
37M_TEST_SUITE_SETUP(GBRTC) {
38 struct GBRTCTest* test = malloc(sizeof(*test));
39 if (!test) {
40 return -1;
41 }
42 test->core = GBCoreCreate();
43 test->d.sample = NULL;
44 test->d.unixTime = _testTime;
45 test->nextTime = 0;
46 if (!test->core) {
47 *state = NULL;
48 return -1;
49 }
50 test->core->init(test->core);
51 mCoreInitConfig(test->core, NULL);
52 struct VFile* vf = VFileMemChunk(NULL, 2048);
53 GBSynthesizeROM(vf);
54 test->core->loadROM(test->core, vf);
55 mCoreSetRTC(test->core, &test->d);
56
57 test->fakeSave = VFileMemChunk(NULL, 0);
58 test->core->loadSave(test->core, test->fakeSave);
59
60 struct GB* gb = test->core->board;
61 gb->memory.mbcType = GB_MBC3_RTC;
62
63 *state = test;
64 return 0;
65}
66
67M_TEST_SUITE_TEARDOWN(GBRTC) {
68 if (!*state) {
69 return 0;
70 }
71 struct GBRTCTest* test = *state;
72 mCoreConfigDeinit(&test->core->config);
73 test->core->deinit(test->core);
74 free(test);
75 return 0;
76}
77
78M_TEST_DEFINE(create) {
79 struct GBRTCTest* test = *state;
80 test->core->reset(test->core);
81 struct GB* gb = test->core->board;
82
83 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
84 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
85 assert_int_equal(gb->memory.mbcType, GB_MBC3_RTC);
86}
87
88M_TEST_DEFINE(tickSecond) {
89 struct GBRTCTest* test = *state;
90 test->nextTime = 0;
91 test->core->reset(test->core);
92 struct GB* gb = test->core->board;
93 test->nextTime = 1;
94
95 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
96 memset(gb->memory.rtcRegs, 0, sizeof(expected));
97
98 gb->memory.rtcRegs[0] = 0;
99 expected[0] = 1;
100 _sampleRtc(gb);
101 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
102
103 gb->memory.rtcRegs[0] = 1;
104 expected[0] = 2;
105 _sampleRtc(gb);
106 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
107
108 gb->memory.rtcRegs[0] = 59;
109 gb->memory.rtcRegs[1] = 0;
110 expected[0] = 0;
111 expected[1] = 1;
112 _sampleRtc(gb);
113 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
114}
115
116M_TEST_DEFINE(tick30Seconds) {
117 struct GBRTCTest* test = *state;
118 test->nextTime = 0;
119 test->core->reset(test->core);
120 struct GB* gb = test->core->board;
121 test->nextTime = 30;
122
123 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
124 memset(gb->memory.rtcRegs, 0, sizeof(expected));
125
126 gb->memory.rtcRegs[0] = 0;
127 expected[0] = 30;
128 _sampleRtc(gb);
129 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
130
131 gb->memory.rtcRegs[0] = 1;
132 expected[0] = 31;
133 _sampleRtc(gb);
134 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
135
136 gb->memory.rtcRegs[0] = 30;
137 gb->memory.rtcRegs[1] = 0;
138 expected[0] = 0;
139 expected[1] = 1;
140 _sampleRtc(gb);
141 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
142
143 gb->memory.rtcRegs[0] = 59;
144 gb->memory.rtcRegs[1] = 0;
145 expected[0] = 29;
146 expected[1] = 1;
147 _sampleRtc(gb);
148 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
149}
150
151M_TEST_DEFINE(tickMinute) {
152 struct GBRTCTest* test = *state;
153 test->nextTime = 0;
154 test->core->reset(test->core);
155 struct GB* gb = test->core->board;
156 test->nextTime = 60;
157
158 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
159 memset(gb->memory.rtcRegs, 0, sizeof(expected));
160
161 gb->memory.rtcRegs[0] = 0;
162 gb->memory.rtcRegs[1] = 0;
163 expected[0] = 0;
164 expected[1] = 1;
165 _sampleRtc(gb);
166 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
167
168 gb->memory.rtcRegs[0] = 1;
169 gb->memory.rtcRegs[1] = 0;
170 expected[0] = 1;
171 expected[1] = 1;
172 _sampleRtc(gb);
173 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
174
175 gb->memory.rtcRegs[0] = 0;
176 gb->memory.rtcRegs[1] = 59;
177 gb->memory.rtcRegs[2] = 0;
178 expected[0] = 0;
179 expected[1] = 0;
180 expected[2] = 1;
181 _sampleRtc(gb);
182 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
183
184 gb->memory.rtcRegs[0] = 1;
185 gb->memory.rtcRegs[1] = 59;
186 gb->memory.rtcRegs[2] = 0;
187 expected[0] = 1;
188 expected[1] = 0;
189 expected[2] = 1;
190 _sampleRtc(gb);
191 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
192}
193
194M_TEST_DEFINE(tick90Seconds) {
195 struct GBRTCTest* test = *state;
196 test->nextTime = 0;
197 test->core->reset(test->core);
198 struct GB* gb = test->core->board;
199 test->nextTime = 90;
200
201 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
202 memset(gb->memory.rtcRegs, 0, sizeof(expected));
203
204 gb->memory.rtcRegs[0] = 0;
205 gb->memory.rtcRegs[1] = 0;
206 expected[0] = 30;
207 expected[1] = 1;
208 _sampleRtc(gb);
209 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
210
211 gb->memory.rtcRegs[0] = 1;
212 gb->memory.rtcRegs[1] = 0;
213 expected[0] = 31;
214 expected[1] = 1;
215 _sampleRtc(gb);
216 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
217
218 gb->memory.rtcRegs[0] = 30;
219 gb->memory.rtcRegs[1] = 0;
220 expected[0] = 0;
221 expected[1] = 2;
222 _sampleRtc(gb);
223 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
224
225 gb->memory.rtcRegs[0] = 59;
226 gb->memory.rtcRegs[1] = 0;
227 expected[0] = 29;
228 expected[1] = 2;
229 _sampleRtc(gb);
230 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
231
232 gb->memory.rtcRegs[0] = 0;
233 gb->memory.rtcRegs[1] = 59;
234 gb->memory.rtcRegs[2] = 0;
235 expected[0] = 30;
236 expected[1] = 0;
237 expected[2] = 1;
238 _sampleRtc(gb);
239 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
240
241 gb->memory.rtcRegs[0] = 1;
242 gb->memory.rtcRegs[1] = 59;
243 gb->memory.rtcRegs[2] = 0;
244 expected[0] = 31;
245 expected[1] = 0;
246 expected[2] = 1;
247 _sampleRtc(gb);
248 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
249}
250
251M_TEST_DEFINE(tick30Minutes) {
252 struct GBRTCTest* test = *state;
253 test->nextTime = 0;
254 test->core->reset(test->core);
255 struct GB* gb = test->core->board;
256 test->nextTime = 1800;
257
258 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
259 memset(gb->memory.rtcRegs, 0, sizeof(expected));
260
261 gb->memory.rtcRegs[0] = 0;
262 gb->memory.rtcRegs[1] = 0;
263 expected[0] = 0;
264 expected[1] = 30;
265 _sampleRtc(gb);
266 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
267
268 gb->memory.rtcRegs[0] = 1;
269 gb->memory.rtcRegs[1] = 0;
270 expected[0] = 1;
271 expected[1] = 30;
272 _sampleRtc(gb);
273 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
274
275 gb->memory.rtcRegs[0] = 0;
276 gb->memory.rtcRegs[1] = 59;
277 gb->memory.rtcRegs[2] = 0;
278 expected[0] = 0;
279 expected[1] = 29;
280 expected[2] = 1;
281 _sampleRtc(gb);
282 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
283
284 gb->memory.rtcRegs[0] = 1;
285 gb->memory.rtcRegs[1] = 59;
286 gb->memory.rtcRegs[2] = 0;
287 expected[0] = 1;
288 expected[1] = 29;
289 expected[2] = 1;
290 _sampleRtc(gb);
291 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
292}
293
294M_TEST_DEFINE(tickHour) {
295 struct GBRTCTest* test = *state;
296 test->nextTime = 0;
297 test->core->reset(test->core);
298 struct GB* gb = test->core->board;
299 test->nextTime = 3600;
300
301 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
302 memset(gb->memory.rtcRegs, 0, sizeof(expected));
303
304 gb->memory.rtcRegs[0] = 0;
305 gb->memory.rtcRegs[1] = 0;
306 gb->memory.rtcRegs[2] = 0;
307 expected[0] = 0;
308 expected[1] = 0;
309 expected[2] = 1;
310 _sampleRtc(gb);
311 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
312
313 gb->memory.rtcRegs[0] = 1;
314 gb->memory.rtcRegs[1] = 0;
315 gb->memory.rtcRegs[2] = 0;
316 expected[0] = 1;
317 expected[1] = 0;
318 expected[2] = 1;
319 _sampleRtc(gb);
320 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
321
322 gb->memory.rtcRegs[0] = 0;
323 gb->memory.rtcRegs[1] = 1;
324 gb->memory.rtcRegs[2] = 0;
325 expected[0] = 0;
326 expected[1] = 1;
327 expected[2] = 1;
328 _sampleRtc(gb);
329 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
330
331 gb->memory.rtcRegs[0] = 0;
332 gb->memory.rtcRegs[1] = 0;
333 gb->memory.rtcRegs[2] = 1;
334 expected[0] = 0;
335 expected[1] = 0;
336 expected[2] = 2;
337 _sampleRtc(gb);
338 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
339
340 gb->memory.rtcRegs[0] = 0;
341 gb->memory.rtcRegs[1] = 0;
342 gb->memory.rtcRegs[2] = 23;
343 gb->memory.rtcRegs[3] = 0;
344 expected[0] = 0;
345 expected[1] = 0;
346 expected[2] = 0;
347 expected[3] = 1;
348 _sampleRtc(gb);
349 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
350}
351
352M_TEST_DEFINE(tick12Hours) {
353 struct GBRTCTest* test = *state;
354 test->nextTime = 0;
355 test->core->reset(test->core);
356 struct GB* gb = test->core->board;
357 test->nextTime = 3600 * 12;
358
359 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
360 memset(gb->memory.rtcRegs, 0, sizeof(expected));
361
362 gb->memory.rtcRegs[0] = 0;
363 gb->memory.rtcRegs[1] = 0;
364 gb->memory.rtcRegs[2] = 0;
365 expected[0] = 0;
366 expected[1] = 0;
367 expected[2] = 12;
368 _sampleRtc(gb);
369 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
370
371 gb->memory.rtcRegs[0] = 1;
372 gb->memory.rtcRegs[1] = 0;
373 gb->memory.rtcRegs[2] = 0;
374 expected[0] = 1;
375 expected[1] = 0;
376 expected[2] = 12;
377 _sampleRtc(gb);
378 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
379
380 gb->memory.rtcRegs[0] = 0;
381 gb->memory.rtcRegs[1] = 1;
382 gb->memory.rtcRegs[2] = 0;
383 expected[0] = 0;
384 expected[1] = 1;
385 expected[2] = 12;
386 _sampleRtc(gb);
387 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
388
389 gb->memory.rtcRegs[0] = 1;
390 gb->memory.rtcRegs[1] = 1;
391 gb->memory.rtcRegs[2] = 0;
392 expected[0] = 1;
393 expected[1] = 1;
394 expected[2] = 12;
395 _sampleRtc(gb);
396 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
397
398 gb->memory.rtcRegs[0] = 0;
399 gb->memory.rtcRegs[1] = 0;
400 gb->memory.rtcRegs[2] = 12;
401 gb->memory.rtcRegs[3] = 0;
402 expected[0] = 0;
403 expected[1] = 0;
404 expected[2] = 0;
405 expected[3] = 1;
406 _sampleRtc(gb);
407 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
408
409 gb->memory.rtcRegs[0] = 0;
410 gb->memory.rtcRegs[1] = 0;
411 gb->memory.rtcRegs[2] = 23;
412 gb->memory.rtcRegs[3] = 0;
413 expected[0] = 0;
414 expected[1] = 0;
415 expected[2] = 11;
416 expected[3] = 1;
417 _sampleRtc(gb);
418 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
419}
420
421M_TEST_DEFINE(tickDay) {
422 struct GBRTCTest* test = *state;
423 test->nextTime = 0;
424 test->core->reset(test->core);
425 struct GB* gb = test->core->board;
426 test->nextTime = 3600 * 24;
427
428 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
429 memset(gb->memory.rtcRegs, 0, sizeof(expected));
430
431 gb->memory.rtcRegs[0] = 0;
432 gb->memory.rtcRegs[1] = 0;
433 gb->memory.rtcRegs[2] = 0;
434 gb->memory.rtcRegs[3] = 0;
435 expected[0] = 0;
436 expected[1] = 0;
437 expected[2] = 0;
438 expected[3] = 1;
439 _sampleRtc(gb);
440 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
441
442 gb->memory.rtcRegs[0] = 1;
443 gb->memory.rtcRegs[1] = 0;
444 gb->memory.rtcRegs[2] = 0;
445 gb->memory.rtcRegs[3] = 0;
446 expected[0] = 1;
447 expected[1] = 0;
448 expected[2] = 0;
449 expected[3] = 1;
450 _sampleRtc(gb);
451 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
452
453 gb->memory.rtcRegs[0] = 0;
454 gb->memory.rtcRegs[1] = 1;
455 gb->memory.rtcRegs[2] = 0;
456 gb->memory.rtcRegs[3] = 0;
457 expected[0] = 0;
458 expected[1] = 1;
459 expected[2] = 0;
460 expected[3] = 1;
461 _sampleRtc(gb);
462 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
463
464 gb->memory.rtcRegs[0] = 1;
465 gb->memory.rtcRegs[1] = 1;
466 gb->memory.rtcRegs[2] = 0;
467 gb->memory.rtcRegs[3] = 0;
468 expected[0] = 1;
469 expected[1] = 1;
470 expected[2] = 0;
471 expected[3] = 1;
472 _sampleRtc(gb);
473 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
474
475 gb->memory.rtcRegs[0] = 0;
476 gb->memory.rtcRegs[1] = 0;
477 gb->memory.rtcRegs[2] = 12;
478 gb->memory.rtcRegs[3] = 0;
479 expected[0] = 0;
480 expected[1] = 0;
481 expected[2] = 12;
482 expected[3] = 1;
483 _sampleRtc(gb);
484 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
485
486 gb->memory.rtcRegs[0] = 0;
487 gb->memory.rtcRegs[1] = 0;
488 gb->memory.rtcRegs[2] = 23;
489 gb->memory.rtcRegs[3] = 0;
490 expected[0] = 0;
491 expected[1] = 0;
492 expected[2] = 23;
493 expected[3] = 1;
494 _sampleRtc(gb);
495 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
496
497 gb->memory.rtcRegs[0] = 0;
498 gb->memory.rtcRegs[1] = 0;
499 gb->memory.rtcRegs[2] = 0;
500 gb->memory.rtcRegs[3] = 1;
501 expected[0] = 0;
502 expected[1] = 0;
503 expected[2] = 0;
504 expected[3] = 2;
505 _sampleRtc(gb);
506 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
507
508 gb->memory.rtcRegs[0] = 0;
509 gb->memory.rtcRegs[1] = 0;
510 gb->memory.rtcRegs[2] = 1;
511 gb->memory.rtcRegs[3] = 1;
512 expected[0] = 0;
513 expected[1] = 0;
514 expected[2] = 1;
515 expected[3] = 2;
516 _sampleRtc(gb);
517 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
518}
519
520M_TEST_DEFINE(wideTickDay) {
521 struct GBRTCTest* test = *state;
522 test->nextTime = 0;
523 test->core->reset(test->core);
524 struct GB* gb = test->core->board;
525 test->nextTime = 3600 * 24 * 2001;
526
527 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
528 memset(gb->memory.rtcRegs, 0, sizeof(expected));
529
530 gb->memory.rtcRegs[0] = 0;
531 gb->memory.rtcRegs[1] = 0;
532 gb->memory.rtcRegs[2] = 0;
533 gb->memory.rtcRegs[3] = 0;
534 expected[0] = 0;
535 expected[1] = 0;
536 expected[2] = 0;
537 expected[3] = 1;
538 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
539 _sampleRtcKeepLatch(gb);
540 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
541
542 gb->memory.rtcRegs[0] = 1;
543 gb->memory.rtcRegs[1] = 0;
544 gb->memory.rtcRegs[2] = 0;
545 gb->memory.rtcRegs[3] = 0;
546 expected[0] = 1;
547 expected[1] = 0;
548 expected[2] = 0;
549 expected[3] = 1;
550 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
551 _sampleRtcKeepLatch(gb);
552 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
553
554 gb->memory.rtcRegs[0] = 0;
555 gb->memory.rtcRegs[1] = 1;
556 gb->memory.rtcRegs[2] = 0;
557 gb->memory.rtcRegs[3] = 0;
558 expected[0] = 0;
559 expected[1] = 1;
560 expected[2] = 0;
561 expected[3] = 1;
562 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
563 _sampleRtcKeepLatch(gb);
564 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
565
566 gb->memory.rtcRegs[0] = 1;
567 gb->memory.rtcRegs[1] = 1;
568 gb->memory.rtcRegs[2] = 0;
569 gb->memory.rtcRegs[3] = 0;
570 expected[0] = 1;
571 expected[1] = 1;
572 expected[2] = 0;
573 expected[3] = 1;
574 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
575 _sampleRtcKeepLatch(gb);
576 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
577
578 gb->memory.rtcRegs[0] = 0;
579 gb->memory.rtcRegs[1] = 0;
580 gb->memory.rtcRegs[2] = 12;
581 gb->memory.rtcRegs[3] = 0;
582 expected[0] = 0;
583 expected[1] = 0;
584 expected[2] = 12;
585 expected[3] = 1;
586 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
587 _sampleRtcKeepLatch(gb);
588 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
589
590 gb->memory.rtcRegs[0] = 0;
591 gb->memory.rtcRegs[1] = 0;
592 gb->memory.rtcRegs[2] = 23;
593 gb->memory.rtcRegs[3] = 0;
594 expected[0] = 0;
595 expected[1] = 0;
596 expected[2] = 23;
597 expected[3] = 1;
598 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
599 _sampleRtcKeepLatch(gb);
600 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
601
602 gb->memory.rtcRegs[0] = 0;
603 gb->memory.rtcRegs[1] = 0;
604 gb->memory.rtcRegs[2] = 0;
605 gb->memory.rtcRegs[3] = 1;
606 expected[0] = 0;
607 expected[1] = 0;
608 expected[2] = 0;
609 expected[3] = 2;
610 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
611 _sampleRtcKeepLatch(gb);
612 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
613
614 gb->memory.rtcRegs[0] = 0;
615 gb->memory.rtcRegs[1] = 0;
616 gb->memory.rtcRegs[2] = 1;
617 gb->memory.rtcRegs[3] = 1;
618 expected[0] = 0;
619 expected[1] = 0;
620 expected[2] = 1;
621 expected[3] = 2;
622 gb->memory.rtcLastLatch = 3600 * 24 * 2000;
623 _sampleRtcKeepLatch(gb);
624 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
625}
626
627M_TEST_DEFINE(rolloverSecond) {
628 struct GBRTCTest* test = *state;
629 test->nextTime = 0;
630 test->core->reset(test->core);
631 struct GB* gb = test->core->board;
632 test->nextTime = 1;
633
634 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
635 memset(gb->memory.rtcRegs, 0, sizeof(expected));
636
637 gb->memory.rtcRegs[0] = 59;
638 gb->memory.rtcRegs[1] = 0;
639 expected[0] = 0;
640 expected[1] = 1;
641 _sampleRtc(gb);
642 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
643
644 gb->memory.rtcRegs[0] = 59;
645 gb->memory.rtcRegs[1] = 59;
646 gb->memory.rtcRegs[2] = 0;
647 expected[0] = 0;
648 expected[1] = 0;
649 expected[2] = 1;
650 _sampleRtc(gb);
651 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
652
653 gb->memory.rtcRegs[0] = 59;
654 gb->memory.rtcRegs[1] = 59;
655 gb->memory.rtcRegs[2] = 23;
656 gb->memory.rtcRegs[3] = 0;
657 expected[0] = 0;
658 expected[1] = 0;
659 expected[2] = 0;
660 expected[3] = 1;
661 _sampleRtc(gb);
662 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
663
664 gb->memory.rtcRegs[0] = 59;
665 gb->memory.rtcRegs[1] = 59;
666 gb->memory.rtcRegs[2] = 23;
667 gb->memory.rtcRegs[3] = 0xFF;
668 gb->memory.rtcRegs[4] = 0;
669 expected[0] = 0;
670 expected[1] = 0;
671 expected[2] = 0;
672 expected[3] = 0;
673 expected[4] = 1;
674 _sampleRtc(gb);
675 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
676
677 gb->memory.rtcRegs[0] = 59;
678 gb->memory.rtcRegs[1] = 59;
679 gb->memory.rtcRegs[2] = 23;
680 gb->memory.rtcRegs[3] = 0xFF;
681 gb->memory.rtcRegs[4] = 1;
682 expected[0] = 0;
683 expected[1] = 0;
684 expected[2] = 0;
685 expected[3] = 0;
686 expected[4] = 0x80;
687 _sampleRtc(gb);
688 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
689}
690
691M_TEST_DEFINE(roundtrip0) {
692 struct GBRTCTest* test = *state;
693 test->nextTime = 0;
694 test->fakeSave->truncate(test->fakeSave, 0);
695 test->core->reset(test->core);
696 struct GB* gb = test->core->board;
697
698 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
699 memset(gb->memory.rtcRegs, 0, sizeof(expected));
700 GBMBCRTCWrite(gb);
701
702 GBMBCRTCRead(gb);
703 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
704
705 GBMBCRTCRead(gb);
706 _sampleRtcKeepLatch(gb);
707 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
708
709 GBMBCRTCWrite(gb);
710 _sampleRtcKeepLatch(gb);
711 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
712 GBMBCRTCRead(gb);
713 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
714
715 test->nextTime = 3600;
716 expected[2] = 1;
717 GBMBCRTCWrite(gb);
718 _sampleRtcKeepLatch(gb);
719 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
720 GBMBCRTCRead(gb);
721 _sampleRtcKeepLatch(gb);
722 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
723
724 GBMBCRTCWrite(gb);
725 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
726 GBMBCRTCRead(gb);
727 _sampleRtcKeepLatch(gb);
728 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
729
730 test->nextTime = 3600 * 2;
731 expected[2] = 2;
732 GBMBCRTCWrite(gb);
733 _sampleRtcKeepLatch(gb);
734 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
735 GBMBCRTCRead(gb);
736 _sampleRtcKeepLatch(gb);
737 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
738}
739
740M_TEST_DEFINE(roundtripSecond) {
741 struct GBRTCTest* test = *state;
742 test->nextTime = 0;
743 test->fakeSave->truncate(test->fakeSave, 0);
744 test->core->reset(test->core);
745 struct GB* gb = test->core->board;
746
747 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
748 memset(gb->memory.rtcRegs, 0, sizeof(expected));
749 GBMBCRTCWrite(gb);
750
751 test->nextTime = 1;
752 GBMBCRTCRead(gb);
753 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
754
755 expected[0] = 1;
756 _sampleRtcKeepLatch(gb);
757 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
758
759 GBMBCRTCWrite(gb);
760
761 test->nextTime = 2;
762 GBMBCRTCRead(gb);
763 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
764 _sampleRtcKeepLatch(gb);
765 expected[0] = 2;
766 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
767
768 test->core->reset(test->core);
769 expected[0] = 1;
770 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
771 _sampleRtcKeepLatch(gb);
772 expected[0] = 2;
773 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
774
775 test->core->reset(test->core);
776 expected[0] = 1;
777 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
778 GBMBCRTCRead(gb);
779 _sampleRtcKeepLatch(gb);
780 expected[0] = 2;
781 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
782
783 test->nextTime = 3;
784 test->core->reset(test->core);
785 expected[0] = 1;
786 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
787 _sampleRtcKeepLatch(gb);
788 expected[0] = 3;
789 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
790
791 test->nextTime = 1;
792 test->core->reset(test->core);
793 expected[0] = 1;
794 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
795 test->nextTime = 4;
796 _sampleRtcKeepLatch(gb);
797 expected[0] = 4;
798 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
799}
800
801M_TEST_DEFINE(roundtripDay) {
802 struct GBRTCTest* test = *state;
803 test->nextTime = 0;
804 test->fakeSave->truncate(test->fakeSave, 0);
805 test->core->reset(test->core);
806 struct GB* gb = test->core->board;
807
808 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
809 memset(gb->memory.rtcRegs, 0, sizeof(expected));
810 GBMBCRTCWrite(gb);
811 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
812
813 test->nextTime = 3600 * 24;
814 GBMBCRTCRead(gb);
815 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
816 expected[0] = 0;
817 expected[1] = 0;
818 expected[2] = 0;
819 expected[3] = 1;
820 _sampleRtcKeepLatch(gb);
821 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
822
823 test->nextTime = 3600 * 24 * 2;
824 expected[0] = 0;
825 expected[1] = 0;
826 expected[2] = 0;
827 expected[3] = 2;
828 GBMBCRTCRead(gb);
829 _sampleRtcKeepLatch(gb);
830 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
831
832 GBMBCRTCWrite(gb);
833
834 test->nextTime = 3600 * 24 * 2;
835 expected[0] = 0;
836 expected[1] = 0;
837 expected[2] = 0;
838 expected[3] = 2;
839 GBMBCRTCRead(gb);
840 _sampleRtcKeepLatch(gb);
841 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
842
843 test->nextTime = 3600 * 24 * 3;
844 expected[0] = 0;
845 expected[1] = 0;
846 expected[2] = 0;
847 expected[3] = 3;
848 GBMBCRTCRead(gb);
849 _sampleRtcKeepLatch(gb);
850 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
851
852 test->nextTime = 3600 * 24 * 2;
853 test->core->reset(test->core);
854 expected[0] = 0;
855 expected[1] = 0;
856 expected[2] = 0;
857 expected[3] = 2;
858 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
859 _sampleRtcKeepLatch(gb);
860 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
861
862 test->nextTime = 3600 * 24 * 3;
863 test->core->reset(test->core);
864 expected[0] = 0;
865 expected[1] = 0;
866 expected[2] = 0;
867 expected[3] = 2;
868 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
869 expected[0] = 0;
870 expected[1] = 0;
871 expected[2] = 0;
872 expected[3] = 3;
873 _sampleRtcKeepLatch(gb);
874 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
875}
876
877M_TEST_DEFINE(roundtripHuge) {
878 struct GBRTCTest* test = *state;
879 test->nextTime = 1500000000;
880 test->fakeSave->truncate(test->fakeSave, 0);
881 test->core->reset(test->core);
882 struct GB* gb = test->core->board;
883
884 uint8_t expected[sizeof(gb->memory.rtcRegs)] = { 0, 0, 0, 0, 0 };
885 memset(gb->memory.rtcRegs, 0, sizeof(expected));
886 GBMBCRTCWrite(gb);
887 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
888 _sampleRtcKeepLatch(gb);
889 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
890
891 test->nextTime = 1500000000 + 3600 * 24;
892 GBMBCRTCRead(gb);
893 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
894 expected[0] = 0;
895 expected[1] = 0;
896 expected[2] = 0;
897 expected[3] = 1;
898 _sampleRtcKeepLatch(gb);
899 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
900
901 test->nextTime = 1500000000 + 3600 * 24 * 2;
902 expected[0] = 0;
903 expected[1] = 0;
904 expected[2] = 0;
905 expected[3] = 2;
906 GBMBCRTCRead(gb);
907 _sampleRtcKeepLatch(gb);
908 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
909
910 GBMBCRTCWrite(gb);
911
912 test->nextTime = 1500000000 + 3600 * 24 * 2;
913 expected[0] = 0;
914 expected[1] = 0;
915 expected[2] = 0;
916 expected[3] = 2;
917 GBMBCRTCRead(gb);
918 _sampleRtcKeepLatch(gb);
919 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
920
921 test->nextTime = 1500000000 + 3600 * 24 * 3;
922 expected[0] = 0;
923 expected[1] = 0;
924 expected[2] = 0;
925 expected[3] = 3;
926 GBMBCRTCRead(gb);
927 _sampleRtcKeepLatch(gb);
928 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
929
930 test->nextTime = 1500000000 + 3600 * 24 * 2;
931 test->core->reset(test->core);
932 expected[0] = 0;
933 expected[1] = 0;
934 expected[2] = 0;
935 expected[3] = 2;
936 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
937 _sampleRtcKeepLatch(gb);
938 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
939
940 test->nextTime = 1500000000 + 3600 * 24 * 3;
941 test->core->reset(test->core);
942 expected[0] = 0;
943 expected[1] = 0;
944 expected[2] = 0;
945 expected[3] = 2;
946 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
947 expected[0] = 0;
948 expected[1] = 0;
949 expected[2] = 0;
950 expected[3] = 3;
951 _sampleRtcKeepLatch(gb);
952 assert_memory_equal(gb->memory.rtcRegs, expected, sizeof(expected));
953}
954
955M_TEST_SUITE_DEFINE_SETUP_TEARDOWN(GBRTC,
956 cmocka_unit_test(create),
957 cmocka_unit_test(tickSecond),
958 cmocka_unit_test(tick30Seconds),
959 cmocka_unit_test(tickMinute),
960 cmocka_unit_test(tick90Seconds),
961 cmocka_unit_test(tick30Minutes),
962 cmocka_unit_test(tickHour),
963 cmocka_unit_test(tick12Hours),
964 cmocka_unit_test(tickDay),
965 cmocka_unit_test(wideTickDay),
966 cmocka_unit_test(rolloverSecond),
967 cmocka_unit_test(roundtrip0),
968 cmocka_unit_test(roundtripSecond),
969 cmocka_unit_test(roundtripDay),
970 cmocka_unit_test(roundtripHuge))