cirrus: fix off-by-one in cirrus_bitblt_rop_bkwd_transp_*_16
[qemu.git] / tests / test-char.c
1 #include "qemu/osdep.h"
2
3 #include "qemu-common.h"
4 #include "qemu/config-file.h"
5 #include "sysemu/char.h"
6 #include "sysemu/sysemu.h"
7 #include "qapi/error.h"
8 #include "qmp-commands.h"
9
10 typedef struct FeHandler {
11 int read_count;
12 int last_event;
13 char read_buf[128];
14 } FeHandler;
15
16 static int fe_can_read(void *opaque)
17 {
18 FeHandler *h = opaque;
19
20 return sizeof(h->read_buf) - h->read_count;
21 }
22
23 static void fe_read(void *opaque, const uint8_t *buf, int size)
24 {
25 FeHandler *h = opaque;
26
27 g_assert_cmpint(size, <=, fe_can_read(opaque));
28
29 memcpy(h->read_buf + h->read_count, buf, size);
30 h->read_count += size;
31 }
32
33 static void fe_event(void *opaque, int event)
34 {
35 FeHandler *h = opaque;
36
37 h->last_event = event;
38 }
39
40 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
41 static void char_stdio_test_subprocess(void)
42 {
43 Chardev *chr;
44 CharBackend be;
45 int ret;
46
47 chr = qemu_chr_new("label", "stdio");
48 g_assert_nonnull(chr);
49
50 qemu_chr_fe_init(&be, chr, &error_abort);
51 qemu_chr_fe_set_open(&be, true);
52 ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
53 g_assert_cmpint(ret, ==, 4);
54
55 qemu_chr_fe_deinit(&be);
56 qemu_chr_delete(chr);
57 }
58
59 static void char_stdio_test(void)
60 {
61 g_test_trap_subprocess("/char/stdio/subprocess", 0, 0);
62 g_test_trap_assert_passed();
63 g_test_trap_assert_stdout("buf");
64 }
65 #endif
66
67
68 static void char_ringbuf_test(void)
69 {
70 QemuOpts *opts;
71 Chardev *chr;
72 CharBackend be;
73 char *data;
74 int ret;
75
76 opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
77 1, &error_abort);
78 qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
79
80 qemu_opt_set(opts, "size", "5", &error_abort);
81 chr = qemu_chr_new_from_opts(opts, NULL);
82 g_assert_null(chr);
83 qemu_opts_del(opts);
84
85 opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
86 1, &error_abort);
87 qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
88 qemu_opt_set(opts, "size", "2", &error_abort);
89 chr = qemu_chr_new_from_opts(opts, &error_abort);
90 g_assert_nonnull(chr);
91 qemu_opts_del(opts);
92
93 qemu_chr_fe_init(&be, chr, &error_abort);
94 ret = qemu_chr_fe_write(&be, (void *)"buff", 4);
95 g_assert_cmpint(ret, ==, 4);
96
97 data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
98 g_assert_cmpstr(data, ==, "ff");
99 g_free(data);
100
101 data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
102 g_assert_cmpstr(data, ==, "");
103 g_free(data);
104
105 qemu_chr_fe_deinit(&be);
106 qemu_chr_delete(chr);
107 }
108
109 static void char_mux_test(void)
110 {
111 QemuOpts *opts;
112 Chardev *chr, *base;
113 char *data;
114 FeHandler h1 = { 0, }, h2 = { 0, };
115 CharBackend chr_be1, chr_be2;
116
117 opts = qemu_opts_create(qemu_find_opts("chardev"), "mux-label",
118 1, &error_abort);
119 qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
120 qemu_opt_set(opts, "size", "128", &error_abort);
121 qemu_opt_set(opts, "mux", "on", &error_abort);
122 chr = qemu_chr_new_from_opts(opts, &error_abort);
123 g_assert_nonnull(chr);
124 qemu_opts_del(opts);
125
126 qemu_chr_fe_init(&chr_be1, chr, &error_abort);
127 qemu_chr_fe_set_handlers(&chr_be1,
128 fe_can_read,
129 fe_read,
130 fe_event,
131 &h1,
132 NULL, true);
133
134 qemu_chr_fe_init(&chr_be2, chr, &error_abort);
135 qemu_chr_fe_set_handlers(&chr_be2,
136 fe_can_read,
137 fe_read,
138 fe_event,
139 &h2,
140 NULL, true);
141 qemu_chr_fe_take_focus(&chr_be2);
142
143 base = qemu_chr_find("mux-label-base");
144 g_assert_cmpint(qemu_chr_be_can_write(base), !=, 0);
145
146 qemu_chr_be_write(base, (void *)"hello", 6);
147 g_assert_cmpint(h1.read_count, ==, 0);
148 g_assert_cmpint(h2.read_count, ==, 6);
149 g_assert_cmpstr(h2.read_buf, ==, "hello");
150 h2.read_count = 0;
151
152 /* switch focus */
153 qemu_chr_be_write(base, (void *)"\1c", 2);
154
155 qemu_chr_be_write(base, (void *)"hello", 6);
156 g_assert_cmpint(h2.read_count, ==, 0);
157 g_assert_cmpint(h1.read_count, ==, 6);
158 g_assert_cmpstr(h1.read_buf, ==, "hello");
159 h1.read_count = 0;
160
161 /* remove first handler */
162 qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL, NULL, true);
163 qemu_chr_be_write(base, (void *)"hello", 6);
164 g_assert_cmpint(h1.read_count, ==, 0);
165 g_assert_cmpint(h2.read_count, ==, 0);
166
167 qemu_chr_be_write(base, (void *)"\1c", 2);
168 qemu_chr_be_write(base, (void *)"hello", 6);
169 g_assert_cmpint(h1.read_count, ==, 0);
170 g_assert_cmpint(h2.read_count, ==, 6);
171 g_assert_cmpstr(h2.read_buf, ==, "hello");
172 h2.read_count = 0;
173
174 /* print help */
175 qemu_chr_be_write(base, (void *)"\1?", 2);
176 data = qmp_ringbuf_read("mux-label-base", 128, false, 0, &error_abort);
177 g_assert_cmpint(strlen(data), !=, 0);
178 g_free(data);
179
180 qemu_chr_fe_deinit(&chr_be1);
181 qemu_chr_fe_deinit(&chr_be2);
182 qemu_chr_delete(chr);
183 }
184
185 static void char_null_test(void)
186 {
187 Error *err = NULL;
188 Chardev *chr;
189 CharBackend be;
190 int ret;
191
192 chr = qemu_chr_find("label-null");
193 g_assert_null(chr);
194
195 chr = qemu_chr_new("label-null", "null");
196 chr = qemu_chr_find("label-null");
197 g_assert_nonnull(chr);
198
199 g_assert(qemu_chr_has_feature(chr,
200 QEMU_CHAR_FEATURE_FD_PASS) == false);
201 g_assert(qemu_chr_has_feature(chr,
202 QEMU_CHAR_FEATURE_RECONNECTABLE) == false);
203
204 /* check max avail */
205 qemu_chr_fe_init(&be, chr, &error_abort);
206 qemu_chr_fe_init(&be, chr, &err);
207 error_free_or_abort(&err);
208
209 /* deinit & reinit */
210 qemu_chr_fe_deinit(&be);
211 qemu_chr_fe_init(&be, chr, &error_abort);
212
213 qemu_chr_fe_set_open(&be, true);
214
215 qemu_chr_fe_set_handlers(&be,
216 fe_can_read,
217 fe_read,
218 fe_event,
219 NULL, NULL, true);
220
221 ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
222 g_assert_cmpint(ret, ==, 4);
223
224 qemu_chr_fe_deinit(&be);
225 qemu_chr_delete(chr);
226 }
227
228 static void char_invalid_test(void)
229 {
230 Chardev *chr;
231
232 chr = qemu_chr_new("label-invalid", "invalid");
233 g_assert_null(chr);
234 }
235
236 int main(int argc, char **argv)
237 {
238 g_test_init(&argc, &argv, NULL);
239
240 module_call_init(MODULE_INIT_QOM);
241 qemu_add_opts(&qemu_chardev_opts);
242
243 g_test_add_func("/char/null", char_null_test);
244 g_test_add_func("/char/invalid", char_invalid_test);
245 g_test_add_func("/char/ringbuf", char_ringbuf_test);
246 g_test_add_func("/char/mux", char_mux_test);
247 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
248 g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess);
249 g_test_add_func("/char/stdio", char_stdio_test);
250 #endif
251
252 return g_test_run();
253 }