# Copyright (C) 2014 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from common.immutables               import ImmutableDict
from common.testing                  import ToUnicode
from file_format.c1visualizer.parser import ParseC1visualizerStream
from file_format.c1visualizer.struct import C1visualizerFile, C1visualizerPass
from file_format.checker.parser      import ParseCheckerStream, ParseCheckerStatement
from file_format.checker.struct      import CheckerFile, TestCase, TestStatement
from match.file                      import MatchTestCase, MatchFailedException, \
                                            BadStructureException
from match.line                      import MatchLines

import io
import unittest

CheckerException = SystemExit

class MatchLines_Test(unittest.TestCase):

  def createTestStatement(self, checkerString):
    checkerFile = CheckerFile("<checker-file>")
    testCase = TestCase(checkerFile, "TestMethod TestPass", 0)
    return ParseCheckerStatement(testCase, checkerString, TestStatement.Variant.InOrder, 0)

  def tryMatch(self, checkerString, c1String, varState={}):
    return MatchLines(self.createTestStatement(checkerString),
                      ToUnicode(c1String),
                      ImmutableDict(varState))

  def assertMatches(self, checkerString, c1String, varState={}):
    self.assertIsNotNone(self.tryMatch(checkerString, c1String, varState))

  def assertDoesNotMatch(self, checkerString, c1String, varState={}):
    self.assertIsNone(self.tryMatch(checkerString, c1String, varState))

  def test_TextAndWhitespace(self):
    self.assertMatches("foo", "foo")
    self.assertMatches("foo", "  foo  ")
    self.assertMatches("foo", "foo bar")
    self.assertDoesNotMatch("foo", "XfooX")
    self.assertDoesNotMatch("foo", "zoo")

    self.assertMatches("foo bar", "foo   bar")
    self.assertMatches("foo bar", "abc foo bar def")
    self.assertMatches("foo bar", "foo foo bar bar")

    self.assertMatches("foo bar", "foo X bar")
    self.assertDoesNotMatch("foo bar", "foo Xbar")

  def test_Pattern(self):
    self.assertMatches("foo{{A|B}}bar", "fooAbar")
    self.assertMatches("foo{{A|B}}bar", "fooBbar")
    self.assertDoesNotMatch("foo{{A|B}}bar", "fooCbar")

  def test_VariableReference(self):
    self.assertMatches("foo<<X>>bar", "foobar", {"X": ""})
    self.assertMatches("foo<<X>>bar", "fooAbar", {"X": "A"})
    self.assertMatches("foo<<X>>bar", "fooBbar", {"X": "B"})
    self.assertDoesNotMatch("foo<<X>>bar", "foobar", {"X": "A"})
    self.assertDoesNotMatch("foo<<X>>bar", "foo bar", {"X": "A"})
    with self.assertRaises(CheckerException):
      self.tryMatch("foo<<X>>bar", "foobar", {})

  def test_VariableDefinition(self):
    self.assertMatches("foo<<X:A|B>>bar", "fooAbar")
    self.assertMatches("foo<<X:A|B>>bar", "fooBbar")
    self.assertDoesNotMatch("foo<<X:A|B>>bar", "fooCbar")

    env = self.tryMatch("foo<<X:A.*B>>bar", "fooABbar", {})
    self.assertEqual(env, {"X": "AB"})
    env = self.tryMatch("foo<<X:A.*B>>bar", "fooAxxBbar", {})
    self.assertEqual(env, {"X": "AxxB"})

    self.assertMatches("foo<<X:A|B>>bar<<X>>baz", "fooAbarAbaz")
    self.assertMatches("foo<<X:A|B>>bar<<X>>baz", "fooBbarBbaz")
    self.assertDoesNotMatch("foo<<X:A|B>>bar<<X>>baz", "fooAbarBbaz")

  def test_NoVariableRedefinition(self):
    with self.assertRaises(CheckerException):
      self.tryMatch("<<X:...>><<X>><<X:...>><<X>>", "foofoobarbar")

  def test_EnvNotChangedOnPartialMatch(self):
    env = {"Y": "foo"}
    self.assertDoesNotMatch("<<X:A>>bar", "Abaz", env)
    self.assertFalse("X" in env.keys())

  def test_VariableContentEscaped(self):
    self.assertMatches("<<X:..>>foo<<X>>", ".*foo.*")
    self.assertDoesNotMatch("<<X:..>>foo<<X>>", ".*fooAAAA")


class MatchFiles_Test(unittest.TestCase):

  def assertMatches(self, checkerString, c1String, isa=None, instructionSetFeatures=None):
    checkerString = \
      """
        /// CHECK-START: MyMethod MyPass
      """ + checkerString
    metaData = ""
    if isa:
      metaData += "isa:" + isa

    if instructionSetFeatures:
      if metaData:
        metaData += " "

      joinedFeatures = ",".join(map(lambda feature: feature
                                                    if instructionSetFeatures[feature]
                                                    else "-" + feature,
                                    instructionSetFeatures))
      metaData += "isa_features:" + joinedFeatures

    metaDataString = ""
    if metaData:
      metaDataString = \
        """
          begin_compilation
            name "%s"
            method "%s"
            date 1234
          end_compilation
        """ % (metaData, metaData)
    c1String = metaDataString + \
      """
        begin_compilation
          name "MyMethod"
          method "MyMethod"
          date 1234
        end_compilation
        begin_cfg
          name "MyPass"
      """ + c1String + \
      """
        end_cfg
      """
    checkerFile = ParseCheckerStream("<test-file>", "CHECK", io.StringIO(ToUnicode(checkerString)))
    c1File = ParseC1visualizerStream("<c1-file>", io.StringIO(ToUnicode(c1String)))
    assert len(checkerFile.testCases) == 1
    assert len(c1File.passes) == 1
    MatchTestCase(checkerFile.testCases[0], c1File.passes[0], c1File.instructionSetFeatures)

  def assertDoesNotMatch(self, checkerString, c1String, isa=None, instructionSetFeatures=None):
    with self.assertRaises(MatchFailedException):
      self.assertMatches(checkerString, c1String, isa, instructionSetFeatures)

  def assertBadStructure(self, checkerString, c1String):
    with self.assertRaises(BadStructureException):
      self.assertMatches(checkerString, c1String)

  def test_Text(self):
    self.assertMatches("/// CHECK: foo bar", "foo bar")
    self.assertDoesNotMatch("/// CHECK: foo bar", "abc def")

  def test_Pattern(self):
    self.assertMatches("/// CHECK: abc {{de.}}", "abc de#")
    self.assertDoesNotMatch("/// CHECK: abc {{de.}}", "abc d#f")

  def test_Variables(self):
    self.assertMatches(
    """
      /// CHECK: foo<<X:.>>bar
      /// CHECK: abc<<X>>def
    """,
    """
      foo0bar
      abc0def
    """)
    self.assertMatches(
    """
      /// CHECK: foo<<X:([0-9]+)>>bar
      /// CHECK: abc<<X>>def
      /// CHECK: ### <<X>> ###
    """,
    """
      foo1234bar
      abc1234def
      ### 1234 ###
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK: foo<<X:([0-9]+)>>bar
      /// CHECK: abc<<X>>def
    """,
    """
      foo1234bar
      abc1235def
    """)

  def test_WholeWordMustMatch(self):
    self.assertMatches("/// CHECK: b{{.}}r", "abc bar def")
    self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc Xbar def")
    self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc barX def")
    self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc b r def")

  def test_InOrderStatements(self):
    self.assertMatches(
    """
      /// CHECK: foo
      /// CHECK: bar
    """,
    """
      foo
      bar
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK: foo
      /// CHECK: bar
    """,
    """
      bar
      foo
    """)

  def test_NextLineStatements(self):
    self.assertMatches(
    """
      /// CHECK:      foo
      /// CHECK-NEXT: bar
      /// CHECK-NEXT: abc
      /// CHECK:      def
    """,
    """
      foo
      bar
      abc
      def
    """)
    self.assertMatches(
    """
      /// CHECK:      foo
      /// CHECK-NEXT: bar
      /// CHECK:      def
    """,
    """
      foo
      bar
      abc
      def
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK:      foo
      /// CHECK-NEXT: bar
    """,
    """
      foo
      abc
      bar
    """)

    self.assertDoesNotMatch(
    """
      /// CHECK:      foo
      /// CHECK-NEXT: bar
    """,
    """
      bar
      foo
      abc
    """)

  def test_DagStatements(self):
    self.assertMatches(
    """
      /// CHECK-DAG: foo
      /// CHECK-DAG: bar
    """,
    """
      foo
      bar
    """)
    self.assertMatches(
    """
      /// CHECK-DAG: foo
      /// CHECK-DAG: bar
    """,
    """
      bar
      foo
    """)

  def test_DagStatementsScope(self):
    self.assertMatches(
    """
      /// CHECK:     foo
      /// CHECK-DAG: abc
      /// CHECK-DAG: def
      /// CHECK:     bar
    """,
    """
      foo
      def
      abc
      bar
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK:     foo
      /// CHECK-DAG: abc
      /// CHECK-DAG: def
      /// CHECK:     bar
    """,
    """
      foo
      abc
      bar
      def
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK:     foo
      /// CHECK-DAG: abc
      /// CHECK-DAG: def
      /// CHECK:     bar
    """,
    """
      foo
      def
      bar
      abc
    """)

  def test_NotStatements(self):
    self.assertMatches(
    """
      /// CHECK-NOT: foo
    """,
    """
      abc
      def
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK-NOT: foo
    """,
    """
      abc foo
      def
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK-NOT: foo
      /// CHECK-NOT: bar
    """,
    """
      abc
      def bar
    """)

  def test_NotStatementsScope(self):
    self.assertMatches(
    """
      /// CHECK:     abc
      /// CHECK-NOT: foo
      /// CHECK:     def
    """,
    """
      abc
      def
    """)
    self.assertMatches(
    """
      /// CHECK:     abc
      /// CHECK-NOT: foo
      /// CHECK:     def
    """,
    """
      abc
      def
      foo
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK:     abc
      /// CHECK-NOT: foo
      /// CHECK:     def
    """,
    """
      abc
      foo
      def
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK-NOT:  foo
      /// CHECK-EVAL: 1 + 1 == 2
      /// CHECK:      bar
    """,
    """
      foo
      abc
      bar
    """);
    self.assertMatches(
    """
      /// CHECK-DAG:  bar
      /// CHECK-DAG:  abc
      /// CHECK-NOT:  foo
    """,
    """
      foo
      abc
      bar
    """);
    self.assertDoesNotMatch(
    """
      /// CHECK-DAG:  abc
      /// CHECK-DAG:  foo
      /// CHECK-NOT:  bar
    """,
    """
      foo
      abc
      bar
    """);

  def test_LineOnlyMatchesOnce(self):
    self.assertMatches(
    """
      /// CHECK-DAG: foo
      /// CHECK-DAG: foo
    """,
    """
      foo
      abc
      foo
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK-DAG: foo
      /// CHECK-DAG: foo
    """,
    """
      foo
      abc
      bar
    """)

  def test_EvalStatements(self):
    self.assertMatches("/// CHECK-EVAL: True", "foo")
    self.assertDoesNotMatch("/// CHECK-EVAL: False", "foo")

    self.assertMatches("/// CHECK-EVAL: 1 + 2 == 3", "foo")
    self.assertDoesNotMatch("/// CHECK-EVAL: 1 + 2 == 4", "foo")

    twoVarTestCase = """
                       /// CHECK-DAG: <<X:\d+>> <<Y:\d+>>
                       /// CHECK-EVAL: <<X>> > <<Y>>
                     """
    self.assertMatches(twoVarTestCase, "42 41");
    self.assertDoesNotMatch(twoVarTestCase, "42 43")

  def test_MisplacedNext(self):
    self.assertBadStructure(
      """
        /// CHECK-DAG:  foo
        /// CHECK-NEXT: bar
      """,
      """
      foo
      bar
      """)
    self.assertBadStructure(
      """
        /// CHECK-NOT:  foo
        /// CHECK-NEXT: bar
      """,
      """
      foo
      bar
      """)
    self.assertBadStructure(
      """
        /// CHECK-EVAL: True
        /// CHECK-NEXT: bar
      """,
      """
      foo
      bar
      """)
    self.assertBadStructure(
      """
        /// CHECK-NEXT: bar
      """,
      """
      foo
      bar
      """)

  def test_EnvVariableEval(self):
    self.assertMatches(
    """
      /// CHECK-IF: os.environ.get('MARTY_MCFLY') != '89mph!'
      /// CHECK-FI:
    """,
    """
    foo
    """
    )
    self.assertMatches(
    """
      /// CHECK-EVAL: os.environ.get('MARTY_MCFLY') != '89mph!'
    """,
    """
    foo
    """
    )

  def test_IfStatements(self):
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: True
      ///   CHECK-NEXT: foo2
      /// CHECK-FI:
      /// CHECK-NEXT: foo3
      /// CHECK-NEXT: bar
    """,
    """
    foo1
    foo2
    foo3
    bar
    """)
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    bar
    """)
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: True
      ///   CHECK-DAG:    foo2
      /// CHECK-FI:
      /// CHECK-DAG:    bar
      /// CHECK: foo3
    """,
    """
    foo1
    bar
    foo2
    foo3
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT: foo2
      /// CHECK-FI:
      /// CHECK-NEXT: foo3
    """,
    """
    foo1
    foo2
    foo3
    """)

  def test_IfElseStatements(self):
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: True
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELSE:
      ///   CHECK-NEXT:    foo3
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    foo2
    bar
    """)
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELSE:
      ///   CHECK-NEXT:    foo3
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    foo3
    bar
    """)
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELSE:
      ///   CHECK-DAG:    bar
      /// CHECK-FI:
      /// CHECK-DAG:    foo3
      /// CHECK: foo4
    """,
    """
    foo1
    foo3
    bar
    foo4
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELSE:
      ///   CHECK-NEXT:    foo3
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    foo2
    bar
    """)

  def test_IfElifElseStatements(self):
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: True
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELIF: True
      ///   CHECK-NEXT:    foo3
      /// CHECK-ELIF: True
      ///   CHECK-NEXT:    foo4
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    foo2
    bar
    """)
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELIF: False
      ///   CHECK-NEXT:    foo3
      /// CHECK-ELIF: True
      ///   CHECK-NEXT:    foo4
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    foo4
    bar
    """)
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELIF: True
      ///   CHECK-NEXT:    foo3
      /// CHECK-ELIF: True
      ///   CHECK-NEXT:    foo4
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    foo3
    bar
    """)
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELIF: False
      ///   CHECK-NEXT:    foo3
      /// CHECK-ELIF: False
      ///   CHECK-NEXT:    foo4
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    bar
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK: foo1
      /// CHECK-IF: False
      ///   CHECK-NEXT:    foo2
      /// CHECK-ELIF: True
      ///   CHECK-NEXT:    foo3
      /// CHECK-ELSE:
      ///   CHECK-NEXT:    foo4
      /// CHECK-FI:
      /// CHECK-NEXT:    bar
    """,
    """
    foo1
    foo2
    bar
    """)

  def test_NestedBranching(self):
    self.assertMatches(
    """
      /// CHECK: foo1
      /// CHECK-IF: True
      ///   CHECK-IF: True
      ///     CHECK-NEXT:    foo2
      ///   CHECK-ELSE:
      ///     CHECK-NEXT:    foo3
      ///   CHECK-FI:
      /// CHECK-ELSE:
      ///   CHECK-IF: True
      ///     CHECK-NEXT:    foo4
      ///   CHECK-ELSE:
      ///     CHECK-NEXT:    foo5
      ///   CHECK-FI:
      /// CHECK-FI:
      /// CHECK-NEXT: foo6
    """,
    """
    foo1
    foo2
    foo6
    """)
    self.assertMatches(
    """
      /// CHECK-IF: True
      ///   CHECK-IF: False
      ///     CHECK:    foo1
      ///   CHECK-ELSE:
      ///     CHECK:    foo2
      ///   CHECK-FI:
      /// CHECK-ELSE:
      ///   CHECK-IF: True
      ///     CHECK:    foo3
      ///   CHECK-ELSE:
      ///     CHECK:    foo4
      ///   CHECK-FI:
      /// CHECK-FI:
    """,
    """
    foo2
    """)
    self.assertMatches(
    """
      /// CHECK-IF: False
      ///   CHECK-IF: True
      ///     CHECK:    foo1
      ///   CHECK-ELSE:
      ///     CHECK:    foo2
      ///   CHECK-FI:
      /// CHECK-ELSE:
      ///   CHECK-IF: False
      ///     CHECK:    foo3
      ///   CHECK-ELSE:
      ///     CHECK-IF: False
      ///       CHECK:    foo4
      ///     CHECK-ELSE:
      ///       CHECK: foo5
      ///     CHECK-FI:
      ///   CHECK-FI:
      /// CHECK-FI:
    """,
    """
    foo5
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK: foo1
      /// CHECK-IF: True
      ///   CHECK-IF: False
      ///     CHECK-NEXT:    foo2
      ///   CHECK-ELSE:
      ///     CHECK-NEXT:    foo3
      ///   CHECK-FI:
      /// CHECK-NEXT: foo6
    """,
    """
    foo1
    foo2
    foo6
    """)

  def test_VariablesInBranches(self):
    self.assertMatches(
    """
      /// CHECK-IF: True
      ///   CHECK: foo<<VarA:\d+>>
      /// CHECK-FI:
      /// CHECK-EVAL: <<VarA>> == 12
    """,
    """
    foo12
    """)
    self.assertDoesNotMatch(
    """
      /// CHECK-IF: True
      ///   CHECK: foo<<VarA:\d+>>
      /// CHECK-FI:
      /// CHECK-EVAL: <<VarA>> == 99
    """,
    """
    foo12
    """)
    self.assertMatches(
    """
      /// CHECK-IF: True
      ///   CHECK: foo<<VarA:\d+>>
      ///   CHECK-IF: <<VarA>> == 12
      ///     CHECK: bar<<VarB:M|N>>
      ///   CHECK-FI:
      /// CHECK-FI:
      /// CHECK-EVAL: "<<VarB>>" == "M"
    """,
    """
    foo12
    barM
    """)
    self.assertMatches(
    """
      /// CHECK-IF: False
      ///   CHECK: foo<<VarA:\d+>>
      /// CHECK-ELIF: True
      ///   CHECK: foo<<VarA:M|N>>
      /// CHECK-FI:
      /// CHECK-EVAL: "<<VarA>>" == "M"
    """,
    """
    fooM
    """)
    self.assertMatches(
    """
      /// CHECK-IF: False
      ///   CHECK: foo<<VarA:A|B>>
      /// CHECK-ELIF: False
      ///   CHECK: foo<<VarA:A|B>>
      /// CHECK-ELSE:
      ///   CHECK-IF: False
      ///     CHECK: foo<<VarA:A|B>>
      ///   CHECK-ELSE:
      ///     CHECK: foo<<VarA:M|N>>
      ///   CHECK-FI:
      /// CHECK-FI:
      /// CHECK-EVAL: "<<VarA>>" == "N"
    """,
    """
    fooN
    """)

  def test_MalformedBranching(self):
    self.assertBadStructure(
      """
        /// CHECK-IF: True
        /// CHECK: foo
      """,
      """
      foo
      """)
    self.assertBadStructure(
      """
        /// CHECK-ELSE:
        /// CHECK: foo
      """,
      """
      foo
      """)
    self.assertBadStructure(
      """
        /// CHECK-IF: True
        /// CHECK: foo
        /// CHECK-ELSE:
      """,
      """
      foo
      """)
    self.assertBadStructure(
      """
        /// CHECK-IF: True
        ///   CHECK: foo
        /// CHECK-ELIF:
        ///   CHECK: foo
        ///   CHECK-IF: True
        ///     CHECK: foo
        /// CHECK-FI:
      """,
      """
      foo
      """)
    self.assertBadStructure(
      """
        /// CHECK-IF: True
        ///   CHECK: foo
        /// CHECK-ELSE:
        ///   CHECK: foo
        /// CHECK-ELIF:
        ///   CHECK: foo
        /// CHECK-FI:
      """,
      """
      foo
      """)
    self.assertBadStructure(
      """
        /// CHECK-IF: True
        ///   CHECK: foo
        /// CHECK-ELSE:
        ///   CHECK: foo
        /// CHECK-ELSE:
        ///   CHECK: foo
        /// CHECK-FI:
      """,
      """
      foo
      """)

  def test_hasIsaFeature(self):
    no_isa = None
    self.assertMatches(
      """
        /// CHECK-EVAL: hasIsaFeature('feature1') and not hasIsaFeature('feature2')
      """,
      """
      foo
      """,
      no_isa,
      ImmutableDict({"feature1": True})
    )
    self.assertDoesNotMatch(
      """
        /// CHECK-EVAL: not hasIsaFeature('feature1')
      """,
      """
      foo
      """,
      no_isa,
      ImmutableDict({"feature1": True})
    )
    self.assertMatches(
      """
        /// CHECK-IF: hasIsaFeature('feature2')
        ///   CHECK: bar1
        /// CHECK-ELSE:
        ///   CHECK: bar2
        /// CHECK-FI:
      """,
      """
      foo
      bar1
      """,
      no_isa,
      ImmutableDict({"feature1": False, "feature2": True})
    )
    self.assertMatches(
      """
        /// CHECK-EVAL: hasIsaFeature('feature1') and not hasIsaFeature('feature2')
      """,
      """
      foo
      """,
      "some_isa",
      ImmutableDict({"feature1": True})
    )
    self.assertDoesNotMatch(
      """
        /// CHECK-EVAL: not hasIsaFeature('feature1')
      """,
      """
      foo
      """,
      "some_isa",
      ImmutableDict({"feature1": True})
    )
    self.assertMatches(
      """
        /// CHECK-IF: hasIsaFeature('feature2')
        ///   CHECK: bar1
        /// CHECK-ELSE:
        ///   CHECK: bar2
        /// CHECK-FI:
      """,
      """
      foo
      bar1
      """,
      "some_isa",
      ImmutableDict({"feature1": False, "feature2": True})
    )