summaryrefslogtreecommitdiff
path: root/test/audio
diff options
context:
space:
mode:
Diffstat (limited to 'test/audio')
-rw-r--r--test/audio/AudioSettingsTest.c213
-rw-r--r--test/audio/SampleBufferTest.c134
2 files changed, 347 insertions, 0 deletions
diff --git a/test/audio/AudioSettingsTest.c b/test/audio/AudioSettingsTest.c
new file mode 100644
index 0000000..bbdbe62
--- /dev/null
+++ b/test/audio/AudioSettingsTest.c
@@ -0,0 +1,213 @@
+#include "audio/AudioSettings.h"
+#include "unit/TestRunner.h"
+
+static void _audioSettingsSetup(void)
+{
+ initAudioSettings();
+}
+
+static void _audioSettingsTeardown(void)
+{
+ freeAudioSettings();
+}
+
+static int _testInitAudioSettings(void)
+{
+ assertDoubleEquals(DEFAULT_SAMPLE_RATE, getSampleRate(), TEST_DEFAULT_TOLERANCE);
+ assertIntEquals(DEFAULT_NUM_CHANNELS, getNumChannels());
+ assertUnsignedLongEquals(DEFAULT_BLOCKSIZE, getBlocksize());
+ assertDoubleEquals(DEFAULT_TEMPO, getTempo(), TEST_DEFAULT_TOLERANCE);
+ assertIntEquals(DEFAULT_TIMESIG_BEATS_PER_MEASURE, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(DEFAULT_TIMESIG_NOTE_VALUE, getTimeSignatureNoteValue());
+ return 0;
+}
+
+static int _testSetSampleRate(void)
+{
+ setSampleRate(22050.0);
+ assertDoubleEquals(22050.0, getSampleRate(), TEST_DEFAULT_TOLERANCE);
+ return 0;
+}
+
+static int _testSetInvalidSampleRate(void)
+{
+ setSampleRate(22050.0);
+ assertDoubleEquals(22050.0, getSampleRate(), TEST_DEFAULT_TOLERANCE);
+ assertFalse(setSampleRate(0.0));
+ assertDoubleEquals(22050.0, getSampleRate(), TEST_DEFAULT_TOLERANCE);
+ return 0;
+}
+
+static int _testSetNumChannels(void)
+{
+ setNumChannels(4);
+ assertIntEquals(4, getNumChannels());
+ return 0;
+}
+
+static int _testSetInvalidNumChannels(void)
+{
+ setNumChannels(2);
+ assertIntEquals(2, getNumChannels());
+ assertFalse(setNumChannels(0));
+ assertIntEquals(2, getNumChannels());
+ return 0;
+}
+
+static int _testSetBlocksize(void)
+{
+ setBlocksize(123);
+ assertUnsignedLongEquals(123l, getBlocksize());
+ return 0;
+}
+
+static int _testSetInvalidBlocksize(void)
+{
+ setBlocksize(123);
+ assertUnsignedLongEquals(123l, getBlocksize());
+ assertFalse(setBlocksize(0));
+ assertUnsignedLongEquals(123l, getBlocksize());
+ return 0;
+}
+
+static int _testSetTempo(void)
+{
+ setTempo(123.45f);
+ assertDoubleEquals(123.45, getTempo(), 0.1);
+ return 0;
+}
+
+static int _testSetInvalidTempo(void)
+{
+ setTempo(100.0);
+ assertDoubleEquals(100.0, getTempo(), TEST_DEFAULT_TOLERANCE);
+ assertFalse(setTempo(-666.0));
+ assertDoubleEquals(100.0, getTempo(), TEST_DEFAULT_TOLERANCE);
+ assertFalse(setTempo(0.0));
+ assertDoubleEquals(100.0, getTempo(), TEST_DEFAULT_TOLERANCE);
+ return 0;
+}
+
+static int _testSetTempoWithMidiBytes(void)
+{
+ byte bytes[3];
+ bytes[0] = 0x13;
+ bytes[1] = 0xe7;
+ bytes[2] = 0x1b;
+ setTempoFromMidiBytes(bytes);
+ assertDoubleEquals(46.0, getTempo(), TEST_DEFAULT_TOLERANCE);
+ return 0;
+}
+
+static int _testSetTempoWithMidiBytesNull(void)
+{
+ setTempo(100.0);
+ assertDoubleEquals(100.0, getTempo(), TEST_DEFAULT_TOLERANCE);
+ setTempoFromMidiBytes(NULL);
+ assertDoubleEquals(100.0, getTempo(), TEST_DEFAULT_TOLERANCE);
+ return 0;
+}
+
+static int _testSetTimeSigBeatsPerMeasure(void)
+{
+ assert(setTimeSignatureBeatsPerMeasure(8));
+ assertIntEquals(8, getTimeSignatureBeatsPerMeasure());
+ return 0;
+}
+
+static int _testSetTimeSigNoteValue(void)
+{
+ assert(setTimeSignatureNoteValue(2));
+ assertIntEquals(2, getTimeSignatureNoteValue());
+ return 0;
+}
+
+static int _testSetTimeSignatureWithMidiBytes(void)
+{
+ byte bytes[2];
+ // Corresponds to a time signature of 3/8
+ bytes[0] = 3;
+ bytes[1] = 3;
+ assert(setTimeSignatureFromMidiBytes(bytes));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ return 0;
+}
+
+static int _testSetTimeSignatureWithMidiBytesNull(void)
+{
+ assert(setTimeSignatureBeatsPerMeasure(3));
+ assert(setTimeSignatureNoteValue(8));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ assertFalse(setTimeSignatureFromMidiBytes(NULL));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ return 0;
+}
+
+static int _testSetTimeSignatureFromString(void)
+{
+ CharString s = newCharStringWithCString("2/16");
+ assert(setTimeSignatureBeatsPerMeasure(3));
+ assert(setTimeSignatureNoteValue(8));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ assert(setTimeSignatureFromString(s));
+ assertIntEquals(2, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(16, getTimeSignatureNoteValue());
+ freeCharString(s);
+ return 0;
+}
+
+static int _testSetTimeSignatureFromInvalidString(void)
+{
+ CharString s = newCharStringWithCString("invalid/none");
+ assert(setTimeSignatureBeatsPerMeasure(3));
+ assert(setTimeSignatureNoteValue(8));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ assertFalse(setTimeSignatureFromString(s));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ freeCharString(s);
+ return 0;
+}
+
+static int _testSetTimeSignatureFromNullString(void)
+{
+ assert(setTimeSignatureBeatsPerMeasure(3));
+ assert(setTimeSignatureNoteValue(8));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ assertFalse(setTimeSignatureFromString(NULL));
+ assertIntEquals(3, getTimeSignatureBeatsPerMeasure());
+ assertIntEquals(8, getTimeSignatureNoteValue());
+ return 0;
+}
+
+TestSuite addAudioSettingsTests(void);
+TestSuite addAudioSettingsTests(void)
+{
+ TestSuite testSuite = newTestSuite("AudioSettings", _audioSettingsSetup, _audioSettingsTeardown);
+ addTest(testSuite, "Initialization", _testInitAudioSettings);
+ addTest(testSuite, "SetSampleRate", _testSetSampleRate);
+ addTest(testSuite, "SetInvalidSampleRate", _testSetInvalidSampleRate);
+ addTest(testSuite, "SetNumChannels", _testSetNumChannels);
+ addTest(testSuite, "SetInvalidNumChannels", _testSetInvalidNumChannels);
+ addTest(testSuite, "SetBlocksize", _testSetBlocksize);
+ addTest(testSuite, "SetInvalidBlocksize", _testSetInvalidBlocksize);
+ addTest(testSuite, "SetTempo", _testSetTempo);
+ addTest(testSuite, "SetInvalidTempo", _testSetInvalidTempo);
+ addTest(testSuite, "SetTempoWithMidiBytes", _testSetTempoWithMidiBytes);
+ addTest(testSuite, "SetTempoWithMidiBytesNull", _testSetTempoWithMidiBytesNull);
+
+ addTest(testSuite, "SetTimeSignatureBeatsPerMeasure", _testSetTimeSigBeatsPerMeasure);
+ addTest(testSuite, "SetTimeSignatureNoteValue", _testSetTimeSigNoteValue);
+ addTest(testSuite, "SetTimeSignatureWithMidiBytes", _testSetTimeSignatureWithMidiBytes);
+ addTest(testSuite, "SetTimeSignatureWithMidiBytesNull", _testSetTimeSignatureWithMidiBytesNull);
+ addTest(testSuite, "SetTimeSignatureFromString", _testSetTimeSignatureFromString);
+ addTest(testSuite, "SetTimeSignatureFromInvalidString", _testSetTimeSignatureFromInvalidString);
+ addTest(testSuite, "SetTimeSignatureFromNullString", _testSetTimeSignatureFromNullString);
+ return testSuite;
+}
diff --git a/test/audio/SampleBufferTest.c b/test/audio/SampleBufferTest.c
new file mode 100644
index 0000000..9909f0f
--- /dev/null
+++ b/test/audio/SampleBufferTest.c
@@ -0,0 +1,134 @@
+#include "audio/AudioSettings.h"
+#include "audio/SampleBuffer.h"
+#include "unit/TestRunner.h"
+
+static SampleBuffer _newMockSampleBuffer(void)
+{
+ return newSampleBuffer(1, 1);
+}
+
+static int _testNewSampleBuffer(void)
+{
+ SampleBuffer s = _newMockSampleBuffer();
+ assertIntEquals(1, s->numChannels);
+ assertUnsignedLongEquals(1l, s->blocksize);
+ freeSampleBuffer(s);
+ return 0;
+}
+
+static int _testNewSampleBufferMultichannel(void)
+{
+ SampleBuffer s = newSampleBuffer(8, 128);
+ unsigned int i, j;
+ assertNotNull(s);
+ assertIntEquals(8, s->numChannels);
+
+ // Actually write a bunch of samples to expose memory corruption
+ for (i = 0; i < s->blocksize; ++i) {
+ for (j = 0; j < s->numChannels; ++j) {
+ s->samples[j][i] = 0.5f;
+ }
+ }
+
+ freeSampleBuffer(s);
+ return 0;
+}
+
+static int _testClearSampleBuffer(void)
+{
+ SampleBuffer s = _newMockSampleBuffer();
+ s->samples[0][0] = 123;
+ sampleBufferClear(s);
+ assertDoubleEquals(0.0, s->samples[0][0], TEST_DEFAULT_TOLERANCE);
+ freeSampleBuffer(s);
+ return 0;
+}
+
+static int _testCopyAndMapChannelsSampleBuffers(void)
+{
+ SampleBuffer s1 = _newMockSampleBuffer();
+ SampleBuffer s2 = _newMockSampleBuffer();
+ s1->samples[0][0] = 123.0;
+ assert(sampleBufferCopyAndMapChannels(s2, s1));
+ assertDoubleEquals(123.0, s2->samples[0][0], TEST_DEFAULT_TOLERANCE);
+ freeSampleBuffer(s1);
+ freeSampleBuffer(s2);
+ return 0;
+}
+
+static int _testCopyAndMapChannelsSampleBuffersDifferentBlocksizes(void)
+{
+ SampleBuffer s1 = newSampleBuffer(1, DEFAULT_BLOCKSIZE);
+ SampleBuffer s2 = _newMockSampleBuffer();
+
+ s1->samples[0][0] = 123.0;
+ assertFalse(sampleBufferCopyAndMapChannels(s2, s1));
+ // Contents should not change; copying with different sizes is invalid
+ assertDoubleEquals(123.0, s1->samples[0][0], TEST_DEFAULT_TOLERANCE);
+
+ freeSampleBuffer(s1);
+ freeSampleBuffer(s2);
+ return 0;
+}
+
+static int _testCopyAndMapChannelsSampleBuffersDifferentChannelsBigger(void)
+{
+ SampleBuffer s1 = newSampleBuffer(4, 1);
+ SampleBuffer s2 = newSampleBuffer(2, 1);
+
+ s2->samples[0][0] = 1.0;
+ s2->samples[1][0] = 2.0;
+
+ assert(sampleBufferCopyAndMapChannels(s1, s2));
+ assertDoubleEquals(1.0, s1->samples[0][0], TEST_DEFAULT_TOLERANCE);
+ assertDoubleEquals(2.0, s1->samples[1][0], TEST_DEFAULT_TOLERANCE);
+ assertDoubleEquals(1.0, s1->samples[2][0], TEST_DEFAULT_TOLERANCE);
+ assertDoubleEquals(2.0, s1->samples[3][0], TEST_DEFAULT_TOLERANCE);
+
+ freeSampleBuffer(s1);
+ freeSampleBuffer(s2);
+ return 0;
+}
+
+static int _testCopyAndMapChannelsSampleBuffersDifferentChannelsSmaller(void)
+{
+ SampleBuffer s1 = newSampleBuffer(1, 1);
+ SampleBuffer s2 = newSampleBuffer(4, 1);
+ unsigned int i;
+
+ for (i = 0; i < s1->numChannels; i++) {
+ s1->samples[i][0] = 1.0;
+ }
+
+ for (i = 0; i < s2->numChannels; i++) {
+ s2->samples[i][0] = 2.0;
+ }
+
+ assert(sampleBufferCopyAndMapChannels(s1, s2));
+ assertDoubleEquals(2.0, s1->samples[0][0], TEST_DEFAULT_TOLERANCE);
+
+ freeSampleBuffer(s1);
+ freeSampleBuffer(s2);
+ return 0;
+}
+
+static int _testFreeNullSampleBuffer(void)
+{
+ freeSampleBuffer(NULL);
+ return 0;
+}
+
+TestSuite addSampleBufferTests(void);
+TestSuite addSampleBufferTests(void)
+{
+ TestSuite testSuite = newTestSuite("SampleBuffer", NULL, NULL);
+ addTest(testSuite, "NewObject", _testNewSampleBuffer);
+ addTest(testSuite, "NewSampleBufferMultichannel", _testNewSampleBufferMultichannel);
+ addTest(testSuite, "ClearSampleBuffer", _testClearSampleBuffer);
+ addTest(testSuite, "CopyAndMapChannelsSampleBuffers", _testCopyAndMapChannelsSampleBuffers);
+ addTest(testSuite, "CopyAndMapChannelsSampleBuffersDifferentSizes", _testCopyAndMapChannelsSampleBuffersDifferentBlocksizes);
+ addTest(testSuite, "CopyAndMapChannelsSampleBuffersDifferentChannelsBigger", _testCopyAndMapChannelsSampleBuffersDifferentChannelsBigger);
+ addTest(testSuite, "CopyAndMapChannelsSampleBuffersDifferentChannelsSmaller", _testCopyAndMapChannelsSampleBuffersDifferentChannelsSmaller);
+ addTest(testSuite, "FreeNullSampleBuffer", _testFreeNullSampleBuffer);
+ return testSuite;
+}
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2025-12-22 10:52:09 +0000