DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
DISTRHO Plugin Framework
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.
2354 Commits
7 Branches
91MB
Tree: 0850a2790c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0850a2790c'
${ noResults }
DPF/tests/Color.cpp

222 lines
11KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Plugin Framework (DPF)

  3.  * Copyright (C) 2012-2024 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * Permission to use, copy, modify, and/or distribute this software for any purpose with

  6.  * or without fee is hereby granted, provided that the above copyright notice and this

  7.  * permission notice appear in all copies.

  8.  *

  9.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  10.  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  11.  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  12.  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  13.  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  14.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  15.  */

  16. 

  17. #include "tests.hpp"

  18. 

  19. #define DPF_TEST_COLOR_CPP

  20. #include "dgl/src/Application.cpp"

  21. #include "dgl/src/ApplicationPrivateData.cpp"

  22. #include "dgl/src/Color.cpp"

  23. 

  24. // --------------------------------------------------------------------------------------------------------------------

  25. 

  26. int main()

  27. {

  28.     using DGL_NAMESPACE::Color;

  29. 

  30.     // constructor with no arguments, must give solid black

  31.     {

  32.         Color c;

  33.         DISTRHO_ASSERT_EQUAL(c.red, 0.0f, "red value is 0");

  34.         DISTRHO_ASSERT_EQUAL(c.green, 0.0f, "green value is 0");

  35.         DISTRHO_ASSERT_EQUAL(c.blue, 0.0f, "blue value is 0");

  36.         DISTRHO_ASSERT_EQUAL(c.alpha, 1.0f, "alpha value is 1");

  37.     }

  38. 

  39.     // constructor gives correct floating-point values (arguments are r, g, b, a; in order)

  40.     {

  41.         Color c(0.1f, 0.2f, 0.3f, 0.4f);

  42.         DISTRHO_ASSERT_EQUAL(c.red, 0.1f, "red value is 0.1");

  43.         DISTRHO_ASSERT_EQUAL(c.green, 0.2f, "green value is 0.2");

  44.         DISTRHO_ASSERT_EQUAL(c.blue, 0.3f, "blue value is 0.3");

  45.         DISTRHO_ASSERT_EQUAL(c.alpha, 0.4f, "alpha value is 0.4");

  46.     }

  47. 

  48.     // constructor gives correct integer values normalized to float (arguments are r, g, b, a; in order)

  49.     {

  50.         Color c(51, 102, 153);

  51.         DISTRHO_ASSERT_SAFE_EQUAL(c.red, 0.2f, "red value is 0.2 (integer 51)");

  52.         DISTRHO_ASSERT_SAFE_EQUAL(c.green, 0.4f, "green value is 0.4 (integer 102)");

  53.         DISTRHO_ASSERT_SAFE_EQUAL(c.blue, 0.6f, "blue value is 0.6 (integer 153)");

  54.         DISTRHO_ASSERT_SAFE_EQUAL(c.alpha, 1.0f, "alpha value is 1");

  55. 

  56.         Color white(255, 255, 255);

  57.         DISTRHO_ASSERT_EQUAL(white.red, 1.0f, "white's red value is 1");

  58.         DISTRHO_ASSERT_EQUAL(white.green, 1.0f, "white's green value is 1");

  59.         DISTRHO_ASSERT_EQUAL(white.blue, 1.0f, "white's blue value is 1");

  60.         DISTRHO_ASSERT_EQUAL(white.alpha, 1.0f, "white alpha value is 1");

  61.     }

  62. 

  63.     // copy colors around

  64.     {

  65.         Color black;

  66.         Color halfTransparentWhite(1.0f, 1.0f, 1.0f, 0.5f);

  67. 

  68.         // constructor copy

  69.         Color test(halfTransparentWhite);

  70.         DISTRHO_ASSERT_EQUAL(test.red, 1.0f, "copied white's red value is 1.0");

  71.         DISTRHO_ASSERT_EQUAL(test.green, 1.0f, "copied white's green value is 1");

  72.         DISTRHO_ASSERT_EQUAL(test.blue, 1.0f, "copied white's blue value is 1");

  73.         DISTRHO_ASSERT_EQUAL(test.alpha, 0.5f, "copied white's alpha value is 0.5");

  74. 

  75.         // assign operator

  76.         test = black;

  77.         DISTRHO_ASSERT_EQUAL(test.red, 0.0f, "assigned black's red value is 0");

  78.         DISTRHO_ASSERT_EQUAL(test.green, 0.0f, "assigned black's green value is 0");

  79.         DISTRHO_ASSERT_EQUAL(test.blue, 0.0f, "assigned black's blue value is 0");

  80.         DISTRHO_ASSERT_EQUAL(test.alpha, 1.0f, "assigned black's alpha value is 1");

  81.     }

  82. 

  83.     // simple color comparisons

  84.     {

  85.         Color black1, black2;

  86.         Color white(1.0f, 1.0f, 1.0f);

  87.         Color halfTransparentWhite(1.0f, 1.0f, 1.0f, 0.5f);

  88. 

  89.         // logic operators

  90.         DISTRHO_ASSERT_EQUAL(black1, black1, "color equals itself");

  91.         DISTRHO_ASSERT_EQUAL(black1, black2, "black equals black");

  92.         DISTRHO_ASSERT_NOT_EQUAL(black1, white, "black is not white");

  93.         DISTRHO_ASSERT_NOT_EQUAL(black1, halfTransparentWhite, "black is not half-transparent white");

  94.         DISTRHO_ASSERT_NOT_EQUAL(white, halfTransparentWhite, "white is not half-transparent white");

  95. 

  96.         // class functions (truthful)

  97.         DISTRHO_ASSERT_EQUAL(black1.isEqual(black1), true, "color equals itself");

  98.         DISTRHO_ASSERT_EQUAL(black1.isEqual(black2), true, "black equals black");

  99.         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(white), true, "black is not white");

  100.         DISTRHO_ASSERT_EQUAL(white.isNotEqual(halfTransparentWhite), true, "white is not half-transparent white");

  101. 

  102.         // class functions (inverted)

  103.         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(black1), false, "color equals itself");

  104.         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(black2), false, "black equals black");

  105.         DISTRHO_ASSERT_EQUAL(black1.isEqual(white), false, "black is not white");

  106.         DISTRHO_ASSERT_EQUAL(white.isEqual(halfTransparentWhite), false, "white is not half-transparent white");

  107. 

  108.         // class functions ignoring alpha

  109.         DISTRHO_ASSERT_EQUAL(black1.isEqual(black1, false), true, "color equals itself");

  110.         DISTRHO_ASSERT_EQUAL(black1.isEqual(black2, false), true, "black equals black");

  111.         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(white, false), true, "black is not white");

  112.         DISTRHO_ASSERT_EQUAL(white.isEqual(halfTransparentWhite, false), true,

  113.                              "white is half-transparent white if we ignore alpha");

  114.     }

  115. 

  116.     // TODO advanced color comparisons

  117.     {

  118.     }

  119. 

  120.     // TODO fromHSL

  121.     {

  122.     }

  123. 

  124.     // create colors from html strings

  125.     {

  126.         Color c000 = Color::fromHTML("#000");

  127.         DISTRHO_ASSERT_EQUAL(c000.red, 0.0f, "#000 red value is 0");

  128.         DISTRHO_ASSERT_EQUAL(c000.green, 0.0f, "#000 green value is 0");

  129.         DISTRHO_ASSERT_EQUAL(c000.blue, 0.0f, "#000 blue value is 0");

  130.         DISTRHO_ASSERT_EQUAL(c000.alpha, 1.0f, "#000 alpha value is 1");

  131. 

  132.         Color c000000 = Color::fromHTML("#000000");

  133.         DISTRHO_ASSERT_EQUAL(c000000.red, 0.0f, "#000000 red value is 0");

  134.         DISTRHO_ASSERT_EQUAL(c000000.green, 0.0f, "#000000 green value is 0");

  135.         DISTRHO_ASSERT_EQUAL(c000000.blue, 0.0f, "#000000 blue value is 0");

  136.         DISTRHO_ASSERT_EQUAL(c000000.alpha, 1.0f, "#000000 alpha value is 1");

  137. 

  138.         Color cfff = Color::fromHTML("#fff");

  139.         DISTRHO_ASSERT_EQUAL(cfff.red, 1.0f, "#fff red value is 1");

  140.         DISTRHO_ASSERT_EQUAL(cfff.green, 1.0f, "#fff green value is 1");

  141.         DISTRHO_ASSERT_EQUAL(cfff.blue, 1.0f, "#fff blue value is 1");

  142.         DISTRHO_ASSERT_EQUAL(cfff.alpha, 1.0f, "#fff alpha value is 1");

  143. 

  144.         Color cffffff = Color::fromHTML("#ffffff");

  145.         DISTRHO_ASSERT_EQUAL(cffffff.red, 1.0f, "#ffffff red value is 1");

  146.         DISTRHO_ASSERT_EQUAL(cffffff.green, 1.0f, "#ffffff green value is 1");

  147.         DISTRHO_ASSERT_EQUAL(cffffff.blue, 1.0f, "#ffffff blue value is 1");

  148.         DISTRHO_ASSERT_EQUAL(cffffff.alpha, 1.0f, "#ffffff alpha value is 1");

  149. 

  150.         Color cf00 = Color::fromHTML("#f00");

  151.         DISTRHO_ASSERT_EQUAL(cf00.red, 1.0f, "#f00 red value is 1");

  152.         DISTRHO_ASSERT_EQUAL(cf00.green, 0.0f, "#f00 green value is 0");

  153.         DISTRHO_ASSERT_EQUAL(cf00.blue, 0.0f, "#f00 blue value is 0");

  154. 

  155.         Color cff0000 = Color::fromHTML("#ff0000");

  156.         DISTRHO_ASSERT_EQUAL(cff0000.red, 1.0f, "#ff0000 red value is 1");

  157.         DISTRHO_ASSERT_EQUAL(cff0000.green, 0.0f, "#ff0000 green value is 0");

  158.         DISTRHO_ASSERT_EQUAL(cff0000.blue, 0.0f, "#ff0000 blue value is 0");

  159. 

  160.         Color c0f0 = Color::fromHTML("#0f0");

  161.         DISTRHO_ASSERT_EQUAL(c0f0.red, 0.0f, "#0f0 red value is 0");

  162.         DISTRHO_ASSERT_EQUAL(c0f0.green, 1.0f, "#0f0 green value is 1");

  163.         DISTRHO_ASSERT_EQUAL(c0f0.blue, 0.0f, "#0f0 blue value is 0");

  164. 

  165.         Color c00ff00 = Color::fromHTML("#00ff00");

  166.         DISTRHO_ASSERT_EQUAL(c00ff00.red, 0.0f, "#00ff00 red value is 0");

  167.         DISTRHO_ASSERT_EQUAL(c00ff00.green, 1.0f, "#00ff00 green value is 1");

  168.         DISTRHO_ASSERT_EQUAL(c00ff00.blue, 0.0f, "#00ff00 blue value is 0");

  169. 

  170.         Color c00f = Color::fromHTML("#00f");

  171.         DISTRHO_ASSERT_EQUAL(c00f.red, 0.0f, "#00f red value is 0");

  172.         DISTRHO_ASSERT_EQUAL(c00f.green, 0.0f, "#00f green value is 0");

  173.         DISTRHO_ASSERT_EQUAL(c00f.blue, 1.0f, "#00f blue value is 1");

  174. 

  175.         Color c0000ff = Color::fromHTML("#0000ff");

  176.         DISTRHO_ASSERT_EQUAL(c0000ff.red, 0.0f, "#0000ff red value is 0");

  177.         DISTRHO_ASSERT_EQUAL(c0000ff.green, 0.0f, "#0000ff green value is 0");

  178.         DISTRHO_ASSERT_EQUAL(c0000ff.blue, 1.0f, "#0000ff blue value is 1");

  179. 

  180.         // half point, round to 1 decimal point due to precision loss

  181.         Color grey = Color::fromHTML("#7b7b7b");

  182.         DISTRHO_ASSERT_SAFE_EQUAL(std::round(grey.red*10)/10, 0.5f, "grey's rounded red value is 0.5");

  183.         DISTRHO_ASSERT_SAFE_EQUAL(std::round(grey.green*10)/10, 0.5f, "grey's rounded green value is 0.5");

  184.         DISTRHO_ASSERT_SAFE_EQUAL(std::round(grey.blue*10)/10, 0.5f, "grey's rounded blue value is 0.5");

  185.     }

  186. 

  187.     // check bounds

  188.     {

  189.         Color negativeInteger(-1, -1, -1, -1.0f);

  190.         DISTRHO_ASSERT_EQUAL(negativeInteger.red, 0.0f, "red value is 0");

  191.         DISTRHO_ASSERT_EQUAL(negativeInteger.green, 0.0f, "green value is 0");

  192.         DISTRHO_ASSERT_EQUAL(negativeInteger.blue, 0.0f, "blue value is 0");

  193.         DISTRHO_ASSERT_EQUAL(negativeInteger.alpha, 0.0f, "alpha value is 0");

  194. 

  195.         Color negativeFloat(-1.0f, -1.0f, -1.0f, -1.0f);

  196.         DISTRHO_ASSERT_EQUAL(negativeFloat.red, 0.0f, "red value is 0");

  197.         DISTRHO_ASSERT_EQUAL(negativeFloat.green, 0.0f, "green value is 0");

  198.         DISTRHO_ASSERT_EQUAL(negativeFloat.blue, 0.0f, "blue value is 0");

  199.         DISTRHO_ASSERT_EQUAL(negativeFloat.alpha, 0.0f, "alpha value is 0");

  200. 

  201.         Color overflowInteger(0xfff, 0xfff, 0xfff, 0xfff);

  202.         DISTRHO_ASSERT_EQUAL(overflowInteger.red, 1.0f, "red value is 1");

  203.         DISTRHO_ASSERT_EQUAL(overflowInteger.green, 1.0f, "green value is 1");

  204.         DISTRHO_ASSERT_EQUAL(overflowInteger.blue, 1.0f, "blue value is 1");

  205.         DISTRHO_ASSERT_EQUAL(overflowInteger.alpha, 1.0f, "alpha value is 1");

  206. 

  207.         Color overflowFloat(2.0f, 2.0f, 2.0f, 2.0f);

  208.         DISTRHO_ASSERT_EQUAL(overflowFloat.red, 1.0f, "red value is 1");

  209.         DISTRHO_ASSERT_EQUAL(overflowFloat.green, 1.0f, "green value is 1");

  210.         DISTRHO_ASSERT_EQUAL(overflowFloat.blue, 1.0f, "blue value is 1");

  211.         DISTRHO_ASSERT_EQUAL(overflowFloat.alpha, 1.0f, "alpha value is 1");

  212.     }

  213. 

  214.     // TODO interpolation

  215.     {

  216.     }

  217. 

  218.     return 0;

  219. }

  220. 

  221. // --------------------------------------------------------------------------------------------------------------------