summaryrefslogtreecommitdiff
path: root/test/time
diff options
context:
space:
mode:
Diffstat (limited to 'test/time')
-rw-r--r--test/time/AudioClockTest.c82
-rw-r--r--test/time/TaskTimerTest.c279
2 files changed, 361 insertions, 0 deletions
diff --git a/test/time/AudioClockTest.c b/test/time/AudioClockTest.c
new file mode 100644
index 0000000..8f29a8c
--- /dev/null
+++ b/test/time/AudioClockTest.c
@@ -0,0 +1,82 @@
+#include "unit/TestRunner.h"
+#include "time/AudioClock.h"
+
+static const unsigned long kAudioClockTestBlocksize = 256;
+
+static void _audioClockTestSetup(void)
+{
+ initAudioClock();
+}
+
+static void _audioClockTestTeardown(void)
+{
+ freeAudioClock(getAudioClock());
+}
+
+static int _testInitAudioClock(void)
+{
+ AudioClock audioClock = getAudioClock();
+ assertUnsignedLongEquals(ZERO_UNSIGNED_LONG, audioClock->currentFrame);
+ assertFalse(audioClock->isPlaying);
+ assertFalse(audioClock->transportChanged);
+ return 0;
+}
+
+static int _testAdvanceAudioClock(void)
+{
+ AudioClock audioClock = getAudioClock();
+ advanceAudioClock(audioClock, kAudioClockTestBlocksize);
+ assertUnsignedLongEquals(kAudioClockTestBlocksize, audioClock->currentFrame);
+ assert(audioClock->isPlaying);
+ assert(audioClock->transportChanged);
+ return 0;
+}
+
+static int _testStopAudioClock(void)
+{
+ AudioClock audioClock = getAudioClock();
+ advanceAudioClock(audioClock, kAudioClockTestBlocksize);
+ audioClockStop(audioClock);
+ assertFalse(audioClock->isPlaying);
+ assert(audioClock->transportChanged)
+ return 0;
+}
+
+static int _testRestartAudioClock(void)
+{
+ AudioClock audioClock = getAudioClock();
+ advanceAudioClock(audioClock, kAudioClockTestBlocksize);
+ audioClockStop(audioClock);
+ advanceAudioClock(audioClock, kAudioClockTestBlocksize);
+ assert(audioClock->isPlaying);
+ assert(audioClock->transportChanged);
+ assertUnsignedLongEquals(kAudioClockTestBlocksize * 2, audioClock->currentFrame);
+ return 0;
+}
+
+static int _testAdvanceClockMulitpleTimes(void)
+{
+ AudioClock audioClock = getAudioClock();
+ int i;
+
+ for (i = 0; i < 100; i++) {
+ advanceAudioClock(audioClock, kAudioClockTestBlocksize);
+ }
+
+ assert(audioClock->isPlaying);
+ assertFalse(audioClock->transportChanged);
+ assertUnsignedLongEquals(kAudioClockTestBlocksize * 100, audioClock->currentFrame);
+ return 0;
+}
+
+TestSuite addAudioClockTests(void);
+TestSuite addAudioClockTests(void)
+{
+ TestSuite testSuite = newTestSuite("AudioClock", _audioClockTestSetup, _audioClockTestTeardown);
+ addTest(testSuite, "Initialization", _testInitAudioClock);
+ addTest(testSuite, "AdvanceClock", _testAdvanceAudioClock);
+ addTest(testSuite, "StopClock", _testStopAudioClock);
+ addTest(testSuite, "RestartClock", _testRestartAudioClock);
+ addTest(testSuite, "MultipleAdvance", _testAdvanceClockMulitpleTimes);
+ return testSuite;
+}
diff --git a/test/time/TaskTimerTest.c b/test/time/TaskTimerTest.c
new file mode 100644
index 0000000..10ae41e
--- /dev/null
+++ b/test/time/TaskTimerTest.c
@@ -0,0 +1,279 @@
+#include <math.h>
+
+#include "unit/TestRunner.h"
+#include "time/TaskTimer.h"
+
+#define SLEEP_DURATION_MS 10.0
+// Timer testing is a bit unreliable, so we just check to see that each sleep
+// call (see below) is recorded off no more than this amount of milliseconds.
+#define MAX_TIMER_TOLERANCE_MS 1.5f
+#define TEST_COMPONENT_NAME "component"
+#define TEST_SUBCOMPONENT_NAME "subcomponent"
+
+// Keep a static task timer which can easily be destroyed in the teardown. The
+// reason for this is that when running the test suite in valgrind, the timing
+// tests often fail, which will cuase the suite to leak. Having failed timing
+// tests is probably ok when running in valgrind, but leaking memory isn't, as
+// that's the entire point of running it there. :)
+static TaskTimer _testTaskTimer;
+
+static void _testTaskTimerSetup(void)
+{
+ _testTaskTimer = newTaskTimerWithCString(TEST_COMPONENT_NAME, TEST_SUBCOMPONENT_NAME);
+}
+
+static void _testTaskTimerTeardown(void)
+{
+ freeTaskTimer(_testTaskTimer);
+}
+
+static int _testNewTaskTimer(void)
+{
+ CharString c = newCharStringWithCString(TEST_COMPONENT_NAME);
+ TaskTimer t = newTaskTimer(c, TEST_SUBCOMPONENT_NAME);
+
+ assert(t->enabled);
+ assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
+ assertCharStringEquals(TEST_SUBCOMPONENT_NAME, t->subcomponent);
+ assertDoubleEquals(0.0, t->totalTaskTime, TEST_DEFAULT_TOLERANCE);
+
+ freeCharString(c);
+ freeTaskTimer(t);
+ return 0;
+}
+
+static int _testNewObjectWithEmptyComponent(void)
+{
+ CharString c = newCharStringWithCString(EMPTY_STRING);
+ TaskTimer t = newTaskTimer(c, TEST_SUBCOMPONENT_NAME);
+
+ assertNotNull(t);
+ assertCharStringEquals(EMPTY_STRING, t->component);
+ assertCharStringEquals(TEST_SUBCOMPONENT_NAME, t->subcomponent);
+
+ freeCharString(c);
+ freeTaskTimer(t);
+ return 0;
+}
+
+static int _testNewObjectWithEmptySubcomponent(void)
+{
+ CharString c = newCharStringWithCString(TEST_COMPONENT_NAME);
+ TaskTimer t = newTaskTimer(c, EMPTY_STRING);
+
+ assertNotNull(t);
+ assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
+ assertCharStringEquals(EMPTY_STRING, t->subcomponent);
+
+ freeCharString(c);
+ freeTaskTimer(t);
+ return 0;
+}
+
+static int _testNewObjectWithNullComponent(void)
+{
+ TaskTimer t = newTaskTimer(NULL, NULL);
+
+ assertNotNull(t);
+ assertCharStringEquals(EMPTY_STRING, t->component);
+ assertCharStringEquals(EMPTY_STRING, t->subcomponent);
+
+ freeTaskTimer(t);
+ return 0;
+}
+
+static int _testNewObjectWithNullComponentCString(void)
+{
+ TaskTimer t = newTaskTimerWithCString(NULL, NULL);
+
+ assertNotNull(t);
+ assertCharStringEquals(EMPTY_STRING, t->component);
+ assertCharStringEquals(EMPTY_STRING, t->subcomponent);
+
+ freeTaskTimer(t);
+ return 0;
+}
+
+static int _testNewObjectWithNullSubcomponent(void)
+{
+ CharString c = newCharStringWithCString(TEST_COMPONENT_NAME);
+ TaskTimer t = newTaskTimer(c, NULL);
+
+ assertNotNull(t);
+ assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
+ assertCharStringEquals(EMPTY_STRING, t->subcomponent);
+
+ freeCharString(c);
+ freeTaskTimer(t);
+ return 0;
+}
+
+static int _testNewObjectWithCStrings(void)
+{
+ TaskTimer t = newTaskTimerWithCString(TEST_COMPONENT_NAME, TEST_SUBCOMPONENT_NAME);
+
+ assert(t->enabled);
+ assertCharStringEquals(TEST_COMPONENT_NAME, t->component);
+ assertCharStringEquals(TEST_SUBCOMPONENT_NAME, t->subcomponent);
+ assertDoubleEquals(0.0, t->totalTaskTime, TEST_DEFAULT_TOLERANCE);
+
+ freeTaskTimer(t);
+ return 0;
+}
+
+static void _testSleep(void)
+{
+ taskTimerSleep(SLEEP_DURATION_MS);
+}
+
+static int _testTaskTimerDuration(void)
+{
+ double elapsedTime = 0.0;
+ taskTimerStart(_testTaskTimer);
+ _testSleep();
+ elapsedTime = taskTimerStop(_testTaskTimer);
+ assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
+ assertTimeEquals(SLEEP_DURATION_MS, elapsedTime, MAX_TIMER_TOLERANCE_MS);
+ return 0;
+}
+
+static int _testTaskTimerDurationMultipleTimes(void)
+{
+ double elapsedTime = 0.0;
+ int i;
+
+ for (i = 0; i < 5; i++) {
+ taskTimerStart(_testTaskTimer);
+ _testSleep();
+ elapsedTime = taskTimerStop(_testTaskTimer);
+ assertTimeEquals(SLEEP_DURATION_MS, elapsedTime, MAX_TIMER_TOLERANCE_MS);
+ elapsedTime = 0.0;
+ }
+
+ assertTimeEquals(5.0 * SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS * 5.0);
+
+ return 0;
+}
+
+static int _testTaskTimerCallStartTwice(void)
+{
+ taskTimerStart(_testTaskTimer);
+ taskTimerStart(_testTaskTimer);
+ _testSleep();
+ taskTimerStop(_testTaskTimer);
+ assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
+ return 0;
+}
+
+static int _testTaskTimerCallStopTwice(void)
+{
+ taskTimerStart(_testTaskTimer);
+ _testSleep();
+ taskTimerStop(_testTaskTimer);
+ taskTimerStop(_testTaskTimer);
+ assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
+ return 0;
+}
+
+static int _testCallStopBeforeStart(void)
+{
+ taskTimerStop(_testTaskTimer);
+ taskTimerStart(_testTaskTimer);
+ _testSleep();
+ taskTimerStop(_testTaskTimer);
+ assertTimeEquals(SLEEP_DURATION_MS, _testTaskTimer->totalTaskTime, MAX_TIMER_TOLERANCE_MS);
+ return 0;
+}
+
+static int _testHumanReadableTimeMs(void)
+{
+ CharString s;
+ _testTaskTimer->totalTaskTime = 230;
+ s = taskTimerHumanReadbleString(_testTaskTimer);
+ assertCharStringEquals("230ms", s);
+ freeCharString(s);
+ return 0;
+}
+
+static int _testHumanReadableTimeSec(void)
+{
+ CharString s;
+ // 23 seconds
+ _testTaskTimer->totalTaskTime = 23000;
+ s = taskTimerHumanReadbleString(_testTaskTimer);
+ assertCharStringEquals("23sec", s);
+ freeCharString(s);
+ return 0;
+}
+
+static int _testHumanReadableTimeMinSec(void)
+{
+ CharString s;
+ // 10 minutes, 23 seconds
+ _testTaskTimer->totalTaskTime = 600000 + 23000;
+ s = taskTimerHumanReadbleString(_testTaskTimer);
+ assertCharStringEquals("10:23sec", s);
+ freeCharString(s);
+ return 0;
+}
+
+static int _testHumanReadableTimeHoursMinSec(void)
+{
+ CharString s;
+ // 2 hours, 10 minutes, 23 seconds
+ _testTaskTimer->totalTaskTime = (1000 * 60 * 60 * 2) + 600000 + 23000;
+ s = taskTimerHumanReadbleString(_testTaskTimer);
+ assertCharStringEquals("2:10:23sec", s);
+ freeCharString(s);
+ return 0;
+}
+
+static int _testHumanReadableTimeNotStarted(void)
+{
+ CharString s = taskTimerHumanReadbleString(_testTaskTimer);
+ assertCharStringEquals("0ms", s);
+ freeCharString(s);
+ return 0;
+}
+
+static int _testSleepMilliseconds(void)
+{
+ double elapsedTime;
+ TaskTimer t = newTaskTimerWithCString("test", "test");
+ taskTimerStart(t);
+ taskTimerSleep(12);
+ elapsedTime = taskTimerStop(t);
+ assertTimeEquals(12, elapsedTime, 0.1);
+ freeTaskTimer(t);
+ return 0;
+}
+
+TestSuite addTaskTimerTests(void);
+TestSuite addTaskTimerTests(void)
+{
+ TestSuite testSuite = newTestSuite("TaskTimer", _testTaskTimerSetup, _testTaskTimerTeardown);
+ addTest(testSuite, "NewObject", _testNewTaskTimer);
+ addTest(testSuite, "NewObjectWithEmptyComponent", _testNewObjectWithEmptyComponent);
+ addTest(testSuite, "NewObjectWithEmptySubcomponent", _testNewObjectWithEmptySubcomponent);
+ addTest(testSuite, "NewObjectWithNullComponent", _testNewObjectWithNullComponent);
+ addTest(testSuite, "NewObjectWithNullComponentCString", _testNewObjectWithNullComponentCString);
+ addTest(testSuite, "NewObjectWithNullSubcomponent", _testNewObjectWithNullSubcomponent);
+ addTest(testSuite, "NewObjectWithCStrings", _testNewObjectWithCStrings);
+
+ addTest(testSuite, "TaskDuration", _testTaskTimerDuration);
+ addTest(testSuite, "TaskDurationMultipleTimes", _testTaskTimerDurationMultipleTimes);
+
+ addTest(testSuite, "CallStartTwice", _testTaskTimerCallStartTwice);
+ addTest(testSuite, "CallStopTwice", _testTaskTimerCallStopTwice);
+ addTest(testSuite, "CallStartTwice", _testTaskTimerCallStartTwice);
+ addTest(testSuite, "CallStopBeforeStart", _testCallStopBeforeStart);
+
+ addTest(testSuite, "HumanReadableTimeMs", _testHumanReadableTimeMs);
+ addTest(testSuite, "HumanReadableTimeSec", _testHumanReadableTimeSec);
+ addTest(testSuite, "HumanReadableTimeMinSec", _testHumanReadableTimeMinSec);
+ addTest(testSuite, "HumanReadableTimeHoursMinSec", _testHumanReadableTimeHoursMinSec);
+ addTest(testSuite, "HumanReadableTimeNotStarted", _testHumanReadableTimeNotStarted);
+
+ addTest(testSuite, "SleepMilliseconds", _testSleepMilliseconds);
+ return testSuite;
+}
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2025-12-12 03:30:00 +0000