1 files changed, 593 insertions, 0 deletions
diff --git a/test/cedet/tests/test.cpp b/test/cedet/tests/test.cpp
new file mode 100644
index 00000000000..43887b084a1
--- /dev/null
+++ b/test/cedet/tests/test.cpp
@@ -0,0 +1,593 @@
+/* Test file for C++ language.
+ * Attempt to include as many aspects of the C++ language as possible.
+ * Do not include things tested in test.c since that shares the
+ * same language.
+ *
+ * $Id: test.cpp,v 1.1.2.1 2009/09/20 04:00:17 cyd Exp $
+ *
+ */
+
+/* An include test */
+#include <stdio.h>
+
+#include <cmath>
+
+#include "c++-test.hh"
+
+#include <c++-test.hh>
+
+double var1 = 1.2;
+
+int simple1(int a) {
+
+}
+
+struct foo1 {
+  int test;
+};
+
+struct foo2 : public foo1 {
+  const int foo21(int a, int b);
+  const int foo22(int a, int b) { return 1 }
+};
+
+/* Classes */
+class class1 {
+private:
+  int var11;
+  struct foo1 var12;
+public:
+  int p_var11;
+  struct foo p_var12;
+};
+
+class i_class1 : public class1 {
+private:
+  int var11;
+  struct foo var12;
+public:
+  int p_var11;
+  struct foo p_var12;
+};
+
+class class2 {
+private:
+  int var21;
+  struct foo var22;
+public:
+  int p_var21;
+  struct foo p_var22;
+};
+
+class i_class2 : public class1, public class2 {
+private:
+  int var21;
+  struct foo var22;
+protected:
+  int pt_var21;
+public:
+  int p_var21;
+  struct foo p_var22;
+};
+
+class class3 {
+  /* A class with strange things in it */
+public:
+  class3(); /* A constructor */
+  enum embedded_foo_enum {
+    a, b, c
+  } embed1;
+  struct embedded_bar_struct {
+    int a;
+    int b;
+  } embed2;
+  class embedded_baz_class {
+    embedded_baz_class();
+    ~embedded_baz_class();
+  } embed3;
+  ~class3(); /* destructor */
+  
+  /* Methods */
+  int method_for_class3(int a, char b);
+
+  int inline_method(int c) { return c; }
+
+  /* Operators */
+  class3& operator^= (const class3& something);
+
+  /* Funny declmods */
+  const class3 * const method_const_ptr_ptr(const int * const argconst) const = 0;
+};
+
+class3::class3()
+{
+  /* Constructor outside the definition. */
+}
+
+int class3::method_for_class3(int a, char b)
+{
+}
+
+int class3::method1_for_class3( int a, int &b)
+{
+  int cvariablename;
+  class3 fooy[];
+  class3 moose = new class3;
+
+  // Complktion testing line should find external members.
+  a = fooy[1].me ;
+  b = cv ;
+
+  if (fooy.emb) {
+    simple1(c);
+  }
+
+  cos(10);
+  abs(10);
+
+  return 1;
+}
+
+char class3::method2_for_class3( int a, int b) throw ( exception1 )
+{
+  return 'a';
+}
+
+void *class3::method3_for_class3( int a, int b) throw ( exception1, exception2 )
+{
+  int q = a;
+  return "Moose";
+}
+
+void *class3::method31_for_class3( int a, int b) throw ( )
+{
+  int q = a;
+  return "Moose";
+}
+
+void *class3::method4_for_class3( int a, int b) reentrant
+{
+  class3 ct;
+
+  ct.method5_for_class3(1,a);
+
+  pritf();
+}
+
+/*
+ * A method on class3.
+ */
+void *class3::method5_for_class3( int a, int b) const
+{
+}
+
+/*
+ * Namespace parsing tests
+ */
+namespace NS {
+  class class_in_namespace {
+    int equiv(const NS::class_in_namespace *) const;
+  };
+}
+
+int NS::class_in_namespace::equiv(const NS::class_in_namespace *cin) const
+{
+  return 0;
+}
+
+// Stuff Klaus found.
+// Inheritance w/out a specifying for public.
+class class4 : class1 {
+  // Pure virtual methods.
+  void virtual print () const = 0;
+
+public:
+  // The whacky constructor type
+  class4()
+    try : class1(args)
+  {
+    // constructor body	
+  }
+  catch ()
+    {
+      
+    }
+  
+
+};
+
+class class5 : public virtual class4 {
+  // Virtual inheritance
+};
+
+class class6 : class1 {
+  // Mutable
+  mutable int i;
+};
+
+/* Namespaces */
+namespace namespace1 {
+  void ns_method1() { }
+
+  class n_class1 {
+  public:
+    void method11(int a) { }
+  };
+
+  /* This shouldn't parse due to missing semicolon. */
+  class _n_class2 : public n_class1 {
+    void n_c2_method1(int a, int b) { }
+  };
+
+  // Macros in the namespace
+#define NSMACRO 1
+
+  // Template in the namespace
+  template<class T> T nsti1(const Foo& foo);
+  template<> int nsti1<int>(const Foo& foo);
+    
+}
+
+namespace namespace2 {
+
+  using namespace1::n_class1;
+
+}
+
+/* Initializers */
+void tinitializers1(): inita1(False),
+		       inita2(False)
+{
+  inita1= 1;
+}
+
+/* How about Extern C type things. */
+int funny_prototype(int ,int b,float c)
+{
+
+}
+
+extern "C"
+int extern_c_1(int a, int b)
+{
+
+  funny_prototype(1,2,3.4);
+
+  printf("Moose", );
+
+  return 1;
+}
+
+extern "C" {
+
+  int extern_c_2(int a, int b)
+  {
+    return 1;
+  }
+
+}
+
+// Some operator stuff
+class Action
+{
+  // Problems!! operator() and operator[] can not be parsed with semantic
+  // 1.4.2 but with latest c.by
+  virtual void operator()(int i, char *p ) = 0;
+  virtual String& operator[]() = 0;
+  virtual void operator!() = 0;
+  virtual void operator->() = 0;
+  virtual T& operator+=();
+  virtual T& operator*();
+  virtual T& operator*=();
+};
+
+// class with namespace qualified parents
+class Multiinherit : public virtual POA::Parent,
+                     public virtual POA::Parent1,
+                     Parent
+{
+private:
+  int i;
+
+public:
+  Multiinherit();
+  ~Multiinherit();
+
+  // method with a list of qualified exceptions
+  void* throwtest()
+    throw(Exception0,
+          Testnamespace::Exception1,
+          Testnamespace::Excpetion2,
+          Testnamespace::testnamespace1::Exception3);
+  
+};
+
+void*
+Multiinherit::throwtest()
+  throw (Exception0,
+         Testnamespace::Exception1,
+         Testnamespace::Excpetion2,
+         Testnamespace::testnamespace1::Exception3)
+{
+  return;
+}
+
+// Jens Rock <jens.rock@asamnet.de>: Nested classes or structs defined
+// outside of the containing class/struct.
+class container
+{
+ public:
+  struct contained;
+  container();
+  ~container();
+};
+
+struct container::contained
+{
+  public:
+  contained();
+  ~contained();
+};
+
+/*
+ * Ok, how about some template stuff.
+ */
+template <class CT, class container = vector<CT> >
+const CT& max (const CT& a, const CT& b)
+{
+  return a < b ? b : a;
+}
+
+// Arne Schmitz found this one
+std::vector<int> &a, &b, &c;
+
+class TemplateUsingClass
+{
+  typedef TestClassMap::iterator iterator;
+  typedef map<long, long> TestClassMap;
+
+  // typedefs with const and volatile
+  typedef const map<long, long> const_TestClassMap;
+  typedef TestClassMap<string>::iterator volatile volatile_iterator;
+
+  map<int, int> mapclassvarthingy;
+};
+
+template<class T> T ti1(const Foo& foo);
+template<> int ti1<int>(const Foo& foo);
+
+
+// -----------------------------------
+// Now some namespace and related stuff
+// -----------------------------------
+
+using CORBA::LEX::get_token;
+using Namespace1;
+
+using namespace POA::std;
+using namespace Test;
+
+
+
+namespace Parser
+{
+  namespace
+  {
+    using Lexer::get_test;
+    string str = "";
+  }
+  
+  namespace XXX
+  {
+    
+    class Foobar : public virtual POA::Parent,
+                   public virtual POA::Parent1,
+                   private POA::list<fact>,
+                   private map<string>
+    {
+      ini i;
+      list <shared_ptr<item> >::const_iterator l;
+    public:
+      
+      Foobar();
+      ~Foobar();
+    };
+  }
+  
+
+  void test_function(int i);
+    
+};
+
+// unnamed namespaces - even nested
+namespace
+{
+  namespace
+  {
+    using Lexer::get_test;
+    string str = "";
+  }
+
+  // some builtin types
+  long long ll = 0;
+  long double d = 0.0;
+  unsigned test;
+  unsigned long int **uli = 0;
+  signed si = 0;
+  signed short ss = 0;
+  short int i = 0;
+  long int li = 0;
+  
+  // expressions with namespace/class-qualifyiers
+  ORB_var cGlobalOrb = ORB::_nil();
+  ORB_var1 cGlobalOrb1 = ORB::_test;
+
+  class Testclass
+  {
+    #define TEST 0
+    ini i;
+
+  public:
+
+    Testclass();
+    ~Testclass();
+  };
+
+  static void test_function(unsigned int i);
+
+};
+
+
+// outside method implementations which should be grouped to type Test
+XXX&
+Test::waiting()
+{
+  return;
+}
+
+void
+Test::print()
+{
+  return;
+}
+
+// outside method implementations with namespaces which should be grouped to
+// their complete (incl. namespace) types
+void*
+Parser::XXX::Foobar::wait(int i, const char const * const * p)
+{
+  return;
+}
+
+void*
+Namespace1::Test::wait1(int i)
+{
+  return;
+}
+
+int
+Namespace1::Test::waiting(int i)
+{
+  return;
+}
+
+// a class with some outside implementations which should all be grouped to
+// this class declaration
+class ClassWithExternals
+{
+private:
+  int i;
+
+public:
+  ClassWithExternals();
+  ~ClassWithExternals();
+  void non_nil();
+};
+
+
+// Foobar is not displayed; seems that semantic tries to add this to the class
+// Foobar but can not find/display it, because contained in the namespace above.
+void
+Foobar::non_nil()
+{
+  return;
+}
+
+// are correctly grouped to the ClassWithExternals class
+void
+ClassWithExternals::non_nil()
+{
+  String s = "l�dfjg dlfgkdlfkgjdl";
+  return;
+}
+
+ClassWithExternals::ClassWithExternals()
+{
+  return;
+}
+
+void
+ClassWithExternals::~ClassWithExternals()
+{
+  return;
+}
+
+
+// -------------------------------
+// Now some macro and define stuff
+// -------------------------------
+
+#define TEST 0
+#define TEST1 "String"
+
+// The first backslash makes this macro unmatched syntax with semantic 1.4.2!
+// With flexing \+newline as nothing all is working fine!
+#define MZK_ENTER(METHOD) \
+{ \
+  CzkMethodLog lMethodLog(METHOD,"Framework");\
+}
+
+#define ZK_ASSERTM(METHOD,ASSERTION,MESSAGE) \
+   { if(!(ASSERTION))\
+      {\
+	std::ostringstream lMesgStream; \
+        lMesgStream << "Assertion failed: " \
+	<< MESSAGE; \
+        CzkLogManager::doLog(CzkLogManager::FATAL,"",METHOD, \
+        "Assert",lMesgStream); \
+        assert(ASSERTION);\
+      }\
+   }
+
+// Test if not newline-backslashes are handled correctly
+string s = "My \"quoted\" string";
+
+// parsed fine as macro
+#define FOO (arg) method(arg, "foo");
+
+// With semantic 1.4.2 this parsed as macro BAR *and* function method.
+// With latest c.bnf at least one-liner macros can be parsed correctly.
+#define BAR (arg) CzkMessageLog method(arg, "bar");
+
+// some const and volatile stuff
+char * p1 = "Hello"; // 1. variable Pointer, variable Data
+const char * p2 = "Hello"; // 2. variable pointer, constant data
+char * const p3 = "Hello"; // 3. constant pointer, variable data
+const char * const p4 = "Hello"; // 4. constant pointer, constant data
+
+// Case 2 and 4 can exchange first "const" and "char"
+char const * p21 = "Hello"; // variable pointer, constant data
+char const * const p41 = "Hello"; // constant pointer, constant data
+
+char volatile a = 0; // a volatile char
+void foo(bar const &arg); // a reference to a const bar
+int foobar(bar const * const p); // a const pointer to a const bar
+int foobar(bar const volatile * const p); // a const pointer to a const bar
+int foobar3(char* p); // a const pointer to a const bar
+
+// Should not be parsed because this is invalid code
+int const & const r3 = i;
+
+boolean i = 0;
+boolean & r1 = i;
+boolean const & r2 = i;
+
+// const * sequences can be very long in C++ ;-)
+char const * const * const * const * ppp;
+
+// complex function declarationen with named pointer-arguments
+const char** foobar1(volatile char const * const **p);
+const char** foobar11(volatile Test::Namespace::Char<char*> const * const **p);
+
+// complex function declarationen with unnamed pointer-arguments
+const char* foobar2(const char***);
+const char* foobar21(const Test::Namespace::Char<char>***);
+
+// string literal parsing even with wchar_t
+char const *p = "string1";
+char const *q = "string1" "str\"ing2" "string3";
+wchar_t testc = L'a';
+
+wchar_t const *wp = L"string with a \" in it";
+wchar_t const *wq = L"string \n\t\"test" L"string2";
+wchar_t const *wr = L"string L";