dlls/shell32/tests/msg.h

   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 <assert.h>
  22 #include <windows.h>
  23
  24 #include "wine/heap.h"
  25 #include "wine/test.h"
  26
  27 /* undocumented SWP flags - from SDK 3.1 */
  28 #define SWP_NOCLIENTSIZE        0x0800
  29 #define SWP_NOCLIENTMOVE        0x1000
  30
  31 typedef enum
  32 {
  33     sent = 0x1,
  34     posted = 0x2,
  35     parent = 0x4,
  36     wparam = 0x8,
  37     lparam = 0x10,
  38     defwinproc = 0x20,
  39     beginpaint = 0x40,
  40     optional = 0x80,
  41     hook = 0x100,
  42     winevent_hook =0x200,
  43     id = 0x400
  44 } msg_flags_t;
  45
  46 struct message
  47 {
  48     UINT message;       /* the WM_* code */
  49     msg_flags_t flags;  /* message props */
  50     WPARAM wParam;      /* expected value of wParam */
  51     LPARAM lParam;      /* expected value of lParam */
  52     UINT id;            /* extra message data: id of the window,
  53                            notify code etc. */
  54 };
  55
  56 struct msg_sequence
  57 {
  58     int count;
  59     int size;
  60     struct message *sequence;
  61 };
  62
  63 static void add_message(struct msg_sequence **seq, int sequence_index,
  64     const struct message *msg)
  65 {
  66     struct msg_sequence *msg_seq = seq[sequence_index];
  67
  68     if (!msg_seq->sequence)
  69     {
  70         msg_seq->size = 10;
  71         msg_seq->sequence = heap_alloc(msg_seq->size * sizeof (struct message));
  72     }
  73
  74     if (msg_seq->count == msg_seq->size)
  75     {
  76         msg_seq->size *= 2;
  77         msg_seq->sequence = heap_realloc(msg_seq->sequence, msg_seq->size * sizeof (struct message));
  78     }
  79
  80     assert(msg_seq->sequence);
  81
  82     msg_seq->sequence[msg_seq->count].message = msg->message;
  83     msg_seq->sequence[msg_seq->count].flags = msg->flags;
  84     msg_seq->sequence[msg_seq->count].wParam = msg->wParam;
  85     msg_seq->sequence[msg_seq->count].lParam = msg->lParam;
  86     msg_seq->sequence[msg_seq->count].id = msg->id;
  87
  88     msg_seq->count++;
  89 }
  90
  91 static void flush_sequence(struct msg_sequence **seg, int sequence_index)
  92 {
  93     struct msg_sequence *msg_seq = seg[sequence_index];
  94     heap_free(msg_seq->sequence);
  95     msg_seq->sequence = NULL;
  96     msg_seq->count = msg_seq->size = 0;
  97 }
  98
  99 static void flush_sequences(struct msg_sequence **seq, int n)
 100 {
 101     int i;
 102
 103     for (i = 0; i < n; i++)
 104         flush_sequence(seq, i);
 105 }
 106
 107 static void ok_sequence_(struct msg_sequence **seq, int sequence_index,
 108     const struct message *expected, const char *context, BOOL todo,
 109     const char *file, int line)
 110 {
 111     struct msg_sequence *msg_seq = seq[sequence_index];
 112     static const struct message end_of_sequence = {0, 0, 0, 0};
 113     const struct message *actual, *sequence;
 114     int failcount = 0;
 115
 116     add_message(seq, sequence_index, &end_of_sequence);
 117
 118     sequence = msg_seq->sequence;
 119     actual = sequence;
 120
 121     while (expected->message && actual->message)
 122     {
 123         trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
 124
 125         if (expected->message == actual->message)
 126         {
 127             if (expected->flags & wparam)
 128             {
 129                 if (expected->wParam != actual->wParam && todo)
 130                 {
 131                     todo_wine
 132                     {
 133                         failcount++;
 134                         ok_(file, line) (FALSE,
 135                             "%s: in msg 0x%04x expecting wParam 0x%Ix got 0x%Ix\n",
 136                             context, expected->message, expected->wParam, actual->wParam);
 137                     }
 138                 }
 139                 else
 140                 {
 141                     ok_(file, line) (expected->wParam == actual->wParam,
 142                         "%s: in msg 0x%04x expecting wParam 0x%Ix got 0x%Ix\n",
 143                         context, expected->message, expected->wParam, actual->wParam);
 144                 }
 145             }
 146
 147             if (expected->flags & lparam)
 148             {
 149                 if (expected->lParam != actual->lParam && todo)
 150                 {
 151                     todo_wine
 152                     {
 153                         failcount++;
 154                         ok_(file, line) (FALSE,
 155                             "%s: in msg 0x%04x expecting lParam 0x%Ix got 0x%Ix\n",
 156                             context, expected->message, expected->lParam, actual->lParam);
 157                     }
 158                 }
 159                 else
 160                 {
 161                     ok_(file, line) (expected->lParam == actual->lParam,
 162                         "%s: in msg 0x%04x expecting lParam 0x%Ix got 0x%Ix\n",
 163                         context, expected->message, expected->lParam, actual->lParam);
 164                 }
 165             }
 166
 167             if (expected->flags & id)
 168             {
 169                 if (expected->id != actual->id && expected->flags & optional)
 170                 {
 171                     expected++;
 172                     continue;
 173                 }
 174                 if (expected->id != actual->id && todo)
 175                 {
 176                     todo_wine
 177                     {
 178                         failcount++;
 179                         ok_(file, line) (FALSE,
 180                             "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
 181                             context, expected->message, expected->id, actual->id);
 182                     }
 183                 }
 184                 else
 185                 {
 186                     ok_(file, line) (expected->id == actual->id,
 187                         "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
 188                         context, expected->message, expected->id, actual->id);
 189                 }
 190             }
 191
 192             if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
 193             {
 194                 todo_wine
 195                 {
 196                     failcount++;
 197                     ok_(file, line) (FALSE,
 198                         "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
 199                         context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
 200                 }
 201             }
 202             else
 203             {
 204                 ok_(file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
 205                     "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
 206                     context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
 207             }
 208
 209             ok_(file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
 210                 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
 211                 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
 212             ok_(file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
 213                 "%s: the msg 0x%04x should have been %s\n",
 214                 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
 215             ok_(file, line) ((expected->flags & parent) == (actual->flags & parent),
 216                 "%s: the msg 0x%04x was expected in %s\n",
 217                 context, expected->message, (expected->flags & parent) ? "parent" : "child");
 218             ok_(file, line) ((expected->flags & hook) == (actual->flags & hook),
 219                 "%s: the msg 0x%04x should have been sent by a hook\n",
 220                 context, expected->message);
 221             ok_(file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
 222                 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
 223                 context, expected->message);
 224             expected++;
 225             actual++;
 226         }
 227         else if (expected->flags & optional)
 228             expected++;
 229         else if (todo)
 230         {
 231             failcount++;
 232             todo_wine
 233             {
 234                 ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
 235                     context, expected->message, actual->message);
 236             }
 237
 238             flush_sequence(seq, sequence_index);
 239             return;
 240         }
 241         else
 242         {
 243             ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
 244                 context, expected->message, actual->message);
 245             expected++;
 246             actual++;
 247         }
 248     }
 249
 250     /* skip all optional trailing messages */
 251     while (expected->message && ((expected->flags & optional)))
 252         expected++;
 253
 254     if (todo)
 255     {
 256         todo_wine
 257         {
 258             if (expected->message || actual->message)
 259             {
 260                 failcount++;
 261                 ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
 262                     context, expected->message, actual->message);
 263             }
 264         }
 265     }
 266     else if (expected->message || actual->message)
 267     {
 268         ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
 269             context, expected->message, actual->message);
 270     }
 271
 272     if(todo && !failcount) /* succeeded yet marked todo */
 273     {
 274         todo_wine
 275         {
 276             ok_(file, line)(TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
 277         }
 278     }
 279
 280     flush_sequence(seq, sequence_index);
 281 }
 282
 283 #define ok_sequence(seq, index, exp, contx, todo) \
 284         ok_sequence_(seq, index, (exp), (contx), (todo), __FILE__, __LINE__)
 285
 286
 287 static void init_msg_sequences(struct msg_sequence **seq, int n)
 288 {
 289     int i;
 290
 291     for (i = 0; i < n; i++)
 292         seq[i] = heap_alloc_zero(sizeof(struct msg_sequence));
 293 }