Make test more robust. It's not guaranteed that a Variable remains usable after continuing the process

adrian-prantl · adrian-prantl · commit de3346a03204 · 2023-04-03T13:54:53.000-07:00
diff --git a/lldb/test/API/lang/swift/variables/consume_operator/TestSwiftConsumeOperator.py b/lldb/test/API/lang/swift/variables/consume_operator/TestSwiftConsumeOperator.py
@@ -71,324 +71,301 @@ def get_var(self, name):
         return frame.FindVariable(name)
 
     def do_check_copyable_value_test(self):
-        # We haven't defined varK yet.
-        varK = self.get_var('k')
-
-        self.assertIsNone(varK.value, "varK initialized too early?!")
+        # We haven't defined k yet.
+        self.assertIsNone(self.get_var('k').value, "k initialized too early?!")
 
         # Go to break point 2. k should be valid.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to breakpoint 3. k should no longer be valid.
         self.process.Continue()
-        self.assertIsNone(varK.value, "K is live but was consumed?!")
+        self.assertIsNone(self.get_var('k').value, "K is live but was consumed?!")
 
         # Run so we hit the next breakpoint to jump to the next test's
         # breakpoint.
         self.process.Continue()
 
     def do_check_copyable_var_test(self):
-        # We haven't defined varK yet.
-        varK = self.get_var('k')
-        self.assertIsNone(varK.value, "varK initialized too early?!")
+        # We haven't defined k yet.
+        self.assertIsNone(self.get_var('k').value, "k initialized too early?!")
 
         # Go to break point 2. k should be valid.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to breakpoint 3. We invalidated k
         self.process.Continue()
-        self.assertIsNone(varK.value, "K is live but was consumed?!")
+        self.assertIsNone(self.get_var('k').value, "K is live but was consumed?!")
 
         # Go to the last breakpoint and make sure that k is reinitialized
         # properly.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized")
 
         # Run so we hit the next breakpoint to go to the next test.
         self.process.Continue()
 
     def do_check_addressonly_value_test(self):
-        # We haven't defined varK yet.
-        varK = self.get_var('k')
-
+        # We haven't defined k yet.
         # Go to break point 2. k should be valid and m should not be. Since M is
         # a dbg.declare it is hard to test robustly that it is not initialized
         # so we don't do so. We have an additional llvm.dbg.addr test where we
         # move the other variable and show the correct behavior with
         # llvm.dbg.declare.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "var not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "var not initialized?!")
 
         # Go to breakpoint 3.
         self.process.Continue()
-        self.assertEqual(varK.unsigned, 0,
-                        "dbg thinks varK is live despite move?!")
+        self.assertEqual(self.get_var('k').unsigned, 0,
+                        "dbg thinks k is live despite move?!")
 
         # Run so we hit the next breakpoint as part of the next test.
         self.process.Continue()
 
     def do_check_addressonly_var_test(self):
-        varK = self.get_var('k')
-
         # Go to break point 2. k should be valid.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to breakpoint 3. K was invalidated.
         self.process.Continue()
-        self.assertIsNone(varK.value, "K is live but was consumed?!")
+        self.assertIsNone(self.get_var('k').value, "K is live but was consumed?!")
 
         # Go to the last breakpoint and make sure that k is reinitialized
         # properly.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized")
 
         # Run so we hit the next breakpoint as part of the next test.
         self.process.Continue()
 
     def do_check_copyable_value_arg_test(self):
         # k is defined by the argument so it is valid.
-        varK = self.get_var('k')
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to break point 2. k should be valid.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to breakpoint 3. k should no longer be valid.
         self.process.Continue()
-        #self.assertIsNone(varK.value, "K is live but was consumed?!")
+        #self.assertIsNone(self.get_var('k').value, "K is live but was consumed?!")
 
         # Run so we hit the next breakpoint to jump to the next test's
         # breakpoint.
         self.process.Continue()
 
     def do_check_copyable_var_arg_test(self):
         # k is already defined and is an argument.
-        varK = self.get_var('k')
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to break point 2. k should be valid.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to breakpoint 3. We invalidated k
         self.process.Continue()
-        self.assertIsNone(varK.value, "K is live but was consumed?!")
+        self.assertIsNone(self.get_var('k').value, "K is live but was consumed?!")
 
         # Go to the last breakpoint and make sure that k is reinitialized
         # properly.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized")
 
         # Run so we hit the next breakpoint to go to the next test.
         self.process.Continue()
 
     def do_check_addressonly_value_arg_test(self):
         # k is defined since it is an argument.
-        varK = self.get_var('k')
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to break point 2. k should be valid and m should not be. Since M is
         # a dbg.declare it is hard to test robustly that it is not initialized
         # so we don't do so. We have an additional llvm.dbg.addr test where we
         # move the other variable and show the correct behavior with
         # llvm.dbg.declare.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "var not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "var not initialized?!")
 
         # Go to breakpoint 3.
         self.process.Continue()
-        self.assertEqual(varK.unsigned, 0,
-                        "dbg thinks varK is live despite move?!")
+        self.assertEqual(self.get_var('k').unsigned, 0,
+                        "dbg thinks k is live despite move?!")
 
         # Run so we hit the next breakpoint as part of the next test.
         self.process.Continue()
 
     def do_check_addressonly_var_arg_test(self):
-        varK = self.get_var('k')
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to break point 2. k should be valid.
         self.process.Continue()
-        self.assertGreater(varK.unsigned, 0, "varK not initialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized?!")
 
         # Go to breakpoint 3. K was invalidated.
         self.process.Continue()
-        self.assertIsNone(varK.value, "K is live but was consumed?!")
+        self.assertIsNone(self.get_var('k').value, "K is live but was consumed?!")
 
         # Go to the last breakpoint and make sure that k is reinitialized
         # properly.
         self.process.Continue()
         # There is some sort of bug here. We should have the value here. For now
         # leave the next line commented out and validate we are not seeing the
         # value so we can detect change in behavior.
-        self.assertGreater(varK.unsigned, 0, "varK not initialized")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k not initialized")
 
         # Run so we hit the next breakpoint as part of the next test.
         self.process.Continue()
 
     def do_check_copyable_value_ccf_true(self):
-        varK = self.get_var('k')
-
-        # Check at our start point that we do not have any state for varK and
+        # Check at our start point that we do not have any state for k and
         # then continue to our next breakpoint.
-        self.assertIsNone(varK.value, "varK should not have a value?!")
+        self.assertIsNone(self.get_var('k').value, "k should not have a value?!")
         self.process.Continue()
 
         # At this breakpoint, k should be defined since we are going to do
         # something with it.
-        self.assertIsNotNone(varK.value, "varK should have a value?!")
+        self.assertIsNotNone(self.get_var('k').value, "k should have a value?!")
         self.process.Continue()
 
         # At this breakpoint, we are now in the conditional control flow part of
         # the loop. Make sure that we can see k still.
-        self.assertIsNotNone(varK.value, "varK should have a value?!")
+        self.assertIsNotNone(self.get_var('k').value, "k should have a value?!")
         self.process.Continue()
 
         # Ok, we just performed the move. k should not be no longer initialized.
-        self.assertIsNone(varK.value, "varK should not have a value?!")
+        self.assertIsNone(self.get_var('k').value, "k should not have a value?!")
         self.process.Continue()
 
         # Finally we left the conditional control flow part of the function. k
         # should still be None.
-        self.assertIsNone(varK.value, "varK should not have a value!")
+        self.assertIsNone(self.get_var('k').value, "k should not have a value!")
 
         # Run again so we go and run to the next test.
         self.process.Continue()
 
     def do_check_copyable_value_ccf_false(self):
-        varK = self.get_var('k')
-
-        # Check at our start point that we do not have any state for varK and
+        # Check at our start point that we do not have any state for k and
         # then continue to our next breakpoint.
-        self.assertIsNone(varK.value, "varK should not have a value?!")
+        self.assertIsNone(self.get_var('k').value, "k should not have a value?!")
         self.process.Continue()
 
         # At this breakpoint, k should be defined since we are going to do
         # something with it.
-        self.assertIsNotNone(varK.value, "varK should have a value?!")
+        self.assertIsNotNone(self.get_var('k').value, "k should have a value?!")
         self.process.Continue()
 
         # At this breakpoint, we are now past the end of the conditional
         # statement. We know due to the move checking that k can not have any
         # uses that are reachable from the move. So it is safe to always not
         # provide the value here.
-        self.assertIsNone(varK.value, "varK should have a value?!")
+        self.assertIsNone(self.get_var('k').value, "k should have a value?!")
 
         # Run again so we go and run to the next test.
         self.process.Continue()
 
     def do_check_copyable_var_ccf_true_reinit_out_block(self):
-        varK = self.get_var('k')
-
         # At first we should not have a value for k.
-        self.assertEqual(varK.unsigned, 0, "varK should be nullptr!")
+        self.assertEqual(self.get_var('k').unsigned, 0, "k should be nullptr!")
         self.process.Continue()
 
         # Now we are in the conditional true block. K should be defined since we
         # are on the move itself.
-        self.assertGreater(varK.unsigned, 0, "varK should not be nullptr!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k should not be nullptr!")
         self.process.Continue()
 
         # Now we have executed the move and we are about to run code using
         # m. Make sure that K is not available!
-        self.assertEqual(varK.unsigned, 0,
-                         "varK was already consumed! Should be nullptr")
+        self.assertEqual(self.get_var('k').unsigned, 0,
+                         "k was already consumed! Should be nullptr")
         self.process.Continue()
 
         # We are now out of the conditional lexical block on the line of code
         # that redefines k. k should still be not available.
-        self.assertEqual(varK.unsigned, 0,
-                         "varK was already consumed! Should be nullptr")
+        self.assertEqual(self.get_var('k').unsigned, 0,
+                         "k was already consumed! Should be nullptr")
         self.process.Continue()
 
         # Ok, we have now reinit k and are about to call a method on it. We
         # should be valid now.
-        self.assertGreater(varK.unsigned, 0,
-                           "varK should have be reinitialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0,
+                           "k should have be reinitialized?!")
 
         # Run again so we go and run to the next test.
         self.process.Continue()
 
     def do_check_copyable_var_ccf_true_reinit_in_block(self):
-        varK = self.get_var('k')
-
         # At first we should not have a value for k.
-        self.assertEqual(varK.unsigned, 0, "varK should be nullptr!")
+        self.assertEqual(self.get_var('k').unsigned, 0, "k should be nullptr!")
         self.process.Continue()
 
         # Now we are in the conditional true block. K should be defined since we
         # are on the move itself.
-        self.assertGreater(varK.unsigned, 0, "varK should not be nullptr!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k should not be nullptr!")
         self.process.Continue()
 
         # Now we have executed the move and we are about to reinit k but have
         # not yet. Make sure we are not available!
-        self.assertEqual(varK.unsigned, 0,
-                         "varK was already consumed! Should be nullptr")
+        self.assertEqual(self.get_var('k').unsigned, 0,
+                         "k was already consumed! Should be nullptr")
         self.process.Continue()
 
         # We are now still inside the conditional part of the code, but have
-        # reinitialized varK.
-        self.assertGreater(varK.unsigned, 0,
-                           "varK was reinit! Should be valid value!")
+        # reinitialized k.
+        self.assertGreater(self.get_var('k').unsigned, 0,
+                           "k was reinit! Should be valid value!")
         self.process.Continue()
 
         # We now have left the conditional part of the function. k should still
         # be available.
-        self.assertGreater(varK.unsigned, 0,
-                           "varK should have be reinitialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0,
+                           "k should have be reinitialized?!")
 
         # Run again so we go and run to the next test.
         self.process.Continue()
 
     def do_check_copyable_var_ccf_false_reinit_out_block(self):
-        varK = self.get_var('k')
-
         # At first we should not have a value for k.
-        self.assertEqual(varK.unsigned, 0, "varK should be nullptr!")
+        self.assertEqual(self.get_var('k').unsigned, 0, "k should be nullptr!")
         self.process.Continue()
 
-        # Now we are right above the beginning of the false check. varK should
+        # Now we are right above the beginning of the false check. k should
         # still be valid.
-        self.assertGreater(varK.unsigned, 0, "varK should not be nullptr!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k should not be nullptr!")
         self.process.Continue()
 
         # Now we are after the conditional part of the code on the reinit
         # line. Since this is reachable from the move and we haven't reinit yet,
         # k should not be available.
-        self.assertEqual(varK.unsigned, 0,
-                         "varK was already consumed! Should be nullptr")
+        self.assertEqual(self.get_var('k').unsigned, 0,
+                         "k was already consumed! Should be nullptr")
         self.process.Continue()
 
         # Ok, we have now reinit k and are about to call a method on it. We
         # should be valid now.
-        self.assertGreater(varK.unsigned, 0,
-                           "varK should have be reinitialized?!")
+        self.assertGreater(self.get_var('k').unsigned, 0,
+                           "k should have be reinitialized?!")
 
         # Run again so we go and run to the next test.
         self.process.Continue()
 
     def do_check_copyable_var_ccf_false_reinit_in_block(self):
-        varK = self.get_var('k')
-
         # At first we should not have a value for k.
-        self.assertEqual(varK.unsigned, 0, "varK should be nullptr!")
+        self.assertEqual(self.get_var('k').unsigned, 0, "k should be nullptr!")
         self.process.Continue()
 
-        # Now we are on the doSomething above the false check. So varK should be
+        # Now we are on the doSomething above the false check. So k should be
         # valid.
-        self.assertGreater(varK.unsigned, 0, "varK should not be nullptr!")
+        self.assertGreater(self.get_var('k').unsigned, 0, "k should not be nullptr!")
         self.process.Continue()
 
         # Now we are after the conditional scope. Since k was reinitialized in
-        # the conditional scope, along all paths we are valid so varK should
+        # the conditional scope, along all paths we are valid so k should
         # still be available.
-        self.assertGreater(varK.unsigned, 0,
-                           "varK should not be nullptr?!")
+        self.assertGreater(self.get_var('k').unsigned, 0,
+                           "k should not be nullptr?!")
 
         # Run again so we go and run to the next test.
         self.process.Continue()
