def test_fail_no_quotes(self, matcher):  # suppress(no-self-use)
     """Check that style/set_var_case fails with {}, because lowercase."""
     line = gen_source_line(matcher,
                            match_transform=lambda x: x.lower())
     with ExpectedException(LinterFailure):
         run_linter_throw(line,
                          whitelist=["style/set_var_case"])

 def test_fail_bad_kw_align(self):  # suppress(no-self-use)
     """style/argument_align fails if args on same line spaced unevenly."""
     with ExpectedException(LinterFailure):
         run_linter_throw("call (ONE\n"
                          "      TWO THREE\n"
                          "        FOUR)\n",
                          whitelist=["style/argument_align"])

 def test_fail_align_macro_name(self):  # suppress(no-self-use)
     """style/argument_align fails when args not aligned after second."""
     with ExpectedException(LinterFailure):
         run_linter_throw("macro (name TWO\n"
                          "       THREE)\n"
                          "endmacro ()\n",
                          whitelist=["style/argument_align"])

 def test_fail_mismatch_if_alt(self, alt):
     """style/indent fails when else, elseif has mismatched indent."""
     with ExpectedException(LinterFailure):
         script = "if (COND)\n {0} (COND)\nendif ()"
         run_linter_throw(script.format(alt),
                          whitelist=["style/indent"],
                          indent=1)

 def test_fail_if_kw_not_var_align(self, keyword):  # suppress(no-self-use)
     """style/argument_align fails when args not aligned after second."""
     kw_len = len(keyword)
     with ExpectedException(LinterFailure):
         run_linter_throw("call (ONE\n"
                          "      {0} ONE".format(keyword) +
                          "      " + " " * kw_len + " TWO)",
                          whitelist=["style/argument_align"])

    def test_fail_variable_unused(self, matcher):  # suppress(no-self-use)
        """Check unused/var_in_func fails when var is unused in {}."""
        call = gen_source_line(matcher)
        script = ("function (f)\n"
                  "    {0}\n"
                  "endfunction ()\n").format(call)

        with ExpectedException(LinterFailure):
            run_linter_throw(script, whitelist=["unused/var_in_func"])

 def test_fail_other_quotes(self, matcher):  # suppress(no-self-use)
     """Check that style/set_var_case fails with other args quoted in {}."""
     quote = "\"{0}\""
     xform = lambda x: quote.format(x)  # suppress(unnecessary-lambda,E731)
     line = gen_source_line(matcher,
                            match_transform=lambda x: x.lower(),
                            other_transform=xform)
     with ExpectedException(LinterFailure):
         run_linter_throw(line,
                          whitelist=["style/set_var_case"])

    def test_lint_fail_excessive_space(self):  # suppress(no-self-use)
        """Check that style/space_before_func fails.

        Test fails where there is more than one space between a function name
        and a call, like so

        function_name ()
        """
        with ExpectedException(LinterFailure):
            run_linter_throw("function_call  ()\n",
                             whitelist=["style/space_before_func"])

 def test_pass_use_var_autoderef(self, cmd, generator):
     """Check that unused/private_var passes when var autodereffed in {}."""
     script = ("set (_ARGUMENT 0)\n"
               "{0} ({1})\n"
               "end{0} ()\n").format(cmd, generator(lambda x: "_" + x))
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/private_var"]))

 def test_pass_priv_func_as_var(self, definition):
     """unused/private passes if private function used as a variable."""
     script = ("{0} (_definition ARGUMENT)\n"
               "end{0} ()\n"
               "call (_definition)\n").format(definition)
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/private"]))

    def test_pass_no_quotes(self, matcher):
        """Check that style/set_var_case passes with {}.

        Variables set by another CMake command should only be uppercase
        """
        result = run_linter_throw(gen_source_line(matcher),
                                  whitelist=["style/set_var_case"])
        self.assertTrue(result)

 def test_pass_pub_var_unused(self, matcher):
     """Check unused/private_var passes when public var is unused in {}."""
     find = matcher.find
     script = ("{0} ({1})\n").format(matcher.cmd,
                                     find.generate(matcher.sub,
                                                   lambda x: x,
                                                   lambda x: x))
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/private_var"]))

 def test_pass_deref_unused(self, matcher):
     """Check unused/var_in_func passes when deref var is set with {}."""
     call = gen_source_line(matcher,
                            match_transform=lambda x: "${" + x + "}")
     script = ("function (f)\n"
               "    {0}\n"
               "endfunction ()\n").format(call)
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/var_in_func"]))

 def test_pass_compound_unused(self, matcher):
     """Check unused/var_in_func passes if compound_lit var passed in {}."""
     call = gen_source_line(matcher,
                            match_transform=lambda x: "${" + x + "}/Other")
     script = ("function (f)\n"
               "    {0}\n"
               "endfunction ()\n").format(call)
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/var_in_func"]))

    def test_pass_no_var_set(self, matcher):
        """Check that style/set_var_case passes with {0.cmd}.

        Where no variable is actually set, then there is no linter failure
        """
        # This will trip up matchers that match other arguments
        result = run_linter_throw("{0} ()\n".format(matcher.cmd),
                                  whitelist=["style/set_var_case"])
        self.assertTrue(result)

 def test_pass_variable_used(self, matcher):
     """Check unused/var_in_func passes when var is used with {}."""
     script = ("function (f)\n"
               "    {0}\n"
               "    message ({1})\n"
               "endfunction ()\n").format(gen_source_line(matcher),
                                          "${VALUE}")
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/var_in_func"]))

 def test_pass_other_quotes(self, matcher):
     """Check that style/set_var_case pass with other args quoted in {}."""
     quote = "\"{0}\""
     xform = lambda x: quote.format(x)  # suppress(unnecessary-lambda,E731)
     line = gen_source_line(matcher,
                            other_transform=xform)
     result = run_linter_throw(line,
                               whitelist=["style/set_var_case"])
     self.assertTrue(result)

 def test_global_priv_used(self):
     """Check unused/private_var passes when var is used in nested ctx."""
     script = ("function (f)\n"
               "    set_property (GLOBAL PROPERTY _VALUE)\n"
               "endfunction (f)\n"
               "function (g)\n"
               "    get_property (VAR GLOBAL PROPERTY _VALUE)\n"
               "endfunction ()\n")
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/private_var"]))

 def test_pass_nested_use(self, matcher):
     """Check unused/var_in_func passes with {}, with use nested."""
     script = ("function (f)\n"
               "    {0}\n"
               "    foreach (VAR LIST)\n"
               "        message ({1} VAR)\n"
               "    endforeach ()\n"
               "endfunction ()\n").format(gen_source_line(matcher),
                                          "${VALUE}")
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/var_in_func"]))

 def test_global_used(self):
     """Check unused/var_in_func passes when global property is used."""
     script = ("function (f)\n"
               "    set_property (GLOBAL PROPERTY VALUE)\n"
               "endfunction (f)\n"
               "function (g)\n"
               "    get_property (VAR GLOBAL PROPERTY VALUE)\n"
               "    message (${VAR})\n"
               "endfunction ()\n")
     self.assertTrue(run_linter_throw(script,
                                      whitelist=["unused/var_in_func"]))