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

583 lines
17KB
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. // includes

  25. #include "CarlaDefines.hpp"

  26. #include "CarlaMIDI.h"

  27. #include "ladspa_rdf.hpp"

  28. #include "lv2_rdf.hpp"

  29. 

  30. // Carla Backend API

  31. #include "CarlaBackend.hpp"

  32. 

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

  34. #include "CarlaUtils.hpp"

  35. #include "CarlaJuceUtils.hpp"

  36. 

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

  38. #include "CarlaMutex.hpp"

  39. #include "CarlaRingBuffer.hpp"

  40. #include "CarlaString.hpp"

  41. #include "RtList.hpp"

  42. 

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

  44. #include "CarlaBackendUtils.hpp"

  45. #include "CarlaBridgeUtils.hpp"

  46. #include "CarlaLadspaUtils.hpp"

  47. #include "CarlaLibUtils.hpp"

  48. // #include "CarlaLv2Utils.hpp"

  49. #include "CarlaOscUtils.hpp"

  50. #include "CarlaShmUtils.hpp"

  51. #include "CarlaStateUtils.hpp"

  52. // #include "CarlaVstUtils.hpp"

  53. 

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

  55. // #include "Lv2AtomQueue.hpp"

  56. 

  57. // Carla Native Plugin API

  58. // #include "CarlaNative.h"

  59. 

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

  61. // #include "CarlaNative.hpp"

  62. 

  63. // Carla Plugin API

  64. // #include "CarlaPlugin.hpp"

  65. 

  66. // Carla Engine API

  67. // #include "CarlaEngine.hpp"

  68. 

  69. // Carla Standalone API

  70. // #include "CarlaStandalone.hpp"

  71. 

  72. // // Carla Plugin

  73. // #include "plugin/CarlaPluginThread.hpp"

  74. // #include "plugin/CarlaPluginInternal.hpp"

  75. 

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

  77. 

  78. namespace CB = CarlaBackend;

  79. 

  80. int safe_assert_return_test(bool test)

  81. {

  82.     CARLA_SAFE_ASSERT_RETURN(test, 1);

  83.     return 0;

  84. }

  85. 

  86. int main()

  87. {

  88.     // ladspa rdf

  89.     {

  90.         LADSPA_RDF_ScalePoint a;

  91.         LADSPA_RDF_Port b;

  92.         LADSPA_RDF_Descriptor c;

  93.     }

  94. 

  95.     // lv2 rdf

  96.     {

  97.         LV2_RDF_PortMidiMap a;

  98.         LV2_RDF_PortPoints b;

  99.         LV2_RDF_PortUnit c;

  100.         LV2_RDF_PortScalePoint d;

  101.         LV2_RDF_Port e;

  102.         LV2_RDF_Preset f;

  103.         LV2_RDF_Feature g;

  104.         LV2_RDF_UI h;

  105.         LV2_RDF_Descriptor i;

  106.     }

  107. 

  108.     // Carla Backend API

  109.     {

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

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

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

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

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

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

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

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

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

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

  120.         CB::CallbackFunc k = nullptr;

  121.         CB::ParameterData l;

  122.         CB::ParameterRanges m;

  123.         CB::MidiProgramData n;

  124.         CB::CustomData o;

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

  126.     }

  127. 

  128. #if 0

  129.     // Carla Native Plugin API

  130.     {

  131.         HostHandle a = nullptr;

  132.         PluginHandle b = nullptr;

  133.         PluginCategory c = PLUGIN_CATEGORY_NONE;

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

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

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

  137.         PluginDispatcherOpcode g = PLUGIN_OPCODE_NULL;

  138.         HostDispatcherOpcode h = HOST_OPCODE_NULL;

  139.         ParameterScalePoint i;

  140.         ParameterRanges j;

  141.         Parameter k;

  142.         MidiEvent l;

  143.         MidiProgram m;

  144.         TimeInfoBBT n;

  145.         TimeInfo o;

  146.         HostDescriptor p;

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

  148.                                0, 0, 0, 0, 0, 0,

  149.                                nullptr, nullptr, nullptr, nullptr,

  150.                                nullptr, nullptr,

  151.                                nullptr, nullptr, nullptr, nullptr,

  152.                                nullptr, nullptr,

  153.                                nullptr, nullptr, nullptr,

  154.                                nullptr, nullptr,

  155.                                nullptr, nullptr, nullptr,

  156.                                nullptr, nullptr, nullptr,

  157.                                nullptr, nullptr,

  158.                                nullptr };

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

  160.         (void)q;

  161.     }

  162. #endif

  163. 

  164.     // Carla common utils

  165.     {

  166.         bool2str(true);

  167.         pass();

  168.         carla_debug("DEBUG");

  169.         carla_stdout("OUT");

  170.         carla_stderr("ERR");

  171.         carla_stderr2("ERR2");

  172.         carla_sleep(1);

  173.         carla_msleep(1);

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

  175.         carla_setprocname("ANSI-Test");

  176. 

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

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

  179. 

  180.         // carla_strdup

  181.         {

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

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

  184.             delete[] s1;

  185.             delete[] s2;

  186.         }

  187. 

  188.         // carla_min

  189.         {

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

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

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

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

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

  195. 

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

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

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

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

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

  201. 

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

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

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

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

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

  207. 

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

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

  210. 

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

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

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

  214. 

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

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

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

  218.         }

  219. 

  220.         // carla_max (same as min)

  221.         {

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

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

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

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

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

  227. 

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

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

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

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

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

  233. 

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

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

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

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

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

  239. 

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

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

  242. 

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

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

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

  246. 

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

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

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

  250.         }

  251.         // carla_fixValue (same as min)

  252.         {

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

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

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

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

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

  258. 

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

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

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

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

  263. 

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

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

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

  267. 

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

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

  270. 

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

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

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

  274.         }

  275. 

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

  277.         {

  278.             int a = 0;

  279.             int b = 1;

  280.             int c = 2;

  281. 

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

  283.             assert(a == 0);

  284. 

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

  286.             assert(a == 1);

  287. 

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

  289.             assert(a == 3);

  290. 

  291.             float d = 10.0f;

  292.             float e = 0.11f;

  293. 

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

  295.             assert(d == 10.11f);

  296. 

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

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

  299. 

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

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

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

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

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

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

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

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

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

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

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

  311. 

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

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

  314.             carla_addFloat(g, f, 3);

  315.             carla_add(g, f, 4);

  316.             carla_add(g, f, 5);

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

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

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

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

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

  322. 

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

  324. 

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

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

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

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

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

  330.             carla_copy(f, g, 3);

  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_stdout("f: %f,%f,%f,%f,%f", f[0], f[1], f[2], f[3], f[4]);

  338.         }

  339. 

  340.         // memory functions

  341.         {

  342.             uint64_t a[100];

  343.             uint64_t at = 9999;

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

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

  346.             assert(at == 9999);

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

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

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

  350.             assert(at == 9999);

  351. 

  352.             uint64_t b[100];

  353.             uint64_t bt = 9999;

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

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

  356.             assert(at == 9999);

  357.             carla_zeroStruct(b);

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

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

  360.             assert(bt == 9999);

  361. 

  362.             uint64_t c[100];

  363.             uint64_t ct = 9999;

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

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

  366.             assert(at == 9999);

  367.             carla_zeroStruct(c, 100);

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

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

  370.             assert(ct == 9999);

  371. 

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

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

  374.             carla_zeroStruct<Test>(d);

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

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

  377. 

  378.             Test* h(new Test);

  379.             h->i = 9;

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

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

  382.             delete h;

  383. 

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

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

  386.             delete[] i;

  387.         }

  388.     }

  389. 

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

  391.     {

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

  393. 

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

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

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

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

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

  399.         e = nullptr;

  400.         delete d.release();

  401.         delete e.release();

  402.         ScopedPointer<Test> f(nullptr);

  403.     }

  404. 

  405. #if 0

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

  407.     {

  408.         class PluginDescriptorClassTest : public PluginDescriptorClass

  409.         {

  410.         public:

  411.             PluginDescriptorClassTest(const HostDescriptor* const host)

  412.                 : PluginDescriptorClass(host) {}

  413.         protected:

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

  415. 

  416.             PluginDescriptorClassEND(PluginDescriptorClassTest)

  417.             CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginDescriptorClassTest)

  418.         };

  419. 

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

  421.                                    nullptr, nullptr, nullptr,

  422.                                    nullptr, nullptr,

  423.                                    nullptr, nullptr, nullptr, nullptr,

  424.                                    nullptr, nullptr,

  425.                                    nullptr };

  426. 

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

  428.                                0, 0, 0, 0, 0, 0,

  429.                                nullptr, nullptr, nullptr, nullptr,

  430.                                PluginDescriptorFILL(PluginDescriptorClassTest) };

  431.         (void)b;

  432. 

  433.         ScopedPointer<PluginDescriptorClassTest> c;

  434.         c = new PluginDescriptorClassTest(&a);

  435.     }

  436. 

  437.     // Carla Backend utils

  438.     {

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

  440. 

  441.         TestClass a, b, c;

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

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

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

  445.         assert(bd > ad);

  446.         assert(cd > bd);

  447. 

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

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

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

  451.         assert(ap == &a);

  452.         assert(bp == &b);

  453.         assert(cp == &c);

  454. 

  455.         ap->i = 4;

  456.         bp->i = 5;

  457.         cp->i = 6;

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

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

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

  461.     }

  462. #endif

  463. 

  464.     // Carla Mutex

  465.     {

  466.         CarlaMutex m;

  467.         m.tryLock();

  468.         m.unlock();

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

  470.     }

  471. 

  472.     // RingBuffer

  473.     {

  474.         RingBuffer buf;

  475.         RingBufferControl ctrl(&buf);

  476. 

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

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

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

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

  481. 

  482.         ctrl.writeChar('z');

  483.         ctrl.commitWrite();

  484.         assert(ctrl.dataAvailable());

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

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

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

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

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

  490. 

  491.         ctrl.writeInt(9999);

  492.         ctrl.commitWrite();

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

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

  495.         assert(i != 0);

  496.         assert(i == 9999);

  497. 

  498.         ctrl.writeLong(-88088);

  499.         ctrl.commitWrite();

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

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

  502.         assert(l != 0);

  503.         assert(l == -88088);

  504. 

  505.         ctrl.writeFloat(5.6789f);

  506.         ctrl.commitWrite();

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

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

  509.         assert(f != 0.0f);

  510.         assert(f == 5.6789f);

  511. 

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

  513. 

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

  515.         {

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

  517.            ctrl.commitWrite();

  518.         }

  519. 

  520.         assert(ctrl.dataAvailable());

  521. 

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

  523. 

  524.         while (ctrl.dataAvailable())

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

  526. 

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

  528. 

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

  530.     }

  531. 

  532.     // RtList

  533.     {

  534.         class ListTester

  535.         {

  536.         public:

  537.             struct CountObj {

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

  539.                 volatile int count;

  540.             };

  541. 

  542.             ListTester()

  543.             {

  544.                 ++getCounter().count;

  545.             }

  546. 

  547.             ~ListTester()

  548.             {

  549.                 --getCounter().count;

  550.             }

  551. 

  552.             static CountObj& getCounter()

  553.             {

  554.                 static CountObj counter;

  555.                 return counter;

  556.             }

  557.         };

  558. 

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

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

  561. 

  562.         NonRtList<ListTester> list;

  563.         obj = ListTester::getCounter();

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

  565. 

  566.         ListTester t1;

  567.         obj = ListTester::getCounter();

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

  569. 

  570.         list.append(t1);

  571.         list.append(t1);

  572.         list.append(t1);

  573.         obj = ListTester::getCounter();

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

  575. 

  576.         list.clear();

  577.         obj = ListTester::getCounter();

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

  579.     }

  580. 

  581.     return 0;

  582. }