← Back to branch summary

~0x44/agent-smith/script_changes_for_testing

« back to all changes in this revision

Viewing changes to tests/check_xen.c

  • Committer: Soren Hansen
  • Date: 2010-06-01 13:34:01 UTC
  • Revision ID: soren.hansen@rackspace.com-20100601133401-1g1k68na2dqzapy3
Import current code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/check_xen.c
 
1
#include <stdlib.h>
 
2
#include <stdio.h>
 
3
#include <string.h>
 
4
#include <check.h>
 
5
#include <xs.h>
 
6
#include "../src/xen.h"
 
7
 
 
8
/*
 
9
 * xen_init tests
 
10
 */
 
11
 
 
12
static struct xs_handle *xs_handle_dummy = (struct xs_handle *) 0x1234abcd;
 
13
 
 
14
static struct xs_handle *xs_daemon_open_success(void);
 
15
static struct xs_handle *xs_daemon_open_fail(void);
 
16
 
 
17
struct xs_handle *(*xs_daemon_open_handler)(void) = xs_daemon_open_success;
 
18
 
 
19
struct xs_handle *xs_daemon_open(void) {
 
20
    return xs_daemon_open_handler();
 
21
}
 
22
 
 
23
static struct xs_handle *xs_daemon_open_success(void) {
 
24
    return xs_handle_dummy;
 
25
}
 
26
 
 
27
static struct xs_handle *xs_daemon_open_fail(void) {
 
28
    return (struct xs_handle *) NULL;
 
29
}
 
30
 
 
31
START_TEST(test_xen_init_success)
 
32
{
 
33
    fail_if(xen_init(), "xen_init failed!");
 
34
}
 
35
END_TEST
 
36
 
 
37
START_TEST(test_xen_init_failure)
 
38
{
 
39
    xs_daemon_open_handler = xs_daemon_open_fail;
 
40
    fail_unless(xen_init(), "xen_init succeeded, but should've failed!");
 
41
}
 
42
END_TEST
 
43
 
 
44
/*
 
45
 * xen_register_watch tests
 
46
 */
 
47
 
 
48
extern void xen_fire_callback_real(const char *path, const char *token, void *buf, unsigned int buflen);
 
49
extern void *xen_read_path_real(const char *path, unsigned int *buflen);
 
50
 
 
51
#define test_read_path "/somepath/something"
 
52
#define test_watch_path "/somepath/something"
 
53
#define test_token "somedata"
 
54
#define test_data "some\0random\0date"
 
55
static int testcb_called = 0;
 
56
static const char *xs_read_watch_retval[] = { test_read_path, test_token };
 
57
static xs_transaction_t dummy_transaction;
 
58
 
 
59
 
 
60
static int testcb(const char *path, const char *buf, size_t buflen, const char *data) {
 
61
    fail_unless(strcmp(path,
 
62
                       "/somepath/something") == 0,
 
63
                "Data was at /somepath/something, but that's not what "
 
64
                "our callback was told.");
 
65
    fail_unless(buflen == sizeof(test_data),
 
66
                "Callback was called with an incorrectly sized size "
 
67
                "buffer");
 
68
    fail_unless(memcmp(buf, test_data, buflen) == 0,
 
69
                "Buffer passed to callback did not match the original "
 
70
                "data.");
 
71
    fail_unless(strcmp(data, test_token) == 0, "Token did not match");
 
72
    testcb_called = 1;
 
73
        return 0;
 
74
}
 
75
 
 
76
char **xs_read_watch(struct xs_handle *h, unsigned int *num) {
 
77
    *num = 2;
 
78
    return (char **) xs_read_watch_retval;
 
79
}
 
80
 
 
81
xs_transaction_t xs_transaction_start(struct xs_handle *h) {
 
82
    fail_unless(h == xs_handle_dummy,
 
83
                "Invalid xs_handle passed to xs_transaction_start");
 
84
    return dummy_transaction;
 
85
}
 
86
 
 
87
void *xs_read(struct xs_handle *h, xs_transaction_t t,
 
88
              const char *path, unsigned int *len)
 
89
{
 
90
    fail_unless(h == xs_handle_dummy,
 
91
                "Invalid xs_handle passed to xs_read");
 
92
    fail_unless(t == dummy_transaction,
 
93
                "Invalid transaction passed to xs_read");
 
94
    fail_unless(strcmp(path,
 
95
                       test_read_path) == 0,
 
96
                "Data was at /somepath/something, but that's not what "
 
97
                "xs_read was asked to read.");
 
98
 
 
99
    *len = sizeof(test_data);
 
100
    return test_data;
 
101
}
 
102
 
 
103
bool xs_watch(struct xs_handle *h, const char *path, const char *token) {
 
104
    fail_unless(h == xs_handle_dummy,
 
105
                "Invalid xs_handle passed to xs_watch");
 
106
    fail_unless(strcmp(path,
 
107
                       test_watch_path) == 0,
 
108
                "xs_watch asked to watch something other than " test_watch_path);
 
109
    fail_unless(strcmp(token,
 
110
                       test_token) == 0,
 
111
                "xs_watch was passed wrong token");
 
112
        return 1;
 
113
}
 
114
 
 
115
bool xs_transaction_end(struct xs_handle *h, xs_transaction_t t,
 
116
                        bool abort) {
 
117
    fail_unless(t == dummy_transaction,
 
118
                "Invalid transaction passed to xs_transaction_end");
 
119
    return 1;
 
120
}
 
121
 
 
122
void xen_fire_callback(const char *path, const char *token, void *buf,
 
123
                       unsigned int buflen) {
 
124
        return xen_fire_callback_real(path, token, buf, buflen);
 
125
}
 
126
 
 
127
void *xen_read_path(const char *path, unsigned int *buflen) {
 
128
        return xen_read_path_real(path, buflen);
 
129
}
 
130
 
 
131
 
 
132
START_TEST(test_xen_fire_callback)
 
133
{
 
134
    xen_init();
 
135
        xen_fire_callback_real(test_read_path, test_token, test_data, sizeof(test_data));
 
136
}
 
137
END_TEST
 
138
 
 
139
START_TEST(test_xen_read_path)
 
140
{
 
141
        unsigned int buflen;
 
142
        void *buf;
 
143
 
 
144
    xen_init();
 
145
        buf = xen_read_path_real(test_read_path, &buflen);
 
146
    fail_unless(buflen == sizeof(test_data),
 
147
                "xen_read_path altered the length of the data buffer");
 
148
    fail_unless(memcmp(buf, test_data, buflen) == 0,
 
149
                "xen_read_path mangled data buffer");
 
150
}
 
151
END_TEST
 
152
 
 
153
START_TEST(test_xen_wait_for_event)
 
154
{
 
155
    xs_daemon_open_handler = xs_daemon_open_success;
 
156
    xen_init();
 
157
    xen_register_watch(test_watch_path, testcb, (void *) test_token);
 
158
    xen_wait_for_event();
 
159
    fail_unless(testcb_called, "Callback didn't fire at all.");
 
160
}
 
161
END_TEST
 
162
 
 
163
Suite *xen_suite(void)
 
164
{
 
165
    Suite *s = suite_create("Xen");
 
166
 
 
167
    TCase *tc_xen_init = tcase_create("xen_init");
 
168
    tcase_add_test(tc_xen_init, test_xen_init_success);
 
169
    tcase_add_test(tc_xen_init, test_xen_init_failure);
 
170
    suite_add_tcase(s, tc_xen_init);
 
171
 
 
172
    TCase *tc_xen_read_path = tcase_create("xen_read_path");
 
173
    tcase_add_test(tc_xen_read_path, test_xen_read_path);
 
174
    suite_add_tcase(s, tc_xen_read_path);
 
175
 
 
176
    TCase *tc_xen_fire_callback = tcase_create("xen_fire_callback");
 
177
    tcase_add_test(tc_xen_fire_callback, test_xen_fire_callback);
 
178
    suite_add_tcase(s, tc_xen_fire_callback);
 
179
 
 
180
    TCase *tc_xen_wait_for_event = tcase_create("xen_wait_for_event");
 
181
    tcase_add_test(tc_xen_wait_for_event, test_xen_wait_for_event);
 
182
    suite_add_tcase(s, tc_xen_wait_for_event);
 
183
 
 
184
    return s;
 
185
}
 
186
 
 
187
int main(void)
 
188
{
 
189
    int number_failed;
 
190
 
 
191
    Suite *s = xen_suite();
 
192
    SRunner *sr = srunner_create(s);
 
193
    srunner_run_all(sr, CK_NORMAL);
 
194
    number_failed = srunner_ntests_failed(sr);
 
195
    srunner_free(sr);
 
196
    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 
197
}