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

import os
import unittest

from model import Model
import ppapi_generator
from schema_loader import SchemaLoader


def _LoadNamespace(filename):
  filename = os.path.join(os.path.dirname(__file__), filename)
  schema_loader = SchemaLoader(
      os.path.dirname(os.path.relpath(os.path.normpath(filename),
                                      os.path.dirname(filename))),
      os.path.dirname(filename))
  schema = os.path.normpath(filename)
  api_def = schema_loader.LoadSchema(os.path.split(schema)[1])[0]

  api_model = Model()
  relpath = os.path.relpath(os.path.normpath(filename),
                            os.path.dirname(filename))
  namespace = api_model.AddNamespace(api_def, relpath)
  generator = ppapi_generator._PpapiGeneratorBase(namespace)
  return namespace, generator


class PpapiGeneratorIdlStructsTest(unittest.TestCase):
  def setUp(self):
    self.namespace, self.generator = _LoadNamespace(
        os.path.join('test', 'idl_pepper.idl'))

  def testTypesOrder(self):
    typename_to_index = dict(
        (type_.name, i) for i, type_ in enumerate(self.generator._types))
    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType2'])
    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType3'])
    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType4'])
    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType5'])
    self.assertLess(typename_to_index['MyType3'], typename_to_index['MyType5'])
    self.assertLess(typename_to_index['MyType4'], typename_to_index['MyType5'])
    self.assertLess(typename_to_index['MyType5'], typename_to_index['MyType6'])

  def testNeedsArray(self):
    self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType1']))
    self.assertTrue(self.generator.NeedsArray(self.namespace.types['MyType2']))
    self.assertTrue(self.generator.NeedsArray(self.namespace.types['MyType3']))
    self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType4']))
    self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType5']))
    self.assertTrue(self.generator.NeedsArray(self.namespace.types['EnumType']))

  def testNeedsOptional(self):
    self.assertFalse(
        self.generator.NeedsOptional(self.namespace.types['MyType1']))
    self.assertFalse(
        self.generator.NeedsOptional(self.namespace.types['MyType2']))
    self.assertTrue(
        self.generator.NeedsOptional(self.namespace.types['MyType3']))
    self.assertTrue(
        self.generator.NeedsOptional(self.namespace.types['MyType4']))
    self.assertFalse(
        self.generator.NeedsOptional(self.namespace.types['MyType5']))
    self.assertTrue(
        self.generator.NeedsOptional(self.namespace.types['EnumType']))

  def testNeedsOptionalArray(self):
    self.assertFalse(
        self.generator.NeedsOptionalArray(self.namespace.types['MyType1']))
    self.assertTrue(
        self.generator.NeedsOptionalArray(self.namespace.types['MyType2']))
    self.assertFalse(
        self.generator.NeedsOptionalArray(self.namespace.types['MyType3']))
    self.assertFalse(
        self.generator.NeedsOptionalArray(self.namespace.types['MyType4']))
    self.assertFalse(
        self.generator.NeedsOptionalArray(self.namespace.types['MyType5']))
    self.assertTrue(
        self.generator.NeedsOptionalArray(self.namespace.types['EnumType']))

  def testFormatParamTypePrimitive(self):
    self.assertEqual('int32_t', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['int_single']))
    self.assertEqual('PP_Int32_Array', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['int_array']))
    self.assertEqual('PP_Optional_Int32', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['optional_int']))
    self.assertEqual('PP_Optional_Int32_Array', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['optional_int_array']))
    self.assertEqual('double_t', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['double_single']))
    self.assertEqual('PP_Double_Array', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['double_array']))
    self.assertEqual('PP_Optional_Double', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['optional_double']))
    self.assertEqual('PP_Optional_Double_Array', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['optional_double_array']))
    self.assertEqual('PP_Var', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['string']))
    self.assertEqual('PP_String_Array', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['string_array']))
    self.assertEqual('PP_Var', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['optional_string']))
    self.assertEqual('PP_Optional_String_Array', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['optional_string_array']))

  def testFormatParamTypeStruct(self):
    self.assertEqual('PP_IdlPepper_MyType0', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['struct_single']))
    self.assertEqual(
        'PP_IdlPepper_MyType0_Array', self.generator.FormatParamType(
            self.namespace.types['MyType'].properties['struct_array']))
    self.assertEqual(
        'PP_IdlPepper_Optional_MyType0', self.generator.FormatParamType(
            self.namespace.types['MyType'].properties['optional_struct']))
    self.assertEqual(
        'PP_IdlPepper_Optional_MyType0_Array', self.generator.FormatParamType(
            self.namespace.types['MyType'].properties[
                'optional_struct_array']))

  def testFormatParamTypeEnum(self):
    self.assertEqual('PP_IdlPepper_EnumType', self.generator.FormatParamType(
        self.namespace.types['MyType'].properties['enum_single']))
    self.assertEqual(
        'PP_IdlPepper_EnumType_Array', self.generator.FormatParamType(
            self.namespace.types['MyType'].properties['enum_array']))
    self.assertEqual(
        'PP_IdlPepper_Optional_EnumType', self.generator.FormatParamType(
            self.namespace.types['MyType'].properties['optional_enum']))
    self.assertEqual(
        'PP_IdlPepper_Optional_EnumType_Array', self.generator.FormatParamType(
            self.namespace.types['MyType'].properties['optional_enum_array']))

  def testEnumValueName(self):
    enum_type = self.namespace.types['EnumType']
    self.assertEqual('PP_IDLPEPPER_ENUMTYPE_NAME1',
                     self.generator.EnumValueName(enum_type.enum_values[0],
                                                  enum_type))
    self.assertEqual('PP_IDLPEPPER_ENUMTYPE_NAME2',
                     self.generator.EnumValueName(enum_type.enum_values[1],
                                                  enum_type))
    enum_type = self.namespace.types['AnotherEnumType']
    self.assertEqual('PP_IDLPEPPER_ANOTHERENUMTYPE_NAME1',
                     self.generator.EnumValueName(enum_type.enum_values[0],
                                                  enum_type))
    self.assertEqual('PP_IDLPEPPER_ANOTHERENUMTYPE_NAME2',
                     self.generator.EnumValueName(enum_type.enum_values[1],
                                                  enum_type))

  def testReturnTypes(self):
    self.assertEqual('void', self.generator.GetFunctionReturnType(
        self.namespace.functions['function1']))
    self.assertEqual('void', self.generator.GetFunctionReturnType(
        self.namespace.functions['function2']))
    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
        self.namespace.functions['function3']))
    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
        self.namespace.functions['function4']))
    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
        self.namespace.functions['function5']))
    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
        self.namespace.functions['function6']))

  def testHasOutArray(self):
    self.assertFalse(self.generator.HasArrayOuts(
        self.namespace.functions['function1']))
    self.assertFalse(self.generator.HasArrayOuts(
        self.namespace.functions['function2']))
    self.assertTrue(self.generator.HasArrayOuts(
        self.namespace.functions['function3']))
    self.assertFalse(self.generator.HasArrayOuts(
        self.namespace.functions['function4']))
    self.assertFalse(self.generator.HasArrayOuts(
        self.namespace.functions['function5']))
    self.assertTrue(self.generator.HasArrayOuts(
        self.namespace.functions['function6']))
    self.assertTrue(self.generator.HasArrayOuts(
        self.namespace.functions['function7']))
    self.assertTrue(self.generator.HasArrayOuts(
        self.namespace.functions['function8']))
    self.assertFalse(self.generator.HasArrayOuts(
        self.namespace.functions['function9']))
    self.assertTrue(self.generator.HasArrayOuts(
        self.namespace.functions['function10']))
    self.assertTrue(self.generator.HasArrayOuts(
        self.namespace.functions['function11']))
    self.assertFalse(self.generator.HasArrayOuts(
        self.namespace.functions['function12']))

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