[TestCppIncompleteTypes] Remove the dependence on std::string.

test/lang/cpp/incomplete-types/Makefile

 LEVEL = ../../../make
 
-CXX_SOURCES = main.cpp length.cpp
+CXX_SOURCES = main.cpp length.cpp a.cpp
 
 CFLAGS_LIMIT = -c $(CXXFLAGS)
 CFLAGS_NO_LIMIT = -c $(CXXFLAGS)
 
 ifneq (,$(findstring clang,$(CC)))
   CFLAGS_LIMIT += -flimit-debug-info
   CFLAGS_NO_LIMIT += -fno-limit-debug-info
 endif
 
 all: limit nolimit
 
-limit: main.o length_limit.o
-  $(CXX) $(LDFLAGS) main.o length_limit.o -o limit
+limit: main.o length_limit.o a.o
+  $(CXX) $(LDFLAGS) main.o length_limit.o a.o -o limit
 
-nolimit: main.o length_nolimit.o
-  $(CXX) $(LDFLAGS) main.o length_nolimit.o -o nolimit
+nolimit: main.o length_nolimit.o a.o
+  $(CXX) $(LDFLAGS) main.o length_nolimit.o a.o -o nolimit
 
 main.o: main.cpp
   $(CXX) $(CFLAGS_LIMIT) main.cpp -o main.o
 
 length_limit.o: length.cpp
   $(CXX) $(CFLAGS_LIMIT) length.cpp -o length_limit.o
 
 length_nolimit.o: length.cpp
   $(CXX) $(CFLAGS_NO_LIMIT) length.cpp -o length_nolimit.o
 
+a.o: a.cpp
+  $(CXX) -c a.cpp -o a.o
+
 clean: OBJECTS += limit nolimit length_limit.o length_nolimit.o
 
 include $(LEVEL)/Makefile.rules

test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py

class TestCppIncompleteTypes(TestBase):
     def test_with_dwarf_limit_debug_info(self):
         self.buildDwarf()
         frame = self.get_test_frame('limit')
 
         value_f = frame.EvaluateExpression("f")
         self.assertTrue(value_f.IsValid(), "'expr f' results in a valid SBValue object")
         self.assertFalse(value_f.GetError().Success(), "'expr f' results in an error, but LLDB does not crash")
 
-        value_s = frame.EvaluateExpression("s")
-        self.assertTrue(value_s.IsValid(), "'expr s' results in a valid SBValue object")
-        self.assertFalse(value_s.GetError().Success(), "'expr s' results in an error, but LLDB does not crash")
+        value_a = frame.EvaluateExpression("a")
+        self.assertTrue(value_a.IsValid(), "'expr a' results in a valid SBValue object")
+        self.assertFalse(value_a.GetError().Success(), "'expr a' results in an error, but LLDB does not crash")
 
     @dwarf_test
     @skipIfGcc
     def test_with_dwarf_partial_limit_debug_info(self):
         self.buildDwarf()
         frame = self.get_test_frame('nolimit')
 
         value_f = frame.EvaluateExpression("f")
         self.assertTrue(value_f.IsValid(), "'expr f' results in a valid SBValue object")
         self.assertTrue(value_f.GetError().Success(), "'expr f' is successful")
 
-        value_s = frame.EvaluateExpression("s")
-        self.assertTrue(value_s.IsValid(), "'expr s' results in a valid SBValue object")
-        self.assertTrue(value_s.GetError().Success(), "'expr s' is successful")
+        value_a = frame.EvaluateExpression("a")
+        self.assertTrue(value_a.IsValid(), "'expr a' results in a valid SBValue object")
+        self.assertTrue(value_a.GetError().Success(), "'expr a' is successful")
 
     def setUp(self):
         TestBase.setUp(self)
 
     def get_test_frame(self, exe):
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)

test/lang/cpp/incomplete-types/a.h

+#ifndef __A_H__
+#define __A_H__
+
+class A
+{
+public:
+  A();
+  virtual int length();
+};
+
+#endif

test/lang/cpp/incomplete-types/a.cpp

+
+#include "a.h"
+
+A::A () { }
+
+int
+A::length ()
+{
+  return 123;
+}

test/lang/cpp/incomplete-types/length.h

 #ifndef __LENGTH_H__
 #define __LENGTH_H__
 
-#include <string>
+#include "a.h"
 
-size_t length (const std::string &str);
+int length (A &a);
 
 #endif

test/lang/cpp/incomplete-types/length.cpp

 
 #include "length.h"
 
-size_t
-length (const std::string &str)
+int
+length (A &a)
 {
-  return str.length();
+  return a.length();
 }

test/lang/cpp/incomplete-types/main.cpp

 
 #include "length.h"
 
 class Foo {
 public:
-    Foo(std::string x) : s(x) {}
-
-private:
-    std::string s;
+    A a;
 };
 
-class MyString : public std::string {
-public:
-    MyString(std::string x) : std::string(x) {}
+class MyA : public A {
 };
 
 int main()
 {
-    Foo f("qwerty");
-    MyString s("qwerty");
+    Foo f;
+    MyA a;
 
-    return length(s); // break here
+    return length(a); // break here
 }