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

   1 extern(C) int printf(const char*, ...);
   2
   3 void test14040()
   4 {
   5     uint[] values = [0, 1, 2, 3, 4, 5, 6, 7];
   6     uint offset = 0;
   7
   8     auto a1 = values[offset .. offset += 2];
   9     if (a1 != [0, 1] || offset != 2)
  10         assert(0);
  11
  12     uint[] fun()
  13     {
  14         offset += 2;
  15         return values;
  16     }
  17     auto a2 = fun()[offset .. offset += 2];
  18     if (a2 != [4, 5] || offset != 6)
  19         assert(0);
  20
  21     // Also test an offset of type size_t such that it is used
  22     // directly without any implicit conversion in the slice expression.
  23     size_t offset_szt = 0;
  24     auto a3 = values[offset_szt .. offset_szt += 2];
  25     if (a3 != [0, 1] || offset_szt != 2)
  26         assert(0);
  27 }
  28
  29 /******************************************/
  30
  31 int add8ret3(T)(ref T s)
  32 {
  33     s += 8;
  34     return 3;
  35 }
  36
  37 int mul11ret3(T)(ref T s)
  38 {
  39     s *= 11;
  40     return 3;
  41 }
  42
  43 void add()
  44 {
  45     static int test1(int val) { val += add8ret3(val); return val; }
  46     assert(test1(1) == (1 + 8 + 3));
  47     static assert(test1(1) == (1 + 8 + 3));
  48
  49     static int test2(int val) { val = val + add8ret3(val); return val; }
  50     // FIXME: assert(test2(1) == (1 + 3));
  51     static assert(test2(1) == (1 + 3));
  52
  53     static int test3(int val) { (val += 7) += mul11ret3(val); return val; }
  54     assert(test3(2) == (((2+7)*11) + 3));
  55     static assert(test3(2) == (((2+7)*11) + 3));
  56 }
  57
  58 void min()
  59 {
  60     static int test1(int val) { val -= add8ret3(val); return val; }
  61     assert(test1(1) == (1 + 8 - 3));
  62     static assert(test1(1) == (1 + 8 - 3));
  63
  64     static int test2(int val) { val = val - add8ret3(val); return val; }
  65     // FIXME: assert(test2(1) == (1 - 3));
  66     static assert(test2(1) == (1 - 3));
  67
  68     static int test3(int val) { (val -= 7) -= mul11ret3(val); return val; }
  69     assert(test3(2) == (((2-7)*11) - 3));
  70     static assert(test3(2) == (((2-7)*11) - 3));
  71 }
  72
  73 void mul()
  74 {
  75     static int test1(int val) { val *= add8ret3(val); return val; }
  76     assert(test1(7) == ((7 + 8) * 3));
  77     static assert(test1(7) == ((7 + 8) * 3));
  78
  79     static int test2(int val) { val = val * add8ret3(val); return val; }
  80     // FIXME: assert(test2(7) == (7 * 3));
  81     static assert(test2(7) == (7 * 3));
  82
  83     static int test3(int val) { (val *= 7) *= add8ret3(val); return val; }
  84     assert(test3(2) == (((2*7)+8) * 3));
  85     static assert(test3(2) == (((2*7)+8) * 3));
  86 }
  87
  88 void xor()
  89 {
  90     static int test1(int val) { val ^= add8ret3(val); return val; }
  91     assert(test1(1) == ((1 + 8) ^ 3));
  92     static assert(test1(1) == ((1 + 8) ^ 3));
  93
  94     static int test2(int val) { val = val ^ add8ret3(val); return val; }
  95     // FIXME: assert(test2(1) == (1 ^ 3));
  96     static assert(test2(1) == (1 ^ 3));
  97
  98     static int test3(int val) { (val ^= 7) ^= add8ret3(val); return val; }
  99     assert(test3(2) == (((2^7)+8) ^ 3));
 100     static assert(test3(2) == (((2^7)+8) ^ 3));
 101 }
 102
 103 void addptr()
 104 {
 105     static int* test1(int* val) { val += add8ret3(val); return val; }
 106     assert(test1(cast(int*)4) == ((cast(int*)4) + 8 + 3));
 107
 108     static int* test2(int* val) { val = val + add8ret3(val); return val; }
 109     // FIXME: assert(test2(cast(int*)4) == ((cast(int*)4) + 3));
 110
 111     static int* test3(int* val) { (val += 7) += add8ret3(val); return val; }
 112     assert(test3(cast(int*)16) == ((cast(int*)16) + 7 + 8 + 3));
 113 }
 114
 115 void lhsCast()
 116 {
 117     static byte test(byte val)
 118     {
 119         // lhs type `byte`, rhs type `int` =>
 120         // rewritten to `cast(int)(cast(int)val += 10) -= mul11ret3(val)`
 121         (val += 10) -= mul11ret3(val);
 122         return val;
 123     }
 124
 125     assert(test(1) == ((1 + 10) * 11 - 3));
 126     static assert(test(1) == ((1 + 10) * 11 - 3));
 127 }
 128
 129 void shr()
 130 {
 131     static ubyte test(ubyte val)
 132     {
 133         // lhs type `ubyte`, rhs type `int` =>
 134         // rewritten to `cast(int)val >>= 1`
 135         // we still want a logical (unsigned) right-shift though
 136         val >>= 1;
 137         return val;
 138     }
 139
 140     assert(test(0x80) == 0x40);
 141     static assert(test(0x80) == 0x40);
 142 }
 143
 144 void ldc_github_1617()
 145 {
 146     add();
 147     min();
 148     mul();
 149     xor();
 150     addptr();
 151     lhsCast();
 152     shr();
 153 }
 154
 155 /******************************************/
 156
 157 int main()
 158 {
 159     test14040();
 160     ldc_github_1617();
 161
 162     printf("Success\n");
 163     return 0;
 164 }