tests/test_nobug_resources_threaded.c

   1 #include "test.h"
   2 #include "nobug.h"
   3
   4 RESOURCE_HANDLE(t);
   5
   6 void* threadfn(void* nop)
   7 {
   8   enum nobug_resource_state threadenter = (enum nobug_resource_state) nop;
   9   NOBUG_THREAD_ID_SET("thread");
  10
  11   RESOURCE_USER(e);
  12   RESOURCE_USER_INIT(e);
  13   ECHO ("thread startup");
  14
  15   if (threadenter != NOBUG_RESOURCE_WAITING)
  16     {
  17       ECHO ("enter via wait");
  18       RESOURCE_WAIT(NOBUG_ON, t, "thread", e);
  19       NOBUG_RESOURCE_STATE(NOBUG_ON, threadenter, e);
  20     }
  21   else
  22     {
  23       ECHO ("enter direct");
  24       RESOURCE_ENTER(NOBUG_ON, t, "thread", threadenter, e);
  25     }
  26
  27   RESOURCE_LEAVE(NOBUG_ON, e);
  28
  29   ECHO ("thread finished");
  30   return nop;
  31 }
  32
  33 void* bugfn(void* nop)
  34 {
  35   RESOURCE_USER(e);
  36   RESOURCE_USER_INIT(e);
  37
  38   ECHO ("thread startup, attach resource");
  39   RESOURCE_WAIT(NOBUG_ON, t, "thread", e);
  40   ECHO ("changing id");
  41
  42   NOBUG_THREAD_ID_SET("thread");
  43
  44   RESOURCE_LEAVE(NOBUG_ON, e);
  45   ECHO ("thread finished");
  46   return nop;
  47 }
  48
  49 TESTS_BEGIN
  50 NOBUG_THREAD_ID_SET("main");
  51 ECHO ("testing");
  52
  53 RESOURCE_HANDLE_INIT (t);
  54 RESOURCE_ANNOUNCE(NOBUG_ON, "type", "test", main, t);
  55
  56 TEST(resourcethreaded_ilg_threadid)
  57 {
  58   ECHO ("create thread");
  59   pthread_t h;
  60   pthread_create (&h, NULL, bugfn, NULL);
  61
  62   pthread_join (h, NULL);
  63   ECHO ("thread joined");
  64 }
  65
  66
  67 TEST(resourcethreaded_assert_state_waiting_ok)
  68 {
  69   RESOURCE_USER(e);
  70   RESOURCE_USER_INIT(e);
  71   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_WAITING, e);
  72
  73   RESOURCE_ASSERT_STATE(t, NOBUG_RESOURCE_WAITING);
  74
  75   RESOURCE_LEAVE(NOBUG_ON, e);
  76 }
  77
  78
  79 TEST(resourcethreaded_assert_state_exclusive_fail)
  80 {
  81   RESOURCE_USER(e);
  82   RESOURCE_USER_INIT(e);
  83   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_WAITING, e);
  84
  85   RESOURCE_ASSERT_STATE(t, NOBUG_RESOURCE_EXCLUSIVE);
  86
  87   RESOURCE_LEAVE(NOBUG_ON, e);
  88 }
  89
  90
  91 TEST(resourcethreaded_waiting_waiting)
  92 {
  93   RESOURCE_USER(e);
  94   RESOURCE_USER_INIT(e);
  95   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_WAITING, e);
  96
  97   ECHO ("create thread");
  98   pthread_t h;
  99   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_WAITING);
 100
 101   pthread_join (h, NULL);
 102   ECHO ("thread joined");
 103
 104   RESOURCE_LEAVE(NOBUG_ON, e);
 105 }
 106
 107 TEST(resourcethreaded_waiting_exclusive)
 108 {
 109   RESOURCE_USER(e);
 110   RESOURCE_USER_INIT(e);
 111   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_WAITING, e);
 112
 113   ECHO ("create thread");
 114   pthread_t h;
 115   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_EXCLUSIVE);
 116   pthread_join (h, NULL);
 117   ECHO ("thread joined");
 118
 119   RESOURCE_LEAVE(NOBUG_ON, e);
 120 }
 121
 122 TEST(resourcethreaded_waiting_recursive)
 123 {
 124   RESOURCE_USER(e);
 125   RESOURCE_USER_INIT(e);
 126   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_WAITING, e);
 127
 128   ECHO ("create thread");
 129   pthread_t h;
 130   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_RECURSIVE);
 131   pthread_join (h, NULL);
 132   ECHO ("thread joined");
 133
 134   RESOURCE_LEAVE(NOBUG_ON, e);
 135 }
 136
 137 TEST(resourcethreaded_waiting_shared)
 138 {
 139   RESOURCE_USER(e);
 140   RESOURCE_USER_INIT(e);
 141   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_WAITING, e);
 142
 143   ECHO ("create thread");
 144   pthread_t h;
 145   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_SHARED);
 146   pthread_join (h, NULL);
 147   ECHO ("thread joined");
 148
 149   RESOURCE_LEAVE(NOBUG_ON, e);
 150 }
 151
 152
 153
 154
 155 TEST(resourcethreaded_exclusive_waiting)
 156 {
 157   RESOURCE_USER(e);
 158   RESOURCE_USER_INIT(e);
 159   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_EXCLUSIVE, e);
 160
 161   ECHO ("create thread");
 162   pthread_t h;
 163   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_WAITING);
 164   pthread_join (h, NULL);
 165   ECHO ("thread joined");
 166
 167   RESOURCE_LEAVE(NOBUG_ON, e);
 168 }
 169
 170 TEST(resourcethreaded_exclusive_exclusive)
 171 {
 172   RESOURCE_USER(e);
 173   RESOURCE_USER_INIT(e);
 174   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_EXCLUSIVE, e);
 175
 176   ECHO ("create thread");
 177   pthread_t h;
 178   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_EXCLUSIVE);
 179   pthread_join (h, NULL);
 180   ECHO ("thread joined");
 181
 182   RESOURCE_LEAVE(NOBUG_ON, e);
 183 }
 184
 185 TEST(resourcethreaded_exclusive_recursive)
 186 {
 187   RESOURCE_USER(e);
 188   RESOURCE_USER_INIT(e);
 189   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_EXCLUSIVE, e);
 190
 191   ECHO ("create thread");
 192   pthread_t h;
 193   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_RECURSIVE);
 194   pthread_join (h, NULL);
 195   ECHO ("thread joined");
 196
 197   RESOURCE_LEAVE(NOBUG_ON, e);
 198 }
 199
 200 TEST(resourcethreaded_exclusive_shared)
 201 {
 202   RESOURCE_USER(e);
 203   RESOURCE_USER_INIT(e);
 204   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_EXCLUSIVE, e);
 205
 206   ECHO ("create thread");
 207   pthread_t h;
 208   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_SHARED);
 209   pthread_join (h, NULL);
 210   ECHO ("thread joined");
 211
 212   RESOURCE_LEAVE(NOBUG_ON, e);
 213 }
 214
 215
 216
 217
 218 TEST(resourcethreaded_recursive_waiting)
 219 {
 220   RESOURCE_USER(e);
 221   RESOURCE_USER_INIT(e);
 222   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_RECURSIVE, e);
 223
 224   ECHO ("create thread");
 225   pthread_t h;
 226   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_WAITING);
 227   pthread_join (h, NULL);
 228   ECHO ("thread joined");
 229
 230   RESOURCE_LEAVE(NOBUG_ON, e);
 231 }
 232
 233 TEST(resourcethreaded_recursive_exclusive)
 234 {
 235   RESOURCE_USER(e);
 236   RESOURCE_USER_INIT(e);
 237   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_RECURSIVE, e);
 238
 239   ECHO ("create thread");
 240   pthread_t h;
 241   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_EXCLUSIVE);
 242   pthread_join (h, NULL);
 243   ECHO ("thread joined");
 244
 245   RESOURCE_LEAVE(NOBUG_ON, e);
 246 }
 247
 248 TEST(resourcethreaded_recursive_recursive)
 249 {
 250   RESOURCE_USER(e);
 251   RESOURCE_USER_INIT(e);
 252   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_RECURSIVE, e);
 253
 254   ECHO ("create thread");
 255   pthread_t h;
 256   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_RECURSIVE);
 257   pthread_join (h, NULL);
 258   ECHO ("thread joined");
 259
 260   RESOURCE_LEAVE(NOBUG_ON, e);
 261 }
 262
 263 TEST(resourcethreaded_recursive_shared)
 264 {
 265   RESOURCE_USER(e);
 266   RESOURCE_USER_INIT(e);
 267   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_RECURSIVE, e);
 268
 269   ECHO ("create thread");
 270   pthread_t h;
 271   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_SHARED);
 272   pthread_join (h, NULL);
 273   ECHO ("thread joined");
 274
 275   RESOURCE_LEAVE(NOBUG_ON, e);
 276 }
 277
 278
 279
 280
 281 TEST(resourcethreaded_shared_waiting)
 282 {
 283   RESOURCE_USER(e);
 284   RESOURCE_USER_INIT(e);
 285   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_SHARED, e);
 286
 287   ECHO ("create thread");
 288   pthread_t h;
 289   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_WAITING);
 290   pthread_join (h, NULL);
 291   ECHO ("thread joined");
 292
 293   RESOURCE_LEAVE(NOBUG_ON, e);
 294 }
 295
 296 TEST(resourcethreaded_shared_exclusive)
 297 {
 298   RESOURCE_USER(e);
 299   RESOURCE_USER_INIT(e);
 300   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_SHARED, e);
 301
 302   ECHO ("create thread");
 303   pthread_t h;
 304   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_EXCLUSIVE);
 305   pthread_join (h, NULL);
 306   ECHO ("thread joined");
 307
 308   RESOURCE_LEAVE(NOBUG_ON, e);
 309 }
 310
 311 TEST(resourcethreaded_shared_recursive)
 312 {
 313   RESOURCE_USER(e);
 314   RESOURCE_USER_INIT(e);
 315   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_SHARED, e);
 316
 317   ECHO ("create thread");
 318   pthread_t h;
 319   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_RECURSIVE);
 320   pthread_join (h, NULL);
 321   ECHO ("thread joined");
 322
 323   RESOURCE_LEAVE(NOBUG_ON, e);
 324 }
 325
 326 TEST(resourcethreaded_shared_shared)
 327 {
 328   RESOURCE_USER(e);
 329   RESOURCE_USER_INIT(e);
 330   RESOURCE_ENTER(NOBUG_ON, t, "main", NOBUG_RESOURCE_SHARED, e);
 331
 332   ECHO ("create thread");
 333   pthread_t h;
 334   pthread_create (&h, NULL, threadfn, (void*)NOBUG_RESOURCE_SHARED);
 335   pthread_join (h, NULL);
 336   ECHO ("thread joined");
 337
 338   RESOURCE_LEAVE(NOBUG_ON, e);
 339 }
 340
 341 RESOURCE_FORGET(NOBUG_ON, t);
 342 TESTS_END