falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 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.
1939 Commits
16 Branches
324MB
Tree: 791da3670e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '791da3670e'
${ noResults }
Carla/source/tests/CarlaUtils.cpp

839 lines
24KB
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. #include "CarlaBridgeUtils.hpp"

  40. #include "CarlaJuceUtils.hpp"

  41. #include "CarlaLibCounter.hpp"

  42. #include "CarlaOscUtils.hpp" // TODO

  43. #include "CarlaPatchbayUtils.hpp" // TODO

  44. // #include "CarlaPipeUtils.hpp"

  45. // #include "CarlaStateUtils.hpp"

  46. #include "CarlaShmUtils.hpp"

  47. 

  48. // used in dssi utils

  49. #include "juce_core.h"

  50. #include <QtCore/QDir>

  51. #include <QtCore/QFileInfo>

  52. #include <QtCore/QStringList>

  53. 

  54. #if 0

  55. // -----------------------------------------------------------------------

  56. 

  57. static void test_CarlaUtils()

  58. {

  59.     // -------------------------------------------------------------------

  60.     // misc functions

  61. 

  62.     {

  63.         bool2str(false);

  64.         bool2str(true);

  65.         pass();

  66. 

  67.         char strBuf[1];

  68.         nullStrBuf(strBuf);

  69.     }

  70. 

  71.     // -------------------------------------------------------------------

  72.     // string print functions

  73. 

  74.     {

  75.         carla_debug("DEBUG");

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

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

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

  79.     }

  80. 

  81.     // -------------------------------------------------------------------

  82.     // carla_*sleep

  83. 

  84.     {

  85.         //carla_sleep(1);

  86.         //carla_msleep(1);

  87.     }

  88. 

  89.     // -------------------------------------------------------------------

  90.     // carla_setenv

  91. 

  92.     {

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

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

  95.     }

  96. 

  97.     // -------------------------------------------------------------------

  98.     // carla_strdup

  99. 

  100.     {

  101.         // with variables

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

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

  104.         delete[] str1;

  105.         delete[] strF;

  106. 

  107.         // without variables

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

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

  110. 

  111.         // common use case in Carla code

  112.         struct TestStruct {

  113.             const char* str1;

  114.             const char* str2;

  115.             const char* str3;

  116.             const char* str4;

  117. 

  118.             TestStruct()

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

  120.                   str2(carla_strdup("str2")),

  121.                   str3(nullptr),

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

  123. 

  124.             ~TestStruct() noexcept

  125.             {

  126.                 if (str1 != nullptr)

  127.                 {

  128.                     delete[] str1;

  129.                     str1 = nullptr;

  130.                 }

  131. 

  132.                 if (str2 != nullptr)

  133.                 {

  134.                     delete[] str2;

  135.                     str2 = nullptr;

  136.                 }

  137. 

  138.                 if (str3 != nullptr)

  139.                 {

  140.                     delete[] str3;

  141.                     str3 = nullptr;

  142.                 }

  143. 

  144.                 if (str4 != nullptr)

  145.                 {

  146.                     delete[] str4;

  147.                     str4 = nullptr;

  148.                 }

  149.             }

  150.         };

  151. 

  152.         TestStruct a, b, c;

  153.     }

  154. 

  155.     // -------------------------------------------------------------------

  156.     // memory functions

  157. 

  158.     {

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

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

  161.         carla_add(a, b, 4);

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

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

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

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

  166. 

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

  168.         carla_add(b, c, 4);

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

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

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

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

  173. 

  174.         carla_copy(a,   c,   2);

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

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

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

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

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

  180.         carla_copy(c, a, 4);

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

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

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

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

  185. 

  186.         carla_fill(a, 0, 4);

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

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

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

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

  191. 

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

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

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

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

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

  197. 

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

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

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

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

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

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

  204. 

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

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

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

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

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

  210. 

  211.         char strBuf[501];

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

  213.         carla_zeroChar(strBuf, 501);

  214. 

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

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

  217. 

  218.         int d = 1527, e = 0;

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

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

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

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

  223.         assert(d == e);

  224. 

  225.         e = -e;

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

  227.         assert(d == 0);

  228. 

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

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

  231.         assert(d == e);

  232. 

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

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

  235.         assert(d == 9999);

  236.         assert(e == 123);

  237. 

  238.         carla_zeroStruct(d);

  239.         assert(d == 0);

  240. 

  241.         carla_copyStruct(d, e);

  242.         assert(d != 0);

  243.         assert(d == e);

  244. 

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

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

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

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

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

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

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

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

  253. 

  254.         carla_copyStruct(c, a, 4);

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

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

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

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

  259. 

  260.         carla_zeroStruct(c, 4);

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

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

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

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

  265. 

  266.         float fl[5];

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

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

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

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

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

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

  273. 

  274.         carla_add(fl, fl, 5);

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

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

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

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

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

  280. 

  281.         carla_add(fl, fl, 4);

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

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

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

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

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

  287. 

  288.         carla_add(fl, fl, 3);

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

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

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

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

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

  294. 

  295.         carla_add(fl, fl, 2);

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

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

  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, 1);

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

  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. }

  310. 

  311. // -----------------------------------------------------------------------

  312. 

  313. static void test_CarlaMathUtils() noexcept

  314. {

  315.     // -------------------------------------------------------------------

  316.     // math functions (base)

  317. 

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

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

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

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

  322. 

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

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

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

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

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

  328. 

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

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

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

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

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

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

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

  336. 

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

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

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

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

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

  342. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  356. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  370. 

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

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

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

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

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

  376. 

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

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

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

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

  381. 

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

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

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

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

  386. 

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

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

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

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

  391. 

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

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

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

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

  396. 

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

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

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

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

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

  402. 

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

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

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

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

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

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

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

  410. 

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

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

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

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

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

  416. 

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

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

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

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

  421. 

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

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

  424. 

  425.     // Get next power of 2.

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

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

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

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

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

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

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

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

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

  435. 

  436.     uint32_t power = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  454. 

  455.     // -------------------------------------------------------------------

  456.     // math functions (extended)

  457. 

  458.     // carla_addFloat, carla_copyFloat & carla_zeroFloat tests skipped

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

  460. }

  461. 

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

  463. 

  464. static void test_CarlaBackendUtils() noexcept

  465. {

  466.     CARLA_BACKEND_USE_NAMESPACE

  467.     carla_stdout(PluginOption2Str(PLUGIN_OPTION_FIXED_BUFFERS));

  468.     carla_stdout(BinaryType2Str(BINARY_NONE));

  469.     carla_stdout(PluginType2Str(PLUGIN_NONE));

  470.     carla_stdout(PluginCategory2Str(PLUGIN_CATEGORY_NONE));

  471.     carla_stdout(ParameterType2Str(PARAMETER_UNKNOWN));

  472.     carla_stdout(InternalParameterIndex2Str(PARAMETER_NULL));

  473.     carla_stdout(EngineCallbackOpcode2Str(ENGINE_CALLBACK_DEBUG));

  474.     carla_stdout(EngineOption2Str(ENGINE_OPTION_DEBUG));

  475.     carla_stdout(EngineProcessMode2Str(ENGINE_PROCESS_MODE_SINGLE_CLIENT));

  476.     carla_stdout(EngineTransportMode2Str(ENGINE_TRANSPORT_MODE_INTERNAL));

  477.     carla_stdout(FileCallbackOpcode2Str(FILE_CALLBACK_DEBUG));

  478.     carla_stdout(getPluginTypeAsString(PLUGIN_INTERNAL));

  479.     carla_stdout(PatchbayIcon2Str(PATCHBAY_ICON_APPLICATION));

  480.     getPluginTypeFromString("none");

  481.     getPluginCategoryFromName("cat");

  482. }

  483. 

  484. // -----------------------------------------------------------------------

  485. 

  486. static void test_CarlaEngineUtils() noexcept

  487. {

  488.     CARLA_BACKEND_USE_NAMESPACE

  489.     carla_stdout(EngineType2Str(kEngineTypeNull));

  490.     carla_stdout(EnginePortType2Str(kEnginePortTypeNull));

  491.     carla_stdout(EngineEventType2Str(kEngineEventTypeNull));

  492.     carla_stdout(EngineControlEventType2Str(kEngineControlEventTypeNull));

  493. }

  494. 

  495. // -----------------------------------------------------------------------

  496. 

  497. static void test_CarlaLadspaUtils()

  498. {

  499.     LADSPA_Descriptor desc;

  500.     carla_zeroStruct(desc);

  501. 

  502.     LADSPA_RDF_Descriptor rdfDesc;

  503.     delete ladspa_rdf_dup(&rdfDesc);

  504. 

  505.     is_ladspa_port_good(0x0, 0x0);

  506.     is_ladspa_rdf_descriptor_valid(&rdfDesc, &desc);

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

  508. }

  509. 

  510. // -----------------------------------------------------------------------

  511. 

  512. namespace dssi_juce {

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

  514. #define HAVE_JUCE

  515. #include "CarlaDssiUtils.cpp"

  516. }

  517. 

  518. namespace dssi_qt {

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

  520. #undef HAVE_JUCE

  521. #include "CarlaDssiUtils.cpp"

  522. }

  523. 

  524. static void test_CarlaDssiUtils() noexcept

  525. {

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

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

  528. 

  529.     CARLA_SAFE_ASSERT(ui_juce != nullptr);

  530.     CARLA_SAFE_ASSERT(ui_qt != nullptr);

  531. 

  532.     if (ui_juce != nullptr)

  533.     {

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

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

  536.         delete[] ui_juce;

  537.     }

  538. 

  539.     if (ui_qt != nullptr)

  540.     {

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

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

  543.         delete[] ui_qt;

  544.     }

  545. }

  546. 

  547. // -----------------------------------------------------------------------

  548. 

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

  550. {

  551.     return 1;

  552. }

  553. 

  554. static void test_CarlaLv2Utils()

  555. {

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

  557.     lv2World.initIfNeeded();

  558. 

  559.     // getPlugin

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

  561.     CARLA_SAFE_ASSERT(plugin != nullptr);

  562. 

  563.     // getState

  564.     LV2_URID_Map uridMap = { nullptr, test_lv2_uridMap };

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

  566.     CARLA_SAFE_ASSERT(state != nullptr);

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

  568. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  584. 

  585.     // misc

  586.     is_lv2_port_supported(0x0);

  587.     is_lv2_feature_supported("test1");

  588.     is_lv2_ui_feature_supported("test2");

  589. }

  590. 

  591. // -----------------------------------------------------------------------

  592. 

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

  594. {

  595.     return 0;

  596. }

  597. 

  598. static void test_CarlaVstUtils() noexcept

  599. {

  600.     AEffect effect;

  601.     carla_zeroStruct(effect);

  602.     effect.dispatcher = test_vst_dispatcher;

  603. 

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

  605.     carla_stdout(vstEffectOpcode2str(effOpen));

  606.     carla_stdout(vstMasterOpcode2str(audioMasterAutomate));

  607. }

  608. 

  609. // -----------------------------------------------------------------------

  610. 

  611. static void test_CarlaBridgeUtils() noexcept

  612. {

  613.     carla_stdout(PluginBridgeInfoType2str(kPluginBridgePong));

  614.     carla_stdout(PluginBridgeOpcode2str(kPluginBridgeOpcodeNull));

  615. }

  616. 

  617. #endif

  618. 

  619. // -----------------------------------------------------------------------

  620. 

  621. class LeakTestClass

  622. {

  623. public:

  624.     LeakTestClass()noexcept

  625.         : i(0) {}

  626. 

  627. private:

  628.     int i;

  629.     CARLA_LEAK_DETECTOR(LeakTestClass)

  630. };

  631. 

  632. static void test_CarlaJuceUtils()

  633. {

  634.     LeakTestClass a, b;

  635.     LeakTestClass* e;

  636.     LeakTestClass* f = nullptr;

  637. 

  638.     e = new LeakTestClass;

  639.     f = new LeakTestClass;

  640.     delete e; delete f;

  641.     delete new LeakTestClass;

  642. 

  643.     int x = 1;

  644. 

  645.     {

  646.         assert(x == 1);

  647.         ScopedValueSetter<int> s(x, 2);

  648.         assert(x == 2);

  649.     }

  650. 

  651.     assert(x == 1);

  652. 

  653.     {

  654.         assert(x == 1);

  655.         ScopedValueSetter<int> s(x, 3, 4);

  656.         assert(x == 3);

  657.     }

  658. 

  659.     assert(x == 4);

  660. }

  661. 

  662. #if 0

  663. // -----------------------------------------------------------------------

  664. 

  665. static void test_CarlaLibUtils() noexcept

  666. {

  667.     void* const libNot = lib_open("/libzzzzz...");

  668.     assert(libNot == nullptr);

  669.     carla_stdout("Force lib_open fail error results in: %s", lib_error("/libzzzzz..."));

  670. 

  671.     void* const lib = lib_open("/usr/lib/liblo.so");

  672.     CARLA_SAFE_ASSERT_RETURN(lib != nullptr,);

  673. 

  674.     void* const libS = lib_symbol(lib, "lo_server_new");

  675.     CARLA_SAFE_ASSERT(libS != nullptr);

  676. 

  677.     const bool closed = lib_close(lib);

  678.     CARLA_SAFE_ASSERT(closed);

  679. 

  680.     LibCounter lc;

  681.     void* const test1 = lc.open("/usr/lib/liblo.so");

  682.     void* const test2 = lc.open("/usr/lib/liblo.so");

  683.     void* const test3 = lc.open("/usr/lib/liblo.so");

  684.     assert(test1 == test2);

  685.     assert(test2 == test3);

  686.     lc.close(test1); lc.close(test2); lc.close(test3);

  687. 

  688.     // test if the pointer changes after all closed

  689.     void* const test1b = lc.open("/usr/lib/liblo.so");

  690.     assert(test1 != test1b);

  691.     lc.close(test1b);

  692. 

  693.     // test non-delete flag

  694.     void* const test4 = lc.open("/usr/lib/liblrdf.so.0", false);

  695.     lc.close(test4);

  696.     void* const test5 = lc.open("/usr/lib/liblrdf.so.0");

  697.     assert(test4 == test5);

  698.     lc.close(test5);

  699. 

  700.     // open non-delete a few times, tests for cleanup on destruction

  701.     lc.open("/usr/lib/liblrdf.so.0");

  702.     lc.open("/usr/lib/liblrdf.so.0");

  703.     lc.open("/usr/lib/liblrdf.so.0");

  704. }

  705. 

  706. // -----------------------------------------------------------------------

  707. 

  708. struct ShmStruct {

  709.     char stringStart[255];

  710.     bool boolean;

  711.     int integer;

  712.     float floating;

  713.     char stringEnd[255];

  714. };

  715. 

  716. static void test_CarlaShmUtils() noexcept

  717. {

  718.     shm_t shm, shma;

  719.     ShmStruct* shmStruct1;

  720.     ShmStruct* shmStruct2;

  721. 

  722.     // base tests first

  723.     carla_shm_init(shm);

  724.     assert(! carla_is_shm_valid(shm));

  725. 

  726.     shm = carla_shm_create("/carla-shm-test1");

  727.     carla_stdout("test %i", shm);

  728.     assert(carla_is_shm_valid(shm));

  729. 

  730.     carla_shm_close(shm);

  731.     assert(! carla_is_shm_valid(shm));

  732. 

  733.     shm = carla_shm_create("/carla-shm-test1");

  734.     assert(carla_is_shm_valid(shm));

  735. 

  736.     shma = carla_shm_attach("/carla-shm-test1");

  737.     assert(carla_is_shm_valid(shma));

  738. 

  739.     carla_shm_close(shm);

  740.     carla_shm_close(shma);

  741.     assert(! carla_is_shm_valid(shm));

  742.     assert(! carla_is_shm_valid(shma));

  743. 

  744.     // test attach invalid

  745.     shma = carla_shm_attach("/carla-shm-test-NOT");

  746.     assert(! carla_is_shm_valid(shma));

  747. 

  748.     // test memory, start

  749.     shm = carla_shm_create("/carla-shm-test1");

  750.     assert(carla_is_shm_valid(shm));

  751. 

  752.     shma = carla_shm_attach("/carla-shm-test1");

  753.     assert(carla_is_shm_valid(shma));

  754. 

  755.     // test memory, check valid

  756.     shmStruct1 = carla_shm_map<ShmStruct>(shm);

  757.     assert(shmStruct1 != nullptr);

  758. 

  759.     shmStruct2 = carla_shm_map<ShmStruct>(shma);

  760.     assert(shmStruct2 != nullptr);

  761. 

  762.     carla_shm_unmap(shma, shmStruct2);

  763.     assert(shmStruct2 == nullptr);

  764. 

  765.     carla_shm_unmap(shm, shmStruct1);

  766.     assert(shmStruct1 == nullptr);

  767. 

  768.     // test memory, check if write data matches

  769.     shmStruct1 = carla_shm_map<ShmStruct>(shm);

  770.     assert(shmStruct1 != nullptr);

  771. 

  772.     shmStruct2 = carla_shm_map<ShmStruct>(shma);

  773.     assert(shmStruct2 != nullptr);

  774. 

  775.     carla_zeroStruct(*shmStruct1);

  776.     assert(shmStruct1->stringStart[0] == '\0');

  777.     assert(shmStruct2->stringStart[0] == '\0');

  778.     assert(shmStruct1->stringEnd[0] == '\0');

  779.     assert(shmStruct2->stringEnd[0] == '\0');

  780.     assert(! shmStruct1->boolean);

  781.     assert(! shmStruct2->boolean);

  782. 

  783.     shmStruct1->boolean = true;

  784.     shmStruct1->integer = 232312;

  785.     assert(shmStruct1->boolean == shmStruct2->boolean);

  786.     assert(shmStruct1->integer == shmStruct2->integer);

  787. 

  788.     shmStruct2->floating = 2342.231f;

  789.     std::strcpy(shmStruct2->stringStart, "test1start");

  790.     std::strcpy(shmStruct2->stringEnd, "test2end");

  791.     assert(shmStruct1->floating == shmStruct2->floating);

  792.     assert(std::strcmp(shmStruct1->stringStart, "test1start") == 0);

  793.     assert(std::strcmp(shmStruct1->stringStart, shmStruct2->stringStart) == 0);

  794.     assert(std::strcmp(shmStruct1->stringEnd, "test2end") == 0);

  795.     assert(std::strcmp(shmStruct1->stringEnd, shmStruct2->stringEnd) == 0);

  796. 

  797.     carla_shm_unmap(shma, shmStruct2);

  798.     assert(shmStruct2 == nullptr);

  799. 

  800.     carla_shm_unmap(shm, shmStruct1);

  801.     assert(shmStruct1 == nullptr);

  802. 

  803.     // test memory, done

  804.     carla_shm_close(shm);

  805.     carla_shm_close(shma);

  806.     assert(! carla_is_shm_valid(shm));

  807.     assert(! carla_is_shm_valid(shma));

  808. }

  809. #endif

  810. 

  811. // -----------------------------------------------------------------------

  812. // main

  813. 

  814. int main()

  815. {

  816. #if 0

  817.     // already tested, skip for now

  818.     test_CarlaUtils();

  819.     test_CarlaMathUtils();

  820. 

  821.     test_CarlaBackendUtils();

  822.     test_CarlaEngineUtils();

  823. 

  824.     test_CarlaLadspaUtils();

  825.     test_CarlaDssiUtils();

  826.     test_CarlaLv2Utils();

  827.     test_CarlaVstUtils();

  828. #endif

  829. 

  830.     //test_CarlaBridgeUtils();

  831.     //test_CarlaLibUtils();

  832.     test_CarlaJuceUtils();

  833.     //test_CarlaShmUtils();

  834. 

  835.     return 0;

  836. }

  837. 

  838. // -----------------------------------------------------------------------