Subversion Repositories openrisc

// { dg-do "run" }

#include 

class A1

{

  double a;

  double b;

};

class A2

{

  double a;

  double b;

};

class B

: private A1 { };

class C

: private A1, private A2 { };

union U

{

  double a;

  double b;

};

template

  bool

  f()

  { return __is_base_of(T, U); }

template

  class My

  {

  public:

    bool

    f()

    { return !!__is_base_of(T, U); }

  };

template

  class My2

  {

  public:

    static const bool trait = __is_base_of(T, U);

  };

template

  const bool My2::trait;

template

  struct My3_help

  { static const bool trait = b; };

template

  const bool My3_help::trait;

template

  class My3

  {

  public:

    bool

    f()

    { return My3_help::trait; }

  };

#define PTEST(T, U) (__is_base_of(T, U) && f() \

                  && My().f() && My2::trait && My3().f())

#define NTEST(T, U) (!__is_base_of(T, U) && !f() \

                  && !My().f() && !My2::trait && !My3().f())

int main()

{

  assert (NTEST (int, A1));

  assert (NTEST (A1, void));

  assert (PTEST (A1, A1));

  assert (NTEST (A1*, A1*));

  assert (NTEST (A1&, A1&));

  assert (PTEST (A1, B));

  assert (NTEST (B, A1));

  assert (PTEST (A1, C));

  assert (PTEST (A2, C));

  assert (NTEST (C, A1));

  assert (PTEST (A1, const B));

  assert (NTEST (const B, A1));

  assert (PTEST (A1, volatile C));

  assert (PTEST (volatile A2, const C));

  assert (NTEST (const volatile C, A1));

  assert (NTEST (U, U));

  return 0;

}