Further streamline TestSwiftPlaygrounds.

Author: adrian-prantl

lldb/test/API/lang/swift/playgrounds/Import.swift

@@ -0,0 +1,2 @@
+import Dylib
+f()

lldb/test/API/lang/swift/playgrounds/TestSwiftPlaygrounds.py

@@ -88,6 +88,7 @@ def test_no_force_target(self):
     @swiftTest
     @skipIf(setting=('symbols.use-swift-clangimporter', 'false'))
     @skipIf(debug_info=decorators.no_match("dsym"))
+    @skipIf(macos_version=["<", "12"])
     def test_concurrency(self):
         """Test that concurrency is available in playgrounds"""
         self.launch(True)
@@ -144,47 +145,56 @@ def launch(self, force_target):
         self.options.SetTryAllThreads(True)
 
 
-    def do_basic_test(self, force_target):
-        contents = ""
-
-        with open('Contents.swift', 'r') as contents_file:
+    def execute_code(self, input_file, expect_error=False):
+        contents = "syntax error"
+        with open(input_file, 'r') as contents_file:
             contents = contents_file.read()
-
-        self.frame().EvaluateExpression(contents, self.options)
+        res = self.frame().EvaluateExpression(contents, self.options)
         ret = self.frame().EvaluateExpression("get_output()")
+        is_error = res.GetError().Fail() and not (
+                     res.GetError().GetType() == 1 and
+                     res.GetError().GetError() == 0x1001)
         playground_output = ret.GetSummary()
+        with recording(self, self.TraceOn()) as sbuf:
+            print("playground result: ", file=sbuf)
+            print(str(res), file=sbuf)
+            if is_error:
+                print("error:", file=sbuf)
+                print(str(res.GetError()), file=sbuf)
+            else:
+                print("playground output:", file=sbuf)
+                print(str(ret), file=sbuf)
+
+        if expect_error:
+            self.assertTrue(is_error)
+            return playground_output
+        self.assertFalse(is_error)
+        self.assertIsNotNone(playground_output)
+        return playground_output
+        
+    def do_basic_test(self, force_target):
+        playground_output = self.execute_code('Contents.swift', not force_target)
         if not force_target:
             # This is expected to fail because the deployment target
             # is less than the availability of the function being
             # called.
             self.assertEqual(playground_output, '""')
             return
 
-        self.assertTrue(playground_output is not None)
-        self.assertTrue("a=\\'3\\'" in playground_output)
-        self.assertTrue("b=\\'5\\'" in playground_output)
-        self.assertTrue("=\\'8\\'" in playground_output)
-        self.assertTrue("=\\'11\\'" in playground_output)
+        self.assertIn("a=\\'3\\'", playground_output)
+        self.assertIn("b=\\'5\\'", playground_output)
+        self.assertIn("=\\'8\\'", playground_output)
+        self.assertIn("=\\'11\\'", playground_output)
 
     def do_concurrency_test(self):
-        contents = "error"
-        with open('Concurrency.swift', 'r') as contents_file:
-            contents = contents_file.read()
-        res = self.frame().EvaluateExpression(contents, self.options)
-        ret = self.frame().EvaluateExpression("get_output()")
-        playground_output = ret.GetSummary()
-        self.assertTrue(playground_output is not None)
+        playground_output = self.execute_code('Concurrency.swift')
         self.assertIn("=\\'23\\'", playground_output)
 
     def do_import_test(self):
         # Test importing a library that adds new Clang options.
         log = self.getBuildArtifact('types.log')
         self.expect('log enable lldb types -f ' + log)
-        contents = "import Dylib\nf()\n"
-        res = self.frame().EvaluateExpression(contents, self.options)
-        ret = self.frame().EvaluateExpression("get_output()")
-        playground_output = ret.GetSummary()
-        self.assertTrue(playground_output is not None)
+        playground_output = self.execute_code('Import.swift')
         self.assertIn("Hello from the Dylib", playground_output)
 
         # Scan through the types log to make sure the SwiftASTContext was poisoned.