first

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;
+}