← Back to branch summary

~ubuntu-branches/ubuntu/natty/vlock/natty

« back to all changes in this revision

Viewing changes to tests/test_list.c

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Wirt
  • Date: 2008-06-17 17:13:25 UTC
  • mfrom: (1.1.2 upstream) (3.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080617171325-ic8yy6tol0165i96
Tags: 2.2.2-3
* Don't try to chgrp to "vlock" during build time (Closes: #486665)
* Bump standards version (No changes)

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_list.c
 
1
#include <CUnit/CUnit.h>
 
2
 
 
3
#include "list.h"
 
4
 
 
5
#include "test_list.h"
 
6
 
 
7
void test_list_new(void)
 
8
{
 
9
  struct list *l = list_new();
 
10
 
 
11
  CU_ASSERT_PTR_NOT_NULL_FATAL(l);
 
12
  CU_ASSERT_PTR_NULL(l->first);
 
13
  CU_ASSERT_PTR_NULL(l->last);
 
14
 
 
15
  list_free(l);
 
16
}
 
17
 
 
18
void test_list_copy(void)
 
19
{
 
20
  struct list *l = list_new();
 
21
  struct list *m;
 
22
 
 
23
  list_append(l, (void *)1);
 
24
  list_append(l, (void *)2);
 
25
  list_append(l, (void *)3);
 
26
 
 
27
  m = list_copy(l);
 
28
 
 
29
  CU_ASSERT_EQUAL(list_length(l), list_length(m));
 
30
  CU_ASSERT_PTR_NOT_EQUAL(l, m);
 
31
 
 
32
  for (struct list_item *item_l = l->first, *item_m = m->first;
 
33
      item_l != NULL && item_m != NULL;
 
34
      item_l = item_l->next, item_m = item_m->next) {
 
35
    CU_ASSERT_PTR_EQUAL(item_l->data, item_m->data);
 
36
    CU_ASSERT_PTR_NOT_EQUAL(item_l, item_m);
 
37
  }
 
38
 
 
39
  list_free(m);
 
40
  list_free(l);
 
41
}
 
42
 
 
43
void test_list_free(void)
 
44
{
 
45
  struct list *l = list_new();
 
46
 
 
47
  list_append(l, (void *)1);
 
48
  list_append(l, (void *)2);
 
49
  list_append(l, (void *)3);
 
50
 
 
51
  list_free(l);
 
52
 
 
53
  CU_PASS("list_free() didn't crash");
 
54
}
 
55
 
 
56
void test_list_length(void)
 
57
{
 
58
  struct list *l = list_new();
 
59
 
 
60
  CU_ASSERT(list_length(l) == 0);
 
61
 
 
62
  list_append(l, (void *)1);
 
63
  CU_ASSERT(list_length(l) == 1);
 
64
 
 
65
  list_append(l, (void *)2);
 
66
  CU_ASSERT(list_length(l) == 2);
 
67
 
 
68
  list_append(l, (void *)3);
 
69
  CU_ASSERT(list_length(l) == 3);
 
70
 
 
71
  list_append(l, (void *)4);
 
72
  CU_ASSERT(list_length(l) == 4);
 
73
 
 
74
  list_free(l);
 
75
}
 
76
 
 
77
void test_list_append(void)
 
78
{
 
79
  struct list *l = list_new();
 
80
 
 
81
  list_append(l, (void *)1);
 
82
 
 
83
  CU_ASSERT_PTR_EQUAL(l->first, l->last);
 
84
  CU_ASSERT_PTR_NULL(l->first->previous);
 
85
  CU_ASSERT_PTR_NULL(l->last->next);
 
86
 
 
87
  CU_ASSERT_PTR_EQUAL(l->first->data, (void *)1);
 
88
 
 
89
  list_append(l, (void *)2);
 
90
 
 
91
  CU_ASSERT_PTR_NOT_EQUAL(l->first, l->last);
 
92
  CU_ASSERT_PTR_EQUAL(l->first->next, l->last);
 
93
  CU_ASSERT_PTR_EQUAL(l->last->previous, l->first);
 
94
  CU_ASSERT_PTR_NULL(l->first->previous);
 
95
  CU_ASSERT_PTR_NULL(l->last->next);
 
96
 
 
97
  CU_ASSERT_PTR_EQUAL(l->last->data, (void *)2);
 
98
 
 
99
  list_append(l, (void *)3);
 
100
 
 
101
  CU_ASSERT_PTR_EQUAL(l->first->next, l->last->previous);
 
102
  CU_ASSERT_PTR_EQUAL(l->last->previous->previous, l->first);
 
103
  CU_ASSERT_PTR_NULL(l->first->previous);
 
104
  CU_ASSERT_PTR_NULL(l->last->next);
 
105
 
 
106
  CU_ASSERT_PTR_EQUAL(l->last->data, (void *)3);
 
107
 
 
108
  list_free(l);
 
109
}
 
110
 
 
111
void test_list_delete_item(void)
 
112
{
 
113
  struct list *l = list_new();
 
114
 
 
115
  list_append(l, (void *)1);
 
116
 
 
117
  list_delete_item(l, l->first);
 
118
 
 
119
  CU_ASSERT_PTR_NULL(l->first);
 
120
  CU_ASSERT_PTR_NULL(l->last);
 
121
 
 
122
  list_append(l, (void *)1);
 
123
  list_append(l, (void *)2);
 
124
  list_append(l, (void *)3);
 
125
 
 
126
  list_delete_item(l, l->first->next);
 
127
 
 
128
  CU_ASSERT_PTR_EQUAL(l->first->next, l->last);
 
129
  CU_ASSERT_PTR_EQUAL(l->last->previous, l->first);
 
130
 
 
131
  CU_ASSERT_PTR_EQUAL(l->first->data, (void *)1)
 
132
  CU_ASSERT_PTR_EQUAL(l->last->data, (void *)3)
 
133
 
 
134
  list_free(l);
 
135
}
 
136
 
 
137
void test_list_delete(void)
 
138
{
 
139
  struct list *l = list_new();
 
140
 
 
141
  list_append(l, (void *)1);
 
142
  list_append(l, (void *)2);
 
143
  list_append(l, (void *)3);
 
144
 
 
145
  list_delete(l, (void *)2);
 
146
 
 
147
  CU_ASSERT_PTR_EQUAL(l->first->next, l->last);
 
148
  CU_ASSERT_PTR_EQUAL(l->last->previous, l->first);
 
149
 
 
150
  CU_ASSERT_PTR_EQUAL(l->first->data, (void *)1)
 
151
  CU_ASSERT_PTR_EQUAL(l->last->data, (void *)3)
 
152
 
 
153
  list_delete(l, (void *)1);
 
154
  list_delete(l, (void *)3);
 
155
 
 
156
  CU_ASSERT(list_length(l) == 0);
 
157
 
 
158
  list_delete(l, (void *)4);
 
159
 
 
160
  list_free(l);
 
161
}
 
162
 
 
163
void test_list_find(void)
 
164
{
 
165
  struct list *l = list_new();
 
166
 
 
167
  list_append(l, (void *)1);
 
168
  list_append(l, (void *)2);
 
169
  list_append(l, (void *)3);
 
170
 
 
171
  CU_ASSERT_PTR_EQUAL(list_find(l, (void *)2), l->first->next);
 
172
  CU_ASSERT_PTR_NULL(list_find(l, (void *)4));
 
173
  CU_ASSERT_PTR_NULL(list_find(l, NULL));
 
174
 
 
175
  list_free(l);
 
176
}
 
177
 
 
178
CU_TestInfo list_tests[] = {
 
179
  { "test_list_new", test_list_new },
 
180
  { "test_list_copy", test_list_copy },
 
181
  { "test_list_free", test_list_free },
 
182
  { "test_list_length", test_list_length },
 
183
  { "test_list_append", test_list_append },
 
184
  { "test_list_delete_item", test_list_delete_item },
 
185
  { "test_list_delete", test_list_delete },
 
186
  { "test_list_find", test_list_find },
 
187
  CU_TEST_INFO_NULL,
 
188
};