← Back to branch summary

~clint-fewbar/ubuntu/natty/upstart/add-serial-console

« back to all changes in this revision

Viewing changes to init/tests/test_job_class.c

  • Committer: James Hunt
  • Date: 2010-12-14 17:04:01 UTC
  • mfrom: (1185.1.11 upstream)
  • Revision ID: james.hunt@ubuntu.com-20101214170401-3a27aef2slvnt5l4
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
init/tests/test_job_class.c
2
2
 *
3
3
 * test_job_class.c - test suite for init/job_class.c
4
4
 *
5
 
 * Copyright © 2009 Canonical Ltd.
 
5
 * Copyright © 2010 Canonical Ltd.
6
6
 * Author: Scott James Remnant <scott@netsplit.com>.
7
7
 *
8
8
 * This program is free software; you can redistribute it and/or modify
3232
3232
        }
3233
3233
}
3234
3234
 
 
3235
void
 
3236
test_get_start_on (void)
 
3237
{
 
3238
        NihDBusMessage *message = NULL;
 
3239
        JobClass       *class = NULL;
 
3240
        EventOperator  *oper = NULL;
 
3241
        EventOperator  *and_oper = NULL;
 
3242
        NihError       *error;
 
3243
        char         ***start_on;
 
3244
        int             ret;
 
3245
 
 
3246
        TEST_FUNCTION ("job_class_get_start_on");
 
3247
 
 
3248
        /* Check that the job's start_on tree is returned as a flattened
 
3249
         * array of string arrays, as a child of the message.
 
3250
         */
 
3251
        TEST_FEATURE ("with event tree");
 
3252
        nih_error_init ();
 
3253
        job_class_init ();
 
3254
 
 
3255
        TEST_ALLOC_FAIL {
 
3256
                TEST_ALLOC_SAFE {
 
3257
                        class = job_class_new (NULL, "test");
 
3258
 
 
3259
                        class->start_on = event_operator_new (
 
3260
                                class, EVENT_OR, NULL, NULL);
 
3261
 
 
3262
                        and_oper = event_operator_new (
 
3263
                                class, EVENT_AND, NULL, NULL);
 
3264
                        nih_tree_add (&class->start_on->node, &and_oper->node,
 
3265
                                      NIH_TREE_LEFT);
 
3266
 
 
3267
                        oper = event_operator_new (
 
3268
                                class->start_on, EVENT_MATCH, "foo", NULL);
 
3269
                        oper->env = nih_str_array_new (oper);
 
3270
                        NIH_MUST (nih_str_array_add (&oper->env, oper, NULL, "omnomnom"));
 
3271
                        NIH_MUST (nih_str_array_add (&oper->env, oper, NULL, "ABER=crombie"));
 
3272
                        NIH_MUST (nih_str_array_add (&oper->env, oper, NULL, "HOBBIT=frodo"));
 
3273
 
 
3274
                        nih_tree_add (&class->start_on->node, &oper->node,
 
3275
                                      NIH_TREE_RIGHT);
 
3276
 
 
3277
                        oper = event_operator_new (
 
3278
                                class->start_on, EVENT_MATCH, "wibble", NULL);
 
3279
                        nih_tree_add (&and_oper->node, &oper->node,
 
3280
                                      NIH_TREE_LEFT);
 
3281
 
 
3282
                        oper = event_operator_new (
 
3283
                                class->start_on, EVENT_MATCH, "wobble", NULL);
 
3284
                        nih_tree_add (&and_oper->node, &oper->node,
 
3285
                                      NIH_TREE_RIGHT);
 
3286
 
 
3287
                        message = nih_new (NULL, NihDBusMessage);
 
3288
                        message->connection = NULL;
 
3289
                        message->message = NULL;
 
3290
                }
 
3291
 
 
3292
                start_on = NULL;
 
3293
 
 
3294
                ret = job_class_get_start_on (class, message, &start_on);
 
3295
 
 
3296
                if (test_alloc_failed) {
 
3297
                        TEST_LT (ret, 0);
 
3298
 
 
3299
                        error = nih_error_get ();
 
3300
                        TEST_EQ (error->number, ENOMEM);
 
3301
                        nih_free (error);
 
3302
 
 
3303
                        nih_free (message);
 
3304
                        nih_free (class);
 
3305
                        continue;
 
3306
                }
 
3307
 
 
3308
                TEST_EQ (ret, 0);
 
3309
 
 
3310
                TEST_ALLOC_PARENT (start_on, message);
 
3311
                TEST_ALLOC_SIZE (start_on, sizeof (char **) * 6);
 
3312
 
 
3313
                TEST_ALLOC_SIZE (start_on[0], sizeof (char *) * 2);
 
3314
                TEST_EQ_STR (start_on[0][0], "wibble");
 
3315
                TEST_EQ_P (start_on[0][1], NULL);
 
3316
 
 
3317
                TEST_ALLOC_SIZE (start_on[1], sizeof (char *) * 2);
 
3318
                TEST_EQ_STR (start_on[1][0], "wobble");
 
3319
                TEST_EQ_P (start_on[1][1], NULL);
 
3320
 
 
3321
                TEST_ALLOC_SIZE (start_on[2], sizeof (char *) * 2);
 
3322
                TEST_EQ_STR (start_on[2][0], "/AND");
 
3323
                TEST_EQ_P (start_on[2][1], NULL);
 
3324
 
 
3325
                TEST_ALLOC_SIZE (start_on[3], sizeof (char *) * 5);
 
3326
                TEST_EQ_STR (start_on[3][0], "foo");
 
3327
                TEST_EQ_STR (start_on[3][1], "omnomnom");
 
3328
                TEST_EQ_STR (start_on[3][2], "ABER=crombie");
 
3329
                TEST_EQ_STR (start_on[3][3], "HOBBIT=frodo");
 
3330
                TEST_EQ_P (start_on[3][4], NULL);
 
3331
 
 
3332
                TEST_ALLOC_SIZE (start_on[4], sizeof (char *) * 2);
 
3333
                TEST_EQ_STR (start_on[4][0], "/OR");
 
3334
                TEST_EQ_P (start_on[4][1], NULL);
 
3335
 
 
3336
                TEST_EQ_P (start_on[5], NULL);
 
3337
 
 
3338
                nih_free (message);
 
3339
                nih_free (class);
 
3340
        }
 
3341
 
 
3342
 
 
3343
        /* Check that an empty array is returned when the job has no
 
3344
         * start_on operator tree.
 
3345
         */
 
3346
        TEST_FEATURE ("with no events");
 
3347
        nih_error_init ();
 
3348
        job_class_init ();
 
3349
 
 
3350
        TEST_ALLOC_FAIL {
 
3351
                TEST_ALLOC_SAFE {
 
3352
                        class = job_class_new (NULL, "test");
 
3353
 
 
3354
                        message = nih_new (NULL, NihDBusMessage);
 
3355
                        message->connection = NULL;
 
3356
                        message->message = NULL;
 
3357
                }
 
3358
 
 
3359
                start_on = NULL;
 
3360
 
 
3361
                ret = job_class_get_start_on (class, message, &start_on);
 
3362
 
 
3363
                if (test_alloc_failed) {
 
3364
                        TEST_LT (ret, 0);
 
3365
 
 
3366
                        error = nih_error_get ();
 
3367
                        TEST_EQ (error->number, ENOMEM);
 
3368
                        nih_free (error);
 
3369
 
 
3370
                        nih_free (message);
 
3371
                        nih_free (class);
 
3372
                        continue;
 
3373
                }
 
3374
 
 
3375
                TEST_EQ (ret, 0);
 
3376
 
 
3377
                TEST_ALLOC_PARENT (start_on, message);
 
3378
                TEST_ALLOC_SIZE (start_on, sizeof (char **));
 
3379
                TEST_EQ_P (start_on[0], NULL);
 
3380
 
 
3381
                nih_free (message);
 
3382
                nih_free (class);
 
3383
        }
 
3384
}
 
3385
 
 
3386
void
 
3387
test_get_stop_on (void)
 
3388
{
 
3389
        NihDBusMessage *message = NULL;
 
3390
        JobClass       *class = NULL;
 
3391
        EventOperator  *oper = NULL;
 
3392
        EventOperator  *and_oper = NULL;
 
3393
        NihError       *error;
 
3394
        char         ***stop_on;
 
3395
        int             ret;
 
3396
 
 
3397
        TEST_FUNCTION ("job_class_get_stop_on");
 
3398
 
 
3399
        /* Check that the job's stop_on tree is returned as a flattened
 
3400
         * array of string arrays, as a child of the message.
 
3401
         */
 
3402
        TEST_FEATURE ("with event tree");
 
3403
        nih_error_init ();
 
3404
        job_class_init ();
 
3405
 
 
3406
        TEST_ALLOC_FAIL {
 
3407
                TEST_ALLOC_SAFE {
 
3408
                        class = job_class_new (NULL, "test");
 
3409
 
 
3410
                        class->stop_on = event_operator_new (
 
3411
                                class, EVENT_OR, NULL, NULL);
 
3412
 
 
3413
                        and_oper = event_operator_new (
 
3414
                                class, EVENT_AND, NULL, NULL);
 
3415
                        nih_tree_add (&class->stop_on->node, &and_oper->node,
 
3416
                                      NIH_TREE_LEFT);
 
3417
 
 
3418
                        oper = event_operator_new (
 
3419
                                class->stop_on, EVENT_MATCH, "foo", NULL);
 
3420
                        oper->env = nih_str_array_new (oper);
 
3421
                        NIH_MUST (nih_str_array_add (&oper->env, oper, NULL, "omnomnom"));
 
3422
                        NIH_MUST (nih_str_array_add (&oper->env, oper, NULL, "ABER=crombie"));
 
3423
                        NIH_MUST (nih_str_array_add (&oper->env, oper, NULL, "HOBBIT=frodo"));
 
3424
 
 
3425
                        nih_tree_add (&class->stop_on->node, &oper->node,
 
3426
                                      NIH_TREE_RIGHT);
 
3427
 
 
3428
                        oper = event_operator_new (
 
3429
                                class->stop_on, EVENT_MATCH, "wibble", NULL);
 
3430
                        nih_tree_add (&and_oper->node, &oper->node,
 
3431
                                      NIH_TREE_LEFT);
 
3432
 
 
3433
                        oper = event_operator_new (
 
3434
                                class->stop_on, EVENT_MATCH, "wobble", NULL);
 
3435
                        nih_tree_add (&and_oper->node, &oper->node,
 
3436
                                      NIH_TREE_RIGHT);
 
3437
 
 
3438
                        message = nih_new (NULL, NihDBusMessage);
 
3439
                        message->connection = NULL;
 
3440
                        message->message = NULL;
 
3441
                }
 
3442
 
 
3443
                stop_on = NULL;
 
3444
 
 
3445
                ret = job_class_get_stop_on (class, message, &stop_on);
 
3446
 
 
3447
                if (test_alloc_failed) {
 
3448
                        TEST_LT (ret, 0);
 
3449
 
 
3450
                        error = nih_error_get ();
 
3451
                        TEST_EQ (error->number, ENOMEM);
 
3452
                        nih_free (error);
 
3453
 
 
3454
                        nih_free (message);
 
3455
                        nih_free (class);
 
3456
                        continue;
 
3457
                }
 
3458
 
 
3459
                TEST_EQ (ret, 0);
 
3460
 
 
3461
                TEST_ALLOC_PARENT (stop_on, message);
 
3462
                TEST_ALLOC_SIZE (stop_on, sizeof (char **) * 6);
 
3463
 
 
3464
                TEST_ALLOC_SIZE (stop_on[0], sizeof (char *) * 2);
 
3465
                TEST_EQ_STR (stop_on[0][0], "wibble");
 
3466
                TEST_EQ_P (stop_on[0][1], NULL);
 
3467
 
 
3468
                TEST_ALLOC_SIZE (stop_on[1], sizeof (char *) * 2);
 
3469
                TEST_EQ_STR (stop_on[1][0], "wobble");
 
3470
                TEST_EQ_P (stop_on[1][1], NULL);
 
3471
 
 
3472
                TEST_ALLOC_SIZE (stop_on[2], sizeof (char *) * 2);
 
3473
                TEST_EQ_STR (stop_on[2][0], "/AND");
 
3474
                TEST_EQ_P (stop_on[2][1], NULL);
 
3475
 
 
3476
                TEST_ALLOC_SIZE (stop_on[3], sizeof (char *) * 5);
 
3477
                TEST_EQ_STR (stop_on[3][0], "foo");
 
3478
                TEST_EQ_STR (stop_on[3][1], "omnomnom");
 
3479
                TEST_EQ_STR (stop_on[3][2], "ABER=crombie");
 
3480
                TEST_EQ_STR (stop_on[3][3], "HOBBIT=frodo");
 
3481
                TEST_EQ_P (stop_on[3][4], NULL);
 
3482
 
 
3483
                TEST_ALLOC_SIZE (stop_on[4], sizeof (char *) * 2);
 
3484
                TEST_EQ_STR (stop_on[4][0], "/OR");
 
3485
                TEST_EQ_P (stop_on[4][1], NULL);
 
3486
 
 
3487
                TEST_EQ_P (stop_on[5], NULL);
 
3488
 
 
3489
                nih_free (message);
 
3490
                nih_free (class);
 
3491
        }
 
3492
 
 
3493
 
 
3494
        /* Check that an empty array is returned when the job has no
 
3495
         * stop_on operator tree.
 
3496
         */
 
3497
        TEST_FEATURE ("with no events");
 
3498
        nih_error_init ();
 
3499
        job_class_init ();
 
3500
 
 
3501
        TEST_ALLOC_FAIL {
 
3502
                TEST_ALLOC_SAFE {
 
3503
                        class = job_class_new (NULL, "test");
 
3504
 
 
3505
                        message = nih_new (NULL, NihDBusMessage);
 
3506
                        message->connection = NULL;
 
3507
                        message->message = NULL;
 
3508
                }
 
3509
 
 
3510
                stop_on = NULL;
 
3511
 
 
3512
                ret = job_class_get_stop_on (class, message, &stop_on);
 
3513
 
 
3514
                if (test_alloc_failed) {
 
3515
                        TEST_LT (ret, 0);
 
3516
 
 
3517
                        error = nih_error_get ();
 
3518
                        TEST_EQ (error->number, ENOMEM);
 
3519
                        nih_free (error);
 
3520
 
 
3521
                        nih_free (message);
 
3522
                        nih_free (class);
 
3523
                        continue;
 
3524
                }
 
3525
 
 
3526
                TEST_EQ (ret, 0);
 
3527
 
 
3528
                TEST_ALLOC_PARENT (stop_on, message);
 
3529
                TEST_ALLOC_SIZE (stop_on, sizeof (char **));
 
3530
                TEST_EQ_P (stop_on[0], NULL);
 
3531
 
 
3532
                nih_free (message);
 
3533
                nih_free (class);
 
3534
        }
 
3535
}
 
3536
 
 
3537
void
 
3538
test_get_emits (void)
 
3539
{
 
3540
        NihDBusMessage *message = NULL;
 
3541
        JobClass       *class = NULL;
 
3542
        NihError       *error;
 
3543
        char          **emits;
 
3544
        int             ret;
 
3545
 
 
3546
        TEST_FUNCTION ("job_class_get_emits");
 
3547
 
 
3548
        /* Check that an array of strings is returned from the property
 
3549
         * as a child of the message when the job declares that it emits
 
3550
         * extra events.
 
3551
         */
 
3552
        TEST_FEATURE ("with events");
 
3553
        nih_error_init ();
 
3554
        job_class_init ();
 
3555
 
 
3556
        TEST_ALLOC_FAIL {
 
3557
                TEST_ALLOC_SAFE {
 
3558
                        class = job_class_new (NULL, "test");
 
3559
                        class->emits = nih_str_array_new (class);
 
3560
 
 
3561
                        NIH_MUST (nih_str_array_add (&class->emits, class, NULL, "foo"));
 
3562
                        NIH_MUST (nih_str_array_add (&class->emits, class, NULL, "bar"));
 
3563
                        NIH_MUST (nih_str_array_add (&class->emits, class, NULL, "baz"));
 
3564
 
 
3565
                        message = nih_new (NULL, NihDBusMessage);
 
3566
                        message->connection = NULL;
 
3567
                        message->message = NULL;
 
3568
                }
 
3569
 
 
3570
                emits = NULL;
 
3571
 
 
3572
                ret = job_class_get_emits (class, message, &emits);
 
3573
 
 
3574
                if (test_alloc_failed) {
 
3575
                        TEST_LT (ret, 0);
 
3576
 
 
3577
                        error = nih_error_get ();
 
3578
                        TEST_EQ (error->number, ENOMEM);
 
3579
                        nih_free (error);
 
3580
 
 
3581
                        nih_free (message);
 
3582
                        nih_free (class);
 
3583
                        continue;
 
3584
                }
 
3585
 
 
3586
                TEST_EQ (ret, 0);
 
3587
 
 
3588
                TEST_ALLOC_PARENT (emits, message);
 
3589
                TEST_ALLOC_SIZE (emits, sizeof (char *) * 4);
 
3590
                TEST_EQ_STR (emits[0], "foo");
 
3591
                TEST_EQ_STR (emits[1], "bar");
 
3592
                TEST_EQ_STR (emits[2], "baz");
 
3593
                TEST_EQ_P (emits[3], NULL);
 
3594
 
 
3595
                nih_free (message);
 
3596
                nih_free (class);
 
3597
        }
 
3598
 
 
3599
 
 
3600
        /* Check that an empty array is returned from the property
 
3601
         * as a child of the message when the job doesn't declare
 
3602
         * any particular emitted events.
 
3603
         */
 
3604
        TEST_FEATURE ("with no events");
 
3605
        nih_error_init ();
 
3606
        job_class_init ();
 
3607
 
 
3608
        TEST_ALLOC_FAIL {
 
3609
                TEST_ALLOC_SAFE {
 
3610
                        class = job_class_new (NULL, "test");
 
3611
 
 
3612
                        message = nih_new (NULL, NihDBusMessage);
 
3613
                        message->connection = NULL;
 
3614
                        message->message = NULL;
 
3615
                }
 
3616
 
 
3617
                emits = NULL;
 
3618
 
 
3619
                ret = job_class_get_emits (class, message, &emits);
 
3620
 
 
3621
                if (test_alloc_failed) {
 
3622
                        TEST_LT (ret, 0);
 
3623
 
 
3624
                        error = nih_error_get ();
 
3625
                        TEST_EQ (error->number, ENOMEM);
 
3626
                        nih_free (error);
 
3627
 
 
3628
                        nih_free (message);
 
3629
                        nih_free (class);
 
3630
                        continue;
 
3631
                }
 
3632
 
 
3633
                TEST_EQ (ret, 0);
 
3634
 
 
3635
                TEST_ALLOC_PARENT (emits, message);
 
3636
                TEST_ALLOC_SIZE (emits, sizeof (char *));
 
3637
                TEST_EQ_P (emits[0], NULL);
 
3638
 
 
3639
                nih_free (message);
 
3640
                nih_free (class);
 
3641
        }
 
3642
}
 
3643
 
3235
3644
 
3236
3645
int
3237
3646
main (int   argc,
3256
3665
        test_get_description ();
3257
3666
        test_get_author ();
3258
3667
        test_get_version ();
 
3668
        test_get_start_on ();
 
3669
        test_get_stop_on ();
 
3670
        test_get_emits ();
3259
3671
 
3260
3672
        return 0;
3261
3673
}