Avoid using stdio in TestVirtual

[labath]

Summary

using stdio in tests does not work on windows, and it is not completely reliable on linux.
Avoid using stdio in this test, as it is not necessary for this purpose.

[clayborg]

packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py

64

Are we relying on std::string data formatters working here? Seems like a dangerous change as we would require any new ports of LLDB to have std::string formatters working or this test will fail?

[labath]

packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py

64

That did not occur to me. Would shoving the data into a char * be acceptable?

[clayborg]

I would just make a large buffer and use snprintf:

char buffer[4096];
char *p = buffer;
char *end = p + sizeof(buffer);
p += snprintf(p, end - p, "a_as_A->a() = '%s'\n", a_as_A->a());
p += snprintf(p, end - p, "a_as_A->b() = '%s'\n", a_as_A->b());

[labath]

New version, which does not rely on pretty-printers.

packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py

def test_virtual_madness(self):
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
         
         self.assertTrue(process.GetState() == lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(thread.IsValid(), "There should be a thread stopped due to breakpoint condition")
 
-        # First, capture the golden output from the program itself from the
-        # series of printf statements.
-        stdout = process.GetSTDOUT(1024)
-        
-        self.assertIsNotNone(stdout, "Encountered an error reading the process's output")
+        # First, capture the golden output from the program itself.
+        golden = thread.GetFrameAtIndex(0).FindVariable("golden")
+        self.assertTrue(golden.IsValid(), "Encountered an error reading the process's golden variable")
+        golden_str = str(golden)
+        self.assertTrue("c_as_C" in golden_str)
 
         # This golden list contains a list of "my_expr = 'value' pairs extracted
         # from the golden output.
         gl = []
 
         # Scan the golden output line by line, looking for the pattern:
         #
         #     my_expr = 'value'
         #
-        for line in stdout.split(os.linesep):
+        for line in golden_str.split(os.linesep):
             match = self.pattern.search(line)
             if match:
                 my_expr, val = match.group(1), match.group(2)
                 gl.append((my_expr, val))
         #print("golden list:", gl)
 
         # Now iterate through the golden list, comparing against the output from
         # 'expression var'.
         for my_expr, val in gl:
 
             self.runCmd("expression %s" % my_expr)
             output = self.res.GetOutput()
             
             # The expression output must match the oracle.
             self.expect(output, Msg(my_expr, val), exe=False,
                 substrs = [val])

packages/Python/lldbsuite/test/lang/cpp/virtual/main.cpp

-#include <stdio.h>
-#include <stdint.h>
+#include <string>
 
 class A
 {
 public:
     A () : m_pad ('c') {}
 
     virtual ~A () {}
     

 int main (int argc, char const *argv[], char const *envp[])
 {
     A *a_as_A = new A();
     B *b_as_B = new B();
     A *b_as_A = b_as_B;
     C *c_as_C = new C();
     A *c_as_A = c_as_C;
 
-    printf ("a_as_A->a() = '%s'\n", a_as_A->a());
-    printf ("a_as_A->b() = '%s'\n", a_as_A->b());
-    printf ("a_as_A->c() = '%s'\n", a_as_A->c());
-    printf ("b_as_A->a() = '%s'\n", b_as_A->a());
-    printf ("b_as_A->b() = '%s'\n", b_as_A->b());
-    printf ("b_as_A->c() = '%s'\n", b_as_A->c());
-    printf ("b_as_B->aa() = '%s'\n", b_as_B->aa());
-    printf ("c_as_A->a() = '%s'\n", c_as_A->a());
-    printf ("c_as_A->b() = '%s'\n", c_as_A->b());
-    printf ("c_as_A->c() = '%s'\n", c_as_A->c());
-    printf ("c_as_C->aa() = '%s'\n", c_as_C->aa());
-    puts("");// Set first breakpoint here.
+    std::string golden;
+    golden += std::string("a_as_A->a() = '") + a_as_A->a() + "'\n";
+    golden += std::string("a_as_A->b() = '") + a_as_A->b() + "'\n";
+    golden += std::string("a_as_A->c() = '") + a_as_A->c() + "'\n";
+    golden += std::string("b_as_A->a() = '") + b_as_A->a() + "'\n";
+    golden += std::string("b_as_A->b() = '") + b_as_A->b() + "'\n";
+    golden += std::string("b_as_A->c() = '") + b_as_A->c() + "'\n";
+    golden += std::string("b_as_B->aa() = '") + b_as_B->aa() + "'\n";
+    golden += std::string("c_as_A->a() = '") + c_as_A->a() + "'\n";
+    golden += std::string("c_as_A->b() = '") + c_as_A->b() + "'\n";
+    golden += std::string("c_as_A->c() = '") + c_as_A->c() + "'\n";
+    golden += std::string("c_as_C->aa() = '") + c_as_C->aa() + "'\n";
+    return 0;// Set first breakpoint here.
     // then evaluate:
     // expression a_as_A->a()
     // expression a_as_A->b()
     // expression a_as_A->c()
     // expression b_as_A->a()
     // expression b_as_A->b()
     // expression b_as_A->c()
     // expression b_as_B->aa()
     // expression c_as_A->a()
     // expression c_as_A->b()
     // expression c_as_A->c()
     // expression c_as_C->aa()
-    
-    return 0;
 }