Get test/types tests passing on remote targets

[vharron]

Summary

redirecting output to a path that will work well on host or target.
copying file from output location to location on local host that
test will read from

[ovyalov]

Please see my comments.

source/Commands/CommandObjectPlatform.cpp

2284

Why we don't need mkdir.. put-file commands in non-debug configurations?

test/types/AbstractBase.py

53

inside?

104–106

You may use "platform process launch" here in order to make it work either locally or remotely.

[vharron]

Looks like I got my diff backwards *blush*

[vharron]

Uses remote working directory for stdout redirect.

Better chance of working on Windows.

[ovyalov]

test/types/AbstractBase.py

107

You may use assertIsNotNone here.

107

https://github.com/llvm-mirror/lldb/blob/29b7ef5538c8f186ae9d5aa2758cebc1d1947c7e/test/lldbtest.py#L1681

It should not be a big deal but it seems lldb.remote_platform_working_dir is considered to be a main root directory and lldb.remote_platform.GetWorkingDirectory is a single test root. So, lldb.remote_platform.GetWorkingDirectory() might be a slightly more fine-grained option here.

109

s/process launch/platform process launch ?

189

Could you extract this logic into a separate method to use it here and within generic_type_tester?

[zturner]

test/types/AbstractBase.py

108–110

For portability this should use the python tempfile module, and also it should not use hardcoded paths like /foo

194–197

Same as above.

[zturner]

test/types/AbstractBase.py

192

Can you use

os.path.join(lldb.remote_platform_working_dir, "lldb-stdout-redirect.txt")

[vharron]

refactored process_launch_o into separate function
using os.path.join instead of string.format
using assertIsNotNone(

instead of assertNotEqual(None,

using lldb.remote_platform.GetWorkingDirectory()

instead of using lldb.remote_platform_working_dir

[zturner]

Would you mind doing the temp file changes too? It wasn't your code that
did it with hardcoded paths, but since you're in there anyway, maybe it's a
quick fix?

[vharron]

I don't see the path you're talking about.

[zturner]

The one you removed then added back in the first and second patch set. It
was /tmp/golden_file.txt or something

[zturner]

I think because it was removed then added back. It was in the diff of diff
1 vs. diff 2. Anyway it's no big deal if it's not easy

[clayborg]

lgtm

[vharron]

Friendly ping.

[zturner]

lgtm

[vharron]

Committed r228217

[vharron]

source/Commands/CommandObjectPlatform.cpp

CommandObjectMultiword (interpreter,
                             "platform [connect|disconnect|info|list|status|select] ...")
 {
     LoadSubCommand ("select", CommandObjectSP (new CommandObjectPlatformSelect (interpreter)));
     LoadSubCommand ("list"  , CommandObjectSP (new CommandObjectPlatformList (interpreter)));
     LoadSubCommand ("status", CommandObjectSP (new CommandObjectPlatformStatus (interpreter)));
     LoadSubCommand ("connect", CommandObjectSP (new CommandObjectPlatformConnect (interpreter)));
     LoadSubCommand ("disconnect", CommandObjectSP (new CommandObjectPlatformDisconnect (interpreter)));
     LoadSubCommand ("settings", CommandObjectSP (new CommandObjectPlatformSettings (interpreter)));
-#ifdef LLDB_CONFIGURATION_DEBUG
     LoadSubCommand ("mkdir", CommandObjectSP (new CommandObjectPlatformMkDir (interpreter)));
     LoadSubCommand ("file", CommandObjectSP (new CommandObjectPlatformFile (interpreter)));
     LoadSubCommand ("get-file", CommandObjectSP (new CommandObjectPlatformGetFile (interpreter)));
     LoadSubCommand ("get-size", CommandObjectSP (new CommandObjectPlatformGetSize (interpreter)));
     LoadSubCommand ("put-file", CommandObjectSP (new CommandObjectPlatformPutFile (interpreter)));
-#endif
     LoadSubCommand ("process", CommandObjectSP (new CommandObjectPlatformProcess (interpreter)));
     LoadSubCommand ("shell", CommandObjectSP (new CommandObjectPlatformShell (interpreter)));
     LoadSubCommand ("target-install", CommandObjectSP (new CommandObjectPlatformInstall (interpreter)));
 }
 
-
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 CommandObjectPlatform::~CommandObjectPlatform()
 {
 }

test/types/AbstractBase.py

class GenericTester(TestBase):
     # 'int.cpp', and the atoms, e.g., set(['unsigned', 'long long']) to the    #
     # functions.  There are also three optional keyword arguments of interest, #
     # as follows:                                                              #
     #                                                                          #
     # dsym -> build for dSYM (defaulted to True)                               #
     #         True: build dSYM file                                            #
     #         False: build DWARF map                                           #
     # bc -> blockCaptured (defaulted to False)                                 #
-    #         True: testing vars of various basic types from isnide a block    #
+    #         True: testing vars of various basic types from inside a block    #
     #         False: testing vars of various basic types from a function       #
     # qd -> quotedDisplay (defaulted to False)                                 #
     #         True: the output from 'frame var' or 'expr var' contains a pair  #
     #               of single quotes around the value                          #
     #         False: no single quotes are to be found around the value of      #
     #                variable                                                  #
     #==========================================================================#
 
def build_and_run_with_source_atoms_expr(self, source, atoms, expr, dsym=True, bc=False, qd=False):
         else:
             self.buildDwarf(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         if expr:
             self.generic_type_expr_tester(self.exe_name, atoms, blockCaptured=bc, quotedDisplay=qd)
         else:
             self.generic_type_tester(self.exe_name, atoms, blockCaptured=bc, quotedDisplay=qd)
 
+    def process_launch_o(self, localPath):
+        # process launch command output redirect always goes to host the process is running on
+        if lldb.remote_platform:
+            # process launch -o requires a path that is valid on the target
+            self.assertIsNotNone(lldb.remote_platform.GetWorkingDirectory())
+            remote_path = os.path.join(lldb.remote_platform.GetWorkingDirectory(), "lldb-stdout-redirect.txt")
+            self.runCmd('process launch -o {remote}'.format(remote=remote_path))
+            # copy remote_path to local host
+            self.runCmd('platform get-file {remote} "{local}"'.format(
+                remote=remote_path, local=self.golden_filename))
+        else:
+            self.runCmd('process launch -o "{local}"'.format(local=self.golden_filename))
+
     def generic_type_tester(self, exe_name, atoms, quotedDisplay=False, blockCaptured=False):
         """Test that variables with basic types are displayed correctly."""
 
         self.runCmd("file %s" % exe_name, CURRENT_EXECUTABLE_SET)
 
         # First, capture the golden output emitted by the oracle, i.e., the
         # series of printf statements.
-        self.runCmd('process launch -o "%s"'%(self.golden_filename))
+
+        self.process_launch_o(self.golden_filename)
+
         with open(self.golden_filename) as f:
             go = f.read()
 
         # This golden list contains a list of (variable, value) pairs extracted
         # from the golden output.
         gl = []
 
         # Scan the golden output line by line, looking for the pattern:
         #
         #     variable = 'value'
         #
         for line in go.split(os.linesep):
class GenericTester(TestBase):
 
     def generic_type_expr_tester(self, exe_name, atoms, quotedDisplay=False, blockCaptured=False):
         """Test that variable expressions with basic types are evaluated correctly."""
 
         self.runCmd("file %s" % exe_name, CURRENT_EXECUTABLE_SET)
 
         # First, capture the golden output emitted by the oracle, i.e., the
         # series of printf statements.
-        self.runCmd('process launch -o "%s"'%(self.golden_filename))
+
+        self.process_launch_o(self.golden_filename)
+
         with open(self.golden_filename) as f:
             go = f.read()
 
         # This golden list contains a list of (variable, value) pairs extracted
         # from the golden output.
         gl = []
 
         # Scan the golden output line by line, looking for the pattern:
         #
         #     variable = 'value'
         #
         for line in go.split(os.linesep):
             # We'll ignore variables of array types from inside a block.
             if blockCaptured and '[' in line:
                 continue
             match = self.pattern.search(line)