# Copyright 2019 Google LLC
#
# 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
#
#     https://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.

"""Tests for util.error."""

import unittest

from compiler.util import error
from compiler.util import parser_types


class MessageTest(unittest.TestCase):
  """Tests for _Message, as returned by error, warn, and note."""

  def test_error(self):
    error_message = error.error("foo.emb", parser_types.make_location(
        (3, 4), (3, 6)), "Bad thing")
    self.assertEqual("foo.emb", error_message.source_file)
    self.assertEqual(error.ERROR, error_message.severity)
    self.assertEqual(parser_types.make_location((3, 4), (3, 6)),
                     error_message.location)
    self.assertEqual("Bad thing", error_message.message)
    sourceless_format = error_message.format({})
    sourced_format = error_message.format({"foo.emb": "\n\nabcdefghijklm"})
    self.assertEqual("foo.emb:3:4: error: Bad thing",
                     "".join([x[1] for x in sourceless_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing"),  # Message
                     ], sourceless_format)
    self.assertEqual("foo.emb:3:4: error: Bad thing\n"
                     "abcdefghijklm\n"
                     "   ^^", "".join([x[1] for x in sourced_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing\n"),  # Message
                      (error.WHITE, "abcdefghijklm\n"),  # Source snippet
                      (error.BRIGHT_GREEN, "   ^^"),  # Error column indicator
                     ], sourced_format)

  def test_synthetic_error(self):
    error_message = error.error("foo.emb", parser_types.make_location(
        (3, 4), (3, 6), True), "Bad thing")
    sourceless_format = error_message.format({})
    sourced_format = error_message.format({"foo.emb": "\n\nabcdefghijklm"})
    self.assertEqual("foo.emb:[compiler bug]: error: Bad thing",
                     "".join([x[1] for x in sourceless_format]))
    self.assertEqual([
        (error.BOLD, "foo.emb:[compiler bug]: "),  # Location
        (error.BRIGHT_RED, "error: "),  # Severity
        (error.BOLD, "Bad thing"),  # Message
    ], sourceless_format)
    self.assertEqual("foo.emb:[compiler bug]: error: Bad thing",
                     "".join([x[1] for x in sourced_format]))
    self.assertEqual([
        (error.BOLD, "foo.emb:[compiler bug]: "),  # Location
        (error.BRIGHT_RED, "error: "),  # Severity
        (error.BOLD, "Bad thing"),  # Message
    ], sourced_format)

  def test_prelude_as_file_name(self):
    error_message = error.error("", parser_types.make_location(
        (3, 4), (3, 6)), "Bad thing")
    self.assertEqual("", error_message.source_file)
    self.assertEqual(error.ERROR, error_message.severity)
    self.assertEqual(parser_types.make_location((3, 4), (3, 6)),
                     error_message.location)
    self.assertEqual("Bad thing", error_message.message)
    sourceless_format = error_message.format({})
    sourced_format = error_message.format({"": "\n\nabcdefghijklm"})
    self.assertEqual("[prelude]:3:4: error: Bad thing",
                     "".join([x[1] for x in sourceless_format]))
    self.assertEqual([(error.BOLD, "[prelude]:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing"),  # Message
                     ], sourceless_format)
    self.assertEqual("[prelude]:3:4: error: Bad thing\n"
                     "abcdefghijklm\n"
                     "   ^^", "".join([x[1] for x in sourced_format]))
    self.assertEqual([(error.BOLD, "[prelude]:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing\n"),  # Message
                      (error.WHITE, "abcdefghijklm\n"),  # Source snippet
                      (error.BRIGHT_GREEN, "   ^^"),  # Error column indicator
                     ], sourced_format)

  def test_multiline_error_source(self):
    error_message = error.error("foo.emb", parser_types.make_location(
        (3, 4), (4, 6)), "Bad thing")
    self.assertEqual("foo.emb", error_message.source_file)
    self.assertEqual(error.ERROR, error_message.severity)
    self.assertEqual(parser_types.make_location((3, 4), (4, 6)),
                     error_message.location)
    self.assertEqual("Bad thing", error_message.message)
    sourceless_format = error_message.format({})
    sourced_format = error_message.format(
        {"foo.emb": "\n\nabcdefghijklm\nnopqrstuv"})
    self.assertEqual("foo.emb:3:4: error: Bad thing",
                     "".join([x[1] for x in sourceless_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing"),  # Message
                     ], sourceless_format)
    self.assertEqual("foo.emb:3:4: error: Bad thing\n"
                     "abcdefghijklm\n"
                     "   ^", "".join([x[1] for x in sourced_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing\n"),  # Message
                      (error.WHITE, "abcdefghijklm\n"),  # Source snippet
                      (error.BRIGHT_GREEN, "   ^"),  # Error column indicator
                     ], sourced_format)

  def test_multiline_error(self):
    error_message = error.error("foo.emb", parser_types.make_location(
        (3, 4), (3, 6)), "Bad thing\nSome explanation\nMore explanation")
    self.assertEqual("foo.emb", error_message.source_file)
    self.assertEqual(error.ERROR, error_message.severity)
    self.assertEqual(parser_types.make_location((3, 4), (3, 6)),
                     error_message.location)
    self.assertEqual("Bad thing\nSome explanation\nMore explanation",
                     error_message.message)
    sourceless_format = error_message.format({})
    sourced_format = error_message.format(
        {"foo.emb": "\n\nabcdefghijklm\nnopqrstuv"})
    self.assertEqual("foo.emb:3:4: error: Bad thing\n"
                     "foo.emb:3:4: note: Some explanation\n"
                     "foo.emb:3:4: note: More explanation",
                     "".join([x[1] for x in sourceless_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing\n"),  # Message
                      (error.BOLD, "foo.emb:3:4: "),  # Location, line 2
                      (error.BRIGHT_BLACK, "note: "),  # "Note" severity, line 2
                      (error.WHITE, "Some explanation\n"),  # Message, line 2
                      (error.BOLD, "foo.emb:3:4: "),  # Location, line 3
                      (error.BRIGHT_BLACK, "note: "),  # "Note" severity, line 3
                      (error.WHITE, "More explanation"),  # Message, line 3
                     ], sourceless_format)
    self.assertEqual("foo.emb:3:4: error: Bad thing\n"
                     "foo.emb:3:4: note: Some explanation\n"
                     "foo.emb:3:4: note: More explanation\n"
                     "abcdefghijklm\n"
                     "   ^^", "".join([x[1] for x in sourced_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_RED, "error: "),  # Severity
                      (error.BOLD, "Bad thing\n"),  # Message
                      (error.BOLD, "foo.emb:3:4: "),  # Location, line 2
                      (error.BRIGHT_BLACK, "note: "),  # "Note" severity, line 2
                      (error.WHITE, "Some explanation\n"),  # Message, line 2
                      (error.BOLD, "foo.emb:3:4: "),  # Location, line 3
                      (error.BRIGHT_BLACK, "note: "),  # "Note" severity, line 3
                      (error.WHITE, "More explanation\n"),  # Message, line 3
                      (error.WHITE, "abcdefghijklm\n"),  # Source snippet
                      (error.BRIGHT_GREEN, "   ^^"),  # Column indicator
                     ], sourced_format)

  def test_warn(self):
    warning_message = error.warn("foo.emb", parser_types.make_location(
        (3, 4), (3, 6)), "Not good thing")
    self.assertEqual("foo.emb", warning_message.source_file)
    self.assertEqual(error.WARNING, warning_message.severity)
    self.assertEqual(parser_types.make_location((3, 4), (3, 6)),
                     warning_message.location)
    self.assertEqual("Not good thing", warning_message.message)
    sourced_format = warning_message.format({"foo.emb": "\n\nabcdefghijklm"})
    self.assertEqual("foo.emb:3:4: warning: Not good thing\n"
                     "abcdefghijklm\n"
                     "   ^^", "".join([x[1] for x in sourced_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_MAGENTA, "warning: "),  # Severity
                      (error.BOLD, "Not good thing\n"),  # Message
                      (error.WHITE, "abcdefghijklm\n"),  # Source snippet
                      (error.BRIGHT_GREEN, "   ^^"),  # Column indicator
                     ], sourced_format)

  def test_note(self):
    note_message = error.note("foo.emb", parser_types.make_location(
        (3, 4), (3, 6)), "OK thing")
    self.assertEqual("foo.emb", note_message.source_file)
    self.assertEqual(error.NOTE, note_message.severity)
    self.assertEqual(parser_types.make_location((3, 4), (3, 6)),
                     note_message.location)
    self.assertEqual("OK thing", note_message.message)
    sourced_format = note_message.format({"foo.emb": "\n\nabcdefghijklm"})
    self.assertEqual("foo.emb:3:4: note: OK thing\n"
                     "abcdefghijklm\n"
                     "   ^^", "".join([x[1] for x in sourced_format]))
    self.assertEqual([(error.BOLD, "foo.emb:3:4: "),  # Location
                      (error.BRIGHT_BLACK, "note: "),  # Severity
                      (error.WHITE, "OK thing\n"),  # Message
                      (error.WHITE, "abcdefghijklm\n"),  # Source snippet
                      (error.BRIGHT_GREEN, "   ^^"),  # Column indicator
                     ], sourced_format)

  def test_equality(self):
    note_message = error.note("foo.emb", parser_types.make_location(
        (3, 4), (3, 6)), "thing")
    self.assertEqual(note_message,
                     error.note("foo.emb", parser_types.make_location(
                         (3, 4), (3, 6)), "thing"))
    self.assertNotEqual(note_message,
                        error.warn("foo.emb", parser_types.make_location(
                            (3, 4), (3, 6)), "thing"))
    self.assertNotEqual(note_message,
                        error.note("foo2.emb", parser_types.make_location(
                            (3, 4), (3, 6)), "thing"))
    self.assertNotEqual(note_message,
                        error.note("foo.emb", parser_types.make_location(
                            (2, 4), (3, 6)), "thing"))
    self.assertNotEqual(note_message,
                        error.note("foo.emb", parser_types.make_location(
                            (3, 4), (3, 6)), "thing2"))


class StringTest(unittest.TestCase):
  """Tests for strings."""

  # These strings are a fixed part of the API.

  def test_color_strings(self):
    self.assertEqual("\033[0;30m", error.BLACK)
    self.assertEqual("\033[0;31m", error.RED)
    self.assertEqual("\033[0;32m", error.GREEN)
    self.assertEqual("\033[0;33m", error.YELLOW)
    self.assertEqual("\033[0;34m", error.BLUE)
    self.assertEqual("\033[0;35m", error.MAGENTA)
    self.assertEqual("\033[0;36m", error.CYAN)
    self.assertEqual("\033[0;37m", error.WHITE)
    self.assertEqual("\033[0;1;30m", error.BRIGHT_BLACK)
    self.assertEqual("\033[0;1;31m", error.BRIGHT_RED)
    self.assertEqual("\033[0;1;32m", error.BRIGHT_GREEN)
    self.assertEqual("\033[0;1;33m", error.BRIGHT_YELLOW)
    self.assertEqual("\033[0;1;34m", error.BRIGHT_BLUE)
    self.assertEqual("\033[0;1;35m", error.BRIGHT_MAGENTA)
    self.assertEqual("\033[0;1;36m", error.BRIGHT_CYAN)
    self.assertEqual("\033[0;1;37m", error.BRIGHT_WHITE)
    self.assertEqual("\033[0;1m", error.BOLD)
    self.assertEqual("\033[0m", error.RESET)

  def test_error_strings(self):
    self.assertEqual("error", error.ERROR)
    self.assertEqual("warning", error.WARNING)
    self.assertEqual("note", error.NOTE)


class SplitErrorsTest(unittest.TestCase):

  def test_split_errors(self):
    user_error = [
        error.error("foo.emb", parser_types.make_location((1, 2), (3, 4)),
                    "Bad thing"),
        error.note("foo.emb", parser_types.make_location((3, 4), (5, 6)),
                   "Note: bad thing referrent")
    ]
    user_error_2 = [
        error.error("foo.emb", parser_types.make_location((8, 9), (10, 11)),
                    "Bad thing"),
        error.note("foo.emb", parser_types.make_location((10, 11), (12, 13)),
                   "Note: bad thing referrent")
    ]
    synthetic_error = [
        error.error("foo.emb", parser_types.make_location((1, 2), (3, 4)),
                    "Bad thing"),
        error.note("foo.emb", parser_types.make_location((3, 4), (5, 6), True),
                   "Note: bad thing referrent")
    ]
    synthetic_error_2 = [
        error.error("foo.emb",
                    parser_types.make_location((8, 9), (10, 11), True),
                    "Bad thing"),
        error.note("foo.emb", parser_types.make_location((10, 11), (12, 13)),
                   "Note: bad thing referrent")
    ]
    user_errors, synthetic_errors = error.split_errors(
        [user_error, synthetic_error])
    self.assertEqual([user_error], user_errors)
    self.assertEqual([synthetic_error], synthetic_errors)
    user_errors, synthetic_errors = error.split_errors(
        [synthetic_error, user_error])
    self.assertEqual([user_error], user_errors)
    self.assertEqual([synthetic_error], synthetic_errors)
    user_errors, synthetic_errors = error.split_errors(
        [synthetic_error, user_error, synthetic_error_2, user_error_2])
    self.assertEqual([user_error, user_error_2], user_errors)
    self.assertEqual([synthetic_error, synthetic_error_2], synthetic_errors)

  def test_filter_errors(self):
    user_error = [
        error.error("foo.emb", parser_types.make_location((1, 2), (3, 4)),
                    "Bad thing"),
        error.note("foo.emb", parser_types.make_location((3, 4), (5, 6)),
                   "Note: bad thing referrent")
    ]
    synthetic_error = [
        error.error("foo.emb", parser_types.make_location((1, 2), (3, 4)),
                    "Bad thing"),
        error.note("foo.emb", parser_types.make_location((3, 4), (5, 6), True),
                   "Note: bad thing referrent")
    ]
    synthetic_error_2 = [
        error.error("foo.emb",
                    parser_types.make_location((8, 9), (10, 11), True),
                    "Bad thing"),
        error.note("foo.emb", parser_types.make_location((10, 11), (12, 13)),
                   "Note: bad thing referrent")
    ]
    self.assertEqual(
        [user_error],
        error.filter_errors([synthetic_error, user_error, synthetic_error_2]))


class FormatErrorsTest(unittest.TestCase):

  def test_format_errors(self):
    errors = [[error.note("foo.emb", parser_types.make_location((3, 4), (3, 6)),
                          "note")]]
    sources = {"foo.emb": "x\ny\nz  bcd\nq\n"}
    self.assertEqual("foo.emb:3:4: note: note\n"
                     "z  bcd\n"
                     "   ^^", error.format_errors(errors, sources))
    bold = error.BOLD
    reset = error.RESET
    white = error.WHITE
    bright_black = error.BRIGHT_BLACK
    bright_green = error.BRIGHT_GREEN
    self.assertEqual(bold + "foo.emb:3:4: " + reset + bright_black + "note: " +
                     reset + white + "note\n" +
                     reset + white + "z  bcd\n" +
                     reset + bright_green + "   ^^" + reset,
                     error.format_errors(errors, sources, use_color=True))

if __name__ == "__main__":
  unittest.main()