| #!/usr/bin/env python2 |
| # |
| # 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. |
| |
| # This is a test file which exercises all feautres supported by the domain- |
| # specific markup language implemented by Checker. |
| |
| import checker |
| import io |
| import unittest |
| |
| # The parent type of exception expected to be thrown by Checker during tests. |
| # It must be specific enough to not cover exceptions thrown due to actual flaws |
| # in Checker. |
| CheckerException = SystemExit |
| |
| |
| class TestCheckFile_PrefixExtraction(unittest.TestCase): |
| def __tryParse(self, string): |
| checkFile = checker.CheckFile(None, []) |
| return checkFile._extractLine("CHECK", string) |
| |
| def test_InvalidFormat(self): |
| self.assertIsNone(self.__tryParse("CHECK")) |
| self.assertIsNone(self.__tryParse(":CHECK")) |
| self.assertIsNone(self.__tryParse("CHECK:")) |
| self.assertIsNone(self.__tryParse("//CHECK")) |
| self.assertIsNone(self.__tryParse("#CHECK")) |
| |
| self.assertIsNotNone(self.__tryParse("//CHECK:foo")) |
| self.assertIsNotNone(self.__tryParse("#CHECK:bar")) |
| |
| def test_InvalidLabel(self): |
| self.assertIsNone(self.__tryParse("//ACHECK:foo")) |
| self.assertIsNone(self.__tryParse("#ACHECK:foo")) |
| |
| def test_NotFirstOnTheLine(self): |
| self.assertIsNone(self.__tryParse("A// CHECK: foo")) |
| self.assertIsNone(self.__tryParse("A # CHECK: foo")) |
| self.assertIsNone(self.__tryParse("// // CHECK: foo")) |
| self.assertIsNone(self.__tryParse("# # CHECK: foo")) |
| |
| def test_WhitespaceAgnostic(self): |
| self.assertIsNotNone(self.__tryParse(" //CHECK: foo")) |
| self.assertIsNotNone(self.__tryParse("// CHECK: foo")) |
| self.assertIsNotNone(self.__tryParse(" //CHECK: foo")) |
| self.assertIsNotNone(self.__tryParse("// CHECK: foo")) |
| |
| |
| class TestCheckLine_Parse(unittest.TestCase): |
| def __getPartPattern(self, linePart): |
| if linePart.variant == checker.CheckElement.Variant.Separator: |
| return "\s+" |
| else: |
| return linePart.pattern |
| |
| def __getRegex(self, checkLine): |
| return "".join(map(lambda x: "(" + self.__getPartPattern(x) + ")", checkLine.lineParts)) |
| |
| def __tryParse(self, string): |
| return checker.CheckLine(string) |
| |
| def __parsesTo(self, string, expected): |
| self.assertEqual(expected, self.__getRegex(self.__tryParse(string))) |
| |
| def __tryParseNot(self, string): |
| return checker.CheckLine(string, checker.CheckLine.Variant.Not) |
| |
| def __parsesPattern(self, string, pattern): |
| line = self.__tryParse(string) |
| self.assertEqual(1, len(line.lineParts)) |
| self.assertEqual(checker.CheckElement.Variant.Pattern, line.lineParts[0].variant) |
| self.assertEqual(pattern, line.lineParts[0].pattern) |
| |
| def __parsesVarRef(self, string, name): |
| line = self.__tryParse(string) |
| self.assertEqual(1, len(line.lineParts)) |
| self.assertEqual(checker.CheckElement.Variant.VarRef, line.lineParts[0].variant) |
| self.assertEqual(name, line.lineParts[0].name) |
| |
| def __parsesVarDef(self, string, name, body): |
| line = self.__tryParse(string) |
| self.assertEqual(1, len(line.lineParts)) |
| self.assertEqual(checker.CheckElement.Variant.VarDef, line.lineParts[0].variant) |
| self.assertEqual(name, line.lineParts[0].name) |
| self.assertEqual(body, line.lineParts[0].pattern) |
| |
| def __doesNotParse(self, string, partType): |
| line = self.__tryParse(string) |
| self.assertEqual(1, len(line.lineParts)) |
| self.assertNotEqual(partType, line.lineParts[0].variant) |
| |
| # Test that individual parts of the line are recognized |
| |
| def test_TextOnly(self): |
| self.__parsesTo("foo", "(foo)") |
| self.__parsesTo(" foo ", "(foo)") |
| self.__parsesTo("f$o^o", "(f\$o\^o)") |
| |
| def test_TextWithWhitespace(self): |
| self.__parsesTo("foo bar", "(foo)(\s+)(bar)") |
| self.__parsesTo("foo bar", "(foo)(\s+)(bar)") |
| |
| def test_RegexOnly(self): |
| self.__parsesPattern("{{a?b.c}}", "a?b.c") |
| |
| def test_VarRefOnly(self): |
| self.__parsesVarRef("[[ABC]]", "ABC") |
| |
| def test_VarDefOnly(self): |
| self.__parsesVarDef("[[ABC:a?b.c]]", "ABC", "a?b.c") |
| |
| def test_TextWithRegex(self): |
| self.__parsesTo("foo{{abc}}bar", "(foo)(abc)(bar)") |
| |
| def test_TextWithVar(self): |
| self.__parsesTo("foo[[ABC:abc]]bar", "(foo)(abc)(bar)") |
| |
| def test_PlainWithRegexAndWhitespaces(self): |
| self.__parsesTo("foo {{abc}}bar", "(foo)(\s+)(abc)(bar)") |
| self.__parsesTo("foo{{abc}} bar", "(foo)(abc)(\s+)(bar)") |
| self.__parsesTo("foo {{abc}} bar", "(foo)(\s+)(abc)(\s+)(bar)") |
| |
| def test_PlainWithVarAndWhitespaces(self): |
| self.__parsesTo("foo [[ABC:abc]]bar", "(foo)(\s+)(abc)(bar)") |
| self.__parsesTo("foo[[ABC:abc]] bar", "(foo)(abc)(\s+)(bar)") |
| self.__parsesTo("foo [[ABC:abc]] bar", "(foo)(\s+)(abc)(\s+)(bar)") |
| |
| def test_AllKinds(self): |
| self.__parsesTo("foo [[ABC:abc]]{{def}}bar", "(foo)(\s+)(abc)(def)(bar)") |
| self.__parsesTo("foo[[ABC:abc]] {{def}}bar", "(foo)(abc)(\s+)(def)(bar)") |
| self.__parsesTo("foo [[ABC:abc]] {{def}} bar", "(foo)(\s+)(abc)(\s+)(def)(\s+)(bar)") |
| |
| # Test that variables and patterns are parsed correctly |
| |
| def test_ValidPattern(self): |
| self.__parsesPattern("{{abc}}", "abc") |
| self.__parsesPattern("{{a[b]c}}", "a[b]c") |
| self.__parsesPattern("{{(a{bc})}}", "(a{bc})") |
| |
| def test_ValidRef(self): |
| self.__parsesVarRef("[[ABC]]", "ABC") |
| self.__parsesVarRef("[[A1BC2]]", "A1BC2") |
| |
| def test_ValidDef(self): |
| self.__parsesVarDef("[[ABC:abc]]", "ABC", "abc") |
| self.__parsesVarDef("[[ABC:ab:c]]", "ABC", "ab:c") |
| self.__parsesVarDef("[[ABC:a[b]c]]", "ABC", "a[b]c") |
| self.__parsesVarDef("[[ABC:(a[bc])]]", "ABC", "(a[bc])") |
| |
| def test_Empty(self): |
| self.__doesNotParse("{{}}", checker.CheckElement.Variant.Pattern) |
| self.__doesNotParse("[[]]", checker.CheckElement.Variant.VarRef) |
| self.__doesNotParse("[[:]]", checker.CheckElement.Variant.VarDef) |
| |
| def test_InvalidVarName(self): |
| self.__doesNotParse("[[0ABC]]", checker.CheckElement.Variant.VarRef) |
| self.__doesNotParse("[[AB=C]]", checker.CheckElement.Variant.VarRef) |
| self.__doesNotParse("[[ABC=]]", checker.CheckElement.Variant.VarRef) |
| self.__doesNotParse("[[0ABC:abc]]", checker.CheckElement.Variant.VarDef) |
| self.__doesNotParse("[[AB=C:abc]]", checker.CheckElement.Variant.VarDef) |
| self.__doesNotParse("[[ABC=:abc]]", checker.CheckElement.Variant.VarDef) |
| |
| def test_BodyMatchNotGreedy(self): |
| self.__parsesTo("{{abc}}{{def}}", "(abc)(def)") |
| self.__parsesTo("[[ABC:abc]][[DEF:def]]", "(abc)(def)") |
| |
| def test_NoVarDefsInNotChecks(self): |
| with self.assertRaises(CheckerException): |
| self.__tryParseNot("[[ABC:abc]]") |
| |
| class TestCheckLine_Match(unittest.TestCase): |
| def __matchSingle(self, checkString, outputString, varState={}): |
| checkLine = checker.CheckLine(checkString) |
| newVarState = checkLine.match(outputString, varState) |
| self.assertIsNotNone(newVarState) |
| return newVarState |
| |
| def __notMatchSingle(self, checkString, outputString, varState={}): |
| checkLine = checker.CheckLine(checkString) |
| self.assertIsNone(checkLine.match(outputString, varState)) |
| |
| def test_TextAndWhitespace(self): |
| self.__matchSingle("foo", "foo") |
| self.__matchSingle("foo", " foo ") |
| self.__matchSingle("foo", "foo bar") |
| self.__notMatchSingle("foo", "XfooX") |
| self.__notMatchSingle("foo", "zoo") |
| |
| self.__matchSingle("foo bar", "foo bar") |
| self.__matchSingle("foo bar", "abc foo bar def") |
| self.__matchSingle("foo bar", "foo foo bar bar") |
| |
| self.__matchSingle("foo bar", "foo X bar") |
| self.__notMatchSingle("foo bar", "foo Xbar") |
| |
| def test_Pattern(self): |
| self.__matchSingle("foo{{A|B}}bar", "fooAbar") |
| self.__matchSingle("foo{{A|B}}bar", "fooBbar") |
| self.__notMatchSingle("foo{{A|B}}bar", "fooCbar") |
| |
| def test_VariableReference(self): |
| self.__matchSingle("foo[[X]]bar", "foobar", {"X": ""}) |
| self.__matchSingle("foo[[X]]bar", "fooAbar", {"X": "A"}) |
| self.__matchSingle("foo[[X]]bar", "fooBbar", {"X": "B"}) |
| self.__notMatchSingle("foo[[X]]bar", "foobar", {"X": "A"}) |
| self.__notMatchSingle("foo[[X]]bar", "foo bar", {"X": "A"}) |
| with self.assertRaises(CheckerException): |
| self.__matchSingle("foo[[X]]bar", "foobar", {}) |
| |
| def test_VariableDefinition(self): |
| self.__matchSingle("foo[[X:A|B]]bar", "fooAbar") |
| self.__matchSingle("foo[[X:A|B]]bar", "fooBbar") |
| self.__notMatchSingle("foo[[X:A|B]]bar", "fooCbar") |
| |
| env = self.__matchSingle("foo[[X:A.*B]]bar", "fooABbar", {}) |
| self.assertEqual(env, {"X": "AB"}) |
| env = self.__matchSingle("foo[[X:A.*B]]bar", "fooAxxBbar", {}) |
| self.assertEqual(env, {"X": "AxxB"}) |
| |
| self.__matchSingle("foo[[X:A|B]]bar[[X]]baz", "fooAbarAbaz") |
| self.__matchSingle("foo[[X:A|B]]bar[[X]]baz", "fooBbarBbaz") |
| self.__notMatchSingle("foo[[X:A|B]]bar[[X]]baz", "fooAbarBbaz") |
| |
| def test_NoVariableRedefinition(self): |
| with self.assertRaises(CheckerException): |
| self.__matchSingle("[[X:...]][[X]][[X:...]][[X]]", "foofoobarbar") |
| |
| def test_EnvNotChangedOnPartialMatch(self): |
| env = {"Y": "foo"} |
| self.__notMatchSingle("[[X:A]]bar", "Abaz", env) |
| self.assertFalse("X" in env.keys()) |
| |
| def test_VariableContentEscaped(self): |
| self.__matchSingle("[[X:..]]foo[[X]]", ".*foo.*") |
| self.__notMatchSingle("[[X:..]]foo[[X]]", ".*fooAAAA") |
| |
| |
| CheckVariant = checker.CheckLine.Variant |
| |
| def prepareSingleCheck(line): |
| if isinstance(line, str): |
| return checker.CheckLine(line) |
| else: |
| return checker.CheckLine(line[0], line[1]) |
| |
| def prepareChecks(lines): |
| if isinstance(lines, str): |
| lines = lines.splitlines() |
| return list(map(lambda line: prepareSingleCheck(line), lines)) |
| |
| |
| class TestCheckGroup_Match(unittest.TestCase): |
| def __matchMulti(self, checkLines, outputString): |
| checkGroup = checker.CheckGroup("MyGroup", prepareChecks(checkLines)) |
| outputGroup = checker.OutputGroup("MyGroup", outputString.splitlines()) |
| return checkGroup.match(outputGroup) |
| |
| def __notMatchMulti(self, checkString, outputString): |
| with self.assertRaises(CheckerException): |
| self.__matchMulti(checkString, outputString) |
| |
| def test_TextAndPattern(self): |
| self.__matchMulti("""foo bar |
| abc {{def}}""", |
| """foo bar |
| abc def"""); |
| self.__matchMulti("""foo bar |
| abc {{de.}}""", |
| """======= |
| foo bar |
| ======= |
| abc de# |
| ======="""); |
| self.__notMatchMulti("""//XYZ: foo bar |
| //XYZ: abc {{def}}""", |
| """======= |
| foo bar |
| ======= |
| abc de# |
| ======="""); |
| |
| def test_Variables(self): |
| self.__matchMulti("""foo[[X:.]]bar |
| abc[[X]]def""", |
| """foo bar |
| abc def"""); |
| self.__matchMulti("""foo[[X:([0-9]+)]]bar |
| abc[[X]]def |
| ### [[X]] ###""", |
| """foo1234bar |
| abc1234def |
| ### 1234 ###"""); |
| |
| def test_Ordering(self): |
| self.__matchMulti([("foo", CheckVariant.InOrder), |
| ("bar", CheckVariant.InOrder)], |
| """foo |
| bar""") |
| self.__notMatchMulti([("foo", CheckVariant.InOrder), |
| ("bar", CheckVariant.InOrder)], |
| """bar |
| foo""") |
| self.__matchMulti([("abc", CheckVariant.DAG), |
| ("def", CheckVariant.DAG)], |
| """abc |
| def""") |
| self.__matchMulti([("abc", CheckVariant.DAG), |
| ("def", CheckVariant.DAG)], |
| """def |
| abc""") |
| self.__matchMulti([("foo", CheckVariant.InOrder), |
| ("abc", CheckVariant.DAG), |
| ("def", CheckVariant.DAG), |
| ("bar", CheckVariant.InOrder)], |
| """foo |
| def |
| abc |
| bar""") |
| self.__notMatchMulti([("foo", CheckVariant.InOrder), |
| ("abc", CheckVariant.DAG), |
| ("def", CheckVariant.DAG), |
| ("bar", CheckVariant.InOrder)], |
| """foo |
| abc |
| bar""") |
| self.__notMatchMulti([("foo", CheckVariant.InOrder), |
| ("abc", CheckVariant.DAG), |
| ("def", CheckVariant.DAG), |
| ("bar", CheckVariant.InOrder)], |
| """foo |
| def |
| bar""") |
| |
| def test_NotAssertions(self): |
| self.__matchMulti([("foo", CheckVariant.Not)], |
| """abc |
| def""") |
| self.__notMatchMulti([("foo", CheckVariant.Not)], |
| """abc foo |
| def""") |
| self.__notMatchMulti([("foo", CheckVariant.Not), |
| ("bar", CheckVariant.Not)], |
| """abc |
| def bar""") |
| |
| def test_LineOnlyMatchesOnce(self): |
| self.__matchMulti([("foo", CheckVariant.DAG), |
| ("foo", CheckVariant.DAG)], |
| """foo |
| foo""") |
| self.__notMatchMulti([("foo", CheckVariant.DAG), |
| ("foo", CheckVariant.DAG)], |
| """foo |
| bar""") |
| |
| class TestOutputFile_Parse(unittest.TestCase): |
| def __parsesTo(self, string, expected): |
| if isinstance(string, str): |
| string = unicode(string) |
| outputStream = io.StringIO(string) |
| return self.assertEqual(checker.OutputFile(outputStream).groups, expected) |
| |
| def test_NoInput(self): |
| self.__parsesTo(None, []) |
| self.__parsesTo("", []) |
| |
| def test_SingleGroup(self): |
| self.__parsesTo("""begin_compilation |
| method "MyMethod" |
| end_compilation |
| begin_cfg |
| name "pass1" |
| foo |
| bar |
| end_cfg""", |
| [ checker.OutputGroup("MyMethod pass1", [ "foo", "bar" ]) ]) |
| |
| def test_MultipleGroups(self): |
| self.__parsesTo("""begin_compilation |
| name "xyz1" |
| method "MyMethod1" |
| date 1234 |
| end_compilation |
| begin_cfg |
| name "pass1" |
| foo |
| bar |
| end_cfg |
| begin_cfg |
| name "pass2" |
| abc |
| def |
| end_cfg""", |
| [ checker.OutputGroup("MyMethod1 pass1", [ "foo", "bar" ]), |
| checker.OutputGroup("MyMethod1 pass2", [ "abc", "def" ]) ]) |
| |
| self.__parsesTo("""begin_compilation |
| name "xyz1" |
| method "MyMethod1" |
| date 1234 |
| end_compilation |
| begin_cfg |
| name "pass1" |
| foo |
| bar |
| end_cfg |
| begin_compilation |
| name "xyz2" |
| method "MyMethod2" |
| date 5678 |
| end_compilation |
| begin_cfg |
| name "pass2" |
| abc |
| def |
| end_cfg""", |
| [ checker.OutputGroup("MyMethod1 pass1", [ "foo", "bar" ]), |
| checker.OutputGroup("MyMethod2 pass2", [ "abc", "def" ]) ]) |
| |
| class TestCheckFile_Parse(unittest.TestCase): |
| def __parsesTo(self, string, expected): |
| if isinstance(string, str): |
| string = unicode(string) |
| checkStream = io.StringIO(string) |
| return self.assertEqual(checker.CheckFile("CHECK", checkStream).groups, expected) |
| |
| def test_NoInput(self): |
| self.__parsesTo(None, []) |
| self.__parsesTo("", []) |
| |
| def test_SingleGroup(self): |
| self.__parsesTo("""// CHECK-START: Example Group |
| // CHECK: foo |
| // CHECK: bar""", |
| [ checker.CheckGroup("Example Group", prepareChecks([ "foo", "bar" ])) ]) |
| |
| def test_MultipleGroups(self): |
| self.__parsesTo("""// CHECK-START: Example Group1 |
| // CHECK: foo |
| // CHECK: bar |
| // CHECK-START: Example Group2 |
| // CHECK: abc |
| // CHECK: def""", |
| [ checker.CheckGroup("Example Group1", prepareChecks([ "foo", "bar" ])), |
| checker.CheckGroup("Example Group2", prepareChecks([ "abc", "def" ])) ]) |
| |
| def test_CheckVariants(self): |
| self.__parsesTo("""// CHECK-START: Example Group |
| // CHECK: foo |
| // CHECK-NOT: bar |
| // CHECK-DAG: abc |
| // CHECK-DAG: def""", |
| [ checker.CheckGroup("Example Group", |
| prepareChecks([ ("foo", CheckVariant.InOrder), |
| ("bar", CheckVariant.Not), |
| ("abc", CheckVariant.DAG), |
| ("def", CheckVariant.DAG) ])) ]) |
| |
| if __name__ == '__main__': |
| checker.Logger.Verbosity = checker.Logger.Level.NoOutput |
| unittest.main() |
