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.
790 Commits
16 Branches
283MB
Tree: 4b681b0e26
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4b681b0e26'
${ noResults }
Carla/source/tests/ANSI.cpp

425 lines
14KB
Raw Blame History 

  1. /*

  2.  * Carla Tests

  3.  * Copyright (C) 2013 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. #undef NDEBUG

  19. #define DEBUG

  20. 

  21. // includes (part1)

  22. #include "CarlaDefines.hpp"

  23. #include "CarlaMIDI.h"

  24. 

  25. // Carla common utils

  26. #include "CarlaUtils.hpp"

  27. 

  28. // Carla misc utils imported from Juce source code

  29. #include "CarlaJuceUtils.hpp"

  30. 

  31. // includes (part2)

  32. #include "ladspa_rdf.hpp"

  33. #include "lv2_rdf.hpp"

  34. 

  35. // Carla Backend API

  36. #include "CarlaBackend.hpp"

  37. 

  38. // Carla Native Plugin API

  39. #include "CarlaNative.h"

  40. 

  41. // Carla Native Plugin API (C++)

  42. #include "CarlaNative.hpp"

  43. 

  44. // Carla String

  45. #include "CarlaString.hpp"

  46. 

  47. // Carla Plugin API

  48. #include "CarlaPlugin.hpp"

  49. 

  50. // Carla Engine API

  51. #include "CarlaEngine.hpp"

  52. 

  53. //#include "standalone/CarlaStandalone.cpp"

  54. 

  55. // #include "CarlaMutex.hpp"

  56. 

  57. // #include "CarlaBackendUtils.hpp"

  58. // #include "CarlaBridgeUtils.hpp"

  59. // #include "CarlaLadspaUtils.hpp"

  60. // #include "CarlaLibUtils.hpp"

  61. // #include "CarlaLv2Utils.hpp"

  62. // #include "CarlaOscUtils.hpp"

  63. // #include "CarlaShmUtils.hpp"

  64. // #include "CarlaStateUtils.hpp"

  65. // #include "CarlaVstUtils.hpp"

  66. // #include "RtList.hpp"

  67. 

  68. int safe_assert_return_test(bool test)

  69. {

  70.     CARLA_SAFE_ASSERT_RETURN(test, 1);

  71.     return 0;

  72. }

  73. 

  74. int main()

  75. {

  76.     // ladspa rdf

  77.     {

  78.         LADSPA_RDF_ScalePoint a;

  79.         LADSPA_RDF_Port b;

  80.         LADSPA_RDF_Descriptor c;

  81.     }

  82. 

  83.     // lv2 rdf

  84.     {

  85.         LV2_RDF_PortMidiMap a;

  86.         LV2_RDF_PortPoints b;

  87.         LV2_RDF_PortUnit c;

  88.         LV2_RDF_PortScalePoint d;

  89.         LV2_RDF_Port e;

  90.         LV2_RDF_Preset f;

  91.         LV2_RDF_Feature g;

  92.         LV2_RDF_UI h;

  93.         LV2_RDF_Descriptor i;

  94.     }

  95. 

  96.     // Carla Backend API

  97.     {

  98.         namespace CB = CarlaBackend;

  99.         CB::BinaryType a = CB::BINARY_NONE;

  100.         CB::PluginType b = CB::PLUGIN_NONE;

  101.         CB::PluginCategory c = CB::PLUGIN_CATEGORY_NONE;

  102.         CB::ParameterType d = CB::PARAMETER_UNKNOWN;

  103.         CB::InternalParametersIndex e = CB::PARAMETER_NULL;

  104.         CB::PatchbayIconType f = CB::PATCHBAY_ICON_APPLICATION;

  105.         CB::OptionsType g = CB::OPTION_PROCESS_NAME;

  106.         CB::CallbackType h = CB::CALLBACK_DEBUG;

  107.         CB::ProcessMode i = CB::PROCESS_MODE_SINGLE_CLIENT;

  108.         CB::TransportMode j = CB::TRANSPORT_MODE_INTERNAL;

  109.         CB::CallbackFunc k = nullptr;

  110.         CB::ParameterData l;

  111.         CB::ParameterRanges m;

  112.         CB::MidiProgramData n;

  113.         CB::CustomData o;

  114.         a=a;b=b;c=c;d=d;e=e;f=f;g=g;h=h;i=i;j=j;k=k;l=l;m=m;n=n;o=o;

  115.     }

  116. 

  117.     // Carla Native Plugin API

  118.     {

  119.         HostHandle a = nullptr;

  120.         PluginHandle b = nullptr;

  121.         PluginCategory c = PLUGIN_CATEGORY_NONE;

  122.         PluginHints d = static_cast<PluginHints>(0x0);

  123.         PluginSupports e = static_cast<PluginSupports>(0x0);

  124.         ParameterHints f = static_cast<ParameterHints>(0x0);

  125.         PluginDispatcherOpcode g = PLUGIN_OPCODE_NULL;

  126.         HostDispatcherOpcode h = HOST_OPCODE_NULL;

  127.         ParameterScalePoint i;

  128.         ParameterRanges j;

  129.         Parameter k;

  130.         MidiEvent l;

  131.         MidiProgram m;

  132.         TimeInfoBBT n;

  133.         TimeInfo o;

  134.         HostDescriptor p;

  135.         PluginDescriptor q = { c, d, e,

  136.                                0, 0, 0, 0, 0, 0,

  137.                                nullptr, nullptr, nullptr, nullptr,

  138.                                nullptr, nullptr,

  139.                                nullptr, nullptr, nullptr, nullptr,

  140.                                nullptr, nullptr,

  141.                                nullptr, nullptr, nullptr,

  142.                                nullptr, nullptr,

  143.                                nullptr, nullptr, nullptr,

  144.                                nullptr, nullptr, nullptr,

  145.                                nullptr, nullptr,

  146.                                nullptr };

  147.         a=a;b=b;c=c;d=d;e=e;f=f;g=g;h=h;i=i;j=j;k=k;l=l;m=m;n=n;o=o;p=p;

  148.         (void)q;

  149.     }

  150. 

  151.     // Carla common utils

  152.     {

  153.         bool2str(true);

  154.         pass();

  155.         carla_debug("DEBUG");

  156.         carla_stdout("OUT");

  157.         carla_stderr("ERR");

  158.         carla_stderr2("ERR2");

  159.         carla_sleep(1);

  160.         carla_msleep(1);

  161.         carla_setenv("x", "y");

  162.         carla_setprocname("ANSI-Test");

  163. 

  164.         assert(safe_assert_return_test(true) == 0);

  165.         assert(safe_assert_return_test(false) == 1);

  166. 

  167.         // carla_strdup

  168.         {

  169.             const char* s1 = carla_strdup("s1");

  170.             const char* s2 = carla_strdup_free(strdup("s2"));

  171.             delete[] s1;

  172.             delete[] s2;

  173.         }

  174. 

  175.         // carla_min

  176.         {

  177.             assert(carla_min<int>( 1,  2, -1) ==  1);

  178.             assert(carla_min<int>( 1,  2,  0) ==  1);

  179.             assert(carla_min<int>( 1,  2,  1) ==  1);

  180.             assert(carla_min<int>( 1,  2,  2) ==  2);

  181.             assert(carla_min<int>( 1,  2,  3) ==  3);

  182. 

  183.             assert(carla_min<int>( 2,  2, -1) ==  2);

  184.             assert(carla_min<int>( 1,  2, -1) ==  1);

  185.             assert(carla_min<int>( 0,  2, -1) ==  0);

  186.             assert(carla_min<int>(-1,  2, -1) == -1);

  187.             assert(carla_min<int>(-2,  2, -1) == -1);

  188. 

  189.             assert(carla_min<int>(-1,  2,  0) ==  0);

  190.             assert(carla_min<int>(-1,  1,  0) ==  0);

  191.             assert(carla_min<int>(-1,  0,  0) ==  0);

  192.             assert(carla_min<int>(-1, -1,  0) ==  0);

  193.             assert(carla_min<int>(-1, -2,  0) ==  0);

  194. 

  195.             unsigned u1 = static_cast<unsigned>(-1);

  196.             unsigned u2 = static_cast<unsigned>(-2);

  197. 

  198.             assert(carla_min<unsigned>(u1, u2,  0) == u2);

  199.             assert(carla_min<unsigned>(u1, u2, u1) == u1);

  200.             assert(carla_min<unsigned>(u1, u2, u2) == u2);

  201. 

  202.             assert(carla_min<unsigned>(u1,  2,  0) == 2);

  203.             assert(carla_min<unsigned>( 2, u1,  0) == 2);

  204.             assert(carla_min<unsigned>( 2,  2, u1) == u1);

  205.         }

  206. 

  207.         // carla_max (same as min)

  208.         {

  209.             assert(carla_max<int>( 1,  2, -1) == -1);

  210.             assert(carla_max<int>( 1,  2,  0) ==  0);

  211.             assert(carla_max<int>( 1,  2,  1) ==  1);

  212.             assert(carla_max<int>( 1,  2,  2) ==  2);

  213.             assert(carla_max<int>( 1,  2,  3) ==  2);

  214. 

  215.             assert(carla_max<int>( 2,  2, -1) == -1);

  216.             assert(carla_max<int>( 1,  2, -1) == -1);

  217.             assert(carla_max<int>( 0,  2, -1) == -1);

  218.             assert(carla_max<int>(-1,  2, -1) == -1);

  219.             assert(carla_max<int>(-2,  2, -1) == -1);

  220. 

  221.             assert(carla_max<int>(-1,  2,  0) ==  0);

  222.             assert(carla_max<int>(-1,  1,  0) ==  0);

  223.             assert(carla_max<int>(-1,  0,  0) ==  0);

  224.             assert(carla_max<int>(-1, -1,  0) == -1);

  225.             assert(carla_max<int>(-1, -2,  0) == -1);

  226. 

  227.             unsigned u1 = static_cast<unsigned>(-1);

  228.             unsigned u2 = static_cast<unsigned>(-2);

  229. 

  230.             assert(carla_max<unsigned>(u1, u2,  0) == 0);

  231.             assert(carla_max<unsigned>(u1, u2, u1) == u1);

  232.             assert(carla_max<unsigned>(u1, u2, u2) == u2);

  233. 

  234.             assert(carla_max<unsigned>(u1,  2,  0) == 0);

  235.             assert(carla_max<unsigned>( 2, u1,  0) == 0);

  236.             assert(carla_max<unsigned>( 2,  2, u1) == 2);

  237.         }

  238.         // carla_fixValue (same as min)

  239.         {

  240.             assert(carla_fixValue<int>( 1,  2, -1) ==  1);

  241.             assert(carla_fixValue<int>( 1,  2,  0) ==  1);

  242.             assert(carla_fixValue<int>( 1,  2,  1) ==  1);

  243.             assert(carla_fixValue<int>( 1,  2,  2) ==  2);

  244.             assert(carla_fixValue<int>( 1,  2,  3) ==  2);

  245. 

  246.             assert(carla_fixValue<int>( 1,  2, -1) ==  1);

  247.             assert(carla_fixValue<int>( 0,  2, -1) ==  0);

  248.             assert(carla_fixValue<int>(-1,  2, -1) == -1);

  249.             assert(carla_fixValue<int>(-2,  2, -1) == -1);

  250. 

  251.             assert(carla_fixValue<int>(-1,  2,  0) ==  0);

  252.             assert(carla_fixValue<int>(-1,  1,  0) ==  0);

  253.             assert(carla_fixValue<int>(-1,  0,  0) ==  0);

  254. 

  255.             unsigned u1 = static_cast<unsigned>(-1);

  256.             unsigned u2 = static_cast<unsigned>(-2);

  257. 

  258.             assert(carla_fixValue<unsigned>(u2, u1,  0) == u2);

  259.             assert(carla_fixValue<unsigned>(u2, u1, u1) == u1);

  260.             assert(carla_fixValue<unsigned>(u2, u1, u2) == u2);

  261.         }

  262. 

  263.         // carla_add (copy and fill are very similar, so they are ignored here)

  264.         {

  265.             int a = 0;

  266.             int b = 1;

  267.             int c = 2;

  268. 

  269.             carla_add<int>(&a, &a, 1);

  270.             assert(a == 0);

  271. 

  272.             carla_add<int>(&a, &b, 1);

  273.             assert(a == 1);

  274. 

  275.             carla_add<int>(&a, &c, 1);

  276.             assert(a == 3);

  277. 

  278.             float d = 10.0f;

  279.             float e = 0.11f;

  280. 

  281.             carla_add<float>(&d, &e, 1);

  282.             assert(d == 10.11f);

  283. 

  284.             float f[5] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };

  285.             float g[5] = { 0.1f, 0.1f, 0.1f, 0.1f, 0.1f };

  286. 

  287.             carla_add<float>(f, g, 5);

  288.             assert(f[0] == f[0]);

  289.             assert(f[1] == f[1]);

  290.             assert(f[2] == f[2]);

  291.             assert(f[3] == f[3]);

  292.             assert(f[4] == f[4]);

  293.             assert(f[0] == g[0]);

  294.             assert(f[1] == g[1]);

  295.             assert(f[2] == g[2]);

  296.             assert(f[3] == g[3]);

  297.             assert(f[4] == g[4]);

  298. 

  299.             carla_add<float>(g, f, 1);

  300.             carla_add<float>(g, f, 2);

  301.             carla_addFloat(g, f, 3);

  302.             carla_add(g, f, 4);

  303.             carla_add(g, f, 5);

  304.             assert(g[0] == f[0]*6);

  305.             assert(g[1] == f[1]*5);

  306.             assert(g[2] == f[2]*4);

  307.             assert(g[3] == f[3]*3);

  308.             assert(g[4] == f[4]*2);

  309. 

  310.             carla_stdout("f: %f,%f,%f,%f,%f", f[0], f[1], f[2], f[3], f[4]);

  311. 

  312.             assert(f[0] != g[0]);

  313.             assert(f[1] != g[1]);

  314.             assert(f[2] != g[2]);

  315.             assert(f[3] != g[3]);

  316.             assert(f[4] != g[4]);

  317.             carla_copy(f, g, 3);

  318.             assert(f[0] == g[0]);

  319.             assert(f[1] == g[1]);

  320.             assert(f[2] == g[2]);

  321.             assert(f[3] != g[3]);

  322.             assert(f[4] != g[4]);

  323. 

  324.             carla_stdout("f: %f,%f,%f,%f,%f", f[0], f[1], f[2], f[3], f[4]);

  325.         }

  326. 

  327.         // memory functions

  328.         {

  329.             uint64_t a[100];

  330.             uint64_t at = 9999;

  331.             carla_fill<uint64_t>(a, 100, 1);

  332.             assert(a[99] == 1);

  333.             assert(at == 9999);

  334.             carla_zeroMem(a, sizeof(uint64_t)*100);

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

  336.             assert(a[99] == 0);

  337.             assert(at == 9999);

  338. 

  339.             uint64_t b[100];

  340.             uint64_t bt = 9999;

  341.             carla_fill<uint64_t>(b, 100, 2);

  342.             assert(b[99] == 2);

  343.             assert(at == 9999);

  344.             carla_zeroStruct(b);

  345.             assert(b[0] == 0);

  346.             assert(b[99] == 0);

  347.             assert(bt == 9999);

  348. 

  349.             uint64_t c[100];

  350.             uint64_t ct = 9999;

  351.             carla_fill<uint64_t>(c, 100, 3);

  352.             assert(c[99] == 3);

  353.             assert(at == 9999);

  354.             carla_zeroStruct(c, 100);

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

  356.             assert(c[99] == 0);

  357.             assert(ct == 9999);

  358. 

  359.             struct Test { bool b; void* p; int i; };

  360.             Test d, e[11], f[9];

  361.             carla_zeroStruct<Test>(d);

  362.             carla_zeroStruct<Test>(e, 11);

  363.             carla_zeroStruct<Test>(f, 9);

  364. 

  365.             Test* h(new Test);

  366.             h->i = 9;

  367.             carla_zeroStruct<Test>(h, 1);

  368.             assert(h->i == 0);

  369.             delete h;

  370. 

  371.             Test* i(new Test[2]);

  372.             carla_zeroStruct<Test>(i, 2);

  373.             delete[] i;

  374.         }

  375.     }

  376. 

  377.     // Carla misc utils imported from Juce source code

  378.     {

  379.         struct Test { char s[24]; void* p; };

  380. 

  381.         ScopedPointer<int> a(new int);

  382.         ScopedPointer<long long> b(new long long);

  383.         ScopedPointer<Test> c(new Test);

  384.         ScopedPointer<Test> d(new Test);

  385.         ScopedPointer<Test> e(new Test);

  386.         e = nullptr;

  387.         delete d.release();

  388.         delete e.release();

  389.         ScopedPointer<Test> f(nullptr);

  390.     }

  391. 

  392.     // Carla Native Plugin API (C++)

  393.     {

  394.         class PluginDescriptorClassTest : public PluginDescriptorClass

  395.         {

  396.         public:

  397.             PluginDescriptorClassTest(const HostDescriptor* const host)

  398.                 : PluginDescriptorClass(host) {}

  399.         protected:

  400.             void process(float** const, float** const, const uint32_t, const uint32_t, const MidiEvent* const) {}

  401. 

  402.             PluginDescriptorClassEND(PluginDescriptorClassTest)

  403.             CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginDescriptorClassTest)

  404.         };

  405. 

  406.         const HostDescriptor a = { nullptr, nullptr, nullptr,

  407.                                    nullptr, nullptr, nullptr,

  408.                                    nullptr, nullptr,

  409.                                    nullptr, nullptr, nullptr, nullptr,

  410.                                    nullptr, nullptr,

  411.                                    nullptr };

  412. 

  413.         PluginDescriptor b = { PLUGIN_CATEGORY_NONE, PLUGIN_IS_RTSAFE, PLUGIN_SUPPORTS_EVERYTHING,

  414.                                0, 0, 0, 0, 0, 0,

  415.                                nullptr, nullptr, nullptr, nullptr,

  416.                                PluginDescriptorFILL(PluginDescriptorClassTest) };

  417.         (void)b;

  418. 

  419.         ScopedPointer<PluginDescriptorClassTest> c;

  420.         c = new PluginDescriptorClassTest(&a);

  421.     }

  422. 

  423.     return 0;

  424. }