#!/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 struct_generator import GenerateField
from struct_generator import GenerateStruct
import unittest

class StructGeneratorTest(unittest.TestCase):
  def testGenerateIntField(self):
    self.assertEqual('const int foo_bar',
                     GenerateField({
                         'type': 'int',
                         'field': 'foo_bar'
                     }))

  def testGenerateStringField(self):
    self.assertEqual('const char* const bar_foo',
                     GenerateField({
                         'type': 'string',
                         'field': 'bar_foo'
                     }))

  def testGenerateString16Field(self):
    self.assertEqual('const char16_t* const foo_bar',
                     GenerateField({
                         'type': 'string16',
                         'field': 'foo_bar'
                     }))

  def testGenerateEnumField(self):
    self.assertEqual(
        'const MyEnumType foo_foo',
        GenerateField({
            'type': 'enum',
            'field': 'foo_foo',
            'ctype': 'MyEnumType'
        }))

  def testGenerateArrayField(self):
    self.assertEqual(
        'const base::span<const int> bar_bar',
        GenerateField({
            'type': 'array',
            'field': 'bar_bar',
            'contents': {
                'type': 'int'
            }
        }))

  def testGenerateClassField(self):
    self.assertEqual(
        'const std::optional<bool> bar',
        GenerateField({
            'type': 'class',
            'field': 'bar',
            'ctype': 'std::optional<bool>'
        }))

  def testGenerateStruct(self):
    schema = [
      {'type': 'int', 'field': 'foo_bar'},
      {'type': 'string', 'field': 'bar_foo', 'default': 'dummy'},
      {
        'type': 'array',
        'field': 'bar_bar',
        'contents': {
          'type': 'enum',
          'ctype': 'MyEnumType'
        }
      }
    ]
    struct = ('struct MyTypeName {\n'
              '  const int foo_bar;\n'
              '  const char* const bar_foo;\n'
              '  const base::span<const MyEnumType> bar_bar;\n'
              '};\n')
    self.assertEqual(struct, GenerateStruct('MyTypeName', schema))

  def testGenerateArrayOfStruct(self):
    schema = [
      {
        'type': 'array',
        'field': 'bar_bar',
        'contents': {
          'type': 'struct',
          'type_name': 'InnerTypeName',
          'fields': [
            {'type': 'string', 'field': 'key'},
            {'type': 'string', 'field': 'value'},
          ]
        }
      }
    ]
    struct = ('struct InnerTypeName {\n'
              '  const char* const key;\n'
              '  const char* const value;\n'
              '};\n'
              '\n'
              'struct MyTypeName {\n'
              '  const base::span<const InnerTypeName> bar_bar;\n'
              '};\n')
    self.assertEqual(struct, GenerateStruct('MyTypeName', schema))

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