Home | History | Annotate | Download | only in jni 
      1 // { dg-do "run" }
      2 #include <cassert>
      3 
      4 struct A
      5 {
      6   double a;
      7   double b;
      8 };
      9 
     10 struct B
     11 {
     12   A a;
     13 };
     14 
     15 struct C
     16 : public A { };
     17 
     18 struct D
     19 {
     20   D& operator=(const D&) throw() { return *this; }
     21 };
     22 
     23 struct E
     24 {
     25   E& operator=(const E&) throw(int) { return *this; }
     26 };
     27 
     28 struct E1
     29 {
     30   E1& operator=(const E1&) throw(int) { throw int(); return *this; }
     31 };
     32 
     33 struct F
     34 {
     35   F() throw(int) { }
     36 };
     37 
     38 struct G
     39 {
     40   G() throw(int) { throw int(); }
     41 };
     42 
     43 struct H
     44 {
     45   H& operator=(H&) throw(int) { return *this; }
     46 };
     47 
     48 struct H1
     49 {
     50   H1& operator=(H1&) throw(int) { throw int(); return *this; }
     51 };
     52 
     53 struct I
     54 {
     55   I& operator=(I&) throw(int) { return *this; }
     56   I& operator=(const I&) throw() { return *this; }
     57 };
     58 
     59 struct I1
     60 {
     61   I1& operator=(I1&) throw(int) { throw int(); return *this; }
     62   I1& operator=(const I1&) throw() { return *this; }
     63 };
     64 
     65 struct J
     66 {
     67   J& operator=(J&) throw() { return *this; }
     68   J& operator=(const J&) throw() { return *this; }
     69   J& operator=(volatile J&) throw() { return *this; }
     70   J& operator=(const volatile J&) throw() { return *this; }
     71 };
     72 
     73 struct K
     74 {
     75   K& operator=(K&) throw() { return *this; }
     76 };
     77 
     78 struct L
     79 {
     80   L& operator=(const L&) throw() { return *this; }
     81 };
     82 
     83 template<typename T>
     84   bool
     85   f()
     86   { return __has_nothrow_assign(T); }
     87 
     88 template<typename T>
     89   class My
     90   {
     91   public:
     92     bool
     93     f()
     94     { return !!__has_nothrow_assign(T); }
     95   };
     96 
     97 template<typename T>
     98   class My2
     99   {
    100   public:
    101     static const bool trait = __has_nothrow_assign(T);
    102   };
    103 
    104 template<typename T>
    105   const bool My2<T>::trait;
    106 
    107 template<typename T, bool b = __has_nothrow_assign(T)>
    108   struct My3_help
    109   { static const bool trait = b; };
    110 
    111 template<typename T, bool b>
    112   const bool My3_help<T, b>::trait;
    113 
    114 template<typename T>
    115   class My3
    116   {
    117   public:
    118     bool
    119     f()
    120     { return My3_help<T>::trait; }
    121   };
    122 
    123 #define PTEST(T) (__has_nothrow_assign(T) && f<T>() \
    124                   && My<T>().f() && My2<T>::trait && My3<T>().f())
    125 
    126 #define NTEST(T) (!__has_nothrow_assign(T) && !f<T>() \
    127                   && !My<T>().f() && !My2<T>::trait && !My3<T>().f())
    128 
    129 int main()
    130 {
    131   assert (PTEST (int));
    132   assert (NTEST (int (int)));
    133   assert (NTEST (void));
    134   assert (PTEST (A));
    135   assert (PTEST (B));
    136   assert (PTEST (C));
    137   assert (NTEST (C[]));
    138   assert (PTEST (D));
    139   assert (NTEST (E));
    140   assert (NTEST (E1));
    141   assert (PTEST (F));
    142   assert (PTEST (G));
    143   assert (NTEST (H));
    144   assert (NTEST (H1));
    145   assert (NTEST (I));
    146   assert (NTEST (I1));
    147   assert (PTEST (J));
    148   assert (NTEST (const K));
    149   assert (NTEST (const L));
    150 
    151   return 0;
    152 }
    153