C++ (Cpp) assert_ulong_equal Examples

Example #1

File: utopiantreetests.c Project: Sobieck00/practice

void five_cycles(){
  int cycles = 5;

  long result = utopian_tree(cycles);

  assert_ulong_equal(14, result);
}

Example #2

File: utopiantreetests.c Project: Sobieck00/practice

void four_cycles(){
  int cycles = 4;

  long result = utopian_tree(cycles);

  assert_ulong_equal(7, result);
}

Example #3

File: utopiantreetests.c Project: Sobieck00/practice

void one_cycle(){
  int cycles = 1;

  long result = utopian_tree(cycles);

  assert_ulong_equal(2, result);
}

Example #4

File: utopiantreetests.c Project: Sobieck00/practice

void two_cycles(){
  int cycles = 2;

  long result = utopian_tree(cycles);

  assert_ulong_equal(3, result);
}

Example #5

File: utopiantreetests.c Project: Sobieck00/practice

void three_cycles(){
  int cycles = 3;

  long result = utopian_tree(cycles);

  assert_ulong_equal(6, result);
}

Example #6

File: test-slist.c Project: vdt/libcore

void test_slist_index(void)
{
    unsigned long *val;

    /* Index the front */
    val = slist_index(test_slist, 0);
    assert_ulong_equal(0, *val);

    /* Index the back */
    val = slist_index(test_slist, slist_size(test_slist) - 1);
    assert_ulong_equal(999, *val);

    /* Index some random place */
    val = slist_index(test_slist, 47);
    assert_ulong_equal(47, *val);
}

Example #7

File: utopiantreetests.c Project: Sobieck00/practice

void zero_cycles(){
  int cycles = 0;

  long result = utopian_tree(cycles);

  assert_ulong_equal(1, result);
}

Example #8

File: test-slist.c Project: vdt/libcore

void test_slist_prepend_to_empty(void)
{
    unsigned long *val = NULL;

    assert_true(test_slist == NULL);

    test_slist = slist_create();

    assert_true(test_slist != NULL);
    assert_true(slist_is_empty(test_slist));

    val = make_ulong_ptr(9999);
    assert_true(val != NULL);

    assert_true(slist_prepend(test_slist, val) == 0);

    /* Verify */
    val = NULL;
    val = slist_index(test_slist, 0);
    assert_true(val != NULL);
    assert_ulong_equal(9999, *val);
    assert_true(slist_size(test_slist) == 1);

    slist_free_all(test_slist, NULL);
    test_slist = NULL;
}

Example #9

File: test-slist.c Project: vdt/libcore

void test_slist_remove_index_from_existing(void)
{
    unsigned long *val;
    unsigned long old_size;

    old_size = slist_size(test_slist);

    /* Verify */
    val = NULL;
    val = slist_remove_index(test_slist, 0);
    assert_ulong_equal(0, *val);
    assert_true((old_size - 1) == slist_size(test_slist));

    free(val);
}

Example #10

File: test-slist.c Project: vdt/libcore

void test_slist_prepend_to_existing(void)
{
    unsigned long *val;
    unsigned long old_size;

    old_size = slist_size(test_slist);
    val = make_ulong_ptr(7777);
    assert_true(slist_prepend(test_slist, val) == 0);

    /* Verify */
    val = NULL;
    val = slist_index(test_slist, 0);
    assert_ulong_equal(7777, *val);
    assert_true((old_size + 1) == slist_size(test_slist));
}

Example #11

File: test-slist.c Project: vdt/libcore

void test_slist_insert_in_middle(void)
{
    unsigned long *val;
    unsigned long old_size;

    old_size = slist_size(test_slist);
    val = make_ulong_ptr(6666);
    assert_true(slist_insert(test_slist, old_size / 2, val) == 0);

    /* Verify */
    val = NULL;
    val = slist_index(test_slist, old_size / 2);
    assert_ulong_equal(6666, *val);
    assert_true((old_size + 1) == slist_size(test_slist));
}

Example #12

File: test-slist.c Project: vdt/libcore

void test_slist_insert_at_back(void)
{
    unsigned long *val;
    unsigned long old_size;

    old_size = slist_size(test_slist);
    val = make_ulong_ptr(7777);
    assert_true(slist_insert(test_slist, old_size, val) == 0);

    /* Verify */
    val = NULL;
    val = slist_index(test_slist, old_size);
    assert_ulong_equal(7777, *val);
    assert_true((old_size + 1) == slist_size(test_slist));
}

Example #13

File: test-slist.c Project: vdt/libcore

void test_slist_insert_at_front(void)
{
    unsigned long *val;
    unsigned long old_size;

    old_size = slist_size(test_slist);
    val = make_ulong_ptr(8888);
    assert_true(slist_insert(test_slist, 0, val) == 0);

    /* Verify */
    val = NULL;
    val = slist_index(test_slist, 0);
    assert_ulong_equal(8888, *val);
    assert_true((old_size + 1) == slist_size(test_slist));
}

Example #14

File: test-slist.c Project: vdt/libcore

void test_slist_remove_index_from_existing_until_empty(void)
{
    unsigned long *val;
    unsigned long i;

    val = NULL;
    i = slist_size(test_slist);
    while(i > 0) {
        val = slist_remove_index(test_slist, --i);
        assert_true(val != NULL);
        assert_ulong_equal(i, *val);
        assert_true(i == slist_size(test_slist));
    }

    assert_true(slist_is_empty(test_slist));
}

Example #15

File: test-slist.c Project: vdt/libcore

void test_slist_reverse_existing(void)
{
    unsigned long *val;
    unsigned long i, val_check;

    val = NULL;
    val_check = *(unsigned long *)slist_index(test_slist,
            slist_size(test_slist) - 1);

    assert_true(slist_reverse(test_slist) == 0);

    for(i = 0; i < slist_size(test_slist); i++, val_check--) {
        val = slist_index(test_slist, i);
        assert_true(val != NULL);
        assert_ulong_equal(*val, val_check);
    }
}

Example #16

File: test-dlist.c Project: vdt/libcore

void test_dlist_reverse_existing(void)
{
    unsigned long old_size, val_check;
    unsigned long *val;
    DListIterator *it;

    old_size = dlist_size(test_dlist);

    assert_true(dlist_reverse(test_dlist) == 0);

    /* Verify */
    val = NULL;
    assert_true(old_size == dlist_size(test_dlist));

    for(it = dlist_begin(test_dlist), val_check = 999;
            it != NULL; it = dlist_next(it), val_check--) {
        val = (unsigned long *)dlist_get_data(it);
        assert_ulong_equal(val_check, *val);
    }
}