src/tools/json_schema_compiler/code_util_test.py

#!/usr/bin/env python3
# Copyright 2012 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from code_util import Code
import unittest


class CodeTest(unittest.TestCase):

  def testAppend(self):
    c = Code()
    c.Append('line')
    self.assertEqual('line', c.Render())

  def testBlock(self):
    c = Code()
    (c.Append('line') \
      .Sblock('sblock') \
        .Append('inner') \
        .Append('moreinner') \
        .Sblock('moresblock') \
          .Append('inner') \
        .Eblock('out') \
        .Append('inner') \
      .Eblock('out')
    )
    self.assertEqual(
        'line\n'
        'sblock\n'
        '  inner\n'
        '  moreinner\n'
        '  moresblock\n'
        '    inner\n'
        '  out\n'
        '  inner\n'
        'out', c.Render())

  def testConcat(self):
    b = Code()
    (b.Sblock('2') \
        .Append('2') \
      .Eblock('2')
    )
    c = Code()
    (c.Sblock('1') \
        .Concat(b) \
        .Append('1') \
      .Eblock('1')
    )
    self.assertMultiLineEqual('1\n'
                              '  2\n'
                              '    2\n'
                              '  2\n'
                              '  1\n'
                              '1', c.Render())
    d = Code()
    a = Code()
    a.Concat(d)
    self.assertEqual('', a.Render())
    a.Concat(c)
    self.assertEqual('1\n'
                     '  2\n'
                     '    2\n'
                     '  2\n'
                     '  1\n'
                     '1', a.Render())

  def testConcatErrors(self):
    c = Code()
    d = Code()
    d.Append('%s')
    self.assertRaises(TypeError, c.Concat, d)
    d = Code()
    d.Append('%(classname)s')
    self.assertRaises(TypeError, c.Concat, d)
    d = 'line of code'
    self.assertRaises(TypeError, c.Concat, d)

  def testSubstitute(self):
    c = Code()
    c.Append('%(var1)s %(var2)s %(var1)s')
    c.Substitute({'var1': 'one', 'var2': 'two'})
    self.assertEqual('one two one', c.Render())
    c.Append('%(var1)s %(var2)s %(var3)s')
    c.Append('%(var2)s %(var1)s %(var3)s')
    c.Substitute({'var1': 'one', 'var2': 'two', 'var3': 'three'})
    self.assertEqual('one two one\n'
                     'one two three\n'
                     'two one three', c.Render())

  def testSubstituteErrors(self):
    # No unnamed placeholders allowed when substitute is run
    c = Code()
    c.Append('%s %s')
    self.assertRaises(TypeError, c.Substitute, ('var1', 'one'))
    c = Code()
    c.Append('%s %(var1)s')
    self.assertRaises(TypeError, c.Substitute, {'var1': 'one'})
    c = Code()
    c.Append('%s %(var1)s')
    self.assertRaises(TypeError, c.Substitute, {'var1': 'one'})
    c = Code()
    c.Append('%(var1)s')
    self.assertRaises(KeyError, c.Substitute, {'clearlynotvar1': 'one'})

  def testIsEmpty(self):
    c = Code()
    self.assertTrue(c.IsEmpty())
    c.Append('asdf')
    self.assertFalse(c.IsEmpty())

  def testComment(self):
    long_comment = ('This comment is ninety one characters in longness, '
                    'that is, using a different word, length.')
    c = Code()
    c.Comment(long_comment)
    self.assertEqual(
        '// This comment is ninety one characters '
        'in longness, that is, using a different\n'
        '// word, length.', c.Render())
    c = Code()
    c.Sblock('sblock')
    c.Comment(long_comment)
    c.Eblock('eblock')
    c.Comment(long_comment)
    self.assertEqual(
        'sblock\n'
        '  // This comment is ninety one characters '
        'in longness, that is, using a\n'
        '  // different word, length.\n'
        'eblock\n'
        '// This comment is ninety one characters in '
        'longness, that is, using a different\n'
        '// word, length.', c.Render())
    # Words that cannot be broken up are left as too long.
    long_word = 'x' * 100
    c = Code()
    c.Comment('xxx')
    c.Comment(long_word)
    c.Comment('xxx')
    self.assertEqual('// xxx\n'
                     '// ' + 'x' * 100 + '\n'
                     '// xxx', c.Render())
    c = Code(indent_size=2, comment_length=40)
    c.Comment(
        'Pretend this is a Closure Compiler style comment, which should '
        'both wrap and indent',
        comment_prefix=' * ',
        wrap_indent=4)
    self.assertEqual(
        ' * Pretend this is a Closure Compiler\n'
        ' *     style comment, which should both\n'
        ' *     wrap and indent', c.Render())

  def testCommentWithSpecialCharacters(self):
    c = Code()
    c.Comment('20% of 80%s')
    c.Substitute({})
    self.assertEqual('// 20% of 80%s', c.Render())
    d = Code()
    d.Append('90')
    d.Concat(c)
    self.assertEqual('90\n'
                     '// 20% of 80%s', d.Render())

  def testLinePrefixes(self):
    c = Code()
    c.Sblock(line='/**', line_prefix=' * ')
    c.Sblock('@typedef {{')
    c.Append('foo: bar,')
    c.Sblock('baz: {')
    c.Append('x: y')
    c.Eblock('}')
    c.Eblock('}}')
    c.Eblock(line=' */')
    output = c.Render()
    self.assertMultiLineEqual(
        '/**\n'
        ' * @typedef {{\n'
        ' *   foo: bar,\n'
        ' *   baz: {\n'
        ' *     x: y\n'
        ' *   }\n'
        ' * }}\n'
        ' */', output)

  def testSameLineAppendConcatComment(self):
    c = Code()
    c.Append('This is a line.')
    c.Append('This too.', new_line=False)
    d = Code()
    d.Append('And this.')
    c.Concat(d, new_line=False)
    self.assertEqual('This is a line.This too.And this.', c.Render())
    c = Code()
    c.Append('This is a')
    c.Comment(' spectacular 80-character line thingy ' +
              'that fits wonderfully everywhere.',
              comment_prefix='',
              new_line=False)
    self.assertEqual(
        'This is a spectacular 80-character line thingy that ' +
        'fits wonderfully everywhere.', c.Render())


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