lolengine
/
lol
espelhamento de https://github.com/lolengine/lol
1
0
Fork 0
Código Issues 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
3187 Commits
5 Branches
269 MiB
 
 
 
Tag: 52e589974d
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 52e589974d
${ noResults }
lol/t/audio-sadd.cpp

183 linhas
9.8 KiB
Original Anotar Histórico 

  1. #include <lol/lib/doctest>

  2. #include <lol/audio/stream>

  3. 

  4. TEST_CASE("sample saturated add: int8_t")

  5. {

  6.     // Underflow

  7.     CHECK(lol::audio::sample::sadd<int8_t>(-0x80, -0x80) == -0x80);

  8.     CHECK(lol::audio::sample::sadd<int8_t>(-0x41, -0x41) == -0x80);

  9.     CHECK(lol::audio::sample::sadd<int8_t>(-0x40, -0x41) == -0x80);

  10. 

  11.     // Standard operating mode

  12.     CHECK(lol::audio::sample::sadd<int8_t>(-0x40, -0x40) == -0x80);

  13.     CHECK(lol::audio::sample::sadd<int8_t>(-0x3f, -0x3f) == -0x7e);

  14.     CHECK(lol::audio::sample::sadd<int8_t>(-0x01, -0x01) == -0x02);

  15.     CHECK(lol::audio::sample::sadd<int8_t>(-0x01,  0x00) == -0x01);

  16.     CHECK(lol::audio::sample::sadd<int8_t>( 0x00,  0x00) ==  0x00);

  17.     CHECK(lol::audio::sample::sadd<int8_t>( 0x00,  0x01) ==  0x01);

  18.     CHECK(lol::audio::sample::sadd<int8_t>( 0x01,  0x01) ==  0x02);

  19.     CHECK(lol::audio::sample::sadd<int8_t>( 0x3f,  0x3f) ==  0x7e);

  20.     CHECK(lol::audio::sample::sadd<int8_t>( 0x3f,  0x40) ==  0x7f);

  21. 

  22.     // Overflow

  23.     CHECK(lol::audio::sample::sadd<int8_t>( 0x40,  0x40) ==  0x7f);

  24.     CHECK(lol::audio::sample::sadd<int8_t>( 0x7f,  0x7f) ==  0x7f);

  25. }

  26. 

  27. TEST_CASE("sample saturated add: uint8_t")

  28. {

  29.     // Underflow

  30.     CHECK(lol::audio::sample::sadd<uint8_t>(0x00, 0x00) == 0x00);

  31.     CHECK(lol::audio::sample::sadd<uint8_t>(0x3f, 0x3f) == 0x00);

  32. 

  33.     // Standard operating mode

  34.     CHECK(lol::audio::sample::sadd<uint8_t>(0x40, 0x40) == 0x00);

  35.     CHECK(lol::audio::sample::sadd<uint8_t>(0x41, 0x41) == 0x02);

  36.     CHECK(lol::audio::sample::sadd<uint8_t>(0x7f, 0x7f) == 0x7e);

  37.     CHECK(lol::audio::sample::sadd<uint8_t>(0x7f, 0x80) == 0x7f);

  38.     CHECK(lol::audio::sample::sadd<uint8_t>(0x80, 0x80) == 0x80);

  39.     CHECK(lol::audio::sample::sadd<uint8_t>(0x80, 0x81) == 0x81);

  40.     CHECK(lol::audio::sample::sadd<uint8_t>(0x81, 0x81) == 0x82);

  41.     CHECK(lol::audio::sample::sadd<uint8_t>(0xbf, 0xbf) == 0xfe);

  42.     CHECK(lol::audio::sample::sadd<uint8_t>(0xbf, 0xc0) == 0xff);

  43. 

  44.     // Overflow

  45.     CHECK(lol::audio::sample::sadd<uint8_t>(0xc0, 0xc0) == 0xff);

  46.     CHECK(lol::audio::sample::sadd<uint8_t>(0xff, 0xff) == 0xff);

  47. }

  48. 

  49. TEST_CASE("sample saturated add: int16_t")

  50. {

  51.     // Underflow

  52.     CHECK(lol::audio::sample::sadd<int16_t>(-0x8000, -0x8000) == -0x8000);

  53.     CHECK(lol::audio::sample::sadd<int16_t>(-0x4001, -0x4001) == -0x8000);

  54.     CHECK(lol::audio::sample::sadd<int16_t>(-0x4000, -0x4001) == -0x8000);

  55. 

  56.     // Standard operating mode

  57.     CHECK(lol::audio::sample::sadd<int16_t>(-0x4000, -0x4000) == -0x8000);

  58.     CHECK(lol::audio::sample::sadd<int16_t>(-0x3fff, -0x3fff) == -0x7ffe);

  59.     CHECK(lol::audio::sample::sadd<int16_t>(-0x0001, -0x0001) == -0x0002);

  60.     CHECK(lol::audio::sample::sadd<int16_t>(-0x0001,  0x0000) == -0x0001);

  61.     CHECK(lol::audio::sample::sadd<int16_t>( 0x0000,  0x0000) ==  0x0000);

  62.     CHECK(lol::audio::sample::sadd<int16_t>( 0x0000,  0x0001) ==  0x0001);

  63.     CHECK(lol::audio::sample::sadd<int16_t>( 0x0001,  0x0001) ==  0x0002);

  64.     CHECK(lol::audio::sample::sadd<int16_t>( 0x3fff,  0x3fff) ==  0x7ffe);

  65.     CHECK(lol::audio::sample::sadd<int16_t>( 0x3fff,  0x4000) ==  0x7fff);

  66. 

  67.     // Overflow

  68.     CHECK(lol::audio::sample::sadd<int16_t>( 0x4000,  0x4000) ==  0x7fff);

  69.     CHECK(lol::audio::sample::sadd<int16_t>( 0x7fff,  0x7fff) ==  0x7fff);

  70. }

  71. 

  72. TEST_CASE("sample saturated add: uint16_t")

  73. {

  74.     // Underflow

  75.     CHECK(lol::audio::sample::sadd<uint16_t>(0x0000, 0x0000) == 0x0000);

  76.     CHECK(lol::audio::sample::sadd<uint16_t>(0x3fff, 0x3fff) == 0x0000);

  77. 

  78.     // Standard operating mode

  79.     CHECK(lol::audio::sample::sadd<uint16_t>(0x4000, 0x4000) == 0x0000);

  80.     CHECK(lol::audio::sample::sadd<uint16_t>(0x4001, 0x4001) == 0x0002);

  81.     CHECK(lol::audio::sample::sadd<uint16_t>(0x7fff, 0x7fff) == 0x7ffe);

  82.     CHECK(lol::audio::sample::sadd<uint16_t>(0x7fff, 0x8000) == 0x7fff);

  83.     CHECK(lol::audio::sample::sadd<uint16_t>(0x8000, 0x8000) == 0x8000);

  84.     CHECK(lol::audio::sample::sadd<uint16_t>(0x8000, 0x8001) == 0x8001);

  85.     CHECK(lol::audio::sample::sadd<uint16_t>(0x8001, 0x8001) == 0x8002);

  86.     CHECK(lol::audio::sample::sadd<uint16_t>(0xbfff, 0xbfff) == 0xfffe);

  87.     CHECK(lol::audio::sample::sadd<uint16_t>(0xbfff, 0xc000) == 0xffff);

  88. 

  89.     // Overflow

  90.     CHECK(lol::audio::sample::sadd<uint16_t>(0xc000, 0xc000) == 0xffff);

  91.     CHECK(lol::audio::sample::sadd<uint16_t>(0xffff, 0xffff) == 0xffff);

  92. }

  93. 

  94. TEST_CASE("sample saturated add: uint32_t")

  95. {

  96.     // Underflow

  97.     CHECK(lol::audio::sample::sadd<uint32_t>(0x00000000, 0x00000000) == 0x00000000);

  98.     CHECK(lol::audio::sample::sadd<uint32_t>(0x3fffffff, 0x3fffffff) == 0x00000000);

  99. 

  100.     // Standard operating mode

  101.     CHECK(lol::audio::sample::sadd<uint32_t>(0x40000000, 0x40000000) == 0x00000000);

  102.     CHECK(lol::audio::sample::sadd<uint32_t>(0x40000001, 0x40000001) == 0x00000002);

  103.     CHECK(lol::audio::sample::sadd<uint32_t>(0x7fffffff, 0x7fffffff) == 0x7ffffffe);

  104.     CHECK(lol::audio::sample::sadd<uint32_t>(0x7fffffff, 0x80000000) == 0x7fffffff);

  105.     CHECK(lol::audio::sample::sadd<uint32_t>(0x80000000, 0x80000000) == 0x80000000);

  106.     CHECK(lol::audio::sample::sadd<uint32_t>(0x80000000, 0x80000001) == 0x80000001);

  107.     CHECK(lol::audio::sample::sadd<uint32_t>(0x80000001, 0x80000001) == 0x80000002);

  108.     CHECK(lol::audio::sample::sadd<uint32_t>(0xbfffffff, 0xbfffffff) == 0xfffffffe);

  109.     CHECK(lol::audio::sample::sadd<uint32_t>(0xbfffffff, 0xc0000000) == 0xffffffff);

  110. 

  111.     // Overflow

  112.     CHECK(lol::audio::sample::sadd<uint32_t>(0xc0000000, 0xc0000000) == 0xffffffff);

  113.     CHECK(lol::audio::sample::sadd<uint32_t>(0xffffffff, 0xffffffff) == 0xffffffff);

  114. }

  115. 

  116. TEST_CASE("sample saturated add: int32_t")

  117. {

  118.     // Underflow

  119.     CHECK(lol::audio::sample::sadd<int32_t>(-0x80000000, -0x80000000) == -0x80000000);

  120.     CHECK(lol::audio::sample::sadd<int32_t>(-0x40000001, -0x40000001) == -0x80000000);

  121.     CHECK(lol::audio::sample::sadd<int32_t>(-0x40000000, -0x40000001) == -0x80000000);

  122. 

  123.     // Standard operating mode

  124.     CHECK(lol::audio::sample::sadd<int32_t>(-0x40000000, -0x40000000) == -0x80000000);

  125.     CHECK(lol::audio::sample::sadd<int32_t>(-0x3fffffff, -0x3fffffff) == -0x7ffffffe);

  126.     CHECK(lol::audio::sample::sadd<int32_t>(-0x00000001, -0x00000001) == -0x00000002);

  127.     CHECK(lol::audio::sample::sadd<int32_t>(-0x00000001,  0x00000000) == -0x00000001);

  128.     CHECK(lol::audio::sample::sadd<int32_t>( 0x00000000,  0x00000000) ==  0x00000000);

  129.     CHECK(lol::audio::sample::sadd<int32_t>( 0x00000000,  0x00000001) ==  0x00000001);

  130.     CHECK(lol::audio::sample::sadd<int32_t>( 0x00000001,  0x00000001) ==  0x00000002);

  131.     CHECK(lol::audio::sample::sadd<int32_t>( 0x3fffffff,  0x3fffffff) ==  0x7ffffffe);

  132.     CHECK(lol::audio::sample::sadd<int32_t>( 0x3fffffff,  0x40000000) ==  0x7fffffff);

  133. 

  134.     // Overflow

  135.     CHECK(lol::audio::sample::sadd<int32_t>( 0x40000000,  0x40000000) ==  0x7fffffff);

  136.     CHECK(lol::audio::sample::sadd<int32_t>( 0x7fffffff,  0x7fffffff) ==  0x7fffffff);

  137. }

  138. 

  139. TEST_CASE("sample saturated add: uint64_t")

  140. {

  141.     // Underflow

  142.     CHECK(lol::audio::sample::sadd<uint64_t>(0x0000000000000000, 0x0000000000000000) == 0x0000000000000000);

  143.     CHECK(lol::audio::sample::sadd<uint64_t>(0x3fffffffffffffff, 0x3fffffffffffffff) == 0x0000000000000000);

  144. 

  145.     // Standard operating mode

  146.     CHECK(lol::audio::sample::sadd<uint64_t>(0x4000000000000000, 0x4000000000000000) == 0x0000000000000000);

  147.     CHECK(lol::audio::sample::sadd<uint64_t>(0x4000000000000001, 0x4000000000000001) == 0x0000000000000002);

  148.     CHECK(lol::audio::sample::sadd<uint64_t>(0x7fffffffffffffff, 0x7fffffffffffffff) == 0x7ffffffffffffffe);

  149.     CHECK(lol::audio::sample::sadd<uint64_t>(0x7fffffffffffffff, 0x8000000000000000) == 0x7fffffffffffffff);

  150.     CHECK(lol::audio::sample::sadd<uint64_t>(0x8000000000000000, 0x8000000000000000) == 0x8000000000000000);

  151.     CHECK(lol::audio::sample::sadd<uint64_t>(0x8000000000000000, 0x8000000000000001) == 0x8000000000000001);

  152.     CHECK(lol::audio::sample::sadd<uint64_t>(0x8000000000000001, 0x8000000000000001) == 0x8000000000000002);

  153.     CHECK(lol::audio::sample::sadd<uint64_t>(0xbfffffffffffffff, 0xbfffffffffffffff) == 0xfffffffffffffffe);

  154.     CHECK(lol::audio::sample::sadd<uint64_t>(0xbfffffffffffffff, 0xc000000000000000) == 0xffffffffffffffff);

  155. 

  156.     // Overflow

  157.     CHECK(lol::audio::sample::sadd<uint64_t>(0xc000000000000000, 0xc000000000000000) == 0xffffffffffffffff);

  158.     CHECK(lol::audio::sample::sadd<uint64_t>(0xffffffffffffffff, 0xffffffffffffffff) == 0xffffffffffffffff);

  159. }

  160. 

  161. TEST_CASE("sample saturated add: int64_t")

  162. {

  163.     // Underflow

  164.     CHECK(lol::audio::sample::sadd<int64_t>(-0x8000000000000000, -0x8000000000000000) == -0x8000000000000000);

  165.     CHECK(lol::audio::sample::sadd<int64_t>(-0x4000000000000001, -0x4000000000000001) == -0x8000000000000000);

  166.     CHECK(lol::audio::sample::sadd<int64_t>(-0x4000000000000000, -0x4000000000000001) == -0x8000000000000000);

  167. 

  168.     // Standard operating mode

  169.     CHECK(lol::audio::sample::sadd<int64_t>(-0x4000000000000000, -0x4000000000000000) == -0x8000000000000000);

  170.     CHECK(lol::audio::sample::sadd<int64_t>(-0x3fffffffffffffff, -0x3fffffffffffffff) == -0x7ffffffffffffffe);

  171.     CHECK(lol::audio::sample::sadd<int64_t>(-0x0000000000000001, -0x0000000000000001) == -0x0000000000000002);

  172.     CHECK(lol::audio::sample::sadd<int64_t>(-0x0000000000000001,  0x0000000000000000) == -0x0000000000000001);

  173.     CHECK(lol::audio::sample::sadd<int64_t>( 0x0000000000000000,  0x0000000000000000) ==  0x0000000000000000);

  174.     CHECK(lol::audio::sample::sadd<int64_t>( 0x0000000000000000,  0x0000000000000001) ==  0x0000000000000001);

  175.     CHECK(lol::audio::sample::sadd<int64_t>( 0x0000000000000001,  0x0000000000000001) ==  0x0000000000000002);

  176.     CHECK(lol::audio::sample::sadd<int64_t>( 0x3fffffffffffffff,  0x3fffffffffffffff) ==  0x7ffffffffffffffe);

  177.     CHECK(lol::audio::sample::sadd<int64_t>( 0x3fffffffffffffff,  0x4000000000000000) ==  0x7fffffffffffffff);

  178. 

  179.     // Overflow

  180.     CHECK(lol::audio::sample::sadd<int64_t>( 0x4000000000000000,  0x4000000000000000) ==  0x7fffffffffffffff);

  181.     CHECK(lol::audio::sample::sadd<int64_t>( 0x7fffffffffffffff,  0x7fffffffffffffff) ==  0x7fffffffffffffff);

  182. }