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

636 lines
18KB
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. #undef DEBUG

  20. #define DEBUG 1

  21. 

  22. #define RING_BUFFER_SIZE 48

  23. 

  24. // 1 - utils

  25. // 2 - engine

  26. // 3 - plugin

  27. // 4 - standalone

  28. #define ANSI_TEST_N 2

  29. 

  30. #if ANSI_TEST_N == 1

  31. // includes

  32. #include "CarlaDefines.hpp"

  33. #include "CarlaMIDI.h"

  34. #include "ladspa_rdf.hpp"

  35. #include "lv2_rdf.hpp"

  36. 

  37. // Carla Backend API

  38. #include "CarlaBackend.hpp"

  39. 

  40. // Carla utils (part 1/4)

  41. #include "CarlaUtils.hpp"

  42. #include "CarlaJuceUtils.hpp"

  43. 

  44. // Carla utils (part 2/4)

  45. #include "CarlaMutex.hpp"

  46. #include "CarlaRingBuffer.hpp"

  47. #include "CarlaString.hpp"

  48. #include "RtList.hpp"

  49. 

  50. // Carla utils (part 3/4)

  51. #include "CarlaBackendUtils.hpp"

  52. #include "CarlaBridgeUtils.hpp"

  53. #include "CarlaLadspaUtils.hpp"

  54. #include "CarlaLibUtils.hpp"

  55. #include "CarlaLv2Utils.hpp"

  56. #include "CarlaOscUtils.hpp"

  57. #include "CarlaShmUtils.hpp"

  58. #include "CarlaStateUtils.hpp"

  59. #include "CarlaVstUtils.hpp"

  60. 

  61. // Carla utils (part 4/4)

  62. #include "Lv2AtomQueue.hpp"

  63. 

  64. // Carla Native Plugin API

  65. #include "CarlaNative.h"

  66. 

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

  68. #include "CarlaNative.hpp"

  69. 

  70. // Carla Plugin API

  71. #include "CarlaPlugin.hpp"

  72. 

  73. // Carla Engine API

  74. #include "CarlaEngine.hpp"

  75. 

  76. // Carla Standalone API

  77. #include "CarlaStandalone.hpp"

  78. // ANSI_TEST_N == 1

  79. #endif

  80. 

  81. #if ANSI_TEST_N == 2

  82. // Carla Engine

  83. #include "engine/CarlaEngineThread.hpp"

  84. #endif

  85. 

  86. #if ANSI_TEST_N == 3

  87. // Carla Plugin

  88. #include "plugin/CarlaPluginThread.hpp"

  89. #include "plugin/CarlaPluginInternal.hpp"

  90. #endif

  91. 

  92. #if ANSI_TEST_N == 4

  93. // Carla Standalone

  94. #include "CarlaStandalone.hpp"

  95. #include "CarlaUtils.hpp"

  96. #endif

  97. 

  98. #if ANSI_TEST_N == 1

  99. // -----------------------------------------------------------------------

  100. 

  101. namespace CB = CarlaBackend;

  102. 

  103. int safe_assert_return_test(bool test)

  104. {

  105.     CARLA_SAFE_ASSERT_RETURN(test, 1);

  106.     return 0;

  107. }

  108. #endif

  109. 

  110. // -----------------------------------------------------------------------

  111. 

  112. int main()

  113. {

  114. #if ANSI_TEST_N == 1

  115.     // ladspa rdf

  116.     {

  117.         LADSPA_RDF_ScalePoint a;

  118.         LADSPA_RDF_Port b;

  119.         LADSPA_RDF_Descriptor c;

  120.     }

  121. 

  122.     // lv2 rdf

  123.     {

  124.         LV2_RDF_PortMidiMap a;

  125.         LV2_RDF_PortPoints b;

  126.         LV2_RDF_PortUnit c;

  127.         LV2_RDF_PortScalePoint d;

  128.         LV2_RDF_Port e;

  129.         LV2_RDF_Preset f;

  130.         LV2_RDF_Feature g;

  131.         LV2_RDF_UI h;

  132.         LV2_RDF_Descriptor i;

  133.     }

  134. 

  135.     // Carla Backend API

  136.     {

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

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

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

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

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

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

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

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

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

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

  147.         CB::CallbackFunc k = nullptr;

  148.         CB::ParameterData l;

  149.         CB::ParameterRanges m;

  150.         CB::MidiProgramData n;

  151.         CB::CustomData o;

  152.         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;

  153.     }

  154. 

  155.     // Carla Native Plugin API

  156.     {

  157.         HostHandle a = nullptr;

  158.         PluginHandle b = nullptr;

  159.         PluginCategory c = PLUGIN_CATEGORY_NONE;

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

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

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

  163.         PluginDispatcherOpcode g = PLUGIN_OPCODE_NULL;

  164.         HostDispatcherOpcode h = HOST_OPCODE_NULL;

  165.         ParameterScalePoint i;

  166.         ParameterRanges j;

  167.         Parameter k;

  168.         MidiEvent l;

  169.         MidiProgram m;

  170.         TimeInfoBBT n;

  171.         TimeInfo o;

  172.         HostDescriptor p;

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

  174.                                0, 0, 0, 0, 0, 0,

  175.                                nullptr, nullptr, nullptr, nullptr,

  176.                                nullptr, nullptr,

  177.                                nullptr, nullptr, nullptr, nullptr,

  178.                                nullptr, nullptr,

  179.                                nullptr, nullptr, nullptr,

  180.                                nullptr, nullptr,

  181.                                nullptr, nullptr, nullptr,

  182.                                nullptr, nullptr, nullptr,

  183.                                nullptr, nullptr,

  184.                                nullptr };

  185.         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;

  186.         (void)q;

  187.     }

  188. 

  189.     // Carla common utils

  190.     {

  191.         bool2str(true);

  192.         pass();

  193.         carla_debug("DEBUG");

  194.         carla_stdout("OUT");

  195.         carla_stderr("ERR");

  196.         carla_stderr2("ERR2");

  197.         carla_sleep(1);

  198.         carla_msleep(1);

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

  200.         carla_setprocname("ANSI-Test");

  201. 

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

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

  204. 

  205.         // carla_strdup

  206.         {

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

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

  209.             delete[] s1;

  210.             delete[] s2;

  211.         }

  212. 

  213.         // carla_min

  214.         {

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

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

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

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

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

  220. 

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

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

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

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

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

  226. 

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

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

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

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

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

  232. 

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

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

  235. 

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

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

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

  239. 

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

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

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

  243.         }

  244. 

  245.         // carla_max (same as min)

  246.         {

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

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

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

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

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

  252. 

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

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

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

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

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

  258. 

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

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

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

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

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

  264. 

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

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

  267. 

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

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

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

  271. 

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

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

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

  275.         }

  276.         // carla_fixValue (same as min)

  277.         {

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

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

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

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

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

  283. 

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

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

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

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

  288. 

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

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

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

  292. 

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

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

  295. 

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

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

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

  299.         }

  300. 

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

  302.         {

  303.             int a = 0;

  304.             int b = 1;

  305.             int c = 2;

  306. 

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

  308.             assert(a == 0);

  309. 

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

  311.             assert(a == 1);

  312. 

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

  314.             assert(a == 3);

  315. 

  316.             float d = 10.0f;

  317.             float e = 0.11f;

  318. 

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

  320.             assert(d == 10.11f);

  321. 

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

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

  324. 

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

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

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

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

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

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

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

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

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

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

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

  336. 

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

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

  339.             carla_addFloat(g, f, 3);

  340.             carla_add(g, f, 4);

  341.             carla_add(g, f, 5);

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

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

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

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

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

  347. 

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

  349. 

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

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

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

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

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

  355.             carla_copy(f, g, 3);

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

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

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

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

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

  361. 

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

  363.         }

  364. 

  365.         // memory functions

  366.         {

  367.             uint64_t a[100];

  368.             uint64_t at = 9999;

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

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

  371.             assert(at == 9999);

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

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

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

  375.             assert(at == 9999);

  376. 

  377.             uint64_t b[100];

  378.             uint64_t bt = 9999;

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

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

  381.             assert(at == 9999);

  382.             carla_zeroStruct(b);

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

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

  385.             assert(bt == 9999);

  386. 

  387.             uint64_t c[100];

  388.             uint64_t ct = 9999;

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

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

  391.             assert(at == 9999);

  392.             carla_zeroStruct(c, 100);

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

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

  395.             assert(ct == 9999);

  396. 

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

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

  399.             carla_zeroStruct<Test>(d);

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

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

  402. 

  403.             Test* h(new Test);

  404.             h->i = 9;

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

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

  407.             delete h;

  408. 

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

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

  411.             delete[] i;

  412.         }

  413.     }

  414. 

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

  416.     {

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

  418. 

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

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

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

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

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

  424.         e = nullptr;

  425.         delete d.release();

  426.         delete e.release();

  427.         ScopedPointer<Test> f(nullptr);

  428.     }

  429. 

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

  431.     {

  432.         class PluginDescriptorClassTest : public PluginDescriptorClass

  433.         {

  434.         public:

  435.             PluginDescriptorClassTest(const HostDescriptor* const host)

  436.                 : PluginDescriptorClass(host) {}

  437.         protected:

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

  439. 

  440.             PluginDescriptorClassEND(PluginDescriptorClassTest)

  441.             CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginDescriptorClassTest)

  442.         };

  443. 

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

  445.                                    nullptr, nullptr, nullptr,

  446.                                    nullptr, nullptr,

  447.                                    nullptr, nullptr, nullptr, nullptr,

  448.                                    nullptr, nullptr,

  449.                                    nullptr };

  450. 

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

  452.                                0, 0, 0, 0, 0, 0,

  453.                                nullptr, nullptr, nullptr, nullptr,

  454.                                PluginDescriptorFILL(PluginDescriptorClassTest) };

  455.         (void)b;

  456. 

  457.         ScopedPointer<PluginDescriptorClassTest> c;

  458.         c = new PluginDescriptorClassTest(&a);

  459.     }

  460. 

  461.     // Carla Backend utils

  462.     {

  463.         class TestClass { public: int i; char pad[50]; };

  464. 

  465.         TestClass a, b, c;

  466.         uintptr_t ad = CarlaBackend::getAddressFromPointer(&a);

  467.         uintptr_t bd = CarlaBackend::getAddressFromPointer(&b);

  468.         uintptr_t cd = CarlaBackend::getAddressFromPointer(&c);

  469.         assert(bd > ad);

  470.         assert(cd > bd);

  471. 

  472.         TestClass* ap = CarlaBackend::getPointerFromAddress<TestClass>(ad);

  473.         TestClass* bp = CarlaBackend::getPointerFromAddress<TestClass>(bd);

  474.         TestClass* cp = CarlaBackend::getPointerFromAddress<TestClass>(cd);

  475.         assert(ap == &a);

  476.         assert(bp == &b);

  477.         assert(cp == &c);

  478. 

  479.         ap->i = 4;

  480.         bp->i = 5;

  481.         cp->i = 6;

  482.         assert(a.i == 4);

  483.         assert(b.i == 5);

  484.         assert(c.i == 6);

  485.     }

  486. 

  487.     // Carla Mutex

  488.     {

  489.         CarlaMutex m;

  490.         m.tryLock();

  491.         m.unlock();

  492.         const CarlaMutex::ScopedLocker sl(m);

  493.     }

  494. 

  495.     // RingBuffer

  496.     {

  497.         RingBuffer buf;

  498.         RingBufferControl ctrl(&buf);

  499. 

  500.         assert(! ctrl.dataAvailable());

  501.         assert(ctrl.readInt() == 0);

  502.         assert(ctrl.readFloat() == 0.0f);

  503.         assert(! ctrl.dataAvailable());

  504. 

  505.         ctrl.writeChar('z');

  506.         ctrl.commitWrite();

  507.         assert(ctrl.dataAvailable());

  508.         const char c = ctrl.readChar();

  509.         carla_stdout("BufRead c = \"%c\"", c);

  510.         assert(c != '\0');

  511.         assert(c == 'z');

  512.         assert(! ctrl.dataAvailable());

  513. 

  514.         ctrl.writeInt(9999);

  515.         ctrl.commitWrite();

  516.         const int i = ctrl.readInt();

  517.         carla_stdout("BufRead i = \"%i\"", i);

  518.         assert(i != 0);

  519.         assert(i == 9999);

  520. 

  521.         ctrl.writeLong(-88088);

  522.         ctrl.commitWrite();

  523.         const long l = ctrl.readLong();

  524.         carla_stdout("BufRead l = \"%li\"", l);

  525.         assert(l != 0);

  526.         assert(l == -88088);

  527. 

  528.         ctrl.writeFloat(5.6789f);

  529.         ctrl.commitWrite();

  530.         const float f = ctrl.readFloat();

  531.         carla_stdout("BufRead f = \"%f\"", f);

  532.         assert(f != 0.0f);

  533.         assert(f == 5.6789f);

  534. 

  535.         assert(! ctrl.dataAvailable());

  536. 

  537.         for (char i='1'; i <= 'z'; ++i)

  538.         {

  539.            ctrl.writeChar(char(i));

  540.            ctrl.commitWrite();

  541.         }

  542. 

  543.         assert(ctrl.dataAvailable());

  544. 

  545.         printf("CHAR DUMP:\n");

  546. 

  547.         while (ctrl.dataAvailable())

  548.             printf("%c", ctrl.readChar());

  549. 

  550.         assert(! ctrl.dataAvailable());

  551. 

  552.         printf("\nDUMP FINISHED\n");

  553.     }

  554. 

  555.     // RtList

  556.     {

  557.         class ListTester

  558.         {

  559.         public:

  560.             struct CountObj {

  561.                 CountObj() : count(0) {}

  562.                 volatile int count;

  563.             };

  564. 

  565.             ListTester()

  566.             {

  567.                 ++getCounter().count;

  568.             }

  569. 

  570.             ~ListTester()

  571.             {

  572.                 --getCounter().count;

  573.             }

  574. 

  575.             static CountObj& getCounter()

  576.             {

  577.                 static CountObj counter;

  578.                 return counter;

  579.             }

  580.         };

  581. 

  582.         ListTester::CountObj& obj = ListTester::getCounter();

  583.         assert(obj.count == 0);

  584. 

  585.         NonRtList<ListTester> list;

  586.         obj = ListTester::getCounter();

  587.         assert(obj.count == 1); // List fRetValue

  588. 

  589.         ListTester t1;

  590.         obj = ListTester::getCounter();

  591.         assert(obj.count == 2); // List fRetValue + t1

  592. 

  593.         list.append(t1);

  594.         list.append(t1);

  595.         list.append(t1);

  596.         obj = ListTester::getCounter();

  597.         assert(obj.count == 5); // List fRetValue + t1 + 3 appends

  598. 

  599.         list.clear();

  600.         obj = ListTester::getCounter();

  601.         assert(obj.count == 2); // List fRetValue + t1

  602.     }

  603. // ANSI_TEST_N == 1

  604. #endif

  605. 

  606. #if ANSI_TEST_N == 2

  607. // ANSI_TEST_N == 2

  608. #endif

  609. 

  610. #if ANSI_TEST_N == 3

  611. // ANSI_TEST_N == 3

  612. #endif

  613. 

  614. #if ANSI_TEST_N == 4

  615.     carla_stdout("NOTICE LICENSE:");

  616.     carla_stdout(carla_get_extended_license_text());

  617.     carla_stdout("");

  618. 

  619.     carla_stdout("FILETYPES:");

  620.     carla_stdout(carla_get_supported_file_types());

  621.     carla_stdout("");

  622. 

  623.     carla_engine_init("beh", "bah");

  624.     carla_stdout(carla_get_last_error());

  625. 

  626.     carla_engine_close();

  627.     carla_stdout(carla_get_last_error());

  628. 

  629. // ANSI_TEST_N == 4

  630. #endif

  631. 

  632.     return 0;

  633. }

  634. 

  635. // -----------------------------------------------------------------------