src/Tests/KitTest.cpp

   1 /*
   2   ZynAddSubFX - a software synthesizer
   3
   4   KitTest.h - Test For Note Allocation Under Kits
   5   Copyright (C) 2016 Mark McCurry
   6
   7   This program is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU General Public License
   9   as published by the Free Software Foundation; either version 2
  10   of the License, or (at your option) any later version.
  11 */
  12 #include "test-suite.h"
  13 #include <cmath>
  14 #include <cstring>
  15 #include <cstdlib>
  16 #include <iostream>
  17 #include "../Misc/Time.h"
  18 #include "../Misc/Allocator.h"
  19 #include "../DSP/FFTwrapper.h"
  20 #include "../Misc/Microtonal.h"
  21 #define private public
  22 #define protected public
  23 #include "../Synth/SynthNote.h"
  24 #include "../Misc/Part.h"
  25 #include "../globals.h"
  26
  27 using namespace std;
  28 using namespace zyn;
  29
  30 SYNTH_T *synth;
  31 int dummy=0;
  32
  33 #define SUSTAIN_BIT 0x04
  34 enum PrivateNoteStatus {
  35     KEY_OFF                    = 0x00,
  36     KEY_PLAYING                = 0x01,
  37     KEY_RELEASED_AND_SUSTAINED = 0x02,
  38     KEY_RELEASED               = 0x03
  39 };
  40
  41
  42 class KitTest
  43 {
  44     private:
  45         Alloc      alloc;
  46         FFTwrapper fft;
  47         Microtonal microtonal;
  48         Part *part;
  49         AbsTime *time;
  50         float *outL, *outR;
  51     public:
  52         KitTest()
  53             :fft(512), microtonal(dummy)
  54         {}
  55         void setUp() {
  56             synth = new SYNTH_T;
  57             time  = new AbsTime(*synth);
  58             outL  = new float[synth->buffersize];
  59             outR = new float[synth->buffersize];
  60             memset(outL, 0, synth->bufferbytes);
  61             memset(outR, 0, synth->bufferbytes);
  62
  63
  64             part = new Part(alloc, *synth, *time, dummy, dummy, &microtonal, &fft);
  65         }
  66
  67         //Standard poly mode with sustain
  68         void testSustainCase1() {
  69             //enable sustain
  70             part->ctl.setsustain(127);
  71
  72             part->NoteOn(64, 127, 0);
  73             part->NoteOn(64, 127, 0);
  74             part->NoteOff(64);
  75
  76             //first note has moved to release state
  77             //second note has moved to sustain state
  78
  79             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
  80                     (NotePool::NoteDescriptor{
  81                     .age=0,
  82                     .note=64,
  83                     .sendto=0,
  84                     .size=1,
  85                     .status=KEY_RELEASED|SUSTAIN_BIT,
  86                     .legatoMirror=false}));
  87
  88             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
  89                     (NotePool::NoteDescriptor{
  90                     .age=0,
  91                     .note=64,
  92                     .sendto=0,
  93                     .size=1,
  94                     .status=KEY_RELEASED_AND_SUSTAINED,
  95                     .legatoMirror=false}));
  96
  97             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
  98                     (NotePool::NoteDescriptor{
  99                     .age=0,
 100                     .note=0,
 101                     .sendto=0,
 102                     .size=0,
 103                     .status=0,
 104                     .legatoMirror=false}));
 105         }
 106
 107         void testSustainCase2() {
 108             //enable sustain
 109             part->ctl.setsustain(127);
 110
 111             part->NoteOn(64, 127, 0);
 112             part->NoteOff(64);
 113             part->NoteOn(64, 127, 0);
 114
 115             //first note has moved to release state
 116             //second note has stayed in playing state
 117
 118             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 119                     (NotePool::NoteDescriptor{
 120                     .age=0,
 121                     .note=64,
 122                     .sendto=0,
 123                     .size=1,
 124                     .status=KEY_RELEASED|SUSTAIN_BIT,
 125                     .legatoMirror=false}));
 126
 127             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 128                     (NotePool::NoteDescriptor{
 129                     .age=0,
 130                     .note=64,
 131                     .sendto=0,
 132                     .size=1,
 133                     .status=KEY_PLAYING,
 134                     .legatoMirror=false}));
 135
 136             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 137                     (NotePool::NoteDescriptor{
 138                     .age=0,
 139                     .note=0,
 140                     .sendto=0,
 141                     .size=0,
 142                     .status=0,
 143                     .legatoMirror=false}));
 144         }
 145
 146         void testMonoSustain() {
 147             //enable sustain
 148             part->ctl.setsustain(127);
 149             part->Ppolymode   = false;
 150
 151             part->NoteOn(64, 127, 0);
 152             part->NoteOff(64);
 153             part->NoteOn(65, 127, 0);
 154
 155             part->notePool.dump();
 156
 157             //first note has moved to release state
 158             //second note has stayed in playing state
 159
 160             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 161                     (NotePool::NoteDescriptor{
 162                     .age=0,
 163                     .note=64,
 164                     .sendto=0,
 165                     .size=1,
 166                     .status=KEY_RELEASED,
 167                     .legatoMirror=false}));
 168
 169             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 170                     (NotePool::NoteDescriptor{
 171                     .age=0,
 172                     .note=65,
 173                     .sendto=0,
 174                     .size=1,
 175                     .status=KEY_PLAYING,
 176                     .legatoMirror=false}));
 177
 178             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 179                     (NotePool::NoteDescriptor{
 180                     .age=0,
 181                     .note=0,
 182                     .sendto=0,
 183                     .size=0,
 184                     .status=0,
 185                     .legatoMirror=false}));
 186         }
 187
 188         //Enumerate cases of:
 189         //Legato = {disabled,enabled}
 190         //Mono   = {disabled, enabled}
 191         //Kit    = {off, normal, single}
 192         //ignore legato=enabled, mono=enabled
 193
 194         //No Kit
 195         void testNoKitNoLegatoNoMono() {
 196             part->NoteOn(64, 127, 0);
 197             part->NoteOn(65, 127, 0);
 198
 199             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 200                     (NotePool::NoteDescriptor{
 201                     .age=0,
 202                     .note=64,
 203                     .sendto=0,
 204                     .size=1,
 205                     .status=KEY_PLAYING,
 206                     .legatoMirror=false}));
 207
 208             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 209                     (NotePool::NoteDescriptor{
 210                     .age=0,
 211                     .note=65,
 212                     .sendto=0,
 213                     .size=1,
 214                     .status=KEY_PLAYING,
 215                     .legatoMirror=false}));
 216
 217             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 218                     (NotePool::NoteDescriptor{
 219                     .age=0,
 220                     .note=0,
 221                     .sendto=0,
 222                     .size=0,
 223                     .status=0,
 224                     .legatoMirror=false}));
 225         }
 226
 227         void testNoKitYesLegatoNoMono() {
 228             part->Ppolymode   = false;
 229             part->Plegatomode = true;
 230             part->NoteOn(64, 127, 0);
 231             part->NoteOn(65, 127, 0);
 232
 233             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 234                     (NotePool::NoteDescriptor{
 235                     .age=0,
 236                     .note=65,
 237                     .sendto=0,
 238                     .size=1,
 239                     .status=KEY_PLAYING,
 240                     .legatoMirror=false}));
 241
 242             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 243                     (NotePool::NoteDescriptor{
 244                     .age=0,
 245                     .note=65,
 246                     .sendto=0,
 247                     .size=1,
 248                     .status=KEY_PLAYING,
 249                     .legatoMirror=false}));
 250
 251             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 252                     (NotePool::NoteDescriptor{
 253                     .age=0,
 254                     .note=0,
 255                     .sendto=0,
 256                     .size=0,
 257                     .status=0,
 258                     .legatoMirror=false}));
 259
 260             TS_NON_NULL(part->notePool.sdesc[0].note);
 261             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 262             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 263             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 264
 265             TS_NON_NULL(part->notePool.sdesc[1].note);
 266             if(part->notePool.sdesc[1].note)
 267                 TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, true);
 268             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 269             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  0);
 270         }
 271
 272         void testNoKitNoLegatoYesMono() {
 273             part->Ppolymode   = false;
 274             part->Plegatomode = false;
 275             part->NoteOn(64, 127, 0);
 276             part->NoteOn(65, 127, 0);
 277
 278
 279             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 280                     (NotePool::NoteDescriptor{
 281                     .age=0,
 282                     .note=64,
 283                     .sendto=0,
 284                     .size=1,
 285                     .status=KEY_RELEASED,
 286                     .legatoMirror=false}));
 287
 288             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 289                     (NotePool::NoteDescriptor{
 290                     .age=0,
 291                     .note=65,
 292                     .sendto=0,
 293                     .size=1,
 294                     .status=KEY_PLAYING,
 295                     .legatoMirror=false}));
 296
 297             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 298                     (NotePool::NoteDescriptor{
 299                     .age=0,
 300                     .note=0,
 301                     .sendto=0,
 302                     .size=0,
 303                     .status=0,
 304                     .legatoMirror=false}));
 305
 306             TS_NON_NULL(part->notePool.sdesc[0].note);
 307             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 308             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 309             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 310
 311             TS_NON_NULL(part->notePool.sdesc[1].note);
 312             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, false);
 313             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 314             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  0);
 315         }
 316
 317         //Normal Kit
 318         //Three patches that overlap give an overlapping response
 319         void testYesKitNoLegatoNoMono() {
 320             part->setkititemstatus(1, true);
 321             part->setkititemstatus(2, true);
 322             part->kit[1].Padenabled = true;
 323             part->kit[2].Padenabled = true;
 324             part->kit[2].Pmaxkey    = 32;
 325             part->Pkitmode = 1;
 326             part->NoteOn(64, 127, 0);
 327             part->NoteOn(65, 127, 0);
 328
 329             part->notePool.dump();
 330
 331             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 332                     (NotePool::NoteDescriptor{
 333                     .age=0,
 334                     .note=64,
 335                     .sendto=0,
 336                     .size=2,
 337                     .status=KEY_PLAYING,
 338                     .legatoMirror=false}));
 339
 340             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 341                     (NotePool::NoteDescriptor{
 342                     .age=0,
 343                     .note=65,
 344                     .sendto=0,
 345                     .size=2,
 346                     .status=KEY_PLAYING,
 347                     .legatoMirror=false}));
 348
 349             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 350                     (NotePool::NoteDescriptor{
 351                     .age=0,
 352                     .note=0,
 353                     .sendto=0,
 354                     .size=0,
 355                     .status=0,
 356                     .legatoMirror=false}));
 357
 358             TS_NON_NULL(part->notePool.sdesc[0].note);
 359             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 360             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 361             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 362
 363             TS_NON_NULL(part->notePool.sdesc[1].note);
 364             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, false);
 365             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 366             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  1);
 367
 368             TS_NON_NULL(part->notePool.sdesc[2].note);
 369             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].note->legato.silent, false);
 370             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].type, 0);
 371             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].kit,  0);
 372
 373             TS_NON_NULL(part->notePool.sdesc[3].note);
 374             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].note->legato.silent, false);
 375             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].type, 0);
 376             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].kit,  1);
 377
 378             assert_ptr_eq(part->notePool.sdesc[4].note,
 379                           nullptr,
 380                           "note free", __LINE__);
 381             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[4].type, 0);
 382             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[4].kit,  0);
 383         }
 384
 385         void testYesKitYesLegatoNoMono() {
 386             part->setkititemstatus(1, true);
 387             part->setkititemstatus(2, true);
 388             part->kit[1].Padenabled = true;
 389             part->kit[2].Padenabled = true;
 390             part->kit[2].Pmaxkey    = 32;
 391             part->Pkitmode    = 1;
 392             part->Ppolymode   = false;
 393             part->Plegatomode = true;
 394             part->NoteOn(64, 127, 0);
 395             part->NoteOn(65, 127, 0);
 396
 397             part->notePool.dump();
 398
 399             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 400                     (NotePool::NoteDescriptor{
 401                     .age=0,
 402                     .note=65,
 403                     .sendto=0,
 404                     .size=2,
 405                     .status=KEY_PLAYING,
 406                     .legatoMirror=false}));
 407
 408             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 409                     (NotePool::NoteDescriptor{
 410                     .age=0,
 411                     .note=65,
 412                     .sendto=0,
 413                     .size=2,
 414                     .status=KEY_PLAYING,
 415                     .legatoMirror=false}));
 416
 417             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 418                     (NotePool::NoteDescriptor{
 419                     .age=0,
 420                     .note=0,
 421                     .sendto=0,
 422                     .size=0,
 423                     .status=0,
 424                     .legatoMirror=false}));
 425
 426             TS_NON_NULL(part->notePool.sdesc[0].note);
 427             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 428             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 429             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 430
 431             TS_NON_NULL(part->notePool.sdesc[1].note);
 432             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, false);
 433             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 434             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  1);
 435
 436             TS_NON_NULL(part->notePool.sdesc[2].note);
 437             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].note->legato.silent, true);
 438             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].type, 0);
 439             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].kit,  0);
 440
 441             TS_NON_NULL(part->notePool.sdesc[3].note);
 442             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].note->legato.silent, true);
 443             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].type, 0);
 444             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].kit,  1);
 445
 446             assert_ptr_eq(part->notePool.sdesc[4].note,
 447                           nullptr,
 448                           "note free", __LINE__);
 449             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[4].type, 0);
 450             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[4].kit,  0);
 451         }
 452
 453         void testYesKitNoLegatoYesMono() {
 454             part->setkititemstatus(1, true);
 455             part->setkititemstatus(2, true);
 456             part->kit[1].Padenabled = true;
 457             part->kit[2].Padenabled = true;
 458             part->kit[2].Pmaxkey    = 32;
 459             part->Pkitmode    = 1;
 460             part->Ppolymode   = false;
 461             part->Plegatomode = false;
 462             part->NoteOn(64, 127, 0);
 463             part->NoteOn(65, 127, 0);
 464
 465             part->notePool.dump();
 466
 467             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 468                     (NotePool::NoteDescriptor{
 469                     .age=0,
 470                     .note=64,
 471                     .sendto=0,
 472                     .size=2,
 473                     .status=KEY_RELEASED,
 474                     .legatoMirror=false}));
 475
 476             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 477                     (NotePool::NoteDescriptor{
 478                     .age=0,
 479                     .note=65,
 480                     .sendto=0,
 481                     .size=2,
 482                     .status=KEY_PLAYING,
 483                     .legatoMirror=false}));
 484
 485             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 486                     (NotePool::NoteDescriptor{
 487                     .age=0,
 488                     .note=0,
 489                     .sendto=0,
 490                     .size=0,
 491                     .status=0,
 492                     .legatoMirror=false}));
 493
 494             TS_NON_NULL(part->notePool.sdesc[0].note);
 495             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 496             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 497             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 498
 499             TS_NON_NULL(part->notePool.sdesc[1].note);
 500             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, false);
 501             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 502             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  1);
 503
 504             TS_NON_NULL(part->notePool.sdesc[2].note);
 505             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].note->legato.silent, false);
 506             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].type, 0);
 507             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].kit,  0);
 508
 509             TS_NON_NULL(part->notePool.sdesc[3].note);
 510             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].note->legato.silent, false);
 511             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].type, 0);
 512             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[3].kit,  1);
 513
 514             assert_ptr_eq(part->notePool.sdesc[4].note,
 515                           nullptr,
 516                           "note free", __LINE__);
 517             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[4].type, 0);
 518             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[4].kit,  0);
 519         }
 520
 521         //Single Kit
 522         void testSingleKitNoLegatoNoMono() {
 523             part->setkititemstatus(1, true);
 524             part->setkititemstatus(2, true);
 525             part->kit[1].Padenabled = true;
 526             part->kit[2].Padenabled = true;
 527             part->kit[2].Pmaxkey    = 32;
 528             part->Pkitmode = 2;
 529             part->NoteOn(64, 127, 0);
 530             part->NoteOn(65, 127, 0);
 531
 532             part->notePool.dump();
 533
 534             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 535                     (NotePool::NoteDescriptor{
 536                     .age=0,
 537                     .note=64,
 538                     .sendto=0,
 539                     .size=1,
 540                     .status=KEY_PLAYING,
 541                     .legatoMirror=false}));
 542
 543             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 544                     (NotePool::NoteDescriptor{
 545                     .age=0,
 546                     .note=65,
 547                     .sendto=0,
 548                     .size=1,
 549                     .status=KEY_PLAYING,
 550                     .legatoMirror=false}));
 551
 552             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 553                     (NotePool::NoteDescriptor{
 554                     .age=0,
 555                     .note=0,
 556                     .sendto=0,
 557                     .size=0,
 558                     .status=0,
 559                     .legatoMirror=false}));
 560
 561             TS_NON_NULL(part->notePool.sdesc[0].note);
 562             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 563             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 564             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 565
 566             TS_NON_NULL(part->notePool.sdesc[1].note);
 567             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, false);
 568             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 569             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  0);
 570
 571             assert_ptr_eq(part->notePool.sdesc[2].note,
 572                           nullptr,
 573                           "note free", __LINE__);
 574             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].type, 0);
 575             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[2].kit,  0);
 576         }
 577
 578         void testSingleKitYesLegatoNoMono() {
 579             part->setkititemstatus(1, true);
 580             part->setkititemstatus(2, true);
 581             part->kit[1].Padenabled = true;
 582             part->kit[2].Padenabled = true;
 583             part->kit[2].Pmaxkey    = 32;
 584             part->Pkitmode    = 2;
 585             part->Ppolymode   = false;
 586             part->Plegatomode = true;
 587             part->NoteOn(64, 127, 0);
 588             part->NoteOn(65, 127, 0);
 589
 590             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 591                     (NotePool::NoteDescriptor{
 592                     .age=0,
 593                     .note=65,
 594                     .sendto=0,
 595                     .size=1,
 596                     .status=KEY_PLAYING,
 597                     .legatoMirror=false}));
 598
 599             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 600                     (NotePool::NoteDescriptor{
 601                     .age=0,
 602                     .note=65,
 603                     .sendto=0,
 604                     .size=1,
 605                     .status=KEY_PLAYING,
 606                     .legatoMirror=false}));
 607
 608             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 609                     (NotePool::NoteDescriptor{
 610                     .age=0,
 611                     .note=0,
 612                     .sendto=0,
 613                     .size=0,
 614                     .status=0,
 615                     .legatoMirror=false}));
 616
 617             TS_NON_NULL(part->notePool.sdesc[0].note);
 618             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 619             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 620             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 621
 622             TS_NON_NULL(part->notePool.sdesc[1].note);
 623             if(part->notePool.sdesc[1].note)
 624                 TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, true);
 625             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 626             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  0);
 627         }
 628
 629         void testSingleKitNoLegatoYesMono() {
 630             part->setkititemstatus(1, true);
 631             part->setkititemstatus(2, true);
 632             part->kit[1].Padenabled = true;
 633             part->kit[2].Padenabled = true;
 634             part->kit[2].Pmaxkey    = 32;
 635             part->Pkitmode    = 2;
 636             part->Ppolymode   = false;
 637             part->Plegatomode = false;
 638             part->NoteOn(64, 127, 0);
 639             part->NoteOn(65, 127, 0);
 640
 641
 642
 643             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[0],
 644                     (NotePool::NoteDescriptor{
 645                     .age=0,
 646                     .note=64,
 647                     .sendto=0,
 648                     .size=1,
 649                     .status=KEY_RELEASED,
 650                     .legatoMirror=false}));
 651
 652             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[1],
 653                     (NotePool::NoteDescriptor{
 654                     .age=0,
 655                     .note=65,
 656                     .sendto=0,
 657                     .size=1,
 658                     .status=KEY_PLAYING,
 659                     .legatoMirror=false}));
 660
 661             TS_ASSERT_EQUAL_CPP(part->notePool.ndesc[2],
 662                     (NotePool::NoteDescriptor{
 663                     .age=0,
 664                     .note=0,
 665                     .sendto=0,
 666                     .size=0,
 667                     .status=0,
 668                     .legatoMirror=false}));
 669
 670             TS_NON_NULL(part->notePool.sdesc[0].note);
 671             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].note->legato.silent, false);
 672             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].type, 0);
 673             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[0].kit,  0);
 674
 675             TS_NON_NULL(part->notePool.sdesc[1].note);
 676             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].note->legato.silent, false);
 677             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].type, 0);
 678             TS_ASSERT_EQUAL_INT(part->notePool.sdesc[1].kit,  0);
 679         }
 680
 681         void testKeyLimit(void)
 682         {
 683             auto &pool = part->notePool;
 684             //Verify that without a key limit, several notes can be run
 685             part->NoteOn(64, 127, 0);
 686             part->NoteOn(65, 127, 0);
 687             part->NoteOn(66, 127, 0);
 688             part->NoteOn(67, 127, 0);
 689             part->NoteOn(68, 127, 0);
 690
 691             //Verify that notes are spawned as expected
 692             TS_ASSERT_EQUAL_INT(pool.usedNoteDesc(),  5);
 693             TS_ASSERT_EQUAL_INT(pool.usedSynthDesc(), 5);
 694
 695             //Reset the part
 696             part->monomemClear();
 697             pool.killAllNotes();
 698
 699             //Verify that notes are despawned
 700             TS_ASSERT_EQUAL_INT(pool.usedNoteDesc(),  0);
 701             TS_ASSERT_EQUAL_INT(pool.usedSynthDesc(), 0);
 702
 703             //Enable keylimit
 704             part->setkeylimit(3);
 705
 706             //Replay notes
 707             part->NoteOn(64, 127, 0);
 708             part->NoteOn(65, 127, 0);
 709             part->NoteOn(66, 127, 0);
 710             part->NoteOn(67, 127, 0);
 711             part->NoteOn(68, 127, 0);
 712
 713             //Verify that notes are spawned as expected with limit
 714             TS_ASSERT_EQUAL_INT(pool.getRunningNotes(),  3);//2 entombed
 715             TS_ASSERT_EQUAL_INT(pool.usedNoteDesc(),     5);
 716             TS_ASSERT_EQUAL_INT(pool.usedSynthDesc(),    5);
 717
 718             //Reset the part
 719             part->monomemClear();
 720             pool.killAllNotes();
 721
 722             //Verify that notes are despawned
 723             TS_ASSERT_EQUAL_INT(pool.usedNoteDesc(),  0);
 724             TS_ASSERT_EQUAL_INT(pool.usedSynthDesc(), 0);
 725
 726             //Now to test note stealing
 727
 728             //Replay notes
 729             part->NoteOn(64, 127, 0);
 730             part->NoteOn(65, 127, 0);
 731             part->NoteOn(66, 127, 0);
 732
 733             //Verify that note pool is full
 734             TS_ASSERT_EQUAL_INT(pool.usedNoteDesc(),  3);
 735             TS_ASSERT_EQUAL_INT(pool.usedSynthDesc(), 3);
 736
 737             //Age the notes
 738             pool.ndesc[1].age = 50;
 739             pool.ndesc[2].age = 500;
 740
 741             printf("-------------------------------------\n");
 742
 743             //Inject two more notes which should steal the note
 744             //descriptors for #66 and #65
 745             part->NoteOn(67, 127, 0);
 746             pool.cleanup();
 747             TS_ASSERT_EQUAL_INT(pool.ndesc[0].note, 64);
 748             TS_ASSERT_EQUAL_INT(pool.ndesc[1].note, 65);
 749             TS_ASSERT_EQUAL_INT(pool.ndesc[2].note, 66);
 750             TS_ASSERT_EQUAL_INT(pool.ndesc[2].status, KEY_RELEASED);
 751             TS_ASSERT_EQUAL_INT(pool.ndesc[3].note, 67);
 752
 753             part->NoteOn(68, 127, 0);
 754
 755             //Verify that note pool is still full and entombed
 756             TS_ASSERT_EQUAL_INT(pool.usedNoteDesc(),  5);
 757             TS_ASSERT_EQUAL_INT(pool.usedSynthDesc(), 5);
 758
 759             //Check that the result is {64, 68, 67}
 760             TS_ASSERT_EQUAL_INT(pool.ndesc[0].note, 64);
 761             TS_ASSERT_EQUAL_INT(pool.ndesc[1].note, 65);
 762             TS_ASSERT_EQUAL_INT(pool.ndesc[1].status, KEY_RELEASED);
 763             TS_ASSERT_EQUAL_INT(pool.ndesc[2].note, 66);
 764             TS_ASSERT_EQUAL_INT(pool.ndesc[2].status, KEY_RELEASED);
 765             TS_ASSERT_EQUAL_INT(pool.ndesc[3].note, 67);
 766             TS_ASSERT_EQUAL_INT(pool.ndesc[4].note, 68);
 767         }
 768
 769         void tearDown() {
 770             delete part;
 771             delete[] outL;
 772             delete[] outR;
 773             delete time;
 774             delete synth;
 775         }
 776 };
 777
 778 int main()
 779 {
 780     KitTest test;
 781     RUN_TEST(testSustainCase1);
 782     RUN_TEST(testSustainCase2);
 783     RUN_TEST(testMonoSustain);
 784     RUN_TEST(testNoKitNoLegatoNoMono);
 785     RUN_TEST(testNoKitYesLegatoNoMono);
 786     RUN_TEST(testNoKitNoLegatoYesMono);
 787     RUN_TEST(testYesKitNoLegatoNoMono);
 788     RUN_TEST(testYesKitYesLegatoNoMono);
 789     RUN_TEST(testYesKitNoLegatoYesMono);
 790     RUN_TEST(testSingleKitNoLegatoNoMono);
 791     RUN_TEST(testSingleKitYesLegatoNoMono);
 792     RUN_TEST(testSingleKitNoLegatoYesMono);
 793     RUN_TEST(testKeyLimit);
 794     return test_summary();
 795 }