falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1926 Commits
17 Branches
940MB
Tree: 51aced51e2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '51aced51e2'
${ noResults }
Carla/source/tests/CarlaUtils.cpp

638 lines
19KB
Raw Blame History 

  1. /*

  2.  * Carla Utility Tests

  3.  * Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #ifdef NDEBUG

  19. # error Build this file with debug ON please

  20. #endif

  21. 

  22. #define HAVE_JUCE

  23. #define VESTIGE_HEADER

  24. 

  25. #include "CarlaUtils.hpp"

  26. #include "CarlaMathUtils.hpp"

  27. 

  28. #undef NULL

  29. #define NULL nullptr

  30. 

  31. #include "CarlaBackendUtils.hpp"

  32. #include "CarlaEngineUtils.hpp"

  33. 

  34. #include "CarlaLadspaUtils.hpp"

  35. #include "CarlaDssiUtils.hpp"

  36. #include "CarlaLv2Utils.hpp"

  37. #include "CarlaVstUtils.hpp"

  38. 

  39. // used in dssi utils

  40. #include "juce_core.h"

  41. #include <QtCore/QDir>

  42. #include <QtCore/QFileInfo>

  43. #include <QtCore/QStringList>

  44. 

  45. // #include "CarlaBridgeUtils.hpp"

  46. // #include "CarlaJuceUtils.hpp"

  47. // #include "CarlaLibUtils.hpp"

  48. // #include "CarlaOscUtils.hpp"

  49. // #include "CarlaShmUtils.hpp"

  50. // #include "CarlaStateUtils.hpp"

  51. // #include "CarlaVstUtils.hpp"

  52. 

  53. // #include "CarlaLibCounter.hpp"

  54. // #include "CarlaLogThread.hpp"

  55. // #include "CarlaRingBuffer.hpp"

  56. // #include "CarlaThread.hpp"

  57. // #include "Lv2AtomQueue.hpp"

  58. 

  59. // #include "JucePluginWindow.hpp"

  60. 

  61. #if 0

  62. // -----------------------------------------------------------------------

  63. 

  64. static void test_CarlaUtils() noexcept

  65. {

  66.     // -------------------------------------------------------------------

  67.     // misc functions

  68. 

  69.     {

  70.         bool2str(false);

  71.         bool2str(true);

  72.         pass();

  73. 

  74.         char strBuf[1];

  75.         nullStrBuf(strBuf);

  76.     }

  77. 

  78.     // -------------------------------------------------------------------

  79.     // string print functions

  80. 

  81.     {

  82.         carla_debug("DEBUG");

  83.         carla_stdout("STDOUT %s", bool2str(true));

  84.         carla_stderr("STDERR %s", bool2str(false));

  85.         carla_stderr2("STDERR2 " P_UINT64, 0xffffffff); // 4294967295

  86.     }

  87. 

  88.     // -------------------------------------------------------------------

  89.     // carla_*sleep

  90. 

  91.     {

  92.         //carla_sleep(1);

  93.         //carla_msleep(1);

  94.     }

  95. 

  96.     // -------------------------------------------------------------------

  97.     // carla_setenv

  98. 

  99.     {

  100.         carla_setenv("THIS", "THAT");

  101.         assert(std::strcmp(std::getenv("THIS"), "THAT") == 0);

  102.     }

  103. 

  104.     // -------------------------------------------------------------------

  105.     // carla_strdup

  106. 

  107.     {

  108.         // with variables

  109.         const char* const str1(carla_strdup("string1"));

  110.         const char* const strF(carla_strdup_free(strdup("string2")));

  111.         delete[] str1;

  112.         delete[] strF;

  113. 

  114.         // without variables

  115.         delete[] carla_strdup("string3");

  116.         delete[] carla_strdup_free(strdup("string4"));

  117. 

  118.         // common use case in Carla code

  119.         struct TestStruct {

  120.             const char* str1;

  121.             const char* str2;

  122.             const char* str3;

  123.             const char* str4;

  124. 

  125.             TestStruct()

  126.                 : str1(carla_strdup("str1")),

  127.                   str2(carla_strdup("str2")),

  128.                   str3(nullptr),

  129.                   str4(carla_strdup("str4")) {}

  130. 

  131.             ~TestStruct() noexcept

  132.             {

  133.                 if (str1 != nullptr)

  134.                 {

  135.                     delete[] str1;

  136.                     str1 = nullptr;

  137.                 }

  138. 

  139.                 if (str2 != nullptr)

  140.                 {

  141.                     delete[] str2;

  142.                     str2 = nullptr;

  143.                 }

  144. 

  145.                 if (str3 != nullptr)

  146.                 {

  147.                     delete[] str3;

  148.                     str3 = nullptr;

  149.                 }

  150. 

  151.                 if (str4 != nullptr)

  152.                 {

  153.                     delete[] str4;

  154.                     str4 = nullptr;

  155.                 }

  156.             }

  157.         };

  158. 

  159.         TestStruct a, b, c;

  160.     }

  161. 

  162.     // -------------------------------------------------------------------

  163.     // memory functions

  164. 

  165.     {

  166.         int a[] = { 4, 3, 2, 1 };

  167.         int b[] = { 1, 2, 3, 4 };

  168.         carla_add(a, b, 4);

  169.         assert(a[0] == 5);

  170.         assert(a[1] == 5);

  171.         assert(a[2] == 5);

  172.         assert(a[3] == 5);

  173. 

  174.         int c[] = { 4, 3, 2, 1 };

  175.         carla_add(b, c, 4);

  176.         assert(a[0] == b[0]);

  177.         assert(a[1] == b[1]);

  178.         assert(a[2] == b[2]);

  179.         assert(a[3] == b[3]);

  180. 

  181.         carla_copy(a,   c,   2);

  182.         carla_copy(b+2, c+2, 2);

  183.         assert(a[0] == c[0]);

  184.         assert(a[1] == c[1]);

  185.         assert(b[2] == c[2]);

  186.         assert(b[3] == c[3]);

  187.         carla_copy(c, a, 4);

  188.         assert(a[0] == c[0]);

  189.         assert(a[1] == c[1]);

  190.         assert(a[2] == c[2]);

  191.         assert(a[3] == c[3]);

  192. 

  193.         carla_fill(a, 0, 4);

  194.         assert(a[0] == 0);

  195.         assert(a[1] == 0);

  196.         assert(a[2] == 0);

  197.         assert(a[3] == 0);

  198. 

  199.         carla_fill(a, -11, 4);

  200.         assert(a[0] == -11);

  201.         assert(a[1] == -11);

  202.         assert(a[2] == -11);

  203.         assert(a[3] == -11);

  204. 

  205.         carla_fill(a+0, 17, 2);

  206.         carla_fill(a+2, 23, 2);

  207.         assert(a[0] == 17);

  208.         assert(a[1] == 17);

  209.         assert(a[2] == 23);

  210.         assert(a[3] == 23);

  211. 

  212.         carla_zeroBytes(a, sizeof(int)*4);

  213.         assert(a[0] == 0);

  214.         assert(a[1] == 0);

  215.         assert(a[2] == 0);

  216.         assert(a[3] == 0);

  217. 

  218.         char strBuf[501];

  219.         strBuf[0] = strBuf[499] = strBuf[500] = '!';

  220.         carla_zeroChar(strBuf, 501);

  221. 

  222.         for (int i=0; i<501; ++i)

  223.             assert(strBuf[i] == '\0');

  224. 

  225.         int d = 1527, e = 0;

  226.         carla_add(&d, &d, 1);

  227.         carla_add(&d, &e, 1);

  228.         carla_add(&e, &d, 1);

  229.         assert(d == 1527*2);

  230.         assert(d == e);

  231. 

  232.         e = -e;

  233.         carla_add(&d, &e, 1);

  234.         assert(d == 0);

  235. 

  236.         carla_copy(&d, &e, 1);

  237.         assert(d == -1527*2);

  238.         assert(d == e);

  239. 

  240.         carla_fill(&d, 9999, 1);

  241.         carla_fill(&e, 123, 1);

  242.         assert(d == 9999);

  243.         assert(e == 123);

  244. 

  245.         carla_zeroStruct(d);

  246.         assert(d == 0);

  247. 

  248.         carla_copyStruct(d, e);

  249.         assert(d != 0);

  250.         assert(d == e);

  251. 

  252.         carla_fill(a+0, 1, 1);

  253.         carla_fill(a+1, 2, 1);

  254.         carla_fill(a+2, 3, 1);

  255.         carla_fill(a+3, 4, 1);

  256.         assert(a[0] == 1);

  257.         assert(a[1] == 2);

  258.         assert(a[2] == 3);

  259.         assert(a[3] == 4);

  260. 

  261.         carla_copyStruct(c, a, 4);

  262.         assert(c[0] == a[0]);

  263.         assert(c[1] == a[1]);

  264.         assert(c[2] == a[2]);

  265.         assert(c[3] == a[3]);

  266. 

  267.         carla_zeroStruct(c, 4);

  268.         assert(c[0] == 0);

  269.         assert(c[1] == 0);

  270.         assert(c[2] == 0);

  271.         assert(c[3] == 0);

  272. 

  273.         float fl[5];

  274.         carla_fill(fl, 1.11f, 5);

  275.         assert(fl[0] == 1.11f);

  276.         assert(fl[1] == 1.11f);

  277.         assert(fl[2] == 1.11f);

  278.         assert(fl[3] == 1.11f);

  279.         assert(fl[4] == 1.11f);

  280. 

  281.         carla_add(fl, fl, 5);

  282.         assert(fl[0] == 1.11f*2);

  283.         assert(fl[1] == 1.11f*2);

  284.         assert(fl[2] == 1.11f*2);

  285.         assert(fl[3] == 1.11f*2);

  286.         assert(fl[4] == 1.11f*2);

  287. 

  288.         carla_add(fl, fl, 4);

  289.         assert(fl[0] == 1.11f*4);

  290.         assert(fl[1] == 1.11f*4);

  291.         assert(fl[2] == 1.11f*4);

  292.         assert(fl[3] == 1.11f*4);

  293.         assert(fl[4] == 1.11f*2);

  294. 

  295.         carla_add(fl, fl, 3);

  296.         assert(fl[0] == 1.11f*8);

  297.         assert(fl[1] == 1.11f*8);

  298.         assert(fl[2] == 1.11f*8);

  299.         assert(fl[3] == 1.11f*4);

  300.         assert(fl[4] == 1.11f*2);

  301. 

  302.         carla_add(fl, fl, 2);

  303.         assert(fl[0] == 1.11f*16);

  304.         assert(fl[1] == 1.11f*16);

  305.         assert(fl[2] == 1.11f*8);

  306.         assert(fl[3] == 1.11f*4);

  307.         assert(fl[4] == 1.11f*2);

  308. 

  309.         carla_add(fl, fl, 1);

  310.         assert(fl[0] == 1.11f*32);

  311.         assert(fl[1] == 1.11f*16);

  312.         assert(fl[2] == 1.11f*8);

  313.         assert(fl[3] == 1.11f*4);

  314.         assert(fl[4] == 1.11f*2);

  315.     }

  316. }

  317. 

  318. // -----------------------------------------------------------------------

  319. 

  320. static void test_CarlaMathUtils() noexcept

  321. {

  322.     // -------------------------------------------------------------------

  323.     // math functions (base)

  324. 

  325.     // Return the lower of 2 values, with 'min' as the minimum possible value.

  326.     assert(carla_min(0, 0, 0) == 0);

  327.     assert(carla_min(0, 3, 0) == 0);

  328.     assert(carla_min(3, 0, 0) == 0);

  329. 

  330.     assert(carla_min(0, 0, 3) == 3);

  331.     assert(carla_min(0, 1, 3) == 3);

  332.     assert(carla_min(0, 2, 3) == 3);

  333.     assert(carla_min(0, 3, 3) == 3);

  334.     assert(carla_min(0, 4, 3) == 3);

  335. 

  336.     assert(carla_min(5, 0, 3) == 3);

  337.     assert(carla_min(5, 1, 3) == 3);

  338.     assert(carla_min(5, 2, 3) == 3);

  339.     assert(carla_min(5, 3, 3) == 3);

  340.     assert(carla_min(5, 4, 3) == 4);

  341.     assert(carla_min(5, 5, 3) == 5);

  342.     assert(carla_min(5, 6, 3) == 5);

  343. 

  344.     assert(carla_min(2, -2, 0) == 0);

  345.     assert(carla_min(2, -1, 0) == 0);

  346.     assert(carla_min(2,  0, 0) == 0);

  347.     assert(carla_min(2,  1, 0) == 1);

  348.     assert(carla_min(2,  2, 0) == 2);

  349. 

  350.     assert(carla_min(5, -6, 3) == 3);

  351.     assert(carla_min(5, -5, 3) == 3);

  352.     assert(carla_min(5, -4, 3) == 3);

  353.     assert(carla_min(5, -3, 3) == 3);

  354.     assert(carla_min(5, -2, 3) == 3);

  355.     assert(carla_min(5, -1, 3) == 3);

  356.     assert(carla_min(5,  0, 3) == 3);

  357.     assert(carla_min(5,  1, 3) == 3);

  358.     assert(carla_min(5,  2, 3) == 3);

  359.     assert(carla_min(5,  3, 3) == 3);

  360.     assert(carla_min(5,  4, 3) == 4);

  361.     assert(carla_min(5,  5, 3) == 5);

  362.     assert(carla_min(5,  6, 3) == 5);

  363. 

  364.     assert(carla_min(5, -6, -3) == -3);

  365.     assert(carla_min(5, -5, -3) == -3);

  366.     assert(carla_min(5, -4, -3) == -3);

  367.     assert(carla_min(5, -3, -3) == -3);

  368.     assert(carla_min(5, -2, -3) == -2);

  369.     assert(carla_min(5, -1, -3) == -1);

  370.     assert(carla_min(5,  0, -3) == 0);

  371.     assert(carla_min(5,  1, -3) == 1);

  372.     assert(carla_min(5,  2, -3) == 2);

  373.     assert(carla_min(5,  3, -3) == 3);

  374.     assert(carla_min(5,  4, -3) == 4);

  375.     assert(carla_min(5,  5, -3) == 5);

  376.     assert(carla_min(5,  6, -3) == 5);

  377. 

  378.     // Return the lower positive of 2 values.

  379.     assert(carla_minPositive(0, 0) == 0);

  380.     assert(carla_minPositive(0, 1) == 0);

  381.     assert(carla_minPositive(0, 2) == 0);

  382.     assert(carla_minPositive(0, 3) == 0);

  383. 

  384.     assert(carla_minPositive(1, 0) == 0);

  385.     assert(carla_minPositive(1, 1) == 1);

  386.     assert(carla_minPositive(1, 2) == 1);

  387.     assert(carla_minPositive(1, 3) == 1);

  388. 

  389.     assert(carla_minPositive(3, 0) == 0);

  390.     assert(carla_minPositive(3, 1) == 1);

  391.     assert(carla_minPositive(3, 2) == 2);

  392.     assert(carla_minPositive(3, 3) == 3);

  393. 

  394.     assert(carla_minPositive(-1, 0) == 0);

  395.     assert(carla_minPositive(-1, 1) == 1);

  396.     assert(carla_minPositive(-1, 2) == 2);

  397.     assert(carla_minPositive(-1, 3) == 3);

  398. 

  399.     // Return the higher of 2 values, with 'max' as the maximum possible value.

  400.     assert(carla_max(0, 0, 0) == 0);

  401.     assert(carla_max(0, 3, 0) == 0);

  402.     assert(carla_max(3, 0, 0) == 0);

  403. 

  404.     assert(carla_max(0, 0, 3) == 0);

  405.     assert(carla_max(0, 1, 3) == 1);

  406.     assert(carla_max(0, 2, 3) == 2);

  407.     assert(carla_max(0, 3, 3) == 3);

  408.     assert(carla_max(0, 4, 3) == 3);

  409. 

  410.     assert(carla_max(5, 0, 3) == 3);

  411.     assert(carla_max(5, 1, 3) == 3);

  412.     assert(carla_max(5, 2, 3) == 3);

  413.     assert(carla_max(5, 3, 3) == 3);

  414.     assert(carla_max(5, 4, 3) == 3);

  415.     assert(carla_max(5, 5, 3) == 3);

  416.     assert(carla_max(5, 6, 3) == 3);

  417. 

  418.     // Fix bounds of 'value' between 'min' and 'max'.

  419.     assert(carla_fixValue(0, 1, -1) == 0);

  420.     assert(carla_fixValue(0, 1,  0) == 0);

  421.     assert(carla_fixValue(0, 1,  1) == 1);

  422.     assert(carla_fixValue(0, 1,  2) == 1);

  423. 

  424.     assert(carla_fixValue(0.0, 1.0, -1.0) == 0.0);

  425.     assert(carla_fixValue(0.0, 1.0,  0.0) == 0.0);

  426.     assert(carla_fixValue(0.0, 1.0,  1.0) == 1.0);

  427.     assert(carla_fixValue(0.0, 1.0,  2.0) == 1.0);

  428. 

  429.     assert(carla_fixValue(0.0, 1.0, -0.1) == 0.0);

  430.     assert(carla_fixValue(0.0, 1.0,  1.1) == 1.0);

  431. 

  432.     // Get next power of 2.

  433.     assert(carla_nextPowerOf2(0) == 0);

  434.     assert(carla_nextPowerOf2(1) == 1);

  435.     assert(carla_nextPowerOf2(2) == 2);

  436.     assert(carla_nextPowerOf2(4) == 4);

  437.     assert(carla_nextPowerOf2(5) == 8);

  438.     assert(carla_nextPowerOf2(6) == 8);

  439.     assert(carla_nextPowerOf2(7) == 8);

  440.     assert(carla_nextPowerOf2(8) == 8);

  441.     assert(carla_nextPowerOf2(9) == 16);

  442. 

  443.     uint32_t power = 1;

  444.     assert((power = carla_nextPowerOf2(power+1)) == 2);

  445.     assert((power = carla_nextPowerOf2(power+1)) == 4);

  446.     assert((power = carla_nextPowerOf2(power+1)) == 8);

  447.     assert((power = carla_nextPowerOf2(power+1)) == 16);

  448.     assert((power = carla_nextPowerOf2(power+1)) == 32);

  449.     assert((power = carla_nextPowerOf2(power+1)) == 64);

  450.     assert((power = carla_nextPowerOf2(power+1)) == 128);

  451.     assert((power = carla_nextPowerOf2(power+1)) == 256);

  452.     assert((power = carla_nextPowerOf2(power+1)) == 512);

  453.     assert((power = carla_nextPowerOf2(power+1)) == 1024);

  454.     assert((power = carla_nextPowerOf2(power+1)) == 2048);

  455.     assert((power = carla_nextPowerOf2(power+1)) == 4096);

  456.     assert((power = carla_nextPowerOf2(power+1)) == 8192);

  457.     assert((power = carla_nextPowerOf2(power+1)) == 16384);

  458.     assert((power = carla_nextPowerOf2(power+1)) == 32768);

  459.     assert((power = carla_nextPowerOf2(power+1)) == 65536);

  460.     assert((power = carla_nextPowerOf2(power+1)) == 131072);

  461. 

  462.     // -------------------------------------------------------------------

  463.     // math functions (extended)

  464. 

  465.     // carla_addFloat, carla_copyFloat & carla_zeroFloat tests skipped

  466.     // mostly unused due to juce::FloatVectorOperations

  467. }

  468. 

  469. // -----------------------------------------------------------------------

  470. 

  471. static void test_CarlaBackendUtils() noexcept

  472. {

  473.     CARLA_BACKEND_USE_NAMESPACE

  474.     carla_stdout(PluginOption2Str(PLUGIN_OPTION_FIXED_BUFFERS));

  475.     carla_stdout(BinaryType2Str(BINARY_NONE));

  476.     carla_stdout(PluginType2Str(PLUGIN_NONE));

  477.     carla_stdout(PluginCategory2Str(PLUGIN_CATEGORY_NONE));

  478.     carla_stdout(ParameterType2Str(PARAMETER_UNKNOWN));

  479.     carla_stdout(InternalParameterIndex2Str(PARAMETER_NULL));

  480.     carla_stdout(EngineCallbackOpcode2Str(ENGINE_CALLBACK_DEBUG));

  481.     carla_stdout(EngineOption2Str(ENGINE_OPTION_DEBUG));

  482.     carla_stdout(EngineProcessMode2Str(ENGINE_PROCESS_MODE_SINGLE_CLIENT));

  483.     carla_stdout(EngineTransportMode2Str(ENGINE_TRANSPORT_MODE_INTERNAL));

  484.     carla_stdout(FileCallbackOpcode2Str(FILE_CALLBACK_DEBUG));

  485.     carla_stdout(getPluginTypeAsString(PLUGIN_INTERNAL));

  486.     carla_stdout(PatchbayIcon2Str(PATCHBAY_ICON_APPLICATION));

  487.     getPluginTypeFromString("none");

  488.     getPluginCategoryFromName("cat");

  489. }

  490. 

  491. // -----------------------------------------------------------------------

  492. 

  493. static void test_CarlaEngineUtils() noexcept

  494. {

  495.     CARLA_BACKEND_USE_NAMESPACE

  496.     carla_stdout(EngineType2Str(kEngineTypeNull));

  497.     carla_stdout(EnginePortType2Str(kEnginePortTypeNull));

  498.     carla_stdout(EngineEventType2Str(kEngineEventTypeNull));

  499.     carla_stdout(EngineControlEventType2Str(kEngineControlEventTypeNull));

  500. }

  501. 

  502. // -----------------------------------------------------------------------

  503. 

  504. static void test_CarlaLadspaUtils() noexcept

  505. {

  506.     LADSPA_Descriptor desc;

  507.     carla_zeroStruct(desc);

  508. 

  509.     LADSPA_RDF_Descriptor rdfDesc;

  510.     delete ladspa_rdf_dup(&rdfDesc);

  511. 

  512.     is_ladspa_port_good(0x0, 0x0);

  513.     is_ladspa_rdf_descriptor_valid(&rdfDesc, &desc);

  514.     get_default_ladspa_port_value(0x0, -1.0f, 1.0f);

  515. }

  516. 

  517. // -----------------------------------------------------------------------

  518. 

  519. namespace dssi_juce {

  520. const char* find_dssi_ui(const char* const filename, const char* const label) noexcept;

  521. #define HAVE_JUCE

  522. #include "CarlaDssiUtils.cpp"

  523. }

  524. 

  525. namespace dssi_qt {

  526. const char* find_dssi_ui(const char* const filename, const char* const label) noexcept;

  527. #undef HAVE_JUCE

  528. #include "CarlaDssiUtils.cpp"

  529. }

  530. 

  531. static void test_CarlaDssiUtils() noexcept

  532. {

  533.     const char* const ui_juce = dssi_juce::find_dssi_ui("/usr/lib/dssi/trivial_sampler.so", "aa");

  534.     const char* const ui_qt   = dssi_qt::find_dssi_ui("/usr/lib/dssi/trivial_sampler.so", "aa");

  535. 

  536.     CARLA_SAFE_ASSERT(ui_juce != nullptr);

  537.     CARLA_SAFE_ASSERT(ui_qt != nullptr);

  538. 

  539.     if (ui_juce != nullptr)

  540.     {

  541.         carla_stdout("%s", ui_juce);

  542.         assert(std::strcmp(ui_juce, "/usr/lib/dssi/trivial_sampler/trivial_sampler_qt") == 0);

  543.         delete[] ui_juce;

  544.     }

  545. 

  546.     if (ui_qt != nullptr)

  547.     {

  548.         carla_stdout("%s", ui_qt);

  549.         assert(std::strcmp(ui_qt, "/usr/lib/dssi/trivial_sampler/trivial_sampler_qt") == 0);

  550.         delete[] ui_qt;

  551.     }

  552. }

  553. 

  554. // -----------------------------------------------------------------------

  555. 

  556. static LV2_URID test_lv2_uridMap(LV2_URID_Map_Handle, const char*)

  557. {

  558.     return 1;

  559. }

  560. 

  561. static void test_CarlaLv2Utils() noexcept

  562. {

  563.     Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  564.     lv2World.initIfNeeded();

  565. 

  566.     // getPlugin

  567.     const LilvPlugin* const plugin(lv2World.getPlugin("urn:juced:DrumSynth"));

  568.     CARLA_SAFE_ASSERT(plugin != nullptr);

  569. 

  570.     // getState

  571.     LV2_URID_Map uridMap = { nullptr, test_lv2_uridMap };

  572.     LilvState* const state(lv2World.getState("http://arcticanaudio.com/plugins/thefunction#preset001", &uridMap));

  573.     CARLA_SAFE_ASSERT(state != nullptr);

  574.     if (state != nullptr) lilv_state_free(state);

  575. 

  576.     // load a bunch of plugins to stress test lilv

  577.     delete lv2_rdf_new("http://arcticanaudio.com/plugins/thefunction", true);

  578.     delete lv2_rdf_new("http://kunz.corrupt.ch/products/tal-noisemaker", true);

  579.     delete lv2_rdf_new("http://calf.sourceforge.net/plugins/Reverb", true);

  580.     delete lv2_rdf_new("http://www.openavproductions.com/fabla", true);

  581.     delete lv2_rdf_new("http://invadarecords.com/plugins/lv2/meter", true);

  582.     delete lv2_rdf_new("http://gareus.org/oss/lv2/meters#spectr30stereo", true);

  583.     delete lv2_rdf_new("http://plugin.org.uk/swh-plugins/revdelay", true);

  584.     delete lv2_rdf_new("http://lv2plug.in/plugins/eg-scope#Stereo", true);

  585.     delete lv2_rdf_new("http://kxstudio.sf.net/carla/plugins/carlarack", true);

  586.     delete lv2_rdf_new("http://guitarix.sourceforge.net/plugins/gxautowah#autowah", true);

  587.     delete lv2_rdf_new("http://github.com/blablack/ams-lv2/mixer_4ch", true);

  588.     delete lv2_rdf_new("http://drumgizmo.org/lv2", true);

  589.     delete lv2_rdf_new("http://synthv1.sourceforge.net/lv2", true);

  590.     delete lv2_rdf_new("urn:juced:DrumSynth", true);

  591. 

  592.     // misc

  593.     is_lv2_port_supported(0x0);

  594.     is_lv2_feature_supported("test1");

  595.     is_lv2_ui_feature_supported("test2");

  596. }

  597. #endif

  598. 

  599. // -----------------------------------------------------------------------

  600. 

  601. static intptr_t test_vst_dispatcher(AEffect*, int, int, intptr_t, void*, float)

  602. {

  603.     return 0;

  604. }

  605. 

  606. static void test_CarlaVstUtils() noexcept

  607. {

  608.     AEffect effect;

  609.     carla_zeroStruct(effect);

  610.     effect.dispatcher = test_vst_dispatcher;

  611. 

  612.     vstPluginCanDo(&effect, "test");

  613.     carla_stdout(vstEffectOpcode2str(effOpen));

  614.     carla_stdout(vstMasterOpcode2str(audioMasterAutomate));

  615. }

  616. 

  617. // -----------------------------------------------------------------------

  618. // main

  619. 

  620. int main()

  621. {

  622.     // already tested, skip for now

  623. //     test_CarlaUtils();

  624. //     test_CarlaMathUtils();

  625. //

  626. //     test_CarlaBackendUtils();

  627. //     test_CarlaEngineUtils();

  628. //

  629. //     test_CarlaLadspaUtils();

  630. //     test_CarlaDssiUtils();

  631. //     test_CarlaLv2Utils();

  632.     test_CarlaVstUtils();

  633. 

  634.     return 0;

  635. }

  636. 

  637. // -----------------------------------------------------------------------