#!/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.

from common.archs               import archs_list
from common.testing             import ToUnicode
from file_format.checker.parser import ParseCheckerStream
from file_format.checker.struct import CheckerFile, TestCase, TestAssertion, TestExpression

import io
import unittest

CheckerException = SystemExit

class CheckerParser_PrefixTest(unittest.TestCase):

  def tryParse(self, string):
    checkerText = u"/// CHECK-START: pass\n" + ToUnicode(string)
    return ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))

  def assertParses(self, string):
    checkFile = self.tryParse(string)
    self.assertEqual(len(checkFile.testCases), 1)
    self.assertNotEqual(len(checkFile.testCases[0].assertions), 0)

  def assertIgnored(self, string):
    checkFile = self.tryParse(string)
    self.assertEqual(len(checkFile.testCases), 1)
    self.assertEqual(len(checkFile.testCases[0].assertions), 0)

  def assertInvalid(self, string):
    with self.assertRaises(CheckerException):
      self.tryParse(string)

  def test_ValidFormat(self):
    self.assertParses("///CHECK:foo")
    self.assertParses("##CHECK:bar")

  def test_InvalidFormat(self):
    self.assertIgnored("CHECK")
    self.assertIgnored(":CHECK")
    self.assertIgnored("CHECK:")
    self.assertIgnored("//CHECK")
    self.assertIgnored("#CHECK")
    self.assertInvalid("///CHECK")
    self.assertInvalid("##CHECK")

  def test_InvalidPrefix(self):
    self.assertInvalid("///ACHECK:foo")
    self.assertInvalid("##ACHECK:foo")

  def test_NotFirstOnTheLine(self):
    self.assertIgnored("A/// CHECK: foo")
    self.assertIgnored("A # CHECK: foo")
    self.assertInvalid("/// /// CHECK: foo")
    self.assertInvalid("## ## CHECK: foo")

  def test_WhitespaceAgnostic(self):
    self.assertParses("  ///CHECK: foo")
    self.assertParses("///  CHECK: foo")
    self.assertParses("    ///CHECK: foo")
    self.assertParses("///    CHECK: foo")

class CheckerParser_TestExpressionTest(unittest.TestCase):

  def parseAssertion(self, string, variant=""):
    checkerText = (u"/// CHECK-START: pass\n" +
                   u"/// CHECK" + ToUnicode(variant) + u": " + ToUnicode(string))
    checkerFile = ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
    self.assertEqual(len(checkerFile.testCases), 1)
    testCase = checkerFile.testCases[0]
    self.assertEqual(len(testCase.assertions), 1)
    return testCase.assertions[0]

  def parseExpression(self, string):
    line = self.parseAssertion(string)
    self.assertEqual(1, len(line.expressions))
    return line.expressions[0]

  def assertEqualsRegex(self, string, expected):
    self.assertEqual(expected, self.parseAssertion(string).toRegex())

  def assertEqualsText(self, string, text):
    self.assertEqual(self.parseExpression(string), TestExpression.createPatternFromPlainText(text))

  def assertEqualsPattern(self, string, pattern):
    self.assertEqual(self.parseExpression(string), TestExpression.createPattern(pattern))

  def assertEqualsVarRef(self, string, name):
    self.assertEqual(self.parseExpression(string), TestExpression.createVariableReference(name))

  def assertEqualsVarDef(self, string, name, pattern):
    self.assertEqual(self.parseExpression(string),
                     TestExpression.createVariableDefinition(name, pattern))

  def assertVariantNotEqual(self, string, variant):
    self.assertNotEqual(variant, self.parseExpression(string).variant)

  # Test that individual parts of the line are recognized

  def test_TextOnly(self):
    self.assertEqualsText("foo", "foo")
    self.assertEqualsText("  foo  ", "foo")
    self.assertEqualsRegex("f$o^o", "(f\$o\^o)")

  def test_PatternOnly(self):
    self.assertEqualsPattern("{{a?b.c}}", "a?b.c")

  def test_VarRefOnly(self):
    self.assertEqualsVarRef("<<ABC>>", "ABC")

  def test_VarDefOnly(self):
    self.assertEqualsVarDef("<<ABC:a?b.c>>", "ABC", "a?b.c")

  def test_TextWithWhitespace(self):
    self.assertEqualsRegex("foo bar", "(foo), (bar)")
    self.assertEqualsRegex("foo   bar", "(foo), (bar)")

  def test_TextWithRegex(self):
    self.assertEqualsRegex("foo{{abc}}bar", "(foo)(abc)(bar)")

  def test_TextWithVar(self):
    self.assertEqualsRegex("foo<<ABC:abc>>bar", "(foo)(abc)(bar)")

  def test_PlainWithRegexAndWhitespaces(self):
    self.assertEqualsRegex("foo {{abc}}bar", "(foo), (abc)(bar)")
    self.assertEqualsRegex("foo{{abc}} bar", "(foo)(abc), (bar)")
    self.assertEqualsRegex("foo {{abc}} bar", "(foo), (abc), (bar)")

  def test_PlainWithVarAndWhitespaces(self):
    self.assertEqualsRegex("foo <<ABC:abc>>bar", "(foo), (abc)(bar)")
    self.assertEqualsRegex("foo<<ABC:abc>> bar", "(foo)(abc), (bar)")
    self.assertEqualsRegex("foo <<ABC:abc>> bar", "(foo), (abc), (bar)")

  def test_AllKinds(self):
    self.assertEqualsRegex("foo <<ABC:abc>>{{def}}bar", "(foo), (abc)(def)(bar)")
    self.assertEqualsRegex("foo<<ABC:abc>> {{def}}bar", "(foo)(abc), (def)(bar)")
    self.assertEqualsRegex("foo <<ABC:abc>> {{def}} bar", "(foo), (abc), (def), (bar)")

  # # Test that variables and patterns are parsed correctly

  def test_ValidPattern(self):
    self.assertEqualsPattern("{{abc}}", "abc")
    self.assertEqualsPattern("{{a[b]c}}", "a[b]c")
    self.assertEqualsPattern("{{(a{bc})}}", "(a{bc})")

  def test_ValidRef(self):
    self.assertEqualsVarRef("<<ABC>>", "ABC")
    self.assertEqualsVarRef("<<A1BC2>>", "A1BC2")

  def test_ValidDef(self):
    self.assertEqualsVarDef("<<ABC:abc>>", "ABC", "abc")
    self.assertEqualsVarDef("<<ABC:ab:c>>", "ABC", "ab:c")
    self.assertEqualsVarDef("<<ABC:a[b]c>>", "ABC", "a[b]c")
    self.assertEqualsVarDef("<<ABC:(a[bc])>>", "ABC", "(a[bc])")

  def test_Empty(self):
    self.assertEqualsText("{{}}", "{{}}")
    self.assertVariantNotEqual("<<>>", TestExpression.Variant.VarRef)
    self.assertVariantNotEqual("<<:>>", TestExpression.Variant.VarDef)

  def test_InvalidVarName(self):
    self.assertVariantNotEqual("<<0ABC>>", TestExpression.Variant.VarRef)
    self.assertVariantNotEqual("<<AB=C>>", TestExpression.Variant.VarRef)
    self.assertVariantNotEqual("<<ABC=>>", TestExpression.Variant.VarRef)
    self.assertVariantNotEqual("<<0ABC:abc>>", TestExpression.Variant.VarDef)
    self.assertVariantNotEqual("<<AB=C:abc>>", TestExpression.Variant.VarDef)
    self.assertVariantNotEqual("<<ABC=:abc>>", TestExpression.Variant.VarDef)

  def test_BodyMatchNotGreedy(self):
    self.assertEqualsRegex("{{abc}}{{def}}", "(abc)(def)")
    self.assertEqualsRegex("<<ABC:abc>><<DEF:def>>", "(abc)(def)")

  def test_NoVarDefsInNotChecks(self):
    with self.assertRaises(CheckerException):
      self.parseAssertion("<<ABC:abc>>", "-NOT")


class CheckerParser_FileLayoutTest(unittest.TestCase):

  # Creates an instance of CheckerFile from provided info.
  # Data format: [ ( <case-name>, [ ( <text>, <assert-variant> ), ... ] ), ... ]
  def createFile(self, caseList):
    testFile = CheckerFile("<test_file>")
    for caseEntry in caseList:
      caseName = caseEntry[0]
      testCase = TestCase(testFile, caseName, 0)
      assertionList = caseEntry[1]
      for assertionEntry in assertionList:
        content = assertionEntry[0]
        variant = assertionEntry[1]
        assertion = TestAssertion(testCase, variant, content, 0)
        assertion.addExpression(TestExpression.createPatternFromPlainText(content))
    return testFile

  def assertParsesTo(self, checkerText, expectedData):
    expectedFile = self.createFile(expectedData)
    actualFile = self.parse(checkerText)
    return self.assertEqual(expectedFile, actualFile)

  def parse(self, checkerText):
    return ParseCheckerStream("<test_file>", "CHECK", io.StringIO(ToUnicode(checkerText)))

  def test_EmptyFile(self):
    self.assertParsesTo("", [])

  def test_SingleGroup(self):
    self.assertParsesTo(
      """
        /// CHECK-START: Example Group
        /// CHECK:  foo
        /// CHECK:    bar
      """,
      [ ( "Example Group", [ ("foo", TestAssertion.Variant.InOrder),
                             ("bar", TestAssertion.Variant.InOrder) ] ) ])

  def test_MultipleGroups(self):
    self.assertParsesTo(
      """
        /// CHECK-START: Example Group1
        /// CHECK: foo
        /// CHECK: bar
        /// CHECK-START: Example Group2
        /// CHECK: abc
        /// CHECK: def
      """,
      [ ( "Example Group1", [ ("foo", TestAssertion.Variant.InOrder),
                              ("bar", TestAssertion.Variant.InOrder) ] ),
        ( "Example Group2", [ ("abc", TestAssertion.Variant.InOrder),
                              ("def", TestAssertion.Variant.InOrder) ] ) ])

  def test_AssertionVariants(self):
    self.assertParsesTo(
      """
        /// CHECK-START: Example Group
        /// CHECK:      foo1
        /// CHECK:      foo2
        /// CHECK-NEXT: foo3
        /// CHECK-NEXT: foo4
        /// CHECK-NOT:  bar
        /// CHECK-DAG:  abc
        /// CHECK-DAG:  def
      """,
      [ ( "Example Group", [ ("foo1", TestAssertion.Variant.InOrder),
                             ("foo2", TestAssertion.Variant.InOrder),
                             ("foo3", TestAssertion.Variant.NextLine),
                             ("foo4", TestAssertion.Variant.NextLine),
                             ("bar", TestAssertion.Variant.Not),
                             ("abc", TestAssertion.Variant.DAG),
                             ("def", TestAssertion.Variant.DAG) ] ) ])

  def test_MisplacedNext(self):
    with self.assertRaises(CheckerException):
      self.parse(
        """
          /// CHECK-START: Example Group
          /// CHECK-DAG:  foo
          /// CHECK-NEXT: bar
        """)
    with self.assertRaises(CheckerException):
      self.parse(
        """
          /// CHECK-START: Example Group
          /// CHECK-NOT:  foo
          /// CHECK-NEXT: bar
        """)
    with self.assertRaises(CheckerException):
      self.parse(
        """
          /// CHECK-START: Example Group
          /// CHECK-EVAL: foo
          /// CHECK-NEXT: bar
        """)
    with self.assertRaises(CheckerException):
      self.parse(
        """
          /// CHECK-START: Example Group
          /// CHECK-NEXT: bar
        """)

class CheckerParser_SuffixTests(unittest.TestCase):

  noarch_block = """
                  /// CHECK-START: Group
                  /// CHECK:       foo
                  /// CHECK-NEXT:  bar
                  /// CHECK-NOT:   baz
                  /// CHECK-DAG:   yoyo
                """

  arch_block = """
                  /// CHECK-START-{test_arch}: Group
                  /// CHECK:       foo
                  /// CHECK-NEXT:  bar
                  /// CHECK-NOT:   baz
                  /// CHECK-DAG:   yoyo
                """

  def parse(self, checkerText):
    return ParseCheckerStream("<test_file>", "CHECK", io.StringIO(ToUnicode(checkerText)))

  def test_NonArchTests(self):
    for arch in [None] + archs_list:
      checkerFile = self.parse(self.noarch_block)
      self.assertEqual(len(checkerFile.testCases), 1)
      self.assertEqual(len(checkerFile.testCases[0].assertions), 4)

  def test_IgnoreNonTargetArch(self):
    for targetArch in archs_list:
      for testArch in [a for a in archs_list if a != targetArch]:
        checkerText = self.arch_block.format(test_arch = testArch)
        checkerFile = self.parse(checkerText)
        self.assertEqual(len(checkerFile.testCases), 1)
        self.assertEqual(len(checkerFile.testCasesForArch(testArch)), 1)
        self.assertEqual(len(checkerFile.testCasesForArch(targetArch)), 0)

  def test_Arch(self):
    for arch in archs_list:
      checkerText = self.arch_block.format(test_arch = arch)
      checkerFile = self.parse(checkerText)
      self.assertEqual(len(checkerFile.testCases), 1)
      self.assertEqual(len(checkerFile.testCasesForArch(arch)), 1)
      self.assertEqual(len(checkerFile.testCases[0].assertions), 4)

  def test_NoDebugAndArch(self):
    testCase = self.parse("""
        /// CHECK-START: Group
        /// CHECK: foo
        """).testCases[0]
    self.assertFalse(testCase.forDebuggable)
    self.assertEqual(testCase.testArch, None)

  def test_SetDebugNoArch(self):
    testCase = self.parse("""
        /// CHECK-START-DEBUGGABLE: Group
        /// CHECK: foo
        """).testCases[0]
    self.assertTrue(testCase.forDebuggable)
    self.assertEqual(testCase.testArch, None)

  def test_NoDebugSetArch(self):
    testCase = self.parse("""
        /// CHECK-START-ARM: Group
        /// CHECK: foo
        """).testCases[0]
    self.assertFalse(testCase.forDebuggable)
    self.assertEqual(testCase.testArch, "ARM")

  def test_SetDebugAndArch(self):
    testCase = self.parse("""
        /// CHECK-START-ARM-DEBUGGABLE: Group
        /// CHECK: foo
        """).testCases[0]
    self.assertTrue(testCase.forDebuggable)
    self.assertEqual(testCase.testArch, "ARM")

class CheckerParser_EvalTests(unittest.TestCase):
  def parseTestCase(self, string):
    checkerText = u"/// CHECK-START: pass\n" + ToUnicode(string)
    checkerFile = ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
    self.assertEqual(len(checkerFile.testCases), 1)
    return checkerFile.testCases[0]

  def parseExpressions(self, string):
    testCase = self.parseTestCase("/// CHECK-EVAL: " + string)
    self.assertEqual(len(testCase.assertions), 1)
    assertion = testCase.assertions[0]
    self.assertEqual(assertion.variant, TestAssertion.Variant.Eval)
    self.assertEqual(assertion.originalText, string)
    return assertion.expressions

  def assertParsesToPlainText(self, text):
    testCase = self.parseTestCase("/// CHECK-EVAL: " + text)
    self.assertEqual(len(testCase.assertions), 1)
    assertion = testCase.assertions[0]
    self.assertEqual(assertion.variant, TestAssertion.Variant.Eval)
    self.assertEqual(assertion.originalText, text)
    self.assertEqual(len(assertion.expressions), 1)
    expression = assertion.expressions[0]
    self.assertEqual(expression.variant, TestExpression.Variant.PlainText)
    self.assertEqual(expression.text, text)

  def test_PlainText(self):
    self.assertParsesToPlainText("XYZ")
    self.assertParsesToPlainText("True")
    self.assertParsesToPlainText("{{abc}}")
    self.assertParsesToPlainText("<<ABC:abc>>")
    self.assertParsesToPlainText("<<ABC=>>")

  def test_VariableReference(self):
    self.assertEqual(self.parseExpressions("<<ABC>>"),
                     [ TestExpression.createVariableReference("ABC") ])
    self.assertEqual(self.parseExpressions("123<<ABC>>"),
                     [ TestExpression.createPlainText("123"),
                       TestExpression.createVariableReference("ABC") ])
    self.assertEqual(self.parseExpressions("123  <<ABC>>"),
                     [ TestExpression.createPlainText("123  "),
                       TestExpression.createVariableReference("ABC") ])
    self.assertEqual(self.parseExpressions("<<ABC>>XYZ"),
                     [ TestExpression.createVariableReference("ABC"),
                       TestExpression.createPlainText("XYZ") ])
    self.assertEqual(self.parseExpressions("<<ABC>>   XYZ"),
                     [ TestExpression.createVariableReference("ABC"),
                       TestExpression.createPlainText("   XYZ") ])
    self.assertEqual(self.parseExpressions("123<<ABC>>XYZ"),
                     [ TestExpression.createPlainText("123"),
                       TestExpression.createVariableReference("ABC"),
                       TestExpression.createPlainText("XYZ") ])
    self.assertEqual(self.parseExpressions("123 <<ABC>>  XYZ"),
                     [ TestExpression.createPlainText("123 "),
                       TestExpression.createVariableReference("ABC"),
                       TestExpression.createPlainText("  XYZ") ])