Fix buildbot breakage after r253106

[chying]

Summary

• expectedFailureAll takes single compiler name rather than compiler list because it also takes version which only apply to single compiler
• Don't try to access self.debug_info if debug_info is None
• Link to broken build, http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake/builds/8441

[zturner]

I think the is None check should go back inside the check_list_or_lambda function. Bringing it outside the function looks identical to me. If None is passed to the function, the callable() check will fail, and then the else branch will return true.

Also the compiler check is wrong currently because of the grouping of parentheses. For example, if someone passes compiler=None and compiler_version=3.7, then check would succeed no matter what the compiler version was.

[zturner]

Ahh ok I see the problem. Sorry I didn't read your description. Let me think about it some more

[zturner]

I guess this is ok. I don't like raising the None check outside the function, but I don't see another way that isn't more convoluted.

However, I think you still need to fix the grouping of the parentheses. the compiler is None should not override the version check.

[chying]

In D14673#289408, @zturner wrote:

I guess this is ok. I don't like raising the None check outside the function, but I don't see another way that isn't more convoluted.

However, I think you still need to fix the grouping of the parentheses. the compiler is None should not override the version check.

I thought a call of expectedFailureAll(..compiler=None, compiler_version=['>=', '3.7']...) doesn't make much sense at the first place, so maybe just ignore compiler check in such cases?
Do you suggest to check current compiler(no matter clang or gcc or others) version against given version?

[zturner]

Makes sense. If compiler is None, but compilerVersion is None, maybe you could just assert. Because that's an error in the use of the decorator IMO

[jingham]

If the problem is that the self of the test object doesn't always have a debug_info setting, why not just always initialize it to None? Seems weird to have a general property like this that we don't initialize.

[zturner]

In D14673#290280, @jingham wrote:

If the problem is that the self of the test object doesn't always have a debug_info setting, why not just always initialize it to None? Seems weird to have a general property like this that we don't initialize.

Gotta love Python. But yea, that seems like a reasonable solution as well, and makes the code cleaner.

I'm still unsure if the change to the compiler here check was the result of a failure or just a drive-by change. It always has a getCompiler() method right? So why was that particular change needed? Maybe it wasn't?

[chying]

The compiler None check is because inside of check_list_or_lambda function, it checks for "value in list_or_lamda", which will throw exception if value is None
I agree that the code will be cleaner if debug_info is initialized to None.
Will try to upload another patch soon.

[chying]

Recommit r253106 - Add a "not_in()" function you can apply to the list type arguments to expectedFailureAll ...
Initialize self.debug_info in Base::setUp()
Check for None before calling "value in list"

[zturner]

Ahh, sorry. I litearlly just committed a change to the same function. You may have to do a merge, sorry about that.

[chying]

In D14673#290556, @zturner wrote:

Ahh, sorry. I litearlly just committed a change to the same function. You may have to do a merge, sorry about that.

Ahh, I see, will merge again.

[chying]

Rebase on the latest commit.

[jingham]

Thanks for dealing with this!

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/TestConsecutiveBreakpoints.py

 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 class ConsecutiveBreakpoitsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @unittest2.expectedFailure("llvm.org/pr23478")
+    @expectedFailureAll("llvm.org/pr23478", oslist = not_in(["macosx"]))
     def test (self):
         self.build ()
         self.consecutive_breakpoints_tests()
         
     def consecutive_breakpoints_tests(self):
         exe = os.path.join (os.getcwd(), "a.out")
 
         # Create a target by the debugger.

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

def expectedFailure_impl(func):
         return wrapper
     # if bugnumber is not-callable(incluing None), that means decorator function is called with optional arguments
     # return decorator in this case, so it will be used to decorating original method
     if six.callable(bugnumber):
         return expectedFailure_impl(bugnumber)
     else:
         return expectedFailure_impl
 
+# You can also pass not_in(list) to reverse the sense of the test for the arguments that
+# are simple lists, namely oslist, compiler, and debug_info.
+
+def not_in (iterable):
+    return lambda x : x not in iterable
+
+def check_list_or_lambda (list_or_lambda, value):
+    if six.callable(list_or_lambda):
+        return list_or_lambda(value)
+    else:
+        return list_or_lambda is None or value is None or value in list_or_lambda
+
 # provide a function to xfail on defined oslist, compiler version, and archs
 # if none is specified for any argument, that argument won't be checked and thus means for all
 # for example,
 # @expectedFailureAll, xfail for all platform/compiler/arch,
 # @expectedFailureAll(compiler='gcc'), xfail for gcc on all platform/architecture
 # @expectedFailureAll(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), xfail for gcc>=4.9 on linux with i386
 def expectedFailureAll(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None, triple=None, debug_info=None, swig_version=None, py_version=None):
     def fn(self):
-        oslist_passes = oslist is None or self.getPlatform() in oslist
-        compiler_passes = compiler is None or (compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version))
+        oslist_passes = check_list_or_lambda(oslist, self.getPlatform())
+        compiler_passes = check_list_or_lambda(self.getCompiler(), compiler) and self.expectedCompilerVersion(compiler_version)
         arch_passes = self.expectedArch(archs)
         triple_passes = triple is None or re.match(triple, lldb.DBG.GetSelectedPlatform().GetTriple())
-        debug_info_passes = debug_info is None or self.debug_info in debug_info
+        debug_info_passes = check_list_or_lambda(debug_info, self.debug_info)
         swig_version_passes = (swig_version is None) or (not hasattr(lldb, 'swig_version')) or (check_expected_version(swig_version[0], swig_version[1], lldb.swig_version))
         py_version_passes = (py_version is None) or check_expected_version(py_version[0], py_version[1], sys.version_info)
 
         return (oslist_passes and
                 compiler_passes and
                 arch_passes and
                 triple_passes and
                 debug_info_passes and
def setUp(self):
         if not self.ci:
             raise Exception('Could not get the command interpreter')
 
         # And the result object.
         self.res = lldb.SBCommandReturnObject()
 
         self.enableLogChannelsForCurrentTest()
 
+        #Initialize debug_info
+        self.debug_info = None
+
     def runHooks(self, child=None, child_prompt=None, use_cmd_api=False):
         """Perform the run hooks to bring lldb debugger to the desired state.
 
         By default, expect a pexpect spawned child and child prompt to be
         supplied (use_cmd_api=False).  If use_cmd_api is true, ignore the child
         and child prompt and use self.runCmd() to run the hooks one by one.
 
         Note that child is a process spawned by pexpect.spawn().  If not, your