1 /* Message Sequence Testing Code
2 *
3 * Copyright (C) 2007 James Hawkins
4 * Copyright (C) 2007 Lei Zhang
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "msg.h"
22
23 void add_message(struct msg_sequence **seq, int sequence_index,
24 const struct message *msg)
25 {
26 struct msg_sequence *msg_seq = seq[sequence_index];
27
28 if (!msg_seq->sequence)
29 {
30 msg_seq->size = 10;
31 msg_seq->sequence = HeapAlloc(GetProcessHeap(), 0,
32 msg_seq->size * sizeof (struct message));
33 }
34
35 if (msg_seq->count == msg_seq->size)
36 {
37 msg_seq->size *= 2;
38 msg_seq->sequence = HeapReAlloc(GetProcessHeap(), 0,
39 msg_seq->sequence,
40 msg_seq->size * sizeof (struct message));
41 }
42
43 assert(msg_seq->sequence);
44
45 msg_seq->sequence[msg_seq->count].message = msg->message;
46 msg_seq->sequence[msg_seq->count].flags = msg->flags;
47 msg_seq->sequence[msg_seq->count].wParam = msg->wParam;
48 msg_seq->sequence[msg_seq->count].lParam = msg->lParam;
49 msg_seq->sequence[msg_seq->count].id = msg->id;
50
51 msg_seq->count++;
52 }
53
54 void flush_sequence(struct msg_sequence **seg, int sequence_index)
55 {
56 struct msg_sequence *msg_seq = seg[sequence_index];
57 HeapFree(GetProcessHeap(), 0, msg_seq->sequence);
58 msg_seq->sequence = NULL;
59 msg_seq->count = msg_seq->size = 0;
60 }
61
62 void flush_sequences(struct msg_sequence **seq, int n)
63 {
64 int i;
65
66 for (i = 0; i < n; i++)
67 flush_sequence(seq, i);
68 }
69
70 void ok_sequence_(struct msg_sequence **seq, int sequence_index,
71 const struct message *expected, const char *context, int todo,
72 const char *file, int line)
73 {
74 struct msg_sequence *msg_seq = seq[sequence_index];
75 static const struct message end_of_sequence = {0, 0, 0, 0};
76 const struct message *actual, *sequence;
77 int failcount = 0;
78
79 add_message(seq, sequence_index, &end_of_sequence);
80
81 sequence = msg_seq->sequence;
82 actual = sequence;
83
84 while (expected->message && actual->message)
85 {
86 trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
87
88 if (expected->message == actual->message)
89 {
90 if (expected->flags & wparam)
91 {
92 if (expected->wParam != actual->wParam && todo)
93 {
94 todo_wine
95 {
96 failcount++;
97 ok_(file, line) (FALSE,
98 "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
99 context, expected->message, expected->wParam, actual->wParam);
100 }
101 }
102 else
103 {
104 ok_(file, line) (expected->wParam == actual->wParam,
105 "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
106 context, expected->message, expected->wParam, actual->wParam);
107 }
108 }
109
110 if (expected->flags & lparam)
111 {
112 if (expected->lParam != actual->lParam && todo)
113 {
114 todo_wine
115 {
116 failcount++;
117 ok_(file, line) (FALSE,
118 "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
119 context, expected->message, expected->lParam, actual->lParam);
120 }
121 }
122 else
123 {
124 ok_(file, line) (expected->lParam == actual->lParam,
125 "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
126 context, expected->message, expected->lParam, actual->lParam);
127 }
128 }
129
130 if (expected->flags & id)
131 {
132 if (expected->id != actual->id && todo)
133 {
134 todo_wine
135 {
136 failcount++;
137 ok_(file, line) (FALSE,
138 "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
139 context, expected->message, expected->id, actual->id);
140 }
141 }
142 else
143 {
144 ok_(file, line) (expected->id == actual->id,
145 "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
146 context, expected->message, expected->id, actual->id);
147 }
148 }
149
150 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
151 {
152 todo_wine
153 {
154 failcount++;
155 ok_(file, line) (FALSE,
156 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
157 context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
158 }
159 }
160 else
161 {
162 ok_(file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
163 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
164 context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
165 }
166
167 ok_(file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
168 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
169 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
170 ok_(file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
171 "%s: the msg 0x%04x should have been %s\n",
172 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
173 ok_(file, line) ((expected->flags & parent) == (actual->flags & parent),
174 "%s: the msg 0x%04x was expected in %s\n",
175 context, expected->message, (expected->flags & parent) ? "parent" : "child");
176 ok_(file, line) ((expected->flags & hook) == (actual->flags & hook),
177 "%s: the msg 0x%04x should have been sent by a hook\n",
178 context, expected->message);
179 ok_(file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
180 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
181 context, expected->message);
182 expected++;
183 actual++;
184 }
185 else if (expected->flags & optional)
186 expected++;
187 else if (todo)
188 {
189 failcount++;
190 todo_wine
191 {
192 ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
193 context, expected->message, actual->message);
194 }
195
196 flush_sequence(seq, sequence_index);
197 return;
198 }
199 else
200 {
201 ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
202 context, expected->message, actual->message);
203 expected++;
204 actual++;
205 }
206 }
207
208 /* skip all optional trailing messages */
209 while (expected->message && ((expected->flags & optional)))
210 expected++;
211
212 if (todo)
213 {
214 todo_wine
215 {
216 if (expected->message || actual->message)
217 {
218 failcount++;
219 ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
220 context, expected->message, actual->message);
221 }
222 }
223 }
224 else if (expected->message || actual->message)
225 {
226 ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
227 context, expected->message, actual->message);
228 }
229
230 if(todo && !failcount) /* succeeded yet marked todo */
231 {
232 todo_wine
233 {
234 ok_(file, line)(TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
235 }
236 }
237
238 flush_sequence(seq, sequence_index);
239 }
240
241 void init_msg_sequences(struct msg_sequence **seq, int n)
242 {
243 int i;
244
245 for (i = 0; i < n; i++)
246 seq[i] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct msg_sequence));
247 }
248
249 START_TEST(msg)
250 {
251 }
252
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.