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

497 lines
15KB
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. #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[1];

  42.         nullStrBuf(strBuf);

  43.     }

  44. 

  45.     // -------------------------------------------------------------------

  46.     // string print functions

  47. 

  48.     {

  49.         carla_debug("DEBUG");

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

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

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

  53.     }

  54. 

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

  56.     // carla_*sleep

  57. 

  58.     {

  59.         carla_sleep(1);

  60.         carla_msleep(1);

  61.     }

  62. 

  63.     // -------------------------------------------------------------------

  64.     // carla_setenv

  65. 

  66.     {

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

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

  69.     }

  70. 

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

  72.     // carla_strdup

  73. 

  74.     {

  75.         // with variables

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

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

  78.         delete[] str1;

  79.         delete[] strF;

  80. 

  81.         // without variables

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

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

  84. 

  85.         // common use case in Carla code

  86.         struct TestStruct {

  87.             const char* str1;

  88.             const char* str2;

  89.             const char* str3;

  90.             const char* str4;

  91. 

  92.             TestStruct()

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

  94.                   str2(carla_strdup("str2")),

  95.                   str3(nullptr),

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

  97. 

  98.             ~TestStruct() noexcept

  99.             {

  100.                 if (str1 != nullptr)

  101.                 {

  102.                     delete[] str1;

  103.                     str1 = nullptr;

  104.                 }

  105. 

  106.                 if (str2 != nullptr)

  107.                 {

  108.                     delete[] str2;

  109.                     str2 = nullptr;

  110.                 }

  111. 

  112.                 if (str3 != nullptr)

  113.                 {

  114.                     delete[] str3;

  115.                     str3 = nullptr;

  116.                 }

  117. 

  118.                 if (str4 != nullptr)

  119.                 {

  120.                     delete[] str4;

  121.                     str4 = nullptr;

  122.                 }

  123.             }

  124. 

  125.             CARLA_DECLARE_NON_COPY_STRUCT(TestStruct)

  126.         };

  127. 

  128.         TestStruct a, b, c;

  129.     }

  130. 

  131.     // -------------------------------------------------------------------

  132.     // memory functions

  133. 

  134.     {

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

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

  137.         carla_add(a, b, 4);

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

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

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

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

  142. 

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

  144.         carla_add(b, c, 4);

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

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

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

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

  149. 

  150.         carla_copy(a,   c,   2);

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

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

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

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

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

  156.         carla_copy(c, a, 4);

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

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

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

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

  161. 

  162.         carla_fill(a, 0, 4);

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

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

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

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

  167. 

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

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

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

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

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

  173. 

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

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

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

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

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

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

  180. 

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

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

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

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

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

  186. 

  187.         char strBuf[501];

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

  189.         carla_zeroChar(strBuf, 501);

  190. 

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

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

  193. 

  194.         int d = 1527, e = 0;

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

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

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

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

  199.         assert(d == e);

  200. 

  201.         e = -e;

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

  203.         assert(d == 0);

  204. 

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

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

  207.         assert(d == e);

  208. 

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

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

  211.         assert(d == 9999);

  212.         assert(e == 123);

  213. 

  214.         carla_zeroStruct(d);

  215.         assert(d == 0);

  216. 

  217.         carla_copyStruct(d, e);

  218.         assert(d != 0);

  219.         assert(d == e);

  220. 

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

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

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

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

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

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

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

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

  229. 

  230.         carla_copyStruct(c, a, 4);

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

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

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

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

  235. 

  236.         carla_zeroStruct(c, 4);

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

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

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

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

  241. 

  242.         float fl[5];

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

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

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

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

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

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

  249. 

  250.         carla_add(fl, fl, 5);

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

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

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

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

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

  256. 

  257.         carla_add(fl, fl, 4);

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

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

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

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

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

  263. 

  264.         carla_add(fl, fl, 3);

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

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

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

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

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

  270. 

  271.         carla_add(fl, fl, 2);

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

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

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

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

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

  277. 

  278.         carla_add(fl, fl, 1);

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

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

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

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

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

  284.     }

  285. }

  286. 

  287. // -----------------------------------------------------------------------

  288. 

  289. static void test_CarlaMathUtils() noexcept

  290. {

  291.     // -------------------------------------------------------------------

  292.     // math functions (base)

  293. 

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

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

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

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

  298. 

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

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

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

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

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

  304. 

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

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

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

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

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

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

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

  312. 

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

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

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

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

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

  318. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  332. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  346. 

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

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

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

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

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

  352. 

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

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

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

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

  357. 

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

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

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

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

  362. 

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

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

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

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

  367. 

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

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

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

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

  372. 

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

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

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

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

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

  378. 

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

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

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

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

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

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

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

  386. 

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

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

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

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

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

  392. 

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

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

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

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

  397. 

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

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

  400. 

  401.     // Get next power of 2.

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

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

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

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

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

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

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

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

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

  411. 

  412.     uint32_t power = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  430. 

  431.     // -------------------------------------------------------------------

  432.     // math functions (extended)

  433. 

  434.     // carla_addFloat, carla_copyFloat & carla_zeroFloat tests skipped

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

  436. }

  437. 

  438. // -----------------------------------------------------------------------

  439. 

  440. static void test_CarlaBackendUtils() noexcept

  441. {

  442.     CARLA_BACKEND_USE_NAMESPACE

  443.     carla_stdout(PluginOption2Str(PLUGIN_OPTION_FIXED_BUFFERS));

  444.     carla_stdout(BinaryType2Str(BINARY_NONE));

  445.     carla_stdout(PluginType2Str(PLUGIN_NONE));

  446.     carla_stdout(PluginCategory2Str(PLUGIN_CATEGORY_NONE));

  447.     carla_stdout(ParameterType2Str(PARAMETER_UNKNOWN));

  448.     carla_stdout(InternalParameterIndex2Str(PARAMETER_NULL));

  449.     carla_stdout(EngineCallbackOpcode2Str(ENGINE_CALLBACK_DEBUG));

  450.     carla_stdout(EngineOption2Str(ENGINE_OPTION_DEBUG));

  451.     carla_stdout(EngineProcessMode2Str(ENGINE_PROCESS_MODE_SINGLE_CLIENT));

  452.     carla_stdout(EngineTransportMode2Str(ENGINE_TRANSPORT_MODE_INTERNAL));

  453.     carla_stdout(FileCallbackOpcode2Str(FILE_CALLBACK_DEBUG));

  454.     carla_stdout(getPluginTypeAsString(PLUGIN_INTERNAL));

  455.     carla_stdout(PatchbayIcon2Str(PATCHBAY_ICON_APPLICATION));

  456.     getPluginTypeFromString("none");

  457.     getPluginCategoryFromName("cat");

  458. }

  459. 

  460. // -----------------------------------------------------------------------

  461. 

  462. static void test_CarlaBridgeUtils() noexcept

  463. {

  464.     carla_stdout(PluginBridgeOscInfoType2str(kPluginBridgeOscPong));

  465.     carla_stdout(PluginBridgeRtOpcode2str(kPluginBridgeRtNull));

  466.     carla_stdout(PluginBridgeNonRtOpcode2str(kPluginBridgeNonRtNull));

  467. }

  468. 

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

  470. 

  471. static void test_CarlaEngineUtils() noexcept

  472. {

  473.     CARLA_BACKEND_USE_NAMESPACE

  474.     carla_stdout(EngineType2Str(kEngineTypeNull));

  475.     carla_stdout(EnginePortType2Str(kEnginePortTypeNull));

  476.     carla_stdout(EngineEventType2Str(kEngineEventTypeNull));

  477.     carla_stdout(EngineControlEventType2Str(kEngineControlEventTypeNull));

  478. }

  479. 

  480. // -----------------------------------------------------------------------

  481. // main

  482. 

  483. int main()

  484. {

  485.     // already tested, skip for now

  486.     test_CarlaUtils();

  487.     test_CarlaMathUtils();

  488. 

  489.     test_CarlaBackendUtils();

  490.     test_CarlaBridgeUtils();

  491.     test_CarlaEngineUtils();

  492. 

  493.     return 0;

  494. }

  495. 

  496. // -----------------------------------------------------------------------