testsuite/supernova/server_node_graph_test.cpp

   1 #include <boost/test/unit_test.hpp>
   2
   3 #include "server/node_graph.hpp"
   4
   5 #include "test_synth.hpp"
   6
   7 #ifdef __GXX_EXPERIMENTAL_CXX0X__
   8 #define auto_ptr unique_ptr
   9 #endif
  10
  11 using namespace nova;
  12 using namespace std;
  13
  14 BOOST_AUTO_TEST_CASE( simple_synth_test_1 )
  15 {
  16     rt_pool.init(1024 * 1024);
  17
  18     node_graph n;
  19
  20     node_position_constraint to_root = std::make_pair(n.root_group(), insert);
  21
  22     {
  23         test_synth * s = new test_synth(1000, 0);
  24         n.add_node(s, to_root);
  25         BOOST_REQUIRE_EQUAL(n.synth_count(), 1u);
  26         BOOST_REQUIRE_EQUAL(n.find_synth(1000), s);
  27         n.remove_node(s);
  28         BOOST_REQUIRE_EQUAL(n.synth_count(), 0u);
  29     }
  30
  31     BOOST_REQUIRE_EQUAL(n.group_count(), 1u);
  32
  33     {
  34         test_synth * s = new test_synth(1000, 0);
  35         n.add_node(s/* , node_position_constraint() */);
  36         BOOST_REQUIRE_EQUAL(n.synth_count(), 1u);
  37         n.remove_node(s);
  38         BOOST_REQUIRE_EQUAL(n.synth_count(), 0u);
  39     }
  40
  41     BOOST_REQUIRE_EQUAL(n.group_count(), 1u);
  42 }
  43
  44 BOOST_AUTO_TEST_CASE( simple_synth_test_2 )
  45 {
  46     node_graph n;
  47
  48     group * g = new group(1);
  49     n.add_node(g);
  50     BOOST_REQUIRE_EQUAL(n.find_group(1), g);
  51     n.remove_node(g);
  52 }
  53
  54 BOOST_AUTO_TEST_CASE( simple_synth_test_3 )
  55 {
  56     node_graph n;
  57
  58     group * g = new group(1);
  59
  60     n.add_node(g);
  61
  62     {
  63         node_position_constraint to_group = std::make_pair(g, insert);
  64
  65         test_synth * s = new test_synth(1000, 0);
  66
  67         n.add_node(s, to_group);
  68         n.remove_node(s);
  69     }
  70     n.remove_node(g);
  71 }
  72
  73 BOOST_AUTO_TEST_CASE( simple_synth_test_4 )
  74 {
  75     node_graph n;
  76
  77     group * g = new group(1);
  78
  79     n.add_node(g);
  80
  81     test_synth * s = new test_synth(1000, 0);
  82     {
  83         node_position_constraint to_group = std::make_pair(g, insert);
  84
  85         n.add_node(s, to_group);
  86     }
  87     n.remove_node(g);
  88 }
  89
  90 BOOST_AUTO_TEST_CASE( simple_synth_test_5 )
  91 {
  92     node_graph n;
  93
  94     test_synth * s = new test_synth(1000, 0);
  95     test_synth * s2 = new test_synth(1001, 0);
  96
  97     n.add_node(s);
  98     n.add_node(s2);
  99
 100     n.remove_node(s);
 101     n.remove_node(s2);
 102 }
 103
 104
 105 BOOST_AUTO_TEST_CASE( simple_synth_test_6 )
 106 {
 107     node_graph n;
 108
 109     test_synth * s1 = new test_synth(1000, 0);
 110     n.add_node(s1);
 111
 112     test_synth * s2 = new test_synth(1001, 0);
 113     {
 114         node_position_constraint to_group = std::make_pair(n.root_group(), insert);
 115
 116         n.add_node(s2, to_group);
 117     }
 118
 119     test_synth * s3 = new test_synth(1002, 0);
 120     {
 121         node_position_constraint position = std::make_pair(s1, after);
 122
 123         n.add_node(s3, position);
 124     }
 125
 126     test_synth * s4 = new test_synth(1003, 0);
 127     {
 128         node_position_constraint position = std::make_pair(s1, before);
 129
 130         n.add_node(s4, position);
 131     }
 132
 133     //n.dump("test.dot");
 134
 135     n.remove_node(s1);
 136     n.remove_node(s2);
 137     n.remove_node(s3);
 138     n.remove_node(s4);
 139 }
 140
 141 BOOST_AUTO_TEST_CASE( free_all_test )
 142 {
 143     node_graph n;
 144
 145     group * g = new group(1);
 146
 147     n.add_node(g);
 148     BOOST_REQUIRE_EQUAL(n.group_count(), 2u);
 149
 150     node_position_constraint to_group = std::make_pair(g, insert);
 151
 152     test_synth * s = new test_synth(1000, 0);
 153     n.add_node(s, to_group);
 154
 155     test_synth * s2 = new test_synth(1001, 0);
 156     n.add_node(s2, to_group);
 157
 158     group * g2 = new group(1002);
 159     n.add_node(g2, to_group);
 160
 161     BOOST_REQUIRE_EQUAL(n.synth_count(), 2u);
 162     BOOST_REQUIRE_EQUAL(n.group_count(), 3u);
 163
 164     BOOST_REQUIRE(n.find_node(s->id()));
 165     BOOST_REQUIRE(n.find_node(s2->id()));
 166     BOOST_REQUIRE(n.find_node(g2->id()));
 167
 168     BOOST_REQUIRE(n.group_free_all(g));
 169
 170     BOOST_REQUIRE(!n.find_node(s->id()));
 171     BOOST_REQUIRE(!n.find_node(s2->id()));
 172     BOOST_REQUIRE(!n.find_node(g2->id()));
 173
 174     BOOST_REQUIRE_EQUAL(n.synth_count(), 0u);
 175     BOOST_REQUIRE_EQUAL(n.group_count(), 2u);
 176
 177     BOOST_REQUIRE(n.find_node(g->id()));
 178     n.remove_node(g);
 179     BOOST_REQUIRE(!n.find_node(g->id()));
 180     BOOST_REQUIRE_EQUAL(n.group_count(), 1u);
 181 }
 182
 183 BOOST_AUTO_TEST_CASE( free_deep_test )
 184 {
 185     node_graph n;
 186
 187     group * g = new group(1);
 188
 189     n.add_node(g);
 190     BOOST_REQUIRE_EQUAL(n.group_count(), 2u);
 191
 192     node_position_constraint to_group = std::make_pair(g, insert);
 193
 194     test_synth * s = new test_synth(1000, 0);
 195     n.add_node(s, to_group);
 196
 197     test_synth * s2 = new test_synth(1001, 0);
 198     n.add_node(s2, to_group);
 199
 200     group * g2 = new group(1002);
 201     n.add_node(g2, to_group);
 202
 203     BOOST_REQUIRE_EQUAL(n.synth_count(), 2u);
 204     BOOST_REQUIRE_EQUAL(n.group_count(), 3u);
 205
 206     BOOST_REQUIRE(n.find_node(s->id()));
 207     BOOST_REQUIRE(n.find_node(s2->id()));
 208     BOOST_REQUIRE(n.find_node(g2->id()));
 209
 210     BOOST_REQUIRE(n.group_free_deep(g));
 211
 212     BOOST_REQUIRE(!n.find_node(s->id()));
 213     BOOST_REQUIRE(!n.find_node(s2->id()));
 214     BOOST_REQUIRE(n.find_node(g2->id()));
 215
 216     BOOST_REQUIRE_EQUAL(n.synth_count(), 0u);
 217     BOOST_REQUIRE_EQUAL(n.group_count(), 3u);
 218
 219     BOOST_REQUIRE(n.find_node(g2->id()));
 220     BOOST_REQUIRE(n.find_node(g->id()));
 221     n.remove_node(g);
 222     BOOST_REQUIRE(!n.find_node(g->id()));
 223     BOOST_REQUIRE(!n.find_node(g2->id()));
 224     BOOST_REQUIRE_EQUAL(n.group_count(), 1u);
 225 }
 226
 227
 228 BOOST_AUTO_TEST_CASE( queue_construction_test_1 )
 229 {
 230     node_graph n;
 231
 232     test_synth * s = new test_synth(1000, 0);
 233     test_synth * s2 = new test_synth(1001, 0);
 234
 235     n.add_node(s);
 236     n.add_node(s2);
 237
 238     auto_ptr<node_graph::dsp_thread_queue> q = n.generate_dsp_queue();
 239
 240     n.remove_node(s);
 241     n.remove_node(s2);
 242 }
 243
 244 BOOST_AUTO_TEST_CASE( queue_construction_test_2 )
 245 {
 246     node_graph n;
 247
 248     group * g = new group(1);
 249
 250     n.add_node(g);
 251     auto_ptr<node_graph::dsp_thread_queue> q = n.generate_dsp_queue();
 252     BOOST_REQUIRE_EQUAL(q->get_total_node_count(), 0u);
 253
 254     n.remove_node(g);
 255 }
 256
 257 BOOST_AUTO_TEST_CASE( queue_construction_test_3 )
 258 {
 259     node_graph n;
 260
 261     test_synth * s = new test_synth(1000, 0);
 262     n.add_node(s);
 263
 264     auto_ptr<node_graph::dsp_thread_queue> q1 = n.generate_dsp_queue();
 265     BOOST_REQUIRE_EQUAL(q1->get_total_node_count(), 1u);
 266
 267     test_synth * s2 = new test_synth(3, 0);
 268     n.add_node(s2);
 269
 270     auto_ptr<node_graph::dsp_thread_queue> q2 = n.generate_dsp_queue();
 271     BOOST_REQUIRE_EQUAL(q2->get_total_node_count(), 1u);
 272
 273     n.remove_node(s);
 274     n.remove_node(s2);
 275 }
 276
 277
 278
 279
 280 BOOST_AUTO_TEST_CASE( pgroup_test_1 )
 281 {
 282     node_graph n;
 283
 284     parallel_group * g = new parallel_group(1);
 285     n.add_node(g);
 286     BOOST_REQUIRE_EQUAL(n.find_group(1), g);
 287
 288     auto_ptr<node_graph::dsp_thread_queue> q = n.generate_dsp_queue();
 289     BOOST_REQUIRE_EQUAL(q->get_total_node_count(), 0u);
 290     n.remove_node(g);
 291 }
 292
 293
 294 BOOST_AUTO_TEST_CASE( pgroup_test_2 )
 295 {
 296     node_graph n;
 297
 298     parallel_group * g = new parallel_group(1);
 299
 300     n.add_node(g);
 301
 302     {
 303         node_position_constraint to_group = std::make_pair(g, insert);
 304
 305         test_synth * s = new test_synth(2, 0);
 306         n.add_node(s, to_group);
 307         n.remove_node(s);
 308     }
 309     n.remove_node(g);
 310 }
 311
 312 BOOST_AUTO_TEST_CASE( pgroup_test_3 )
 313 {
 314     node_graph n;
 315
 316     parallel_group * g = new parallel_group(1);
 317
 318     n.add_node(g);
 319
 320     test_synth * s = new test_synth(2, 0);
 321     {
 322         node_position_constraint to_group = std::make_pair(g, insert);
 323
 324         n.add_node(s, to_group);
 325     }
 326     n.remove_node(g);
 327 }
 328
 329 BOOST_AUTO_TEST_CASE( pgroup_test_4 )
 330 {
 331     node_graph n;
 332
 333     parallel_group * g = new parallel_group(1);
 334
 335     n.add_node(g);
 336
 337     {
 338         node_position_constraint to_group = std::make_pair(g, insert);
 339
 340         test_synth * s = new test_synth(2, 0);
 341         n.add_node(s, to_group);
 342
 343         auto_ptr<node_graph::dsp_thread_queue> q = n.generate_dsp_queue();
 344         BOOST_REQUIRE_EQUAL(q->get_total_node_count(), 1u);
 345
 346         n.remove_node(s);
 347     }
 348     n.remove_node(g);
 349 }
 350
 351
 352 BOOST_AUTO_TEST_CASE( pgroup_test_5 )
 353 {
 354     node_graph n;
 355
 356     parallel_group * g = new parallel_group(1);
 357
 358     n.add_node(g);
 359
 360     {
 361         node_position_constraint to_group = std::make_pair(g, insert);
 362
 363         test_synth * s1 = new test_synth(2, 0);
 364         test_synth * s2 = new test_synth(3, 0);
 365         n.add_node(s1, to_group);
 366         n.add_node(s2, to_group);
 367
 368         auto_ptr<node_graph::dsp_thread_queue> q = n.generate_dsp_queue();
 369
 370         BOOST_REQUIRE_EQUAL(q->get_total_node_count(), 2u);
 371
 372         n.remove_node(s1);
 373         n.remove_node(s2);
 374     }
 375     n.remove_node(g);
 376 }
 377
 378 BOOST_AUTO_TEST_CASE( pgroup_test_6 )
 379 {
 380     node_graph n;
 381
 382     parallel_group * g = new parallel_group(1);
 383
 384     n.add_node(g);
 385
 386     {
 387         node_position_constraint to_group = std::make_pair(g, insert);
 388
 389         test_synth * s1 = new test_synth(2, 0);
 390         test_synth * s2 = new test_synth(3, 0);
 391         test_synth * s3 = new test_synth(4, 0);
 392         n.add_node(s1, to_group);
 393         n.add_node(s2, to_group);
 394         n.add_node(s3, to_group);
 395
 396         auto_ptr<node_graph::dsp_thread_queue> q = n.generate_dsp_queue();
 397         BOOST_REQUIRE_EQUAL(q->get_total_node_count(), 3u);
 398     }
 399     n.remove_node(g);
 400 }
 401
 402 BOOST_AUTO_TEST_CASE( pgroup_test_7 )
 403 {
 404     node_graph n;
 405
 406     parallel_group * g = new parallel_group(1);
 407
 408     n.add_node(g);
 409
 410     {
 411         node_position_constraint to_group = std::make_pair(g, insert);
 412
 413         group * g1 = new group(2);
 414         group * g2 = new group(3);
 415         group * g3 = new group(4);
 416         n.add_node(g1, to_group);
 417         n.add_node(g2, to_group);
 418         n.add_node(g3, to_group);
 419
 420         node_position_constraint to_g1 = std::make_pair(g1, insert);
 421         node_position_constraint to_g2 = std::make_pair(g2, insert);
 422         test_synth * s1 = new test_synth(1000, 0);
 423         test_synth * s2 = new test_synth(1001, 0);
 424         n.add_node(s1, to_g1);
 425         n.add_node(s2, to_g2);
 426
 427         auto_ptr<node_graph::dsp_thread_queue> q = n.generate_dsp_queue();
 428         BOOST_REQUIRE_EQUAL(q->get_total_node_count(), 2u);
 429     }
 430     n.remove_node(g);
 431 }
 432
 433 BOOST_AUTO_TEST_CASE( noid_test )
 434 {
 435     rt_pool.init(1024 * 1024);
 436
 437     node_graph n;
 438
 439     node_position_constraint to_root = std::make_pair(n.root_group(), insert);
 440
 441     {
 442         test_synth * s = new test_synth(1000, 0);
 443         n.add_node(s, to_root);
 444         BOOST_REQUIRE(s->id() == 1000 );
 445         n.synth_reassign_id(1000);
 446         BOOST_REQUIRE(s->id() != 1000 );
 447         n.remove_node(s);
 448     }
 449
 450     {
 451         test_synth * s = new test_synth(1000, 0);
 452         n.add_node(s/* , node_position_constraint() */);
 453         BOOST_REQUIRE(s->id() == 1000 );
 454         n.synth_reassign_id(1000);
 455         BOOST_REQUIRE(s->id() != 1000 );
 456         n.remove_node(s);
 457     }
 458 }
 459