[don't review]Creating environment variable test for lldbd

[• diazhector98]

Creating env tes

[• diazhector98]

Squashing

[wallace]

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/completions/TestVSCode_completions.py

26

don't forget to remove the #

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/TestVSCode_environmentVariables.py

20–25

remove this

39–44

you can write different tests:

• inheritEnvironment = false -> no PATH
• inheritEnvironment = true
  • send an additional env in the config -> it should override the inherited
  • PATH should be correct

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

906

inheritEnv should be passed here

lldb/tools/lldb-vscode/lldb-vscode.cpp

1400–1415

the env sent by the user in the launch.json config should have more priority than the inherited environment. For example, if env = ["X=A"] and the inherited env is ["X=Z", "Y=V"], then the resulting environment should be ["X=A", "Y=V"].
You should also write a test for that

1405

remove this

2250–2251

lol

lldb/tools/lldb-vscode/package.json

89 ↗

(On Diff #244547)

Inherit the debugger environment when launching a process. Only works for binaries launched directly by LLDB.

[• diazhector98]

Working on comments

[wallace]

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/TestVSCode_environmentVariables.py

32–36

this becomes more readable if you make it a function. That way you avoid having the mutable found variable and you can stop the for loop as soon as you return

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/main.cpp

11

remove this comment

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py

315

try not to delete existing blank lines

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

906

I think you need a comma here

907–908

put the ) in line 906

lldb/tools/lldb-vscode/lldb-vscode.cpp

1411–1413

in llvm, you don't need to use { } for one line ifs

[• diazhector98]

.

[• diazhector98]

• Merge branch 'master' of https://github.com/llvm/llvm-project

[• diazhector98]

• Comment

[• diazhector98]

Comments

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/completions/TestVSCode_completions.py

class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
     def verify_completions(self, actual_list, expected_list, not_expected_list=[]):
         for expected_item in expected_list:
             self.assertTrue(expected_item in actual_list)
 
         for not_expected_item in not_expected_list:
             self.assertFalse(not_expected_item in actual_list)
 
     @skipIfWindows
-    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    #@skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
     def test_completions(self):
         """
             Tests the completion request at different breakpoints
         """
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         source = "main.cpp"
         breakpoint1_line = line_number(source, "// breakpoint 1")

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/TestVSCode_environmentVariables.py

+"""
+Test lldb-vscode completions request
+"""
+
+
+import lldbvscode_testcase
+import unittest2
+import vscode
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+import os
+
+
+class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def verify_completions(self, actual_list, expected_list, not_expected_list=[]):
+        for expected_item in expected_list:
+            self.assertTrue(expected_item in actual_list)
+
+        for not_expected_item in not_expected_list:
+            self.assertFalse(not_expected_item in actual_list)
+
+    @skipIfWindows
+    #@skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    def test_environment_variable(self):
+        """
+            Tests the completion request at different breakpoints
+        """
+        program = self.getBuildArtifact("a.out")
+        path_env_variable = 'PATH='+os.environ['PATH']
+        self.build_and_launch(program, inheritEnvironment=False)
+        self.continue_to_exit()
+        output = self.get_stdout().encode('utf-8')
+        lines = output.splitlines()
+        found = False
+        for line in lines:
+            if line.startswith('PATH='):
+                found = True
+                self.assertTrue(path_env_variable == line, "PATH environment variable not the same")
+        self.assertTrue(found, 'PATH environment variable not found')
 No newline at end of file

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/main.cpp

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+extern char **environ;
+
+int main(int argc, char const *argv[], char const *envp[]) {
+    char** env_var_pointer = environ;
+    // std::vector<std::string> vscode_env_variables;
+    int count = 0;
+    for (char* env_variable = *env_var_pointer; env_variable; env_variable=*++env_var_pointer) {
+        printf("%s\n", env_variable);
+        count++;
+    }
+    return 0; // breakpoint 1
+}

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py

def attach(self, program=None, pid=None, waitFor=None, trace=None,
             self.assertTrue(response['success'],
                             'attach failed (%s)' % (response['message']))
 
     def launch(self, program=None, args=None, cwd=None, env=None,
                stopOnEntry=False, disableASLR=True,
                disableSTDIO=False, shellExpandArguments=False,
                trace=False, initCommands=None, preRunCommands=None,
                stopCommands=None, exitCommands=None,sourcePath= None,
-               debuggerRoot=None, launchCommands=None):
+               debuggerRoot=None, launchCommands=None, inheritEnvironment=False):
         '''Sending launch request to vscode
         '''
 
         # Make sure we disconnect and terminate the VSCode debug adapter,
         # if we throw an exception during the test case
         def cleanup():
             self.vscode.request_disconnect(terminateDebuggee=True)
             self.vscode.terminate()
def launch(self, program=None, args=None, cwd=None, env=None,
             shellExpandArguments=shellExpandArguments,
             trace=trace,
             initCommands=initCommands,
             preRunCommands=preRunCommands,
             stopCommands=stopCommands,
             exitCommands=exitCommands,
             sourcePath=sourcePath,
             debuggerRoot=debuggerRoot,
-            launchCommands=launchCommands)
+            launchCommands=launchCommands,
+            inheritEnvironment=inheritEnvironment
+            )
         if not (response and response['success']):
             self.assertTrue(response['success'],
                             'launch failed (%s)' % (response['message']))
 
     def build_and_launch(self, program, args=None, cwd=None, env=None,
                          stopOnEntry=False, disableASLR=True,
                          disableSTDIO=False, shellExpandArguments=False,
                          trace=False, initCommands=None, preRunCommands=None,
                          stopCommands=None, exitCommands=None,
-                         sourcePath=None, debuggerRoot=None):
+                         sourcePath=None, debuggerRoot=None, inheritEnvironment=False):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and launch the process.
         '''
         self.build_and_create_debug_adaptor()
         self.assertTrue(os.path.exists(program), 'executable must exist')
-
         self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
                     disableSTDIO, shellExpandArguments, trace,
                     initCommands, preRunCommands, stopCommands, exitCommands,
-                    sourcePath, debuggerRoot)
+                    sourcePath, debuggerRoot, inheritEnvironment=inheritEnvironment)

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

def request_initialize(self):
                 self.initialize_body = response['body']
         return response
 
     def request_launch(self, program, args=None, cwd=None, env=None,
                        stopOnEntry=False, disableASLR=True,
                        disableSTDIO=False, shellExpandArguments=False,
                        trace=False, initCommands=None, preRunCommands=None,
                        stopCommands=None, exitCommands=None, sourcePath=None,
-                       debuggerRoot=None, launchCommands=None):
+                       debuggerRoot=None, launchCommands=None, inheritEnvironment=False):
         args_dict = {
             'program': program
         }
         if args:
             args_dict['args'] = args
         if cwd:
             args_dict['cwd'] = cwd
         if env:
def request_launch(self, program, args=None, cwd=None, env=None,
         if exitCommands:
             args_dict['exitCommands'] = exitCommands
         if sourcePath:
             args_dict['sourcePath'] = sourcePath
         if debuggerRoot:
             args_dict['debuggerRoot'] = debuggerRoot
         if launchCommands:
             args_dict['launchCommands'] = launchCommands
+        if inheritEnvironment:
+            args_dict['inheritEnvironment'] = inheritEnvironment
         command_dict = {
             'command': 'launch',
             'type': 'request',
             'arguments': args_dict
         }
         response = self.send_recv(command_dict)
 
         # Wait for a 'process' and 'initialized' event in any order
if attach_options_specified(options):
                                       pid=options.pid,
                                       waitFor=options.waitFor,
                                       attachCommands=options.attachCmds,
                                       initCommands=options.initCmds,
                                       preRunCommands=options.preRunCmds,
                                       stopCommands=options.stopCmds,
                                       exitCommands=options.exitCmds)
     else:
+        print('Options.Envs: ', options.envs)
         response = dbg.request_launch(options.program,
                                       args=args,
                                       env=options.envs,
                                       cwd=options.workingDir,
                                       debuggerRoot=options.debuggerRoot,
                                       sourcePath=options.sourcePath,
                                       initCommands=options.initCmds,
                                       preRunCommands=options.preRunCmds,
                                       stopCommands=options.stopCmds,
                                       exitCommands=options.exitCmds)
 
     if response['success']:
         if options.sourceBreakpoints:
             source_to_lines = {}
             for file_line in options.sourceBreakpoints:
                 (path, line) = file_line.split(':')
                 if len(path) == 0 or len(line) == 0:
                     print('error: invalid source with line "%s"' %
                           (file_line))
 
if response['success']:
         dbg.wait_for_stopped()
     else:
         if 'message' in response:
             print(response['message'])
     dbg.request_disconnect(terminateDebuggee=True)
 
 
 def main():
+    print("Hello This Is Main")
     parser = optparse.OptionParser(
         description=('A testing framework for the Visual Studio Code Debug '
                      'Adaptor protocol'))
 
     parser.add_option(
         '--vscode',
         type='string',
         dest='vscode_path',

lldb/tools/lldb-vscode/lldb-vscode.cpp

void request_launch(const llvm::json::Object &request) {
 
   // Extract any extra arguments and append them to our program arguments for
   // when we launch
   auto args = GetStrings(arguments, "args");
   if (!args.empty()) 
     g_vsc.launch_info.SetArguments(MakeArgv(args).data(), true);
 
   // Pass any environment variables along that the user specified.
   auto envs = GetStrings(arguments, "env");
 
   // if arguments has launchWithDebuggerEnvironment
   // then append current environment to g_vsc.launch_info
   if (launchWithDebuggerEnvironment) {
+  // if (true) {
     char** env_var_pointer = environ;
     std::vector<std::string> vscode_env_variables;
-    for (char* c = *env_var_pointer; c; c=*++env_var_pointer){
-      vscode_env_variables.push_back(c);
+    for (char* env_variable = *env_var_pointer; env_variable; env_variable=*++env_var_pointer){
+      vscode_env_variables.push_back(env_variable);
     }
     envs.insert(std::end(envs), std::begin(vscode_env_variables), std::end(vscode_env_variables));
   } 
   if (!envs.empty()) {
     g_vsc.launch_info.SetEnvironmentEntries(MakeArgv(envs).data(), true);
   }
 
   auto flags = g_vsc.launch_info.GetLaunchFlags();
 
   if (GetBoolean(arguments, "disableASLR", true))
     flags |= lldb::eLaunchFlagDisableASLR;
   if (GetBoolean(arguments, "disableSTDIO", false))
     flags |= lldb::eLaunchFlagDisableSTDIO;
   if (GetBoolean(arguments, "shellExpandArguments", false))

 // "StepInResponse": {
 //   "allOf": [ { "$ref": "#/definitions/Response" }, {
 //     "type": "object",
 //     "description": "Response to 'stepIn' request. This is just an
 //     acknowledgement, so no body field is required."
 //   }]
 // }
 void request_stepIn(const llvm::json::Object &request) {
 
   return;
   llvm::json::Object response;
   FillResponse(request, response);
   auto arguments = request.getObject("arguments");
   lldb::SBThread thread = g_vsc.GetLLDBThread(*arguments);
   if (thread.IsValid()) {
     // Remember the thread ID that caused the resume so we can set the
     // "threadCausedFocus" boolean value in the "stopped" events.
     g_vsc.focus_tid = thread.GetThreadID();