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.
5372 Commits
17 Branches
381MB
Tree: acf9561ec8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'acf9561ec8'
${ noResults }
Carla/source/tests.old/CarlaUtils1.cpp

587 lines
17KB
Raw Blame History 

  1. /*

  2.  * Carla Utility Tests

  3.  * Copyright (C) 2013-2015 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. #include "CarlaUtils.hpp"

  23. #include "CarlaMathUtils.hpp"

  24. 

  25. // #include "CarlaBackendUtils.hpp"

  26. // #include "CarlaBridgeUtils.hpp"

  27. // #include "CarlaEngineUtils.hpp"

  28. 

  29. // --------------------------------------------------------------------------------------------------------------------

  30. 

  31. static void test_CarlaUtils()

  32. {

  33.     // ----------------------------------------------------------------------------------------------------------------

  34.     // misc functions

  35. 

  36.     {

  37.         bool2str(false);

  38.         bool2str(true);

  39.         pass();

  40. 

  41.         char strBuf[2];

  42.         nullStrBuf(strBuf);

  43. 

  44.         char* const strBuf2(strBuf+1);

  45.         nullStrBuf(strBuf2);

  46.     }

  47. 

  48.     // ----------------------------------------------------------------------------------------------------------------

  49.     // string print functions

  50. 

  51.     {

  52.         carla_debug("DEBUG");

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

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

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

  56.     }

  57. 

  58.     // ----------------------------------------------------------------------------------------------------------------

  59.     // carla_*sleep

  60. 

  61.     {

  62.         carla_sleep(1);

  63.         carla_msleep(1);

  64.     }

  65. 

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

  67.     // carla_setenv

  68. 

  69.     {

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

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

  72. 

  73.         carla_unsetenv("THIS");

  74.         assert(std::getenv("THIS") == nullptr);

  75.     }

  76. 

  77.     // ----------------------------------------------------------------------------------------------------------------

  78.     // carla_strdup

  79. 

  80.     {

  81.         // with variables

  82.         const char* const str1(carla_strdup("stringN"));

  83.         const char* const strF(carla_strdup_free(strdup("stringF")));

  84.         const char* const str2(carla_strdup_safe("stringS"));

  85.         delete[] str1;

  86.         delete[] str2;

  87.         delete[] strF;

  88. 

  89.         // without variables

  90.         delete[] carla_strdup("string_normal");

  91.         delete[] carla_strdup_free(strdup("string_free"));

  92.         delete[] carla_strdup_safe("string_safe");

  93.     }

  94. 

  95.     {

  96.         // common use case in Carla code

  97.         struct TestStruct {

  98.             const char* strNull;

  99.             const char* strNormal;

  100.             const char* strFree;

  101.             const char* strSafe;

  102. 

  103.             TestStruct()

  104.                 : strNull(nullptr),

  105.                   strNormal(carla_strdup("strNormal")),

  106.                   strFree(carla_strdup_free(strdup("strFree"))),

  107.                   strSafe(carla_strdup_safe("strSafe")) {}

  108. 

  109.             ~TestStruct() noexcept

  110.             {

  111.                 if (strNull != nullptr)

  112.                 {

  113.                     delete[] strNull;

  114.                     strNull = nullptr;

  115.                 }

  116. 

  117.                 if (strNormal != nullptr)

  118.                 {

  119.                     delete[] strNormal;

  120.                     strNormal = nullptr;

  121.                 }

  122. 

  123.                 if (strFree != nullptr)

  124.                 {

  125.                     delete[] strFree;

  126.                     strFree = nullptr;

  127.                 }

  128. 

  129.                 if (strSafe != nullptr)

  130.                 {

  131.                     delete[] strSafe;

  132.                     strSafe = nullptr;

  133.                 }

  134.             }

  135. 

  136.             CARLA_DECLARE_NON_COPY_STRUCT(TestStruct)

  137.         };

  138. 

  139.         TestStruct a, b, c;

  140.     }

  141. 

  142.     // ----------------------------------------------------------------------------------------------------------------

  143.     // memory functions

  144. 

  145.     {

  146.         int a1[] = { 4, 3, 2, 1 };

  147.         int a2[] = { 4, 3, 2, 1 };

  148.         int b1[] = { 1, 2, 3, 4 };

  149.         int b2[] = { 1, 2, 3, 4 };

  150. 

  151.         carla_add(a1, b1, 4);

  152.         assert(a1[0] == 5);

  153.         assert(a1[1] == 5);

  154.         assert(a1[2] == 5);

  155.         assert(a1[3] == 5);

  156. 

  157.         carla_add(b1, a2, 4);

  158.         assert(b1[0] == 5);

  159.         assert(b1[1] == 5);

  160.         assert(b1[2] == 5);

  161.         assert(b1[3] == 5);

  162.         assert(a1[0] == b1[0]);

  163.         assert(a1[1] == b1[1]);

  164.         assert(a1[2] == b1[2]);

  165.         assert(a1[3] == b1[3]);

  166. 

  167.         carla_copy(a1, b2, 4);

  168.         assert(a1[0] != b1[0]);

  169.         assert(a1[1] != b1[1]);

  170.         assert(a1[2] != b1[2]);

  171.         assert(a1[3] != b1[3]);

  172.         assert(a1[0] == b2[0]);

  173.         assert(a1[1] == b2[1]);

  174.         assert(a1[2] == b2[2]);

  175.         assert(a1[3] == b2[3]);

  176. 

  177.         carla_copy(a1, b1, 4);

  178.         assert(a1[0] == b1[0]);

  179.         assert(a1[1] == b1[1]);

  180.         assert(a1[2] == b1[2]);

  181.         assert(a1[3] == b1[3]);

  182. 

  183.         carla_copy(a1, b2, 2);

  184.         assert(a1[0] != b1[0]);

  185.         assert(a1[1] != b1[1]);

  186.         assert(a1[2] == b1[2]);

  187.         assert(a1[3] == b1[3]);

  188. 

  189.         carla_copy(a1+2, b2+2, 2);

  190.         assert(a1[0] != b1[0]);

  191.         assert(a1[1] != b1[1]);

  192.         assert(a1[2] != b1[2]);

  193.         assert(a1[3] != b1[3]);

  194. 

  195.         carla_copy(a1, b1, 2);

  196.         assert(a1[0] == b1[0]);

  197.         assert(a1[1] == b1[1]);

  198.         assert(a1[2] != b1[2]);

  199.         assert(a1[3] != b1[3]);

  200. 

  201.         carla_copy(a1+2, b1+2, 2);

  202.         assert(a1[0] == b1[0]);

  203.         assert(a1[1] == b1[1]);

  204.         assert(a1[2] == b1[2]);

  205.         assert(a1[3] == b1[3]);

  206. 

  207.         carla_fill(a1, 0, 4);

  208.         assert(a1[0] == 0);

  209.         assert(a1[1] == 0);

  210.         assert(a1[2] == 0);

  211.         assert(a1[3] == 0);

  212. 

  213.         carla_fill(a1, -11, 4);

  214.         assert(a1[0] == -11);

  215.         assert(a1[1] == -11);

  216.         assert(a1[2] == -11);

  217.         assert(a1[3] == -11);

  218. 

  219.         carla_fill(a1, 1791, 2);

  220.         assert(a1[0] == 1791);

  221.         assert(a1[1] == 1791);

  222.         assert(a1[2] == -11);

  223.         assert(a1[3] == -11);

  224. 

  225.         carla_fill(a1+2, 1791, 2);

  226.         assert(a1[0] == 1791);

  227.         assert(a1[1] == 1791);

  228.         assert(a1[2] == 1791);

  229.         assert(a1[3] == 1791);

  230. 

  231.         int16_t d = 1527, d2 = d, e = 0;

  232. 

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

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

  235. 

  236.         carla_add(&d, &d2, 1);

  237.         assert(d == 1527*3);

  238. 

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

  240.         assert(d == 1527*3);

  241.         assert(e == 0);

  242. 

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

  244.         assert(d == e);

  245. 

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

  247.         assert(e == d*2);

  248. 

  249.         d = -e;

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

  251.         assert(d == 0);

  252.     }

  253. 

  254.     {

  255.         bool x;

  256.         const bool f = false, t = true;

  257. 

  258.         carla_copy(&x, &t, 1);

  259.         assert(x);

  260. 

  261.         carla_copy(&x, &f, 1);

  262.         assert(! x);

  263. 

  264.         carla_fill(&x, true, 1);

  265.         assert(x);

  266. 

  267.         carla_fill(&x, false, 1);

  268.         assert(! x);

  269.     }

  270. 

  271.     {

  272.         uint8_t a[] = { 3, 2, 1, 0 };

  273.         carla_zeroBytes(a, 1);

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

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

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

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

  278. 

  279.         carla_zeroBytes(a+1, 2);

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

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

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

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

  284.     }

  285. 

  286.     {

  287.         char a[501];

  288. 

  289.         for (int i=500; --i>=0;)

  290.             a[i] = 'a';

  291. 

  292.         carla_zeroChars(a, 501);

  293. 

  294.         for (int i=501; --i>=0;)

  295.             assert(a[i] == '\0');

  296. 

  297.         for (int i=500; --i>=0;)

  298.             a[i] = 'a';

  299. 

  300.         assert(std::strlen(a) == 500);

  301. 

  302.         carla_fill(a+200, '\0', 1);

  303.         assert(std::strlen(a) == 200);

  304.     }

  305. 

  306.     {

  307.         void* a[33];

  308.         carla_zeroPointers(a, 33);

  309. 

  310.         for (int i=33; --i>=0;)

  311.             assert(a[i] == nullptr);

  312.     }

  313. 

  314.     {

  315.         struct Thing {

  316.             char c;

  317.             int i;

  318.             int64_t h;

  319. 

  320.             bool operator==(const Thing& t) const noexcept

  321.             {

  322.                 return (t.c == c && t.i == i && t.h == h);

  323.             }

  324. 

  325.             bool operator!=(const Thing& t) const noexcept

  326.             {

  327.                 return !operator==(t);

  328.             }

  329.         };

  330. 

  331.         Thing a, b, c;

  332. 

  333.         a.c = 0;

  334.         a.i = 0;

  335.         a.h = 0;

  336. 

  337.         b.c = 64;

  338.         b.i = 64;

  339.         b.h = 64;

  340. 

  341.         c = a;

  342. 

  343.         carla_copyStruct(a, b);

  344.         assert(a == b);

  345. 

  346.         carla_zeroStruct(a);

  347.         assert(a == c);

  348. 

  349.         carla_copyStruct(c, b);

  350.         assert(a != c);

  351. 

  352.         // make it non-zero

  353.         a.c = 1;

  354. 

  355.         Thing d[3];

  356. 

  357.         carla_zeroStructs(d, 3);

  358.         assert(d[0] != a);

  359.         assert(d[1] != b);

  360.         assert(d[2] != c);

  361. 

  362.         carla_copyStructs(d, &a, 1);

  363.         assert(d[0] == a);

  364.         assert(d[1] != b);

  365.         assert(d[2] != c);

  366. 

  367.         carla_copyStructs(&c, d+2, 1);

  368.         assert(d[0] == a);

  369.         assert(d[1] != b);

  370.         assert(d[2] == c);

  371.     }

  372. }

  373. 

  374. #if 0

  375. // --------------------------------------------------------------------------------------------------------------------

  376. 

  377. static void test_CarlaMathUtils() noexcept

  378. {

  379.     // ----------------------------------------------------------------------------------------------------------------

  380.     // math functions (base)

  381. 

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

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

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

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

  386. 

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

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

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

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

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

  392. 

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

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

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

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

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

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

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

  400. 

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

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

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

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

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

  406. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  420. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  434. 

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

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

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

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

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

  440. 

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

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

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

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

  445. 

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

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

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

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

  450. 

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

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

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

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

  455. 

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

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

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

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

  460. 

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

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

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

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

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

  466. 

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

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

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

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

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

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

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

  474. 

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

  476.     assert(carla_fixedValue(0, 1, -1) == 0);

  477.     assert(carla_fixedValue(0, 1,  0) == 0);

  478.     assert(carla_fixedValue(0, 1,  1) == 1);

  479.     assert(carla_fixedValue(0, 1,  2) == 1);

  480. 

  481.     assert(carla_fixedValue(0.0, 1.0, -1.0) == 0.0);

  482.     assert(carla_fixedValue(0.0, 1.0,  0.0) == 0.0);

  483.     assert(carla_fixedValue(0.0, 1.0,  1.0) == 1.0);

  484.     assert(carla_fixedValue(0.0, 1.0,  2.0) == 1.0);

  485. 

  486.     assert(carla_fixedValue(0.0, 1.0, -0.1) == 0.0);

  487.     assert(carla_fixedValue(0.0, 1.0,  1.1) == 1.0);

  488. 

  489.     // Get next power of 2.

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

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

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

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

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

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

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

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

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

  499. 

  500.     uint32_t power = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  518. 

  519.     // ----------------------------------------------------------------------------------------------------------------

  520.     // math functions (extended)

  521. 

  522.     // carla_addFloat, carla_copyFloat & carla_zeroFloat tests skipped

  523.     // mostly unused due to water::FloatVectorOperations

  524. }

  525. #endif

  526. 

  527. #if 0

  528. // --------------------------------------------------------------------------------------------------------------------

  529. 

  530. static void test_CarlaBackendUtils() noexcept

  531. {

  532.     CARLA_BACKEND_USE_NAMESPACE

  533.     carla_stdout(PluginOption2Str(PLUGIN_OPTION_FIXED_BUFFERS));

  534.     carla_stdout(BinaryType2Str(BINARY_NONE));

  535.     carla_stdout(PluginType2Str(PLUGIN_NONE));

  536.     carla_stdout(PluginCategory2Str(PLUGIN_CATEGORY_NONE));

  537.     carla_stdout(ParameterType2Str(PARAMETER_UNKNOWN));

  538.     carla_stdout(InternalParameterIndex2Str(PARAMETER_NULL));

  539.     carla_stdout(EngineCallbackOpcode2Str(ENGINE_CALLBACK_DEBUG));

  540.     carla_stdout(EngineOption2Str(ENGINE_OPTION_DEBUG));

  541.     carla_stdout(EngineProcessMode2Str(ENGINE_PROCESS_MODE_SINGLE_CLIENT));

  542.     carla_stdout(EngineTransportMode2Str(ENGINE_TRANSPORT_MODE_INTERNAL));

  543.     carla_stdout(FileCallbackOpcode2Str(FILE_CALLBACK_DEBUG));

  544.     carla_stdout(getPluginTypeAsString(PLUGIN_INTERNAL));

  545.     carla_stdout(PatchbayIcon2Str(PATCHBAY_ICON_APPLICATION));

  546.     getPluginTypeFromString("none");

  547.     getPluginCategoryFromName("cat");

  548. }

  549. 

  550. // --------------------------------------------------------------------------------------------------------------------

  551. 

  552. static void test_CarlaBridgeUtils() noexcept

  553. {

  554.     carla_stdout(PluginBridgeOscInfoType2str(kPluginBridgeOscPong));

  555.     carla_stdout(PluginBridgeRtOpcode2str(kPluginBridgeRtNull));

  556.     carla_stdout(PluginBridgeNonRtOpcode2str(kPluginBridgeNonRtNull));

  557. }

  558. 

  559. // --------------------------------------------------------------------------------------------------------------------

  560. 

  561. static void test_CarlaEngineUtils() noexcept

  562. {

  563.     CARLA_BACKEND_USE_NAMESPACE

  564.     carla_stdout(EngineType2Str(kEngineTypeNull));

  565.     carla_stdout(EnginePortType2Str(kEnginePortTypeNull));

  566.     carla_stdout(EngineEventType2Str(kEngineEventTypeNull));

  567.     carla_stdout(EngineControlEventType2Str(kEngineControlEventTypeNull));

  568. }

  569. #endif

  570. 

  571. // --------------------------------------------------------------------------------------------------------------------

  572. // main

  573. 

  574. int main()

  575. {

  576.     test_CarlaUtils();

  577.     //test_CarlaMathUtils();

  578. 

  579.     //test_CarlaBackendUtils();

  580.     //test_CarlaBridgeUtils();

  581.     //test_CarlaEngineUtils();

  582. 

  583.     return 0;

  584. }

  585. 

  586. // --------------------------------------------------------------------------------------------------------------------