zynaddsubfx

ZynAddSubFX open source synthesizer
Log | Files | Refs | Submodules | LICENSE

MqTest.cpp (3925B)

      1 /*
      2   ZynAddSubFX - a software synthesizer
      3 
      4   PluginTest.h - CxxTest for embedding zyn
      5   Copyright (C) 2013-2013 Mark McCurry
      6   Authors: Mark McCurry
      7 
      8   This program is free software; you can redistribute it and/or
      9   modify it under the terms of the GNU General Public License
     10   as published by the Free Software Foundation; either version 2
     11   of the License, or (at your option) any later version.
     12 */
     13 #include "test-suite.h"
     14 #include <cmath>
     15 #include <cstdlib>
     16 #include <iostream>
     17 #include <fstream>
     18 #include <string>
     19 #include <thread>
     20 #include <rtosc/thread-link.h>
     21 #include <unistd.h>
     22 #include "../Containers/MultiPseudoStack.h"
     23 using namespace std;
     24 using namespace zyn;
     25 
     26 char *instance_name=(char*)"";
     27 
     28 class MessageTest
     29 {
     30     public:
     31         MultiQueue *s;
     32         void setUp() {
     33             s = new MultiQueue;
     34         }
     35 
     36         void tearDown() {
     37             delete s;
     38         }
     39 
     40         void testBasic(void)
     41         {
     42             auto *mem = s->alloc();
     43             TS_NON_NULL(mem);
     44             TS_NON_NULL(mem->memory);
     45             TS_ASSERT(!s->read());
     46             s->write(mem);
     47             auto *mem2 = s->read();
     48             assert_ptr_eq(mem, mem2,
     49                     "both locations are the same", __LINE__);
     50             s->free(mem2);
     51         }
     52         void testMed(void)
     53         {
     54             for(int i=0; i<100; ++i) {
     55                 auto *mem = s->alloc();
     56                 TS_NON_NULL(mem);
     57                 TS_NON_NULL(mem->memory);
     58                 TS_ASSERT(!s->read());
     59                 s->write(mem);
     60                 auto *mem2 = s->read();
     61                 assert_ptr_eq(mem, mem2,
     62                         "both locations are the same", __LINE__);
     63                 s->free(mem2);
     64             }
     65         }
     66 
     67 #define OPS 1000
     68 #define THREADS 8
     69         void testThreads(void)
     70         {
     71             uint8_t messages[OPS*THREADS];
     72             memset(messages, 0, sizeof(messages));
     73             std::thread *t[THREADS];
     74             for(int i=0; i<THREADS; ++i) {
     75                 t[i] = new std::thread([this,i,&messages](){
     76                     int op=0;
     77                     while(op<OPS) {
     78                         int read = rand()%2;
     79                         if(read) {
     80                             auto *mem = s->read();
     81                             if(mem) {
     82                                 //printf("r%d",i%10);
     83                                 //printf("got: <%s>\n", mem->memory);
     84                                 messages[atoi(mem->memory)]++;
     85                             }
     86                             s->free(mem);
     87                         } else {
     88                             auto *mem = s->alloc();
     89                             if(mem) {
     90                                 snprintf(mem->memory, mem->size, "%d written by %d@op%d", i*OPS+op,i,op);
     91                                 //printf("w%d",i%10);
     92                                 op++;
     93                             }
     94                             s->write(mem);
     95                         }
     96                     }
     97                 });
     98             }
     99 
    100             printf("thread started...\n");
    101             for(int i=0; i<THREADS; ++i) {
    102                 t[i]->join();
    103                 delete t[i];
    104             }
    105             printf("thread stopped...\n");
    106             //read the last few
    107             while(1) {
    108                 auto *mem = s->read();
    109                 if(mem) {
    110                     printf("got: <%s>\n", mem->memory);
    111                     messages[atoi(mem->memory)]++;
    112                 } else
    113                     break;
    114                 s->free(mem);
    115             }
    116 
    117             int good = 1;
    118             for(int i=0; i<OPS*THREADS; ++i) {
    119                 if(messages[i] != 1) {
    120                     assert(false);
    121                     good = 0;
    122                 }
    123             }
    124             TS_ASSERT(good);
    125         }
    126 };
    127 
    128 int main()
    129 {
    130     MessageTest test;
    131     RUN_TEST(testBasic);
    132     RUN_TEST(testMed);
    133     RUN_TEST(testThreads);
    134     return test_summary();
    135 }