Add tests (used to verify carla base code)

.gitignore

@@ -56,6 +56,10 @@ carla-discovery-native
 carla-discovery-posix32
 carla-discovery-posix64
 
+source/tests/CarlaString
+source/tests/RtList
+source/tests/Thread
+
 # Docs
 doc/carla-backend/
 doc/carla-bridge/

source/tests/CarlaString.cpp

@@ -0,0 +1,173 @@
+/*
+ * Carla Tests
+ * Copyright (C) 2013 Filipe Coelho <falktx@falktx.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * For a full copy of the GNU General Public License see the GPL.txt file
+ */
+
+#include "carla_utils.hpp"
+
+#include <cassert>
+
+int main()
+{
+    CarlaString str;
+
+    // empty
+    assert(str.length() == 0);
+    assert(str.length() == std::strlen(""));
+    assert(str.isEmpty());
+    assert(str.contains(""));
+    assert(! str.isNotEmpty());
+    assert(! str.contains("-"));
+    assert(! str.isDigit(0));
+
+    // single number
+    str = "5";
+    assert(str.length() == 1);
+    assert(str.length() == std::strlen("5"));
+    assert(str.isNotEmpty());
+    assert(str.contains(""));
+    assert(str.contains("5"));
+    assert(str.isDigit(0));
+    assert(! str.isEmpty());
+    assert(! str.contains("6"));
+    assert(! str.isDigit(1));
+
+    // single number, using constructor
+    str = CarlaString(5);
+    assert(str.length() == 1);
+    assert(str.length() == std::strlen("5"));
+    assert(str.isNotEmpty());
+    assert(str.contains(""));
+    assert(str.contains("5"));
+    assert(str.isDigit(0));
+    assert(! str.isEmpty());
+    assert(! str.contains("6"));
+    assert(! str.isDigit(1));
+
+    // decimal number
+    str = CarlaString(51);
+    assert(str.length() == 2);
+    assert(str.length() == std::strlen("51"));
+    assert(str.isNotEmpty());
+    assert(str.contains(""));
+    assert(str.contains("1"));
+    assert(str.contains("51"));
+    assert(str.isDigit(0));
+    assert(str.isDigit(1));
+    assert(! str.isEmpty());
+    assert(! str.contains("6"));
+    assert(! str.isDigit(2));
+    assert(! str.isDigit(-1));
+
+    // negative number
+    str = CarlaString(-51);
+    assert(str.length() == 3);
+    assert(str.length() == std::strlen("-51"));
+    assert(str.isNotEmpty());
+    assert(str.contains(""));
+    assert(str.contains("-5"));
+    assert(str.contains("51"));
+    assert(str.isDigit(1));
+    assert(str.isDigit(2));
+    assert(! str.isEmpty());
+    assert(! str.contains("6"));
+    assert(! str.isDigit(0));
+    assert(! str.isDigit(-1));
+
+    // small operations
+    str += "ah";
+    assert(str.length() == 5);
+    assert(str.length() == std::strlen("-51ah"));
+    assert(str.contains("-51ah"));
+    assert(! str.isDigit(3));
+
+    // hexacimal number
+    unsigned int n = 0x91;
+    str += CarlaString(n, true);
+    assert(str.length() == 9);
+    assert(str.length() == std::strlen("-51ah0x91"));
+    assert(str.contains("-51ah0x91"));
+    assert(! str.isDigit(6));
+
+    // float number
+    str += CarlaString(0.0102f);
+    assert(str.length() == 17);
+    assert(str.length() == std::strlen("-51ah0x910.010200"));
+    assert(str.contains("-51ah0x91"));
+    assert(! str.isDigit(6));
+
+    // double number
+    str += CarlaString(7.9642);
+    assert(str.length() == 23);
+    assert(str.length() == std::strlen("-51ah0x910.0102007.9642"));
+    assert(str.contains("7.9642"));
+
+    // replace
+    str.replace('0', 'k');
+    str.replace('k', 'O');
+    str.replace('O', '0');
+    str.replace('0', '\0'); // shouldn't do anything
+
+    // truncate
+    str.truncate(11);
+    assert(str.length() == 11);
+    assert(str.length() == std::strlen("-51ah0x910."));
+
+    // basic
+    str.toBasic();
+    assert(str.length() == 11);
+    assert(str == "_51ah0x910_");
+
+    // upper
+    str.toUpper();
+    assert(str.length() == 11);
+    assert(str == "_51AH0X910_");
+
+    // lower
+    str.toLower();
+    assert(str.length() == 11);
+    assert(str == "_51ah0x910_");
+
+    // random stuff
+    CarlaString str1(1.23);
+    str1 += "_  ?";
+
+    CarlaString str2("test1");
+    str2  = "test2";
+    str2 += ".0";
+
+    CarlaString str3("1.23_  ?test2.0 final");
+
+    CarlaString str4 = "" + str1 + str2 + " final";
+
+    assert(str3 == "1.23_  ?test2.0 final");
+    assert(str3 == str4);
+    assert(str3.length() == str4.length());
+    assert(str3.length() == std::strlen("1.23_  ?test2.0 final"));
+
+    CarlaString str5 = "ola " + str + " " + CarlaString(6);
+    assert(str5 == "ola _51ah0x910_ 6");
+    assert(str5.length() == std::strlen("ola _51ah0x910_ 6"));
+
+    printf("FINAL: \"%s\"\n", (const char*)str5);
+
+    // clear
+    str.clear();
+    assert(str.length() == 0);
+    assert(str.length() == std::strlen(""));
+    assert(str == "");
+
+    return 0;
+}

source/tests/Makefile

@@ -0,0 +1,39 @@
+#!/usr/bin/make -f
+# Makefile for carla tests #
+# ------------------------ #
+# Created by falkTX
+#
+
+include ../Makefile.mk
+
+# --------------------------------------------------------------
+
+BUILD_CXX_FLAGS += -I../backend -I../includes -I../utils
+BUILD_CXX_FLAGS += $(shell pkg-config --cflags QtCore)
+LINK_FLAGS      += $(shell pkg-config --libs QtCore)
+
+TARGETS = CarlaString RtList Thread
+
+all: $(TARGETS) RUN
+
+# --------------------------------------------------------------
+
+CarlaString: CarlaString.cpp
+	$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) -o $@
+
+RtList: RtList.cpp ../libs/rtmempool.a
+	$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) -o $@
+
+Thread_: Thread.cpp
+	$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) -pthread -lpthread -o $@
+
+RUN: $(TARGETS)
+	./CarlaString && ./RtList && ./Thread
+
+# --------------------------------------------------------------
+
+clean:
+	rm -f $(TARGETS)
+
+debug:
+	$(MAKE) DEBUG=true

source/tests/RtList.cpp

@@ -0,0 +1,158 @@
+/*
+ * Carla Tests
+ * Copyright (C) 2013 Filipe Coelho <falktx@falktx.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * For a full copy of the GNU General Public License see the GPL.txt file
+ */
+
+#include "carla_utils.hpp"
+#include "rt_list.hpp"
+
+#include <cassert>
+
+const unsigned short MIN_RT_EVENTS = 152;
+const unsigned short MAX_RT_EVENTS = 512;
+
+struct MyData {
+    CarlaString str;
+    int idStr;
+
+    MyData()
+        : idStr(-1) {}
+
+    MyData(int id)
+        : str(id),
+          idStr(id) {}
+
+    MyData(MyData&) = delete;
+    MyData(const MyData&) = delete;
+};
+
+struct PostRtEvents {
+    CarlaMutex mutex;
+    RtList<MyData>::Pool dataPool;
+    RtList<MyData> data;
+    RtList<MyData> dataPendingRT;
+
+    PostRtEvents()
+        : dataPool(MIN_RT_EVENTS, MAX_RT_EVENTS),
+          data(&dataPool),
+          dataPendingRT(&dataPool) {}
+
+    ~PostRtEvents()
+    {
+        clear();
+    }
+
+    void appendRT(const MyData& event)
+    {
+        dataPendingRT.append(event);
+    }
+
+    void clear()
+    {
+        mutex.lock();
+        data.clear();
+        dataPendingRT.clear();
+        mutex.unlock();
+    }
+
+    void trySplice()
+    {
+        if (mutex.tryLock())
+        {
+            dataPendingRT.splice(data, true);
+            mutex.unlock();
+        }
+    }
+
+    //void appendNonRT(const PluginPostRtEvent& event)
+    //{
+    //    data.append_sleepy(event);
+    //}
+
+} postRtEvents;
+
+void run4Tests()
+{
+    unsigned short k = 0;
+    MyData allMyData[MAX_RT_EVENTS];
+
+    // Make a safe copy of events while clearing them
+    postRtEvents.mutex.lock();
+
+    while (! postRtEvents.data.isEmpty())
+    {
+        MyData& my = postRtEvents.data.getFirst(true);
+        allMyData[k++] = my;
+        //std::memcpy(&allMyData[i++], &my, sizeof(MyData));
+    }
+
+    postRtEvents.mutex.unlock();
+
+    printf("Post-Rt Event Count: %i\n", k);
+    assert(k == 4);
+
+    // data should be empty now
+    assert(postRtEvents.data.count() == 0);
+    assert(postRtEvents.data.isEmpty());
+    assert(postRtEvents.dataPendingRT.count() == 0);
+    assert(postRtEvents.dataPendingRT.isEmpty());
+
+    // Handle events now
+    for (unsigned short i=0; i < k; i++)
+    {
+        const MyData& my = allMyData[i];
+
+        printf("Got data: %i %s\n", my.idStr, (const char*)my.str);
+    }
+}
+
+int main()
+{
+    MyData m1(1);
+    MyData m2(2);
+    MyData m3(3);
+    MyData m4(4);
+
+    // start
+    assert(postRtEvents.data.count() == 0);
+    assert(postRtEvents.data.isEmpty());
+    assert(postRtEvents.dataPendingRT.count() == 0);
+    assert(postRtEvents.dataPendingRT.isEmpty());
+
+    // single append
+    postRtEvents.appendRT(m1);
+    postRtEvents.trySplice();
+    assert(postRtEvents.data.count() == 1);
+    assert(postRtEvents.dataPendingRT.count() == 0);
+
+    // +3 appends
+    postRtEvents.appendRT(m2);
+    postRtEvents.appendRT(m4);
+    postRtEvents.appendRT(m3);
+    postRtEvents.trySplice();
+    assert(postRtEvents.data.count() == 4);
+    assert(postRtEvents.dataPendingRT.count() == 0);
+
+    run4Tests();
+
+    // reset
+    postRtEvents.clear();
+    assert(postRtEvents.data.count() == 0);
+    assert(postRtEvents.data.isEmpty());
+    assert(postRtEvents.dataPendingRT.count() == 0);
+    assert(postRtEvents.dataPendingRT.isEmpty());
+
+    return 0;
+}

source/tests/Thread.cpp

@@ -0,0 +1,92 @@
+/*
+ * Carla Tests
+ * Copyright (C) 2013 Filipe Coelho <falktx@falktx.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * For a full copy of the GNU General Public License see the GPL.txt file
+ */
+
+#include "carla_utils.hpp"
+
+#include <cassert>
+
+class MyThread : public CarlaThread
+{
+public:
+    MyThread(bool wait)
+        : blockWait(wait)
+    {
+    }
+
+protected:
+    void run()
+    {
+        printf("RUN(%i)\n", blockWait);
+
+        if (blockWait)
+        {
+            for (int i=0; i < 100; i++)
+            {
+                carla_msleep(50);
+                printf("RUN(%i) - BLOCKING\n", blockWait);
+            }
+        }
+
+        printf("RUN(%i) - FINISHED\n", blockWait);
+    }
+
+private:
+    bool blockWait;
+};
+
+int main()
+{
+    MyThread t1(false);
+    MyThread t2(true);
+
+    MyThread t3(true);
+    MyThread t4(true);
+    MyThread t5(false);
+
+    t1.start();
+    t2.start();
+    //t3.start();
+
+    //t3.waitForStarted();
+    //t3.stop();
+
+    t1.waitForStarted();
+    t2.waitForStarted();
+
+    printf("THREADS STARTED\n");
+
+    // test if threds keep working
+    carla_sleep(1);
+
+    printf("THREAD1 STOPPING...\n");
+
+    if (t1.isRunning() && ! t1.stop(500))
+    {
+       printf("THREAD1 FAILED, TERMINATE\n");
+       t1.terminate();
+    }
+
+    printf("THREAD2 STOPPING...\n");
+
+    if (t2.isRunning() && ! t2.stop(500))
+    {
+       printf("THREAD2 FAILED, TERMINATE\n");
+       t2.terminate();
+    }
+
+    return 0;
+}