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.
965 Commits
16 Branches
14GB
Tree: 6e781f09ce
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6e781f09ce'
${ noResults }
Carla/source/tests/ANSI.cpp

660 lines
19KB
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. // 0 - base

  25. // 1 - utils

  26. // 2 - engine

  27. // 3 - plugin

  28. // 4 - standalone

  29. #define ANSI_TEST_N 0

  30. 

  31. #if ANSI_TEST_N == 0

  32. // utils

  33. #include "CarlaUtils.hpp"

  34. 

  35. // Carla Backend API

  36. #include "CarlaBackend.hpp"

  37. #endif

  38. 

  39. #if ANSI_TEST_N == 1

  40. // includes

  41. #include "CarlaDefines.hpp"

  42. #include "CarlaMIDI.h"

  43. #include "ladspa_rdf.hpp"

  44. #include "lv2_rdf.hpp"

  45. 

  46. // Carla Backend API

  47. #include "CarlaBackend.hpp"

  48. 

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

  50. #include "CarlaUtils.hpp"

  51. #include "CarlaJuceUtils.hpp"

  52. 

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

  54. #include "CarlaMutex.hpp"

  55. #include "CarlaRingBuffer.hpp"

  56. #include "CarlaString.hpp"

  57. #include "RtList.hpp"

  58. 

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

  60. #include "CarlaBackendUtils.hpp"

  61. #include "CarlaBridgeUtils.hpp"

  62. #include "CarlaLadspaUtils.hpp"

  63. #include "CarlaLibUtils.hpp"

  64. #include "CarlaLv2Utils.hpp"

  65. #include "CarlaOscUtils.hpp"

  66. #include "CarlaShmUtils.hpp"

  67. #include "CarlaStateUtils.hpp"

  68. #include "CarlaVstUtils.hpp"

  69. 

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

  71. #include "Lv2AtomQueue.hpp"

  72. 

  73. // Carla Native Plugin API

  74. #include "CarlaNative.h"

  75. 

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

  77. #include "CarlaNative.hpp"

  78. 

  79. // Carla Plugin API

  80. #include "CarlaPlugin.hpp"

  81. 

  82. // Carla Engine API

  83. #include "CarlaEngine.hpp"

  84. 

  85. // Carla Host API

  86. #include "CarlaHost.hpp"

  87. // ANSI_TEST_N == 1

  88. #endif

  89. 

  90. #if ANSI_TEST_N == 2

  91. // Carla Engine

  92. #include "engine/CarlaEngineThread.hpp"

  93. #endif

  94. 

  95. #if ANSI_TEST_N == 3

  96. // Carla Plugin

  97. #include "plugin/CarlaPluginThread.hpp"

  98. #include "plugin/CarlaPluginInternal.hpp"

  99. #endif

  100. 

  101. #if ANSI_TEST_N == 4

  102. // Carla Host Standalone

  103. #include "CarlaHost.hpp"

  104. #include "CarlaUtils.hpp"

  105. #endif

  106. 

  107. #if ANSI_TEST_N == 1

  108. // -----------------------------------------------------------------------

  109. 

  110. namespace CB = CarlaBackend;

  111. using juce::ScopedPointer;

  112. 

  113. int safe_assert_return_test(bool test)

  114. {

  115.     CARLA_SAFE_ASSERT_RETURN(test, 1);

  116.     return 0;

  117. }

  118. #endif

  119. 

  120. // -----------------------------------------------------------------------

  121. 

  122. int main()

  123. {

  124. #if ANSI_TEST_N == 0

  125.     CARLA_BACKEND_USE_NAMESPACE

  126. 

  127.     BinaryType b;

  128.     CallbackType c;

  129.     CARLA_ASSERT(sizeof(b) == sizeof(BinaryType));

  130.     CARLA_ASSERT(sizeof(b) == sizeof(int));

  131.     CARLA_ASSERT(sizeof(BinaryType) == sizeof(int));

  132. 

  133.     CARLA_ASSERT(sizeof(c) == sizeof(CallbackType));

  134.     CARLA_ASSERT(sizeof(c) == sizeof(int));

  135.     CARLA_ASSERT(sizeof(CallbackType) == sizeof(int));

  136. #endif

  137. 

  138. #if ANSI_TEST_N == 1

  139.     // ladspa rdf

  140.     {

  141.         LADSPA_RDF_ScalePoint a;

  142.         LADSPA_RDF_Port b;

  143.         LADSPA_RDF_Descriptor c;

  144.     }

  145. 

  146.     // lv2 rdf

  147.     {

  148.         LV2_RDF_PortMidiMap a;

  149.         LV2_RDF_PortPoints b;

  150.         LV2_RDF_PortUnit c;

  151.         LV2_RDF_PortScalePoint d;

  152.         LV2_RDF_Port e;

  153.         LV2_RDF_Preset f;

  154.         LV2_RDF_Feature g;

  155.         LV2_RDF_UI h;

  156.         LV2_RDF_Descriptor i;

  157.     }

  158. 

  159.     // Carla Backend API

  160.     {

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

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

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

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

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

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

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

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

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

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

  171.         CB::CallbackFunc k = nullptr;

  172.         CB::ParameterData l;

  173.         CB::ParameterRanges m;

  174.         CB::MidiProgramData n;

  175.         CB::CustomData o;

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

  177.     }

  178. 

  179.     // Carla Native Plugin API

  180.     {

  181.         HostHandle a = nullptr;

  182.         PluginHandle b = nullptr;

  183.         PluginCategory c = PLUGIN_CATEGORY_NONE;

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

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

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

  187.         PluginDispatcherOpcode g = PLUGIN_OPCODE_NULL;

  188.         HostDispatcherOpcode h = HOST_OPCODE_NULL;

  189.         ParameterScalePoint i;

  190.         ParameterRanges j;

  191.         Parameter k;

  192.         MidiEvent l;

  193.         MidiProgram m;

  194.         TimeInfoBBT n;

  195.         TimeInfo o;

  196.         HostDescriptor p;

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

  198.                                0, 0, 0, 0, 0, 0,

  199.                                nullptr, nullptr, nullptr, nullptr,

  200.                                nullptr, nullptr,

  201.                                nullptr, nullptr, nullptr, nullptr,

  202.                                nullptr, nullptr,

  203.                                nullptr, nullptr, nullptr,

  204.                                nullptr, nullptr,

  205.                                nullptr, nullptr, nullptr,

  206.                                nullptr, nullptr, nullptr,

  207.                                nullptr, nullptr,

  208.                                nullptr };

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

  210.         (void)q;

  211.     }

  212. 

  213.     // Carla common utils

  214.     {

  215.         bool2str(true);

  216.         pass();

  217.         carla_debug("DEBUG");

  218.         carla_stdout("OUT");

  219.         carla_stderr("ERR");

  220.         carla_stderr2("ERR2");

  221.         carla_sleep(1);

  222.         carla_msleep(1);

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

  224.         carla_setprocname("ANSI-Test");

  225. 

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

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

  228. 

  229.         // carla_strdup

  230.         {

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

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

  233.             delete[] s1;

  234.             delete[] s2;

  235.         }

  236. 

  237.         // carla_min

  238.         {

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

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

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

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

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

  244. 

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

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

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

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

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

  250. 

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

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

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

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

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

  256. 

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

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

  259. 

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

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

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

  263. 

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

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

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

  267.         }

  268. 

  269.         // carla_max (same as min)

  270.         {

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

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

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

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

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

  276. 

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

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

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

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

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

  282. 

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

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

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

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

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

  288. 

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

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

  291. 

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

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

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

  295. 

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

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

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

  299.         }

  300.         // carla_fixValue (same as min)

  301.         {

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

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

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

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

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

  307. 

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

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

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

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

  312. 

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

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

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

  316. 

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

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

  319. 

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

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

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

  323.         }

  324. 

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

  326.         {

  327.             int a = 0;

  328.             int b = 1;

  329.             int c = 2;

  330. 

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

  332.             assert(a == 0);

  333. 

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

  335.             assert(a == 1);

  336. 

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

  338.             assert(a == 3);

  339. 

  340.             float d = 10.0f;

  341.             float e = 0.11f;

  342. 

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

  344.             assert(d == 10.11f);

  345. 

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

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

  348. 

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

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

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

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

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

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

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

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

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

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

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

  360. 

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

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

  363.             carla_addFloat(g, f, 3);

  364.             carla_add(g, f, 4);

  365.             carla_add(g, f, 5);

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

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

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

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

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

  371. 

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

  373. 

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

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

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

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

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

  379.             carla_copy(f, g, 3);

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

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

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

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

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

  385. 

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

  387.         }

  388. 

  389.         // memory functions

  390.         {

  391.             uint64_t a[100];

  392.             uint64_t at = 9999;

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

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

  395.             assert(at == 9999);

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

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

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

  399.             assert(at == 9999);

  400. 

  401.             uint64_t b[100];

  402.             uint64_t bt = 9999;

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

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

  405.             assert(at == 9999);

  406.             carla_zeroStruct(b);

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

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

  409.             assert(bt == 9999);

  410. 

  411.             uint64_t c[100];

  412.             uint64_t ct = 9999;

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

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

  415.             assert(at == 9999);

  416.             carla_zeroStruct(c, 100);

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

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

  419.             assert(ct == 9999);

  420. 

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

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

  423.             carla_zeroStruct<Test>(d);

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

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

  426. 

  427.             Test* h(new Test);

  428.             h->i = 9;

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

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

  431.             delete h;

  432. 

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

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

  435.             delete[] i;

  436.         }

  437.     }

  438. 

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

  440.     {

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

  442. 

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

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

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

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

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

  448.         e = nullptr;

  449.         delete d.release();

  450.         delete e.release();

  451.         ScopedPointer<Test> f(nullptr);

  452.     }

  453. 

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

  455.     {

  456.         class PluginClassTest : public PluginClass

  457.         {

  458.         public:

  459.             PluginDescriptorClassTest(const HostDescriptor* const host)

  460.                 : PluginClass(host) {}

  461.         protected:

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

  463. 

  464.             PluginClassEND(PluginClassTest)

  465.             CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginClassTest)

  466.         };

  467. 

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

  469.                                    nullptr, nullptr, nullptr,

  470.                                    nullptr, nullptr,

  471.                                    nullptr, nullptr, nullptr, nullptr,

  472.                                    nullptr, nullptr,

  473.                                    nullptr };

  474. 

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

  476.                                0, 0, 0, 0, 0, 0,

  477.                                nullptr, nullptr, nullptr, nullptr,

  478.                                PluginDescriptorFILL(PluginDescriptorClassTest) };

  479.         (void)b;

  480. 

  481.         ScopedPointer<PluginDescriptorClassTest> c;

  482.         c = new PluginDescriptorClassTest(&a);

  483.     }

  484. 

  485.     // Carla Backend utils

  486.     {

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

  488. 

  489.         TestClass a, b, c;

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

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

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

  493.         assert(bd > ad);

  494.         assert(cd > bd);

  495. 

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

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

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

  499.         assert(ap == &a);

  500.         assert(bp == &b);

  501.         assert(cp == &c);

  502. 

  503.         ap->i = 4;

  504.         bp->i = 5;

  505.         cp->i = 6;

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

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

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

  509.     }

  510. 

  511.     // Carla Mutex

  512.     {

  513.         CarlaMutex m;

  514.         m.tryLock();

  515.         m.unlock();

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

  517.     }

  518. 

  519.     // RingBuffer

  520.     {

  521.         RingBuffer buf;

  522.         RingBufferControl ctrl(&buf);

  523. 

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

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

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

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

  528. 

  529.         ctrl.writeChar('z');

  530.         ctrl.commitWrite();

  531.         assert(ctrl.dataAvailable());

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

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

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

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

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

  537. 

  538.         ctrl.writeInt(9999);

  539.         ctrl.commitWrite();

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

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

  542.         assert(i != 0);

  543.         assert(i == 9999);

  544. 

  545.         ctrl.writeLong(-88088);

  546.         ctrl.commitWrite();

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

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

  549.         assert(l != 0);

  550.         assert(l == -88088);

  551. 

  552.         ctrl.writeFloat(5.6789f);

  553.         ctrl.commitWrite();

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

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

  556.         assert(f != 0.0f);

  557.         assert(f == 5.6789f);

  558. 

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

  560. 

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

  562.         {

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

  564.            ctrl.commitWrite();

  565.         }

  566. 

  567.         assert(ctrl.dataAvailable());

  568. 

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

  570. 

  571.         while (ctrl.dataAvailable())

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

  573. 

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

  575. 

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

  577.     }

  578. 

  579.     // RtList

  580.     {

  581.         class ListTester

  582.         {

  583.         public:

  584.             struct CountObj {

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

  586.                 volatile int count;

  587.             };

  588. 

  589.             ListTester()

  590.             {

  591.                 ++getCounter().count;

  592.             }

  593. 

  594.             ~ListTester()

  595.             {

  596.                 --getCounter().count;

  597.             }

  598. 

  599.             static CountObj& getCounter()

  600.             {

  601.                 static CountObj counter;

  602.                 return counter;

  603.             }

  604.         };

  605. 

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

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

  608. 

  609.         NonRtList<ListTester> list;

  610.         obj = ListTester::getCounter();

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

  612. 

  613.         ListTester t1;

  614.         obj = ListTester::getCounter();

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

  616. 

  617.         list.append(t1);

  618.         list.append(t1);

  619.         list.append(t1);

  620.         obj = ListTester::getCounter();

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

  622. 

  623.         list.clear();

  624.         obj = ListTester::getCounter();

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

  626.     }

  627. // ANSI_TEST_N == 1

  628. #endif

  629. 

  630. #if ANSI_TEST_N == 2

  631. // ANSI_TEST_N == 2

  632. #endif

  633. 

  634. #if ANSI_TEST_N == 3

  635. // ANSI_TEST_N == 3

  636. #endif

  637. 

  638. #if ANSI_TEST_N == 4

  639.     carla_stdout("NOTICE LICENSE:");

  640.     carla_stdout(carla_get_extended_license_text());

  641.     carla_stdout("");

  642. 

  643.     carla_stdout("FILETYPES:");

  644.     carla_stdout(carla_get_supported_file_types());

  645.     carla_stdout("");

  646. 

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

  648.     carla_stdout(carla_get_last_error());

  649. 

  650.     carla_engine_close();

  651.     carla_stdout(carla_get_last_error());

  652. 

  653. // ANSI_TEST_N == 4

  654. #endif

  655. 

  656.     return 0;

  657. }

  658. 

  659. // -----------------------------------------------------------------------