summaryrefslogtreecommitdiff
path: root/test/plugin
diff options
context:
space:
mode:
Diffstat (limited to 'test/plugin')
-rw-r--r--test/plugin/PluginChainTest.c311
-rw-r--r--test/plugin/PluginMock.c95
-rw-r--r--test/plugin/PluginMock.h19
-rw-r--r--test/plugin/PluginPresetMock.c42
-rw-r--r--test/plugin/PluginPresetMock.h15
-rw-r--r--test/plugin/PluginPresetTest.c78
-rw-r--r--test/plugin/PluginTest.c91
-rw-r--r--test/plugin/PluginVst2xIdTest.c87
8 files changed, 738 insertions, 0 deletions
diff --git a/test/plugin/PluginChainTest.c b/test/plugin/PluginChainTest.c
new file mode 100644
index 0000000..cb07f71
--- /dev/null
+++ b/test/plugin/PluginChainTest.c
@@ -0,0 +1,311 @@
+#include "unit/TestRunner.h"
+#include "audio/AudioSettings.h"
+#include "midi/MidiEvent.h"
+#include "plugin/PluginChain.h"
+#include "plugin/PluginPassthru.h"
+
+#include "PluginMock.h"
+#include "PluginPresetMock.h"
+
+static void _pluginChainTestSetup(void)
+{
+ initPluginChain();
+}
+
+static void _pluginChainTestTeardown(void)
+{
+ freePluginChain(getPluginChain());
+}
+
+static int _testInitPluginChain(void)
+{
+ PluginChain p = getPluginChain();
+ assertIntEquals(0, p->numPlugins);
+ assertNotNull(p->plugins);
+ assertNotNull(p->presets);
+ return 0;
+}
+
+static int _testAddFromArgumentStringNull(void)
+{
+ PluginChain p = getPluginChain();
+ CharString c = newCharStringWithCString("/");
+
+ assertFalse(pluginChainAddFromArgumentString(p, NULL, c));
+ assertIntEquals(0, p->numPlugins);
+
+ freeCharString(c);
+ return 0;
+}
+
+static int _testAddFromArgumentStringEmpty(void)
+{
+ PluginChain p = getPluginChain();
+ CharString c = newCharStringWithCString("/");
+ CharString empty = newCharString();
+
+ assertFalse(pluginChainAddFromArgumentString(p, empty, c));
+ assertIntEquals(0, p->numPlugins);
+
+ freeCharString(c);
+ freeCharString(empty);
+ return 0;
+}
+
+static int _testAddFromArgumentStringEmptyLocation(void)
+{
+ PluginChain p = getPluginChain();
+ CharString c = newCharStringWithCString(kInternalPluginPassthruName);
+ CharString empty = newCharString();
+
+ assert(pluginChainAddFromArgumentString(p, c, empty));
+ assertIntEquals(1, p->numPlugins);
+
+ freeCharString(c);
+ freeCharString(empty);
+ return 0;
+}
+
+static int _testAddFromArgumentStringNullLocation(void)
+{
+ PluginChain p = getPluginChain();
+ CharString c = newCharStringWithCString(kInternalPluginPassthruName);
+
+ assert(pluginChainAddFromArgumentString(p, c, NULL));
+ assertIntEquals(1, p->numPlugins);
+
+ freeCharString(c);
+ return 0;
+}
+
+static int _testAddFromArgumentString(void)
+{
+ PluginChain p = getPluginChain();
+ CharString testArgs = newCharStringWithCString(kInternalPluginPassthruName);
+
+ assert(pluginChainAddFromArgumentString(p, testArgs, NULL));
+ assertIntEquals(1, p->numPlugins);
+ assertNotNull(p->plugins[0]);
+ assertIntEquals(PLUGIN_TYPE_INTERNAL, p->plugins[0]->pluginType);
+ assertCharStringEquals(kInternalPluginPassthruName, p->plugins[0]->pluginName);
+
+ freeCharString(testArgs);
+ return 0;
+}
+
+static int _testAddFromArgumentStringMultiple(void)
+{
+ PluginChain p = getPluginChain();
+ CharString testArgs = newCharStringWithCString(kInternalPluginPassthruName);
+ unsigned int i;
+
+ assert(pluginChainAddFromArgumentString(p, testArgs, NULL));
+ assert(pluginChainAddFromArgumentString(p, testArgs, NULL));
+ assertIntEquals(2, p->numPlugins);
+
+ for (i = 0; i < p->numPlugins; i++) {
+ assertNotNull(p->plugins[i]);
+ assertIntEquals(PLUGIN_TYPE_INTERNAL, p->plugins[i]->pluginType);
+ assertCharStringEquals(kInternalPluginPassthruName, p->plugins[i]->pluginName);
+ }
+
+ freeCharString(testArgs);
+ return 0;
+}
+
+static int _testAddPluginWithPresetFromArgumentString(void)
+{
+ PluginChain p = getPluginChain();
+ CharString testArgs = newCharStringWithCString("mrs_passthru,testPreset.fxp");
+
+ assert(pluginChainAddFromArgumentString(p, testArgs, NULL));
+ assertIntEquals(1, p->numPlugins);
+ assertIntEquals(PLUGIN_TYPE_INTERNAL, p->plugins[0]->pluginType);
+ assertCharStringEquals(kInternalPluginPassthruName, p->plugins[0]->pluginName);
+ assertNotNull(p->presets[0]);
+ assertCharStringEquals("testPreset.fxp", p->presets[0]->presetName);
+
+ freeCharString(testArgs);
+ return 0;
+}
+
+static int _testAddFromArgumentStringWithPresetSpaces(void)
+{
+ PluginChain p = getPluginChain();
+ CharString testArgs = newCharStringWithCString("mrs_passthru,test preset.fxp");
+
+ assert(pluginChainAddFromArgumentString(p, testArgs, NULL));
+ assertIntEquals(1, p->numPlugins);
+ assertIntEquals(PLUGIN_TYPE_INTERNAL, p->plugins[0]->pluginType);
+ assertCharStringEquals(kInternalPluginPassthruName, p->plugins[0]->pluginName);
+ assertNotNull(p->presets[0]);
+ assertCharStringEquals("test preset.fxp", p->presets[0]->presetName);
+
+ freeCharString(testArgs);
+ return 0;
+}
+
+static int _testAppendPlugin(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+ assert(pluginChainAppend(p, mock, NULL));
+ return 0;
+}
+
+static int _testAppendWithNullPlugin(void)
+{
+ PluginChain p = getPluginChain();
+ assertFalse(pluginChainAppend(p, NULL, NULL));
+ return 0;
+}
+
+static int _testAppendWithPreset(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+ PluginPreset mockPreset = newPluginPresetMock();
+ assert(pluginChainAppend(p, mock, mockPreset));
+ return 0;
+}
+
+static int _testInitializePluginChain(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+ PluginPreset mockPreset = newPluginPresetMock();
+
+ assert(pluginChainAppend(p, mock, mockPreset));
+ pluginChainInitialize(p);
+ assert(((PluginMockData)mock->extraData)->isOpen);
+ assert(((PluginPresetMockData)mockPreset->extraData)->isOpen);
+ assert(((PluginPresetMockData)mockPreset->extraData)->isLoaded);
+
+ return 0;
+}
+
+static int _testGetMaximumTailTime(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+ int maxTailTime = 0;
+
+ assert(pluginChainAppend(p, mock, NULL));
+ maxTailTime = pluginChainGetMaximumTailTimeInMs(p);
+ assertIntEquals(kPluginMockTailTime, maxTailTime);
+
+ return 0;
+}
+
+static int _testPrepareForProcessing(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+
+ assert(pluginChainAppend(p, mock, NULL));
+ assertIntEquals(RETURN_CODE_SUCCESS, pluginChainInitialize(p));
+ pluginChainPrepareForProcessing(p);
+ assert(((PluginMockData)mock->extraData)->isPrepared);
+
+ return 0;
+}
+
+static int _testProcessPluginChainAudio(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+ SampleBuffer inBuffer = newSampleBuffer(DEFAULT_NUM_CHANNELS, DEFAULT_BLOCKSIZE);
+ SampleBuffer outBuffer = newSampleBuffer(DEFAULT_NUM_CHANNELS, DEFAULT_BLOCKSIZE);
+
+ assert(pluginChainAppend(p, mock, NULL));
+ pluginChainProcessAudio(p, inBuffer, outBuffer);
+ assert(((PluginMockData)mock->extraData)->processAudioCalled);
+
+ freeSampleBuffer(inBuffer);
+ freeSampleBuffer(outBuffer);
+ return 0;
+}
+
+static int _testProcessPluginChainAudioRealtime(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+ SampleBuffer inBuffer = newSampleBuffer(DEFAULT_NUM_CHANNELS, DEFAULT_BLOCKSIZE);
+ SampleBuffer outBuffer = newSampleBuffer(DEFAULT_NUM_CHANNELS, DEFAULT_BLOCKSIZE);
+ TaskTimer t = newTaskTimerWithCString("test", "test");
+
+ assert(pluginChainAppend(p, mock, NULL));
+ pluginChainSetRealtime(p, true);
+ taskTimerStart(t);
+ pluginChainProcessAudio(p, inBuffer, outBuffer);
+ assertTimeEquals(1000 * DEFAULT_BLOCKSIZE / getSampleRate(), taskTimerStop(t), 0.1);
+ assert(((PluginMockData)mock->extraData)->processAudioCalled);
+
+ freeTaskTimer(t);
+ freeSampleBuffer(inBuffer);
+ freeSampleBuffer(outBuffer);
+ return 0;
+}
+
+static int _testProcessPluginChainMidiEvents(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+ SampleBuffer inBuffer = newSampleBuffer(DEFAULT_NUM_CHANNELS, DEFAULT_BLOCKSIZE);
+ SampleBuffer outBuffer = newSampleBuffer(DEFAULT_NUM_CHANNELS, DEFAULT_BLOCKSIZE);
+ LinkedList list = newLinkedList();
+ MidiEvent midi = newMidiEvent();
+
+ linkedListAppend(list, midi);
+ assert(pluginChainAppend(p, mock, NULL));
+ pluginChainProcessMidi(p, list);
+ assert(((PluginMockData)mock->extraData)->processMidiCalled);
+
+ freeMidiEvent(midi);
+ freeLinkedList(list);
+ freeSampleBuffer(inBuffer);
+ freeSampleBuffer(outBuffer);
+ return 0;
+}
+
+static int _testShutdown(void)
+{
+ Plugin mock = newPluginMock();
+ PluginChain p = getPluginChain();
+
+ assert(pluginChainAppend(p, mock, NULL));
+ pluginChainShutdown(p);
+ assertFalse(((PluginMockData)mock->extraData)->isOpen);
+
+ return 0;
+}
+
+TestSuite addPluginChainTests(void);
+TestSuite addPluginChainTests(void)
+{
+ TestSuite testSuite = newTestSuite("PluginChain", _pluginChainTestSetup, _pluginChainTestTeardown);
+ addTest(testSuite, "Initialization", _testInitPluginChain);
+ addTest(testSuite, "AddFromArgumentStringNull", _testAddFromArgumentStringNull);
+ addTest(testSuite, "AddFromArgumentStringEmpty", _testAddFromArgumentStringEmpty);
+ addTest(testSuite, "AddFromArgumentStringEmptyLocation", _testAddFromArgumentStringEmptyLocation);
+ addTest(testSuite, "AddFromArgumentStringNullLocation", _testAddFromArgumentStringNullLocation);
+ addTest(testSuite, "AddFromArgumentString", _testAddFromArgumentString);
+ addTest(testSuite, "AddFromArgumentStringMultiple", _testAddFromArgumentStringMultiple);
+ addTest(testSuite, "AddPluginWithPresetFromArgumentString", _testAddPluginWithPresetFromArgumentString);
+ addTest(testSuite, "AddFromArgumentStringWithPresetSpaces", _testAddFromArgumentStringWithPresetSpaces);
+ addTest(testSuite, "AppendPlugin", _testAppendPlugin);
+ addTest(testSuite, "AppendWithNullPlugin", _testAppendWithNullPlugin);
+ addTest(testSuite, "AppendWithPreset", _testAppendWithPreset);
+ addTest(testSuite, "InitializePluginChain", _testInitializePluginChain);
+
+ addTest(testSuite, "GetMaximumTailTime", _testGetMaximumTailTime);
+
+ addTest(testSuite, "PrepareForProcessing", _testPrepareForProcessing);
+ addTest(testSuite, "ProcessPluginChainAudio", _testProcessPluginChainAudio);
+ addTest(testSuite, "ProcessPluginChainAudioRealtime", _testProcessPluginChainAudioRealtime);
+ addTest(testSuite, "ProcessPluginChainMidiEvents", _testProcessPluginChainMidiEvents);
+
+ addTest(testSuite, "Shutdown", _testShutdown);
+
+ return testSuite;
+}
diff --git a/test/plugin/PluginMock.c b/test/plugin/PluginMock.c
new file mode 100644
index 0000000..249a722
--- /dev/null
+++ b/test/plugin/PluginMock.c
@@ -0,0 +1,95 @@
+#include "PluginMock.h"
+
+
+static void _pluginMockEmpty(void *pluginPtr)
+{
+ // Nothing to do here
+}
+
+static boolByte _pluginMockOpen(void *pluginPtr)
+{
+ Plugin self = (Plugin)pluginPtr;
+ PluginMockData extraData = (PluginMockData)self->extraData;
+ extraData->isOpen = true;
+ return true;
+}
+
+static int _pluginMockGetSetting(void *pluginPtr, PluginSetting pluginSetting)
+{
+ switch (pluginSetting) {
+ case PLUGIN_SETTING_TAIL_TIME_IN_MS:
+ return kPluginMockTailTime;
+
+ case PLUGIN_NUM_INPUTS:
+ return 2;
+
+ case PLUGIN_NUM_OUTPUTS:
+ return 2;
+
+ case PLUGIN_INITIAL_DELAY:
+ return 0;
+
+ default:
+ return 0;
+ }
+}
+
+static void _pluginMockPrepareForProcessing(void *pluginPtr)
+{
+ Plugin self = (Plugin)pluginPtr;
+ PluginMockData extraData = (PluginMockData)self->extraData;
+ extraData->isPrepared = true;
+}
+
+static void _pluginMockProcessAudio(void *pluginPtr, SampleBuffer inputs, SampleBuffer outputs)
+{
+ Plugin self = (Plugin)pluginPtr;
+ PluginMockData extraData = (PluginMockData)self->extraData;
+ extraData->processAudioCalled = true;
+ sampleBufferClear(outputs);
+}
+
+static void _pluginMockProcessMidiEvents(void *pluginPtr, LinkedList midiEvents)
+{
+ Plugin self = (Plugin)pluginPtr;
+ PluginMockData extraData = (PluginMockData)self->extraData;
+ extraData->processMidiCalled = true;
+}
+
+static boolByte _pluginMockSetParameter(void *pluginPtr, unsigned int i, float value)
+{
+ return false;
+}
+
+static void _pluginMockClose(void *pluginPtr)
+{
+ Plugin self = (Plugin)pluginPtr;
+ PluginMockData extraData = (PluginMockData)self->extraData;
+ extraData->isOpen = false;
+}
+
+Plugin newPluginMock(void)
+{
+ Plugin plugin = _newPlugin(PLUGIN_TYPE_INTERNAL, PLUGIN_TYPE_INSTRUMENT);
+ charStringCopyCString(plugin->pluginName, "Mock");
+ charStringCopyCString(plugin->pluginLocation, "Internal");
+
+ plugin->openPlugin = _pluginMockOpen;
+ plugin->displayInfo = _pluginMockEmpty;
+ plugin->getSetting = _pluginMockGetSetting;
+ plugin->prepareForProcessing = _pluginMockPrepareForProcessing;
+ plugin->processAudio = _pluginMockProcessAudio;
+ plugin->processMidiEvents = _pluginMockProcessMidiEvents;
+ plugin->setParameter = _pluginMockSetParameter;
+ plugin->closePlugin = _pluginMockClose;
+ plugin->freePluginData = _pluginMockEmpty;
+
+ PluginMockData extraData = (PluginMockData)malloc(sizeof(PluginMockDataMembers));
+ extraData->isOpen = false;
+ extraData->isPrepared = false;
+ extraData->processAudioCalled = false;
+ extraData->processMidiCalled = false;
+ plugin->extraData = extraData;
+
+ return plugin;
+}
diff --git a/test/plugin/PluginMock.h b/test/plugin/PluginMock.h
new file mode 100644
index 0000000..e5eaa15
--- /dev/null
+++ b/test/plugin/PluginMock.h
@@ -0,0 +1,19 @@
+#ifndef MrsWatson_PluginMock_h
+#define MrsWatson_PluginMock_h
+
+#include "base/Types.h"
+#include "plugin/Plugin.h"
+
+static const int kPluginMockTailTime = 123;
+
+typedef struct {
+ boolByte isOpen;
+ boolByte isPrepared;
+ boolByte processAudioCalled;
+ boolByte processMidiCalled;
+} PluginMockDataMembers;
+typedef PluginMockDataMembers *PluginMockData;
+
+Plugin newPluginMock(void);
+
+#endif
diff --git a/test/plugin/PluginPresetMock.c b/test/plugin/PluginPresetMock.c
new file mode 100644
index 0000000..8911c75
--- /dev/null
+++ b/test/plugin/PluginPresetMock.c
@@ -0,0 +1,42 @@
+#include "PluginPresetMock.h"
+
+static boolByte _openPluginPresetMock(void *pluginPresetPtr)
+{
+ PluginPreset pluginPreset = (PluginPreset)pluginPresetPtr;
+ PluginPresetMockData extraData = (PluginPresetMockData)pluginPreset->extraData;
+ extraData->isOpen = true;
+ return true;
+}
+
+static boolByte _loadPluginPresetMock(void *pluginPresetPtr, Plugin plugin)
+{
+ PluginPreset pluginPreset = (PluginPreset)pluginPresetPtr;
+ PluginPresetMockData extraData = (PluginPresetMockData)pluginPreset->extraData;
+ extraData->isLoaded = true;
+ return true;
+}
+
+static void _freePluginPresetMock(void *extraDataPtr)
+{
+}
+
+PluginPreset newPluginPresetMock(void)
+{
+ PluginPreset pluginPreset = (PluginPreset)malloc(sizeof(PluginPresetMembers));
+ PluginPresetMockData extraData = (PluginPresetMockData)malloc(sizeof(PluginPresetMockDataMembers));
+
+ pluginPreset->presetType = PRESET_TYPE_INTERNAL_PROGRAM;
+ pluginPreset->presetName = newCharString();
+ pluginPreset->compatiblePluginTypes = 0;
+ pluginPresetSetCompatibleWith(pluginPreset, PLUGIN_TYPE_INTERNAL);
+
+ pluginPreset->openPreset = _openPluginPresetMock;
+ pluginPreset->loadPreset = _loadPluginPresetMock;
+ pluginPreset->freePresetData = _freePluginPresetMock;
+
+ extraData->isOpen = false;
+ extraData->isLoaded = false;
+ pluginPreset->extraData = extraData;
+
+ return pluginPreset;
+}
diff --git a/test/plugin/PluginPresetMock.h b/test/plugin/PluginPresetMock.h
new file mode 100644
index 0000000..70c9089
--- /dev/null
+++ b/test/plugin/PluginPresetMock.h
@@ -0,0 +1,15 @@
+#ifndef MrsWaston_PluginPresetMock_h
+#define MrsWaston_PluginPresetMock_h
+
+#include "base/Types.h"
+#include "plugin/PluginPreset.h"
+
+typedef struct {
+ boolByte isOpen;
+ boolByte isLoaded;
+} PluginPresetMockDataMembers;
+typedef PluginPresetMockDataMembers *PluginPresetMockData;
+
+PluginPreset newPluginPresetMock(void);
+
+#endif
diff --git a/test/plugin/PluginPresetTest.c b/test/plugin/PluginPresetTest.c
new file mode 100644
index 0000000..e16024f
--- /dev/null
+++ b/test/plugin/PluginPresetTest.c
@@ -0,0 +1,78 @@
+#include "unit/TestRunner.h"
+#include "plugin/PluginPreset.h"
+#include "PluginMock.h"
+
+const char *TEST_PRESET_FILENAME = "test.fxp";
+
+static int _testGuessPluginPresetType(void)
+{
+ CharString c = newCharStringWithCString(TEST_PRESET_FILENAME);
+ PluginPreset p = pluginPresetFactory(c);
+ assertIntEquals(PRESET_TYPE_FXP, p->presetType);
+ freePluginPreset(p);
+ freeCharString(c);
+ return 0;
+}
+
+static int _testGuessPluginPresetTypeInvalid(void)
+{
+ CharString c = newCharStringWithCString("invalid");
+ PluginPreset p = pluginPresetFactory(c);
+ assertIsNull(p);
+ freePluginPreset(p);
+ freeCharString(c);
+ return 0;
+}
+
+static int _testNewObject(void)
+{
+ CharString c = newCharStringWithCString(TEST_PRESET_FILENAME);
+ PluginPreset p = pluginPresetFactory(c);
+ assertIntEquals(p->presetType, PRESET_TYPE_FXP);
+ assertCharStringEquals(TEST_PRESET_FILENAME, p->presetName);
+ freePluginPreset(p);
+ freeCharString(c);
+ return 0;
+}
+
+static int _testIsPresetCompatibleWithPlugin(void)
+{
+ CharString c = newCharStringWithCString(TEST_PRESET_FILENAME);
+ PluginPreset p = pluginPresetFactory(c);
+ Plugin mockPlugin = newPluginMock();
+
+ pluginPresetSetCompatibleWith(p, PLUGIN_TYPE_INTERNAL);
+ assert(pluginPresetIsCompatibleWith(p, mockPlugin));
+
+ freePlugin(mockPlugin);
+ freeCharString(c);
+ freePluginPreset(p);
+ return 0;
+}
+
+static int _testIsPresetNotCompatibleWithPlugin(void)
+{
+ CharString c = newCharStringWithCString(TEST_PRESET_FILENAME);
+ PluginPreset p = pluginPresetFactory(c);
+ Plugin mockPlugin = newPluginMock();
+
+ pluginPresetSetCompatibleWith(p, PLUGIN_TYPE_VST_2X);
+ assertFalse(pluginPresetIsCompatibleWith(p, mockPlugin));
+
+ freePlugin(mockPlugin);
+ freeCharString(c);
+ freePluginPreset(p);
+ return 0;
+}
+
+TestSuite addPluginPresetTests(void);
+TestSuite addPluginPresetTests(void)
+{
+ TestSuite testSuite = newTestSuite("PluginPreset", NULL, NULL);
+ addTest(testSuite, "GuessPluginPresetType", _testGuessPluginPresetType);
+ addTest(testSuite, "GuessPluginPresetTypeInvalid", _testGuessPluginPresetTypeInvalid);
+ addTest(testSuite, "NewObject", _testNewObject);
+ addTest(testSuite, "IsPresetCompatibleWithPlugin", _testIsPresetCompatibleWithPlugin);
+ addTest(testSuite, "IsPresetNotCompatibleWithPlugin", _testIsPresetNotCompatibleWithPlugin);
+ return testSuite;
+}
diff --git a/test/plugin/PluginTest.c b/test/plugin/PluginTest.c
new file mode 100644
index 0000000..7c2a575
--- /dev/null
+++ b/test/plugin/PluginTest.c
@@ -0,0 +1,91 @@
+#include "unit/TestRunner.h"
+#include "plugin/Plugin.h"
+
+static int _testPluginFactory(void)
+{
+ CharString silence = newCharStringWithCString("mrs_silence");
+ CharString pluginRoot = newCharString();
+ Plugin p = pluginFactory(silence, pluginRoot);
+
+ assertNotNull(p);
+ assertIntEquals(PLUGIN_TYPE_INTERNAL, p->interfaceType);
+ assertCharStringEquals(silence->data, p->pluginName);
+
+ freeCharString(silence);
+ freeCharString(pluginRoot);
+ freePlugin(p);
+ return 0;
+}
+
+static int _testPluginFactoryInvalidPlugin(void)
+{
+ CharString invalid = newCharStringWithCString("invalid");
+ CharString pluginRoot = newCharString();
+ Plugin p = pluginFactory(invalid, pluginRoot);
+
+ assertIsNull(p);
+
+ freeCharString(invalid);
+ freeCharString(pluginRoot);
+ freePlugin(p);
+ return 0;
+}
+
+static int _testPluginFactoryNullPluginName(void)
+{
+ CharString pluginRoot = newCharString();
+ Plugin p = pluginFactory(NULL, pluginRoot);
+
+ assertIsNull(p);
+
+ freeCharString(pluginRoot);
+ freePlugin(p);
+ return 0;
+}
+
+static int _testPluginFactoryEmptyPluginName(void)
+{
+ CharString invalid = newCharString();
+ CharString pluginRoot = newCharString();
+ Plugin p = pluginFactory(invalid, pluginRoot);
+
+ assertIsNull(p);
+
+ freeCharString(invalid);
+ freeCharString(pluginRoot);
+ freePlugin(p);
+ return 0;
+}
+
+static int _testPluginFactoryNullRoot(void)
+{
+ CharString silence = newCharStringWithCString("mrs_silence");
+ Plugin p = pluginFactory(silence, NULL);
+
+ assertNotNull(p);
+ assertIntEquals(PLUGIN_TYPE_INTERNAL, p->interfaceType);
+ assertCharStringEquals(silence->data, p->pluginName);
+
+ freeCharString(silence);
+ freePlugin(p);
+ return 0;
+}
+
+static int _testFreeNullPlugin(void)
+{
+ freePlugin(NULL);
+ return 0;
+}
+
+TestSuite addPluginTests(void);
+TestSuite addPluginTests(void)
+{
+ TestSuite testSuite = newTestSuite("Plugin", NULL, NULL);
+ addTest(testSuite, "PluginFactory", _testPluginFactory);
+ addTest(testSuite, "PluginFactoryInvalidPlugin", _testPluginFactoryInvalidPlugin);
+ addTest(testSuite, "PluginFactoryNullPluginName", _testPluginFactoryNullPluginName);
+ addTest(testSuite, "PluginFactoryEmptyPluginName", _testPluginFactoryEmptyPluginName);
+ addTest(testSuite, "PluginFactoryNullRoot", _testPluginFactoryNullRoot);
+ addTest(testSuite, "FreeNullPlugin", _testFreeNullPlugin);
+ return testSuite;
+}
diff --git a/test/plugin/PluginVst2xIdTest.c b/test/plugin/PluginVst2xIdTest.c
new file mode 100644
index 0000000..a065a55
--- /dev/null
+++ b/test/plugin/PluginVst2xIdTest.c
@@ -0,0 +1,87 @@
+#include "unit/TestRunner.h"
+#include "plugin/PluginVst2xId.h"
+
+static int _testNewPluginVst2xId(void)
+{
+ PluginVst2xId id = newPluginVst2xId();
+ assertUnsignedLongEquals(ZERO_UNSIGNED_LONG, id->id);
+ assertCharStringEquals(PLUGIN_VST2X_ID_UNKNOWN, id->idString);
+ freePluginVst2xId(id);
+ return 0;
+}
+
+static int _testNewPluginVst2xIdWithIntId(void)
+{
+ PluginVst2xId id = newPluginVst2xIdWithId(0x61626364);
+ assertUnsignedLongEquals(0x61626364l, id->id);
+ assertCharStringEquals("abcd", id->idString);
+ freePluginVst2xId(id);
+ return 0;
+}
+
+static int _testNewPluginVst2xIdWithZeroIntId(void)
+{
+ PluginVst2xId id = newPluginVst2xIdWithId(0);
+ assertUnsignedLongEquals(ZERO_UNSIGNED_LONG, id->id);
+ assertCharStringEquals(EMPTY_STRING, id->idString);
+ freePluginVst2xId(id);
+ return 0;
+}
+
+static int _testNewPluginVst2xIdWithStringId(void)
+{
+ CharString c = newCharStringWithCString("abcd");
+ PluginVst2xId id = newPluginVst2xIdWithStringId(c);
+ assertUnsignedLongEquals(0x61626364l, id->id);
+ assertCharStringEquals(c->data, id->idString);
+ freePluginVst2xId(id);
+ freeCharString(c);
+ return 0;
+}
+
+static int _testNewPluginVst2xIdWithEmptyStringId(void)
+{
+ CharString empty = newCharStringWithCString(EMPTY_STRING);
+ PluginVst2xId id = newPluginVst2xIdWithStringId(empty);
+ assertUnsignedLongEquals(ZERO_UNSIGNED_LONG, id->id);
+ assertCharStringEquals(PLUGIN_VST2X_ID_UNKNOWN, id->idString);
+ freePluginVst2xId(id);
+ freeCharString(empty);
+ return 0;
+}
+
+static int _testNewPluginVst2xIdWithNullStringId(void)
+{
+ PluginVst2xId id = newPluginVst2xIdWithStringId(NULL);
+ assertUnsignedLongEquals(ZERO_UNSIGNED_LONG, id->id);
+ assertCharStringEquals(PLUGIN_VST2X_ID_UNKNOWN, id->idString);
+ freePluginVst2xId(id);
+ return 0;
+}
+
+static int _testNewPluginVst2xIdWithInvalidStringId(void)
+{
+ CharString c = newCharStringWithCString("a");
+ PluginVst2xId id = newPluginVst2xIdWithStringId(c);
+ assertUnsignedLongEquals(ZERO_UNSIGNED_LONG, id->id);
+ assertCharStringEquals(PLUGIN_VST2X_ID_UNKNOWN, id->idString);
+ freePluginVst2xId(id);
+ freeCharString(c);
+ return 0;
+}
+
+TestSuite addPluginVst2xIdTests(void);
+TestSuite addPluginVst2xIdTests(void)
+{
+ TestSuite testSuite = newTestSuite("PluginVst2xId", NULL, NULL);
+
+ addTest(testSuite, "NewPluginVst2xId", _testNewPluginVst2xId);
+ addTest(testSuite, "NewPluginVst2xIdWithIntId", _testNewPluginVst2xIdWithIntId);
+ addTest(testSuite, "NewPluginVst2xIdWithZeroIntId", _testNewPluginVst2xIdWithZeroIntId);
+ addTest(testSuite, "NewPluginVst2xIdWithStringId", _testNewPluginVst2xIdWithStringId);
+ addTest(testSuite, "NewPluginVst2xIdWithNullStringId", _testNewPluginVst2xIdWithNullStringId);
+ addTest(testSuite, "NewPluginVst2xIdWithEmptyStringId", _testNewPluginVst2xIdWithEmptyStringId);
+ addTest(testSuite, "NewPluginVst2xIdWithInvalidStringId", _testNewPluginVst2xIdWithInvalidStringId);
+
+ return testSuite;
+}
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2025-12-11 00:19:45 +0000