source/tests.old/CarlaUtils1.cpp

   1 /*
   2  * Carla Utility Tests
   3  * Copyright (C) 2013-2015 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[2];
  42         nullStrBuf(strBuf);
  43
  44         char* const strBuf2(strBuf+1);
  45         nullStrBuf(strBuf2);
  46     }
  47
  48     // ----------------------------------------------------------------------------------------------------------------
  49     // string print functions
  50
  51     {
  52         carla_debug("DEBUG");
  53         carla_stdout("STDOUT %s", bool2str(true));
  54         carla_stderr("STDERR %s", bool2str(false));
  55         carla_stderr2("STDERR2 " P_UINT64, 0xffffffff); // 4294967295
  56     }
  57
  58     // ----------------------------------------------------------------------------------------------------------------
  59     // carla_*sleep
  60
  61     {
  62         carla_sleep(1);
  63         carla_msleep(1);
  64     }
  65
  66     // ----------------------------------------------------------------------------------------------------------------
  67     // carla_setenv
  68
  69     {
  70         carla_setenv("THIS", "THAT");
  71         assert(std::strcmp(std::getenv("THIS"), "THAT") == 0);
  72
  73         carla_unsetenv("THIS");
  74         assert(std::getenv("THIS") == nullptr);
  75     }
  76
  77     // ----------------------------------------------------------------------------------------------------------------
  78     // carla_strdup
  79
  80     {
  81         // with variables
  82         const char* const str1(carla_strdup("stringN"));
  83         const char* const strF(carla_strdup_free(strdup("stringF")));
  84         const char* const str2(carla_strdup_safe("stringS"));
  85         delete[] str1;
  86         delete[] str2;
  87         delete[] strF;
  88
  89         // without variables
  90         delete[] carla_strdup("string_normal");
  91         delete[] carla_strdup_free(strdup("string_free"));
  92         delete[] carla_strdup_safe("string_safe");
  93     }
  94
  95     {
  96         // common use case in Carla code
  97         struct TestStruct {
  98             const char* strNull;
  99             const char* strNormal;
 100             const char* strFree;
 101             const char* strSafe;
 102
 103             TestStruct()
 104                 : strNull(nullptr),
 105                   strNormal(carla_strdup("strNormal")),
 106                   strFree(carla_strdup_free(strdup("strFree"))),
 107                   strSafe(carla_strdup_safe("strSafe")) {}
 108
 109             ~TestStruct() noexcept
 110             {
 111                 if (strNull != nullptr)
 112                 {
 113                     delete[] strNull;
 114                     strNull = nullptr;
 115                 }
 116
 117                 if (strNormal != nullptr)
 118                 {
 119                     delete[] strNormal;
 120                     strNormal = nullptr;
 121                 }
 122
 123                 if (strFree != nullptr)
 124                 {
 125                     delete[] strFree;
 126                     strFree = nullptr;
 127                 }
 128
 129                 if (strSafe != nullptr)
 130                 {
 131                     delete[] strSafe;
 132                     strSafe = nullptr;
 133                 }
 134             }
 135
 136             CARLA_DECLARE_NON_COPY_STRUCT(TestStruct)
 137         };
 138
 139         TestStruct a, b, c;
 140     }
 141
 142     // ----------------------------------------------------------------------------------------------------------------
 143     // memory functions
 144
 145     {
 146         int a1[] = { 4, 3, 2, 1 };
 147         int a2[] = { 4, 3, 2, 1 };
 148         int b1[] = { 1, 2, 3, 4 };
 149         int b2[] = { 1, 2, 3, 4 };
 150
 151         carla_add(a1, b1, 4);
 152         assert(a1[0] == 5);
 153         assert(a1[1] == 5);
 154         assert(a1[2] == 5);
 155         assert(a1[3] == 5);
 156
 157         carla_add(b1, a2, 4);
 158         assert(b1[0] == 5);
 159         assert(b1[1] == 5);
 160         assert(b1[2] == 5);
 161         assert(b1[3] == 5);
 162         assert(a1[0] == b1[0]);
 163         assert(a1[1] == b1[1]);
 164         assert(a1[2] == b1[2]);
 165         assert(a1[3] == b1[3]);
 166
 167         carla_copy(a1, b2, 4);
 168         assert(a1[0] != b1[0]);
 169         assert(a1[1] != b1[1]);
 170         assert(a1[2] != b1[2]);
 171         assert(a1[3] != b1[3]);
 172         assert(a1[0] == b2[0]);
 173         assert(a1[1] == b2[1]);
 174         assert(a1[2] == b2[2]);
 175         assert(a1[3] == b2[3]);
 176
 177         carla_copy(a1, b1, 4);
 178         assert(a1[0] == b1[0]);
 179         assert(a1[1] == b1[1]);
 180         assert(a1[2] == b1[2]);
 181         assert(a1[3] == b1[3]);
 182
 183         carla_copy(a1, b2, 2);
 184         assert(a1[0] != b1[0]);
 185         assert(a1[1] != b1[1]);
 186         assert(a1[2] == b1[2]);
 187         assert(a1[3] == b1[3]);
 188
 189         carla_copy(a1+2, b2+2, 2);
 190         assert(a1[0] != b1[0]);
 191         assert(a1[1] != b1[1]);
 192         assert(a1[2] != b1[2]);
 193         assert(a1[3] != b1[3]);
 194
 195         carla_copy(a1, b1, 2);
 196         assert(a1[0] == b1[0]);
 197         assert(a1[1] == b1[1]);
 198         assert(a1[2] != b1[2]);
 199         assert(a1[3] != b1[3]);
 200
 201         carla_copy(a1+2, b1+2, 2);
 202         assert(a1[0] == b1[0]);
 203         assert(a1[1] == b1[1]);
 204         assert(a1[2] == b1[2]);
 205         assert(a1[3] == b1[3]);
 206
 207         carla_fill(a1, 0, 4);
 208         assert(a1[0] == 0);
 209         assert(a1[1] == 0);
 210         assert(a1[2] == 0);
 211         assert(a1[3] == 0);
 212
 213         carla_fill(a1, -11, 4);
 214         assert(a1[0] == -11);
 215         assert(a1[1] == -11);
 216         assert(a1[2] == -11);
 217         assert(a1[3] == -11);
 218
 219         carla_fill(a1, 1791, 2);
 220         assert(a1[0] == 1791);
 221         assert(a1[1] == 1791);
 222         assert(a1[2] == -11);
 223         assert(a1[3] == -11);
 224
 225         carla_fill(a1+2, 1791, 2);
 226         assert(a1[0] == 1791);
 227         assert(a1[1] == 1791);
 228         assert(a1[2] == 1791);
 229         assert(a1[3] == 1791);
 230
 231         int16_t d = 1527, d2 = d, e = 0;
 232
 233         carla_add(&d, &d2, 1);
 234         assert(d == 1527*2);
 235
 236         carla_add(&d, &d2, 1);
 237         assert(d == 1527*3);
 238
 239         carla_add(&d, &e, 1);
 240         assert(d == 1527*3);
 241         assert(e == 0);
 242
 243         carla_add(&e, &d, 1);
 244         assert(d == e);
 245
 246         carla_add(&e, &d, 1);
 247         assert(e == d*2);
 248
 249         d = -e;
 250         carla_add(&d, &e, 1);
 251         assert(d == 0);
 252     }
 253
 254     {
 255         bool x;
 256         const bool f = false, t = true;
 257
 258         carla_copy(&x, &t, 1);
 259         assert(x);
 260
 261         carla_copy(&x, &f, 1);
 262         assert(! x);
 263
 264         carla_fill(&x, true, 1);
 265         assert(x);
 266
 267         carla_fill(&x, false, 1);
 268         assert(! x);
 269     }
 270
 271     {
 272         uint8_t a[] = { 3, 2, 1, 0 };
 273         carla_zeroBytes(a, 1);
 274         assert(a[0] == 0);
 275         assert(a[1] == 2);
 276         assert(a[2] == 1);
 277         assert(a[3] == 0);
 278
 279         carla_zeroBytes(a+1, 2);
 280         assert(a[0] == 0);
 281         assert(a[1] == 0);
 282         assert(a[2] == 0);
 283         assert(a[3] == 0);
 284     }
 285
 286     {
 287         char a[501];
 288
 289         for (int i=500; --i>=0;)
 290             a[i] = 'a';
 291
 292         carla_zeroChars(a, 501);
 293
 294         for (int i=501; --i>=0;)
 295             assert(a[i] == '\0');
 296
 297         for (int i=500; --i>=0;)
 298             a[i] = 'a';
 299
 300         assert(std::strlen(a) == 500);
 301
 302         carla_fill(a+200, '\0', 1);
 303         assert(std::strlen(a) == 200);
 304     }
 305
 306     {
 307         void* a[33];
 308         carla_zeroPointers(a, 33);
 309
 310         for (int i=33; --i>=0;)
 311             assert(a[i] == nullptr);
 312     }
 313
 314     {
 315         struct Thing {
 316             char c;
 317             int i;
 318             int64_t h;
 319
 320             bool operator==(const Thing& t) const noexcept
 321             {
 322                 return (t.c == c && t.i == i && t.h == h);
 323             }
 324
 325             bool operator!=(const Thing& t) const noexcept
 326             {
 327                 return !operator==(t);
 328             }
 329         };
 330
 331         Thing a, b, c;
 332
 333         a.c = 0;
 334         a.i = 0;
 335         a.h = 0;
 336
 337         b.c = 64;
 338         b.i = 64;
 339         b.h = 64;
 340
 341         c = a;
 342
 343         carla_copyStruct(a, b);
 344         assert(a == b);
 345
 346         carla_zeroStruct(a);
 347         assert(a == c);
 348
 349         carla_copyStruct(c, b);
 350         assert(a != c);
 351
 352         // make it non-zero
 353         a.c = 1;
 354
 355         Thing d[3];
 356
 357         carla_zeroStructs(d, 3);
 358         assert(d[0] != a);
 359         assert(d[1] != b);
 360         assert(d[2] != c);
 361
 362         carla_copyStructs(d, &a, 1);
 363         assert(d[0] == a);
 364         assert(d[1] != b);
 365         assert(d[2] != c);
 366
 367         carla_copyStructs(&c, d+2, 1);
 368         assert(d[0] == a);
 369         assert(d[1] != b);
 370         assert(d[2] == c);
 371     }
 372 }
 373
 374 #if 0
 375 // --------------------------------------------------------------------------------------------------------------------
 376
 377 static void test_CarlaMathUtils() noexcept
 378 {
 379     // ----------------------------------------------------------------------------------------------------------------
 380     // math functions (base)
 381
 382     // Return the lower of 2 values, with 'min' as the minimum possible value.
 383     assert(carla_min(0, 0, 0) == 0);
 384     assert(carla_min(0, 3, 0) == 0);
 385     assert(carla_min(3, 0, 0) == 0);
 386
 387     assert(carla_min(0, 0, 3) == 3);
 388     assert(carla_min(0, 1, 3) == 3);
 389     assert(carla_min(0, 2, 3) == 3);
 390     assert(carla_min(0, 3, 3) == 3);
 391     assert(carla_min(0, 4, 3) == 3);
 392
 393     assert(carla_min(5, 0, 3) == 3);
 394     assert(carla_min(5, 1, 3) == 3);
 395     assert(carla_min(5, 2, 3) == 3);
 396     assert(carla_min(5, 3, 3) == 3);
 397     assert(carla_min(5, 4, 3) == 4);
 398     assert(carla_min(5, 5, 3) == 5);
 399     assert(carla_min(5, 6, 3) == 5);
 400
 401     assert(carla_min(2, -2, 0) == 0);
 402     assert(carla_min(2, -1, 0) == 0);
 403     assert(carla_min(2,  0, 0) == 0);
 404     assert(carla_min(2,  1, 0) == 1);
 405     assert(carla_min(2,  2, 0) == 2);
 406
 407     assert(carla_min(5, -6, 3) == 3);
 408     assert(carla_min(5, -5, 3) == 3);
 409     assert(carla_min(5, -4, 3) == 3);
 410     assert(carla_min(5, -3, 3) == 3);
 411     assert(carla_min(5, -2, 3) == 3);
 412     assert(carla_min(5, -1, 3) == 3);
 413     assert(carla_min(5,  0, 3) == 3);
 414     assert(carla_min(5,  1, 3) == 3);
 415     assert(carla_min(5,  2, 3) == 3);
 416     assert(carla_min(5,  3, 3) == 3);
 417     assert(carla_min(5,  4, 3) == 4);
 418     assert(carla_min(5,  5, 3) == 5);
 419     assert(carla_min(5,  6, 3) == 5);
 420
 421     assert(carla_min(5, -6, -3) == -3);
 422     assert(carla_min(5, -5, -3) == -3);
 423     assert(carla_min(5, -4, -3) == -3);
 424     assert(carla_min(5, -3, -3) == -3);
 425     assert(carla_min(5, -2, -3) == -2);
 426     assert(carla_min(5, -1, -3) == -1);
 427     assert(carla_min(5,  0, -3) == 0);
 428     assert(carla_min(5,  1, -3) == 1);
 429     assert(carla_min(5,  2, -3) == 2);
 430     assert(carla_min(5,  3, -3) == 3);
 431     assert(carla_min(5,  4, -3) == 4);
 432     assert(carla_min(5,  5, -3) == 5);
 433     assert(carla_min(5,  6, -3) == 5);
 434
 435     // Return the lower positive of 2 values.
 436     assert(carla_minPositive(0, 0) == 0);
 437     assert(carla_minPositive(0, 1) == 0);
 438     assert(carla_minPositive(0, 2) == 0);
 439     assert(carla_minPositive(0, 3) == 0);
 440
 441     assert(carla_minPositive(1, 0) == 0);
 442     assert(carla_minPositive(1, 1) == 1);
 443     assert(carla_minPositive(1, 2) == 1);
 444     assert(carla_minPositive(1, 3) == 1);
 445
 446     assert(carla_minPositive(3, 0) == 0);
 447     assert(carla_minPositive(3, 1) == 1);
 448     assert(carla_minPositive(3, 2) == 2);
 449     assert(carla_minPositive(3, 3) == 3);
 450
 451     assert(carla_minPositive(-1, 0) == 0);
 452     assert(carla_minPositive(-1, 1) == 1);
 453     assert(carla_minPositive(-1, 2) == 2);
 454     assert(carla_minPositive(-1, 3) == 3);
 455
 456     // Return the higher of 2 values, with 'max' as the maximum possible value.
 457     assert(carla_max(0, 0, 0) == 0);
 458     assert(carla_max(0, 3, 0) == 0);
 459     assert(carla_max(3, 0, 0) == 0);
 460
 461     assert(carla_max(0, 0, 3) == 0);
 462     assert(carla_max(0, 1, 3) == 1);
 463     assert(carla_max(0, 2, 3) == 2);
 464     assert(carla_max(0, 3, 3) == 3);
 465     assert(carla_max(0, 4, 3) == 3);
 466
 467     assert(carla_max(5, 0, 3) == 3);
 468     assert(carla_max(5, 1, 3) == 3);
 469     assert(carla_max(5, 2, 3) == 3);
 470     assert(carla_max(5, 3, 3) == 3);
 471     assert(carla_max(5, 4, 3) == 3);
 472     assert(carla_max(5, 5, 3) == 3);
 473     assert(carla_max(5, 6, 3) == 3);
 474
 475     // Fix bounds of 'value' between 'min' and 'max'.
 476     assert(carla_fixedValue(0, 1, -1) == 0);
 477     assert(carla_fixedValue(0, 1,  0) == 0);
 478     assert(carla_fixedValue(0, 1,  1) == 1);
 479     assert(carla_fixedValue(0, 1,  2) == 1);
 480
 481     assert(carla_fixedValue(0.0, 1.0, -1.0) == 0.0);
 482     assert(carla_fixedValue(0.0, 1.0,  0.0) == 0.0);
 483     assert(carla_fixedValue(0.0, 1.0,  1.0) == 1.0);
 484     assert(carla_fixedValue(0.0, 1.0,  2.0) == 1.0);
 485
 486     assert(carla_fixedValue(0.0, 1.0, -0.1) == 0.0);
 487     assert(carla_fixedValue(0.0, 1.0,  1.1) == 1.0);
 488
 489     // Get next power of 2.
 490     assert(carla_nextPowerOf2(0) == 0);
 491     assert(carla_nextPowerOf2(1) == 1);
 492     assert(carla_nextPowerOf2(2) == 2);
 493     assert(carla_nextPowerOf2(4) == 4);
 494     assert(carla_nextPowerOf2(5) == 8);
 495     assert(carla_nextPowerOf2(6) == 8);
 496     assert(carla_nextPowerOf2(7) == 8);
 497     assert(carla_nextPowerOf2(8) == 8);
 498     assert(carla_nextPowerOf2(9) == 16);
 499
 500     uint32_t power = 1;
 501     assert((power = carla_nextPowerOf2(power+1)) == 2);
 502     assert((power = carla_nextPowerOf2(power+1)) == 4);
 503     assert((power = carla_nextPowerOf2(power+1)) == 8);
 504     assert((power = carla_nextPowerOf2(power+1)) == 16);
 505     assert((power = carla_nextPowerOf2(power+1)) == 32);
 506     assert((power = carla_nextPowerOf2(power+1)) == 64);
 507     assert((power = carla_nextPowerOf2(power+1)) == 128);
 508     assert((power = carla_nextPowerOf2(power+1)) == 256);
 509     assert((power = carla_nextPowerOf2(power+1)) == 512);
 510     assert((power = carla_nextPowerOf2(power+1)) == 1024);
 511     assert((power = carla_nextPowerOf2(power+1)) == 2048);
 512     assert((power = carla_nextPowerOf2(power+1)) == 4096);
 513     assert((power = carla_nextPowerOf2(power+1)) == 8192);
 514     assert((power = carla_nextPowerOf2(power+1)) == 16384);
 515     assert((power = carla_nextPowerOf2(power+1)) == 32768);
 516     assert((power = carla_nextPowerOf2(power+1)) == 65536);
 517     assert((power = carla_nextPowerOf2(power+1)) == 131072);
 518
 519     // ----------------------------------------------------------------------------------------------------------------
 520     // math functions (extended)
 521
 522     // carla_addFloat, carla_copyFloat & carla_zeroFloat tests skipped
 523     // mostly unused due to water::FloatVectorOperations
 524 }
 525 #endif
 526
 527 #if 0
 528 // --------------------------------------------------------------------------------------------------------------------
 529
 530 static void test_CarlaBackendUtils() noexcept
 531 {
 532     CARLA_BACKEND_USE_NAMESPACE
 533     carla_stdout(PluginOption2Str(PLUGIN_OPTION_FIXED_BUFFERS));
 534     carla_stdout(BinaryType2Str(BINARY_NONE));
 535     carla_stdout(PluginType2Str(PLUGIN_NONE));
 536     carla_stdout(PluginCategory2Str(PLUGIN_CATEGORY_NONE));
 537     carla_stdout(ParameterType2Str(PARAMETER_UNKNOWN));
 538     carla_stdout(InternalParameterIndex2Str(PARAMETER_NULL));
 539     carla_stdout(EngineCallbackOpcode2Str(ENGINE_CALLBACK_DEBUG));
 540     carla_stdout(EngineOption2Str(ENGINE_OPTION_DEBUG));
 541     carla_stdout(EngineProcessMode2Str(ENGINE_PROCESS_MODE_SINGLE_CLIENT));
 542     carla_stdout(EngineTransportMode2Str(ENGINE_TRANSPORT_MODE_INTERNAL));
 543     carla_stdout(FileCallbackOpcode2Str(FILE_CALLBACK_DEBUG));
 544     carla_stdout(getPluginTypeAsString(PLUGIN_INTERNAL));
 545     carla_stdout(PatchbayIcon2Str(PATCHBAY_ICON_APPLICATION));
 546     getPluginTypeFromString("none");
 547     getPluginCategoryFromName("cat");
 548 }
 549
 550 // --------------------------------------------------------------------------------------------------------------------
 551
 552 static void test_CarlaBridgeUtils() noexcept
 553 {
 554     carla_stdout(PluginBridgeOscInfoType2str(kPluginBridgeOscPong));
 555     carla_stdout(PluginBridgeRtOpcode2str(kPluginBridgeRtNull));
 556     carla_stdout(PluginBridgeNonRtOpcode2str(kPluginBridgeNonRtNull));
 557 }
 558
 559 // --------------------------------------------------------------------------------------------------------------------
 560
 561 static void test_CarlaEngineUtils() noexcept
 562 {
 563     CARLA_BACKEND_USE_NAMESPACE
 564     carla_stdout(EngineType2Str(kEngineTypeNull));
 565     carla_stdout(EnginePortType2Str(kEnginePortTypeNull));
 566     carla_stdout(EngineEventType2Str(kEngineEventTypeNull));
 567     carla_stdout(EngineControlEventType2Str(kEngineControlEventTypeNull));
 568 }
 569 #endif
 570
 571 // --------------------------------------------------------------------------------------------------------------------
 572 // main
 573
 574 int main()
 575 {
 576     test_CarlaUtils();
 577     //test_CarlaMathUtils();
 578
 579     //test_CarlaBackendUtils();
 580     //test_CarlaBridgeUtils();
 581     //test_CarlaEngineUtils();
 582
 583     return 0;
 584 }
 585
 586 // --------------------------------------------------------------------------------------------------------------------