gcc/testsuite/gdc.test/runnable/testthread2.d

   1 // PERMUTE_ARGS:
   2
   3 // Quick, dirty and inefficient AA using linear search, useful for testing.
   4 struct LinearAA(K, V) {
   5     K[] keys;
   6     V[] values;
   7
   8     V opIndex(K key) {
   9         foreach(i, k; keys) {
  10             if(k == key) {
  11                 return values[i];
  12             }
  13         }
  14
  15         assert(0, "Key not present.");
  16     }
  17
  18     V opIndexAssign(V val, K key) {
  19         foreach(i, k; keys) {
  20             if(k == key) {
  21                 return values[i] = val;
  22             }
  23         }
  24
  25         keys ~= key;
  26         values ~= val;
  27         return val;
  28     }
  29
  30     V* opBinaryRight(string op : "in")(K key) {
  31         foreach(i, k; keys) {
  32             if(key == k) {
  33                 return values.ptr + i;
  34             }
  35         }
  36
  37         return null;
  38     }
  39
  40     void remove(K key) {
  41         size_t i = 0;
  42         for(; i < keys.length; i++) {
  43             if(keys[i] == key) {
  44                 break;
  45             }
  46         }
  47
  48         assert(i < keys.length);
  49
  50         for(; i < keys.length - 1; i++) {
  51             keys[i] = keys[i + 1];
  52             values[i] = values[i + 1];
  53         }
  54
  55         keys = keys[0..$ - 1];
  56         values = values[0..$ - 1];
  57     }
  58
  59     size_t length() {
  60         return values.length;
  61     }
  62 }
  63
  64 extern (C) int rand();
  65
  66 uint random(const uint max = uint.max)
  67 {
  68     version (Windows)
  69     {
  70         // RAND_MAX is quite low for windows, extend the range by
  71         // abusing multiple random values and rounding errors.
  72         const a = rand(), b = rand();
  73         const c = a < b ? double(a) / b : double(b) / a;
  74         return (cast(int) (c * max)) % max;
  75     }
  76     else
  77         return rand() % max;
  78 }
  79
  80 void main()
  81 {
  82     foreach(iter; 0..10) {  // Bug only happens after a few iterations.
  83
  84         uint[size_t] builtin;
  85         LinearAA!(size_t, uint) linAA;
  86         uint[] nums = new uint[100_000];
  87         foreach(ref num; nums) {
  88             num = random();
  89         }
  90
  91         foreach(i; 0..10_000) {
  92             auto index = random(cast(uint) nums.length);
  93             if(index in builtin) {
  94                 assert(index in linAA);
  95                 assert(builtin[index] == nums[index]);
  96                 assert(linAA[index] == nums[index]);
  97                 builtin.remove(index);
  98                 linAA.remove(index);
  99             } else {
 100                 assert(!(index in linAA));
 101                 builtin[index] = nums[index];
 102                 linAA[index] = nums[index];
 103             }
 104         }
 105
 106         assert(builtin.length == linAA.length);
 107         foreach(k, v; builtin) {
 108             assert(k in linAA);
 109             assert(*(k in builtin) == *(k in linAA));
 110             assert(linAA[k] == v);
 111         }
 112     }
 113 }