dlls/comctl32/tests/msg.c

   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 static 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 && expected->flags & optional)
 133                 {
 134                     expected++;
 135                     continue;
 136                 }
 137                 if (expected->id != actual->id && todo)
 138                 {
 139                     todo_wine
 140                     {
 141                         failcount++;
 142                         ok_(file, line) (FALSE,
 143                             "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
 144                             context, expected->message, expected->id, actual->id);
 145                     }
 146                 }
 147                 else
 148                 {
 149                     ok_(file, line) (expected->id == actual->id,
 150                         "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
 151                         context, expected->message, expected->id, actual->id);
 152                 }
 153             }
 154
 155             if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
 156             {
 157                 todo_wine
 158                 {
 159                     failcount++;
 160                     ok_(file, line) (FALSE,
 161                         "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
 162                         context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
 163                 }
 164             }
 165             else
 166             {
 167                 ok_(file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
 168                     "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
 169                     context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
 170             }
 171
 172             ok_(file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
 173                 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
 174                 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
 175             ok_(file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
 176                 "%s: the msg 0x%04x should have been %s\n",
 177                 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
 178             ok_(file, line) ((expected->flags & parent) == (actual->flags & parent),
 179                 "%s: the msg 0x%04x was expected in %s\n",
 180                 context, expected->message, (expected->flags & parent) ? "parent" : "child");
 181             ok_(file, line) ((expected->flags & hook) == (actual->flags & hook),
 182                 "%s: the msg 0x%04x should have been sent by a hook\n",
 183                 context, expected->message);
 184             ok_(file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
 185                 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
 186                 context, expected->message);
 187             expected++;
 188             actual++;
 189         }
 190         else if (expected->flags & optional)
 191             expected++;
 192         else if (todo)
 193         {
 194             failcount++;
 195             todo_wine
 196             {
 197                 ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
 198                     context, expected->message, actual->message);
 199             }
 200
 201             flush_sequence(seq, sequence_index);
 202             return;
 203         }
 204         else
 205         {
 206             ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
 207                 context, expected->message, actual->message);
 208             expected++;
 209             actual++;
 210         }
 211     }
 212
 213     /* skip all optional trailing messages */
 214     while (expected->message && ((expected->flags & optional)))
 215         expected++;
 216
 217     if (todo)
 218     {
 219         todo_wine
 220         {
 221             if (expected->message || actual->message)
 222             {
 223                 failcount++;
 224                 ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
 225                     context, expected->message, actual->message);
 226             }
 227         }
 228     }
 229     else if (expected->message || actual->message)
 230     {
 231         ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
 232             context, expected->message, actual->message);
 233     }
 234
 235     if(todo && !failcount) /* succeeded yet marked todo */
 236     {
 237         todo_wine
 238         {
 239             ok_(file, line)(TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
 240         }
 241     }
 242
 243     flush_sequence(seq, sequence_index);
 244 }
 245
 246 void init_msg_sequences(struct msg_sequence **seq, int n)
 247 {
 248     int i;
 249
 250     for (i = 0; i < n; i++)
 251         seq[i] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct msg_sequence));
 252 }
 253
 254 START_TEST(msg)
 255 {
 256 }