# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import contextlib
import logging
import unittest
import sys

from cmakelang.format import __main__
from cmakelang import configuration
from cmakelang import lex
from cmakelang import parse
from cmakelang.format import formatter
from cmakelang.parse.common import NodeType


def strip_indent(content, indent=6):
  """
  Strings used in this file are indented by 6-spaces to keep them readable
  within the python code that they are embedded. Remove those 6-spaces from
  the front of each line before running the tests.
  """

  # NOTE(josh): don't use splitlines() so that we get the same result
  # regardless of windows or unix line endings in content.
  return '\n'.join([line[indent:] for line in content.split('\n')])


def overzip(iterable_a, iterable_b):
  """
  Like itertools.izip but instead if the two lists have different sizes then
  the resulting generator will yield a number of pairs equal to the larger of
  the two inputs (rathe than the smaller). The empty list will be padded with
  None elements.
  """
  iter_a = iter(iterable_a)
  iter_b = iter(iterable_b)

  item_a = next(iter_a, None)
  item_b = next(iter_b, None)

  while item_a is not None and item_b is not None:
    yield(item_a, item_b)
    item_a = next(iter_a, None)
    item_b = next(iter_b, None)

  while item_a is not None:
    yield(item_a, None)
    item_a = next(iter_a, None)

  while item_b is not None:
    yield(None, item_b)
    item_b = next(iter_b, None)


def assert_tree(test, nodes, tups, tree=None, history=None):
  if tree is None:
    tree = nodes
  if history is None:
    history = []

  for node, tup in overzip(nodes, tups):
    if isinstance(node, lex.Token):
      continue
    subhistory = history + [node]
    message = (" for node {} at\n {} \n\n\n"
               "If the actual result is expected, then update the test with"
               " this:\n# pylint: disable=bad-continuation\n# noqa: E122\n{}"
               .format(node,
                       formatter.tree_string(tree, subhistory),
                       formatter.test_string(tree)))
    test.assertIsNotNone(node, msg="Missing node" + message)
    test.assertIsNotNone(tup, msg="Extra node" + message)
    if len(tup) == 6:
      ntype, wrap, row, col, colextent, expect_children = tup
      test.assertEqual(node.passno, wrap,
                       msg="Expected wrap={}".format(wrap) + message)
    else:
      ntype, row, col, colextent, expect_children = tup

    test.assertEqual(node.node_type, ntype,
                     msg="Expected type={}".format(ntype) + message)
    test.assertEqual(node.position[0], row,
                     msg="Expected row={}".format(row) + message)
    test.assertEqual(node.position[1], col,
                     msg="Expected col={}".format(col) + message)
    test.assertEqual(node.colextent, colextent,
                     msg="Expected colextent={}".format(colextent) + message)
    assert_tree(test, node.children, expect_children, tree, subhistory)


class TestCanonicalLayout(unittest.TestCase):
  """
  Given a bunch of example inputs, ensure that the output is as expected.
  """

  def __init__(self, *args, **kwargs):
    super(TestCanonicalLayout, self).__init__(*args, **kwargs)
    self.config = configuration.Configuration()
    parse_db = parse.funs.get_parse_db()
    self.parse_ctx = parse.ParseContext(parse_db)

  def setUp(self):
    self.config.parse.fn_spec.add(
        'foo',
        flags=['BAR', 'BAZ'],
        kwargs={
            "HEADERS": '*',
            "SOURCES": '*',
            "DEPENDS": '*'
        })

    self.parse_ctx.parse_db.update(
        parse.funs.get_funtree(self.config.parse.fn_spec))

  def tearDown(self):
    pass

  @contextlib.contextmanager
  def subTest(self, msg=None, **params):
    # pylint: disable=no-member
    if sys.version_info < (3, 4, 0):
      yield None
    else:
      yield super(TestCanonicalLayout, self).subTest(msg=msg, **params)

  def do_layout_test(self, input_str, expect_tree, strip_len=6):
    """
    Run the formatter on the input string and assert that the result matches
    the output string
    """

    input_str = strip_indent(input_str, strip_len)
    tokens = lex.tokenize(input_str)
    parse_tree = parse.parse(tokens, self.parse_ctx)
    box_tree = formatter.layout_tree(parse_tree, self.config)
    assert_tree(self, [box_tree], expect_tree)

  def test_simple_statement(self):
    self.do_layout_test("""\
      cmake_minimum_required(VERSION 2.8.11)
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 38, [
  (NodeType.STATEMENT, 0, 0, 0, 38, [
    (NodeType.FUNNAME, 0, 0, 0, 22, []),
    (NodeType.LPAREN, 0, 0, 22, 23, []),
    (NodeType.ARGGROUP, 0, 0, 23, 37, [
      (NodeType.KWARGGROUP, 0, 0, 23, 37, [
        (NodeType.KEYWORD, 0, 0, 23, 30, []),
        (NodeType.ARGGROUP, 0, 0, 31, 37, [
          (NodeType.PARGGROUP, 0, 0, 31, 37, [
            (NodeType.ARGUMENT, 0, 0, 31, 37, []),
          ]),
        ]),
      ]),
    ]),
    (NodeType.RPAREN, 0, 0, 37, 38, []),
  ]),
]),
      ])

  def test_collapse_additional_newlines(self):
    self.do_layout_test("""\
      # The following multiple newlines should be collapsed into a single newline




      cmake_minimum_required(VERSION 2.8.11)
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 75, [
  (NodeType.COMMENT, 0, 0, 0, 75, []),
  (NodeType.WHITESPACE, 0, 1, 0, 0, []),
  (NodeType.STATEMENT, 0, 2, 0, 38, [
    (NodeType.FUNNAME, 0, 2, 0, 22, []),
    (NodeType.LPAREN, 0, 2, 22, 23, []),
    (NodeType.ARGGROUP, 0, 2, 23, 37, [
      (NodeType.KWARGGROUP, 0, 2, 23, 37, [
        (NodeType.KEYWORD, 0, 2, 23, 30, []),
        (NodeType.ARGGROUP, 0, 2, 31, 37, [
          (NodeType.PARGGROUP, 0, 2, 31, 37, [
            (NodeType.ARGUMENT, 0, 2, 31, 37, []),
          ]),
        ]),
      ]),
    ]),
    (NodeType.RPAREN, 0, 2, 37, 38, []),
  ]),
]),
      ])

  def test_multiline_reflow(self):
    self.do_layout_test("""\
      # This multiline-comment should be reflowed
      # into a single comment
      # on one line
      """, [
          (NodeType.BODY, 0, 0, 77, [
              (NodeType.COMMENT, 0, 0, 77, []),
          ])
      ])

  def test_long_args_command_split(self):
    self.do_layout_test("""\
      # This very long command should be split to multiple lines
      set(HEADERS very_long_header_name_a.h very_long_header_name_b.h very_long_header_name_c.h)
      """, [
# pylint: disable=bad-continuation
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 63, [
  (NodeType.COMMENT, 0, 0, 0, 58, []),
  (NodeType.STATEMENT, 0, 1, 0, 63, [
    (NodeType.FUNNAME, 0, 1, 0, 3, []),
    (NodeType.LPAREN, 0, 1, 3, 4, []),
    (NodeType.ARGGROUP, 0, 1, 4, 63, [
      (NodeType.PARGGROUP, 0, 1, 4, 11, [
        (NodeType.ARGUMENT, 0, 1, 4, 11, []),
      ]),
      (NodeType.PARGGROUP, 0, 1, 12, 63, [
        (NodeType.ARGUMENT, 0, 1, 12, 37, []),
        (NodeType.ARGUMENT, 0, 1, 38, 63, []),
        (NodeType.ARGUMENT, 0, 2, 12, 37, []),
      ]),
    ]),
    (NodeType.RPAREN, 0, 2, 37, 38, []),
  ]),
]),
      ])

  def test_long_arg_on_newline(self):
    self.do_layout_test("""\
      # This command has a very long argument and can't be aligned with the command
      # end, so it should be moved to a new line with block indent + 1.
      some_long_command_name("Some very long argument that really needs to be on the next line.")
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 77, [
  (NodeType.COMMENT, 0, 0, 0, 77, []),
  (NodeType.STATEMENT, 1, 2, 0, 70, [
    (NodeType.FUNNAME, 0, 2, 0, 22, []),
    (NodeType.LPAREN, 0, 2, 22, 23, []),
    (NodeType.ARGGROUP, 0, 3, 2, 69, [
      (NodeType.PARGGROUP, 0, 3, 2, 69, [
        (NodeType.ARGUMENT, 0, 3, 2, 69, []),
      ]),
    ]),
    (NodeType.RPAREN, 0, 3, 69, 70, []),
  ]),
]),
      ])

  def test_argcomment_preserved_and_reflowed(self):
    self.do_layout_test("""\
      set(HEADERS header_a.h header_b.h # This comment should
                                        # be preserved, moreover it should be split
                                        # across two lines.
          header_c.h header_d.h)
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 80, [
  (NodeType.STATEMENT, 4, 0, 0, 80, [
    (NodeType.FUNNAME, 0, 0, 0, 3, []),
    (NodeType.LPAREN, 0, 0, 3, 4, []),
    (NodeType.ARGGROUP, 4, 0, 4, 80, [
      (NodeType.PARGGROUP, 0, 0, 4, 11, [
        (NodeType.ARGUMENT, 0, 0, 4, 11, []),
      ]),
      (NodeType.PARGGROUP, 0, 1, 4, 80, [
        (NodeType.ARGUMENT, 0, 1, 4, 14, []),
        (NodeType.ARGUMENT, 0, 1, 15, 80, [
          (NodeType.COMMENT, 0, 1, 26, 80, []),
        ]),
        (NodeType.ARGUMENT, 0, 3, 4, 14, []),
        (NodeType.ARGUMENT, 0, 3, 15, 25, []),
      ]),
    ]),
    (NodeType.RPAREN, 0, 3, 25, 26, []),
  ]),
]),
      ])

  def test_complex_nested_stuff(self):
    self.config.format.autosort = False
    self.do_layout_test("""\
      if(foo)
      if(sbar)
      # This comment is in-scope.
      add_library(foo_bar_baz foo.cc bar.cc # this is a comment for arg2
                    # this is more comment for arg2, it should be joined with the first.
          baz.cc) # This comment is part of add_library

      other_command(some_long_argument some_long_argument) # this comment is very long and gets split across some lines

      other_command(some_long_argument some_long_argument some_long_argument) # this comment is even longer and wouldn't make sense to pack at the end of the command so it gets it's own lines
      endif()
      endif()
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 80, [
  (NodeType.FLOW_CONTROL, 0, 0, 0, 80, [
    (NodeType.STATEMENT, 0, 0, 0, 7, [
      (NodeType.FUNNAME, 0, 0, 0, 2, []),
      (NodeType.LPAREN, 0, 0, 2, 3, []),
      (NodeType.ARGGROUP, 0, 0, 3, 6, [
        (NodeType.PARGGROUP, 0, 0, 3, 6, [
          (NodeType.ARGUMENT, 0, 0, 3, 6, []),
        ]),
      ]),
      (NodeType.RPAREN, 0, 0, 6, 7, []),
    ]),
    (NodeType.BODY, 0, 1, 2, 80, [
      (NodeType.FLOW_CONTROL, 0, 1, 2, 80, [
        (NodeType.STATEMENT, 0, 1, 2, 10, [
          (NodeType.FUNNAME, 0, 1, 2, 4, []),
          (NodeType.LPAREN, 0, 1, 4, 5, []),
          (NodeType.ARGGROUP, 0, 1, 5, 9, [
            (NodeType.PARGGROUP, 0, 1, 5, 9, [
              (NodeType.ARGUMENT, 0, 1, 5, 9, []),
            ]),
          ]),
          (NodeType.RPAREN, 0, 1, 9, 10, []),
        ]),
        (NodeType.BODY, 0, 2, 4, 80, [
          (NodeType.COMMENT, 0, 2, 4, 31, []),
          (NodeType.STATEMENT, 4, 3, 4, 74, [
            (NodeType.FUNNAME, 0, 3, 4, 15, []),
            (NodeType.LPAREN, 0, 3, 15, 16, []),
            (NodeType.ARGGROUP, 4, 4, 6, 74, [
              (NodeType.PARGGROUP, 0, 4, 6, 17, [
                (NodeType.ARGUMENT, 0, 4, 6, 17, []),
              ]),
              (NodeType.PARGGROUP, 0, 5, 6, 74, [
                (NodeType.ARGUMENT, 0, 5, 6, 12, []),
                (NodeType.ARGUMENT, 0, 5, 13, 48, [
                  (NodeType.COMMENT, 0, 5, 20, 48, []),
                ]),
                (NodeType.COMMENT, 0, 6, 6, 74, []),
                (NodeType.ARGUMENT, 0, 7, 6, 12, []),
              ]),
            ]),
            (NodeType.RPAREN, 0, 7, 12, 13, []),
            (NodeType.COMMENT, 0, 7, 14, 51, []),
          ]),
          (NodeType.WHITESPACE, 0, 8, 4, 0, []),
          (NodeType.STATEMENT, 1, 9, 4, 76, [
            (NodeType.FUNNAME, 0, 9, 4, 17, []),
            (NodeType.LPAREN, 0, 9, 17, 18, []),
            (NodeType.ARGGROUP, 0, 10, 6, 43, [
              (NodeType.PARGGROUP, 0, 10, 6, 43, [
                (NodeType.ARGUMENT, 0, 10, 6, 24, []),
                (NodeType.ARGUMENT, 0, 10, 25, 43, []),
              ]),
            ]),
            (NodeType.RPAREN, 0, 10, 43, 44, []),
            (NodeType.COMMENT, 0, 10, 45, 76, []),
          ]),
          (NodeType.WHITESPACE, 0, 12, 4, 0, []),
          (NodeType.STATEMENT, 1, 13, 4, 80, [
            (NodeType.FUNNAME, 0, 13, 4, 17, []),
            (NodeType.LPAREN, 0, 13, 17, 18, []),
            (NodeType.ARGGROUP, 0, 14, 6, 62, [
              (NodeType.PARGGROUP, 0, 14, 6, 62, [
                (NodeType.ARGUMENT, 0, 14, 6, 24, []),
                (NodeType.ARGUMENT, 0, 14, 25, 43, []),
                (NodeType.ARGUMENT, 0, 14, 44, 62, []),
              ]),
            ]),
            (NodeType.RPAREN, 0, 14, 62, 63, []),
            (NodeType.COMMENT, 0, 14, 64, 80, []),
          ]),
        ]),
        (NodeType.STATEMENT, 0, 23, 2, 9, [
          (NodeType.FUNNAME, 0, 23, 2, 7, []),
          (NodeType.LPAREN, 0, 23, 7, 8, []),
          (NodeType.ARGGROUP, 0, 23, 8, 8, []),
          (NodeType.RPAREN, 0, 23, 8, 9, []),
        ]),
      ]),
    ]),
    (NodeType.STATEMENT, 0, 24, 0, 7, [
      (NodeType.FUNNAME, 0, 24, 0, 5, []),
      (NodeType.LPAREN, 0, 24, 5, 6, []),
      (NodeType.ARGGROUP, 0, 24, 6, 6, []),
      (NodeType.RPAREN, 0, 24, 6, 7, []),
    ]),
  ]),
]),
      ])

  def test_custom_command(self):
    self.do_layout_test("""\
      # This very long command should be broken up along keyword arguments
      foo(nonkwarg_a nonkwarg_b HEADERS a.h b.h c.h d.h e.h f.h SOURCES a.cc b.cc d.cc DEPENDS foo bar baz)
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 68, [
  (NodeType.COMMENT, 0, 0, 0, 68, []),
  (NodeType.STATEMENT, 4, 1, 0, 35, [
    (NodeType.FUNNAME, 0, 1, 0, 3, []),
    (NodeType.LPAREN, 0, 1, 3, 4, []),
    (NodeType.ARGGROUP, 4, 1, 4, 35, [
      (NodeType.PARGGROUP, 0, 1, 4, 25, [
        (NodeType.ARGUMENT, 0, 1, 4, 14, []),
        (NodeType.ARGUMENT, 0, 1, 15, 25, []),
      ]),
      (NodeType.KWARGGROUP, 0, 2, 4, 35, [
        (NodeType.KEYWORD, 0, 2, 4, 11, []),
        (NodeType.ARGGROUP, 0, 2, 12, 35, [
          (NodeType.PARGGROUP, 0, 2, 12, 35, [
            (NodeType.ARGUMENT, 0, 2, 12, 15, []),
            (NodeType.ARGUMENT, 0, 2, 16, 19, []),
            (NodeType.ARGUMENT, 0, 2, 20, 23, []),
            (NodeType.ARGUMENT, 0, 2, 24, 27, []),
            (NodeType.ARGUMENT, 0, 2, 28, 31, []),
            (NodeType.ARGUMENT, 0, 2, 32, 35, []),
          ]),
        ]),
      ]),
      (NodeType.KWARGGROUP, 0, 3, 4, 26, [
        (NodeType.KEYWORD, 0, 3, 4, 11, []),
        (NodeType.ARGGROUP, 0, 3, 12, 26, [
          (NodeType.PARGGROUP, 0, 3, 12, 26, [
            (NodeType.ARGUMENT, 0, 3, 12, 16, []),
            (NodeType.ARGUMENT, 0, 3, 17, 21, []),
            (NodeType.ARGUMENT, 0, 3, 22, 26, []),
          ]),
        ]),
      ]),
      (NodeType.KWARGGROUP, 0, 4, 4, 15, [
        (NodeType.KEYWORD, 0, 4, 4, 11, []),
        (NodeType.ARGGROUP, 0, 4, 12, 15, [
          (NodeType.PARGGROUP, 0, 4, 12, 15, [
            (NodeType.ARGUMENT, 0, 4, 12, 15, []),
          ]),
        ]),
      ]),
      (NodeType.PARGGROUP, 0, 5, 4, 11, [
        (NodeType.FLAG, 0, 5, 4, 7, []),
        (NodeType.FLAG, 0, 5, 8, 11, []),
      ]),
    ]),
    (NodeType.RPAREN, 0, 5, 11, 12, []),
  ]),
]),
      ])

  def test_multiline_string(self):
    self.do_layout_test("""\
      foo(some_arg some_arg "
          This string is on multiple lines
      ")
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 36, [
  (NodeType.STATEMENT, 0, 0, 0, 36, [
    (NodeType.FUNNAME, 0, 0, 0, 3, []),
    (NodeType.LPAREN, 0, 0, 3, 4, []),
    (NodeType.ARGGROUP, 0, 0, 4, 36, [
      (NodeType.PARGGROUP, 0, 0, 4, 36, [
        (NodeType.ARGUMENT, 0, 0, 4, 12, []),
        (NodeType.ARGUMENT, 0, 0, 13, 21, []),
        (NodeType.ARGUMENT, 0, 0, 22, 36, []),
      ]),
    ]),
    (NodeType.RPAREN, 0, 2, 1, 2, []),
  ]),
]),
      ])

  def test_nested_parens(self):
    self.do_layout_test("""\
      if((NOT HELLO) OR (NOT EXISTS ${WORLD}))
        message(WARNING "something is wrong")
        set(foobar FALSE)
      endif()
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 40, [
  (NodeType.FLOW_CONTROL, 0, 0, 0, 40, [
    (NodeType.STATEMENT, 0, 0, 0, 40, [
      (NodeType.FUNNAME, 0, 0, 0, 2, []),
      (NodeType.LPAREN, 0, 0, 2, 3, []),
      (NodeType.ARGGROUP, 0, 0, 3, 39, [
        (NodeType.PARENGROUP, 0, 0, 3, 14, [
          (NodeType.LPAREN, 0, 0, 3, 4, []),
          (NodeType.ARGGROUP, 0, 0, 4, 13, [
            (NodeType.PARGGROUP, 0, 0, 4, 13, [
              (NodeType.FLAG, 0, 0, 4, 7, []),
              (NodeType.ARGUMENT, 0, 0, 8, 13, []),
            ]),
          ]),
          (NodeType.RPAREN, 0, 0, 13, 14, []),
        ]),
        (NodeType.KWARGGROUP, 0, 0, 15, 39, [
          (NodeType.KEYWORD, 0, 0, 15, 17, []),
          (NodeType.ARGGROUP, 0, 0, 18, 39, [
            (NodeType.PARENGROUP, 0, 0, 18, 39, [
              (NodeType.LPAREN, 0, 0, 18, 19, []),
              (NodeType.ARGGROUP, 0, 0, 19, 38, [
                (NodeType.PARGGROUP, 0, 0, 19, 38, [
                  (NodeType.FLAG, 0, 0, 19, 22, []),
                  (NodeType.FLAG, 0, 0, 23, 29, []),
                  (NodeType.ARGUMENT, 0, 0, 30, 38, []),
                ]),
              ]),
              (NodeType.RPAREN, 0, 0, 38, 39, []),
            ]),
          ]),
        ]),
      ]),
      (NodeType.RPAREN, 0, 0, 39, 40, []),
    ]),
    (NodeType.BODY, 0, 1, 2, 39, [
      (NodeType.STATEMENT, 0, 1, 2, 39, [
        (NodeType.FUNNAME, 0, 1, 2, 9, []),
        (NodeType.LPAREN, 0, 1, 9, 10, []),
        (NodeType.ARGGROUP, 0, 1, 10, 38, [
          (NodeType.KWARGGROUP, 0, 1, 10, 38, [
            (NodeType.KEYWORD, 0, 1, 10, 17, []),
            (NodeType.ARGGROUP, 0, 1, 18, 38, [
              (NodeType.PARGGROUP, 0, 1, 18, 38, [
                (NodeType.ARGUMENT, 0, 1, 18, 38, []),
              ]),
            ]),
          ]),
        ]),
        (NodeType.RPAREN, 0, 1, 38, 39, []),
      ]),
      (NodeType.STATEMENT, 0, 2, 2, 19, [
        (NodeType.FUNNAME, 0, 2, 2, 5, []),
        (NodeType.LPAREN, 0, 2, 5, 6, []),
        (NodeType.ARGGROUP, 0, 2, 6, 18, [
          (NodeType.PARGGROUP, 0, 2, 6, 12, [
            (NodeType.ARGUMENT, 0, 2, 6, 12, []),
          ]),
          (NodeType.PARGGROUP, 0, 2, 13, 18, [
            (NodeType.ARGUMENT, 0, 2, 13, 18, []),
          ]),
        ]),
        (NodeType.RPAREN, 0, 2, 18, 19, []),
      ]),
    ]),
    (NodeType.STATEMENT, 0, 3, 0, 7, [
      (NodeType.FUNNAME, 0, 3, 0, 5, []),
      (NodeType.LPAREN, 0, 3, 5, 6, []),
      (NodeType.ARGGROUP, 0, 3, 6, 6, []),
      (NodeType.RPAREN, 0, 3, 6, 7, []),
    ]),
  ]),
]),
      ])

  def test_comment_after_command(self):
    with self.subTest(sub=1):
      self.do_layout_test("""\
        foo_command() # comment
        """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 23, [
  (NodeType.STATEMENT, 0, 0, 0, 23, [
    (NodeType.FUNNAME, 0, 0, 0, 11, []),
    (NodeType.LPAREN, 0, 0, 11, 12, []),
    (NodeType.ARGGROUP, 0, 0, 12, 12, []),
    (NodeType.RPAREN, 0, 0, 12, 13, []),
    (NodeType.COMMENT, 0, 0, 14, 23, []),
  ]),
]),
        ])

    with self.subTest(sub=2):
      self.do_layout_test("""\
        foo_command() # this is a long comment that exceeds the desired page width and will be wrapped to a newline
        """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 78, [
  (NodeType.STATEMENT, 0, 0, 0, 78, [
    (NodeType.FUNNAME, 0, 0, 0, 11, []),
    (NodeType.LPAREN, 0, 0, 11, 12, []),
    (NodeType.ARGGROUP, 0, 0, 12, 12, []),
    (NodeType.RPAREN, 0, 0, 12, 13, []),
    (NodeType.COMMENT, 0, 0, 14, 78, []),
  ]),
]),

        ])

  def test_arg_just_fits(self):
    """
    Ensure that if an argument *just* fits that it isn't superfluously wrapped
    """

    with self.subTest(chars=81):
      self.do_layout_test("""\
      message(FATAL_ERROR "81 character line ----------------------------------------")
    """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 75, [
  (NodeType.STATEMENT, 1, 0, 0, 75, [
    (NodeType.FUNNAME, 0, 0, 0, 7, []),
    (NodeType.LPAREN, 0, 0, 7, 8, []),
    (NodeType.ARGGROUP, 0, 1, 2, 74, [
      (NodeType.KWARGGROUP, 0, 1, 2, 74, [
        (NodeType.KEYWORD, 0, 1, 2, 13, []),
        (NodeType.ARGGROUP, 0, 1, 14, 74, [
          (NodeType.PARGGROUP, 0, 1, 14, 74, [
            (NodeType.ARGUMENT, 0, 1, 14, 74, []),
          ]),
        ]),
      ]),
    ]),
    (NodeType.RPAREN, 0, 1, 74, 75, []),
  ]),
]),
    ])

    with self.subTest(chars=100, with_prefix=True):
      self.do_layout_test("""\
      message(FATAL_ERROR
              "100 character line ----------------------------------------------------------"
      ) # Closing parenthesis is indented one space!
    """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 83, [
  (NodeType.STATEMENT, 5, 0, 0, 83, [
    (NodeType.FUNNAME, 0, 0, 0, 7, []),
    (NodeType.LPAREN, 0, 0, 7, 8, []),
    (NodeType.ARGGROUP, 5, 1, 2, 83, [
      (NodeType.KWARGGROUP, 5, 1, 2, 83, [
        (NodeType.KEYWORD, 0, 1, 2, 13, []),
        (NodeType.ARGGROUP, 5, 2, 4, 83, [
          (NodeType.PARGGROUP, 4, 2, 4, 83, [
            (NodeType.ARGUMENT, 0, 2, 4, 83, []),
          ]),
        ]),
      ]),
    ]),
    (NodeType.RPAREN, 0, 3, 0, 1, []),
    (NodeType.COMMENT, 0, 3, 2, 46, []),
  ]),
]),
    ])

    with self.subTest(chars=100):
      self.do_layout_test("""\
      message(
        "100 character line ----------------------------------------------------------------------"
        ) # Closing parenthesis is indented one space!
    """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 93, [
  (NodeType.STATEMENT, 5, 0, 0, 93, [
    (NodeType.FUNNAME, 0, 0, 0, 7, []),
    (NodeType.LPAREN, 0, 0, 7, 8, []),
    (NodeType.ARGGROUP, 5, 1, 2, 93, [
      (NodeType.PARGGROUP, 4, 1, 2, 93, [
        (NodeType.ARGUMENT, 0, 1, 2, 93, []),
      ]),
    ]),
    (NodeType.RPAREN, 0, 2, 0, 1, []),
    (NodeType.COMMENT, 0, 2, 2, 46, []),
  ]),
]),
    ])

  def test_string_preserved_during_split(self):
    self.do_layout_test("""\
      # The string in this command should not be split
      set_target_properties(foo bar baz PROPERTIES COMPILE_FLAGS "-std=c++11 -Wall -Wextra")
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 72, [
  (NodeType.COMMENT, 0, 0, 0, 48, []),
  (NodeType.STATEMENT, 0, 1, 0, 72, [
    (NodeType.FUNNAME, 0, 1, 0, 21, []),
    (NodeType.LPAREN, 0, 1, 21, 22, []),
    (NodeType.ARGGROUP, 0, 1, 22, 71, [
      (NodeType.PARGGROUP, 0, 1, 22, 33, [
        (NodeType.ARGUMENT, 0, 1, 22, 25, []),
        (NodeType.ARGUMENT, 0, 1, 26, 29, []),
        (NodeType.ARGUMENT, 0, 1, 30, 33, []),
      ]),
      (NodeType.KWARGGROUP, 0, 1, 34, 71, [
        (NodeType.KEYWORD, 0, 1, 34, 44, []),
        (NodeType.ARGGROUP, 0, 1, 45, 71, [
          (NodeType.PARGGROUP, 0, 1, 45, 71, [
            (NodeType.ARGUMENT, 0, 1, 45, 58, []),
            (NodeType.ARGUMENT, 0, 2, 45, 71, []),
          ]),
        ]),
      ]),
    ]),
    (NodeType.RPAREN, 0, 2, 71, 72, []),
  ]),
]),
      ])

  def test_while(self):
    self.do_layout_test("""\
      while(forbarbaz arg1 arg2, arg3)
        message(hello ${foobarbaz})
      endwhile()
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 32, [
  (NodeType.FLOW_CONTROL, 0, 0, 0, 32, [
    (NodeType.STATEMENT, 0, 0, 0, 32, [
      (NodeType.FUNNAME, 0, 0, 0, 5, []),
      (NodeType.LPAREN, 0, 0, 5, 6, []),
      (NodeType.ARGGROUP, 0, 0, 6, 31, [
        (NodeType.PARGGROUP, 0, 0, 6, 31, [
          (NodeType.ARGUMENT, 0, 0, 6, 15, []),
          (NodeType.ARGUMENT, 0, 0, 16, 20, []),
          (NodeType.ARGUMENT, 0, 0, 21, 26, []),
          (NodeType.ARGUMENT, 0, 0, 27, 31, []),
        ]),
      ]),
      (NodeType.RPAREN, 0, 0, 31, 32, []),
    ]),
    (NodeType.BODY, 0, 1, 2, 29, [
      (NodeType.STATEMENT, 0, 1, 2, 29, [
        (NodeType.FUNNAME, 0, 1, 2, 9, []),
        (NodeType.LPAREN, 0, 1, 9, 10, []),
        (NodeType.ARGGROUP, 0, 1, 10, 28, [
          (NodeType.PARGGROUP, 0, 1, 10, 28, [
            (NodeType.ARGUMENT, 0, 1, 10, 15, []),
            (NodeType.ARGUMENT, 0, 1, 16, 28, []),
          ]),
        ]),
        (NodeType.RPAREN, 0, 1, 28, 29, []),
      ]),
    ]),
    (NodeType.STATEMENT, 0, 2, 0, 10, [
      (NodeType.FUNNAME, 0, 2, 0, 8, []),
      (NodeType.LPAREN, 0, 2, 8, 9, []),
      (NodeType.ARGGROUP, 0, 2, 9, 9, []),
      (NodeType.RPAREN, 0, 2, 9, 10, []),
    ]),
  ]),
]),
      ])

  def test_keyword_comment(self):
    self.do_layout_test("""\
      find_package(package REQUIRED
                   COMPONENTS # --------------------------------------
                              # @TODO: This has to be filled manually
                              # --------------------------------------
                              this_is_a_really_long_word_foo)
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 53, [
  (NodeType.STATEMENT, 4, 0, 0, 53, [
    (NodeType.FUNNAME, 0, 0, 0, 12, []),
    (NodeType.LPAREN, 0, 0, 12, 13, []),
    (NodeType.ARGGROUP, 4, 1, 2, 53, [
      (NodeType.PARGGROUP, 0, 1, 2, 18, [
        (NodeType.ARGUMENT, 0, 1, 2, 9, []),
        (NodeType.FLAG, 0, 1, 10, 18, []),
      ]),
      (NodeType.KWARGGROUP, 4, 2, 2, 53, [
        (NodeType.KEYWORD, 0, 2, 2, 12, []),
        (NodeType.ARGGROUP, 4, 2, 13, 53, [
          (NodeType.COMMENT, 0, 2, 13, 53, []),
          (NodeType.PARGGROUP, 0, 5, 13, 43, [
            (NodeType.ARGUMENT, 0, 5, 13, 43, []),
          ]),
        ]),
      ]),
    ]),
    (NodeType.RPAREN, 0, 5, 43, 44, []),
  ]),
]),
      ])

  def test_sortable_set(self):
    self.do_layout_test("""\
      set(SOURCES #[[cmf:sortable]] foo.cc bar.cc baz.cc)
      """, [
# pylint: disable=bad-continuation
# noqa: E122
(NodeType.BODY, 0, 0, 0, 51, [
  (NodeType.STATEMENT, 0, 0, 0, 51, [
    (NodeType.FUNNAME, 0, 0, 0, 3, []),
    (NodeType.LPAREN, 0, 0, 3, 4, []),
    (NodeType.ARGGROUP, 0, 0, 4, 50, [
      (NodeType.PARGGROUP, 0, 0, 4, 11, [
        (NodeType.ARGUMENT, 0, 0, 4, 11, []),
      ]),
      (NodeType.PARGGROUP, 0, 0, 12, 50, [
        (NodeType.COMMENT, 0, 0, 12, 29, []),
        (NodeType.ARGUMENT, 0, 0, 30, 36, []),
        (NodeType.ARGUMENT, 0, 0, 37, 43, []),
        (NodeType.ARGUMENT, 0, 0, 44, 50, []),
      ]),
    ]),
    (NodeType.RPAREN, 0, 0, 50, 51, []),
  ]),
]),
      ])


if __name__ == '__main__':
  format_str = '[%(levelname)-4s] %(filename)s:%(lineno)-3s: %(message)s'
  logging.basicConfig(level=logging.DEBUG,
                      format=format_str,
                      datefmt='%Y-%m-%d %H:%M:%S',
                      filemode='w')
  unittest.main()