xref: /system/tpm/trunks/generator/generator_test.py

#!/usr/bin/python

#
# Copyright (C) 2014 The Android Open Source Project
#
# 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
#
#      http://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.
#

"""Unit tests for the TPM 2.0 code generator."""

from __future__ import print_function

import StringIO
import unittest

import generator


class TestGenerators(unittest.TestCase):
  """Test generator classes."""

  def testTypedef(self):
    """Test generation of typedefs and dependencies."""
    typedef = generator.Typedef('int', 'INT')
    defined_types = set(['int'])
    typemap = {}
    out_file = StringIO.StringIO()
    # Expect this to just write the typedef.
    typedef.OutputForward(out_file, defined_types, typemap)
    # Expect this to know it has already been written.
    typedef.Output(out_file, defined_types, typemap)
    self.assertEqual(out_file.getvalue(), 'typedef int INT;\n')
    self.assertIn('INT', defined_types)
    typedef2 = generator.Typedef('TYPE1', 'TYPE2')
    typemap = {'TYPE1': generator.Structure('TYPE1', False)}
    defined_types = set([])
    out_file2 = StringIO.StringIO()
    # Expect this to write first TYPE1 forward then TYPE2 typedef.
    typedef2.Output(out_file2, defined_types, typemap)
    output_re = r'struct TYPE1;\s+typedef TYPE1 TYPE2;\s+'
    self.assertRegexpMatches(out_file2.getvalue(), output_re)
    self.assertIn('TYPE2', defined_types)
    out_file.close()
    out_file2.close()

  def testTypedefSerialize(self):
    """Test generation of serialization code for typedefs."""
    serialized_types = set(['int'])
    typedef = generator.Typedef('int', 'INT')
    typedef2 = generator.Typedef('INT', 'INT2')
    typemap = {'INT': typedef}
    out_file = StringIO.StringIO()
    typedef2.OutputSerialize(out_file, serialized_types, typemap)
    self.assertIn('INT', serialized_types)
    self.assertIn('INT2', serialized_types)
    out_file.close()

  def testConstant(self):
    """Test generation of constant definitions and type dependencies."""
    constant = generator.Constant('INT', 'test', '1')
    typemap = {'INT': generator.Structure('INT', False)}
    defined_types = set([])
    out_file = StringIO.StringIO()
    constant.Output(out_file, defined_types, typemap)
    output_re = r'struct INT;\s+const INT test = 1;\s+'
    self.assertRegexpMatches(out_file.getvalue(), output_re)
    out_file.close()

  def testStructure(self):
    """Test generation of structure declarations and field dependencies."""
    struct = generator.Structure('STRUCT', False)
    struct.AddField('int', 'i')
    struct.AddDependency('DEPEND')
    union = generator.Structure('UNION', True)
    union.AddField('STRUCT', 'inner')
    depend = generator.Structure('DEPEND', False)
    defined_types = set(['int'])
    out_file = StringIO.StringIO()
    typemap = {'STRUCT': struct, 'DEPEND': depend}
    # Only output |union|, this will test the dependency logic.
    union.OutputForward(out_file, defined_types, typemap)
    union.OutputForward(out_file, defined_types, typemap)
    union.Output(out_file, defined_types, typemap)
    output_re = r'union UNION;\s+struct DEPEND {\s+};\s+'
    output_re += r'struct STRUCT {\s+int i;\s+};\s+'
    output_re += r'union UNION {\s+STRUCT inner;\s+};\s+'
    self.assertRegexpMatches(out_file.getvalue(), output_re)
    for t in ('STRUCT', 'DEPEND', 'UNION'):
      self.assertIn(t, defined_types)
    # Test serialize / parse code generation.
    out_file.close()

  def testStructSerialize(self):
    """Test generation of serialization code for typedefs."""
    serialized_types = set(['int', 'FOO', 'BAR', 'TPMI_ALG_SYM_OBJECT'])
    struct = generator.Structure('TEST_STRUCT', False)
    struct.fields = [('TPMI_ALG_SYM_OBJECT', 'selector'),
                     ('TPMU_SYM_MODE', 'mode'),
                     ('int', 'sizeOfFoo'),
                     ('int', 'foo[FOO_MAX]')]
    # Choose TPMU_SYM_MODE because it exists in the selectors definition and it
    # has few fields.
    union = generator.Structure('TPMU_SYM_MODE', True)
    union.fields = [('FOO', 'aes'), ('BAR', 'sm4')]
    typemap = {'TPMU_SYM_MODE': union}
    out_file = StringIO.StringIO()
    struct.OutputSerialize(out_file, serialized_types, typemap)
    self.assertIn('TPMU_SYM_MODE', serialized_types)
    self.assertIn('TEST_STRUCT', serialized_types)
    out_file.close()

  def testDefine(self):
    """Test generation of preprocessor defines."""
    define = generator.Define('name', 'value')
    out_file = StringIO.StringIO()
    define.Output(out_file)
    output_re = r'#if !defined\(name\)\s+#define name value\s+#endif\s+'
    self.assertRegexpMatches(out_file.getvalue(), output_re)
    out_file.close()

  def _MakeArg(self, arg_type, arg_name):
    return {'type': arg_type,
            'name': arg_name,
            'command_code': None,
            'description': None}

  def testCommand(self):
    """Test generation of command methods and callbacks."""
    command = generator.Command('TPM2_Test')
    command.request_args = [self._MakeArg('int', 'input')]
    command.response_args = [self._MakeArg('char', 'output')]
    out_file = StringIO.StringIO()
    command.OutputDeclarations(out_file)
    expected_callback = """typedef base::Callback<void(
      TPM_RC response_code,
      const char& output)> TestResponse;"""
    self.assertIn(expected_callback, out_file.getvalue())
    expected_serialize = """static TPM_RC SerializeCommand_Test(
      const int& input,
      std::string* serialized_command,
      AuthorizationDelegate* authorization_delegate);"""
    self.assertIn(expected_serialize, out_file.getvalue())
    expected_parse = """static TPM_RC ParseResponse_Test(
      const std::string& response,
      char* output,
      AuthorizationDelegate* authorization_delegate);"""
    self.assertIn(expected_parse, out_file.getvalue())
    expected_async = """virtual void Test(
      const int& input,
      AuthorizationDelegate* authorization_delegate,
      const TestResponse& callback);"""
    self.assertIn(expected_async, out_file.getvalue())
    expected_sync = """virtual TPM_RC TestSync(
      const int& input,
      char* output,
      AuthorizationDelegate* authorization_delegate);"""
    self.assertIn(expected_sync, out_file.getvalue())
    out_file.close()


class TestParsers(unittest.TestCase):
  """Test parser classes."""

  FAKE_TYPEDEF = '_BEGIN_TYPES\n_OLD_TYPE type1\n_NEW_TYPE type2\n_END\n'
  FAKE_CONSTANT = ('_BEGIN_CONSTANTS\n_CONSTANTS (base_type) const_type\n'
                   '_TYPE base_type\n_NAME const_name\n_VALUE const_value\n'
                   '_END\n')
  FAKE_STRUCTURE = ('_BEGIN_STRUCTURES\n_STRUCTURE struct_type\n'
                    '_TYPE field_type\n'
                    '_NAME field_name[sizeof(depend_type)]\n_END\n')
  FAKE_DEFINE = '_BEGIN_DEFINES\n_NAME define_name\n_VALUE define_value\n_END'
  FAKE_COMMAND = ('_BEGIN\n_INPUT_START TPM2_Test\n'
                  '_TYPE UINT32\n_NAME commandSize\n'
                  '_TYPE TPM_CC\n_NAME commandCode\n_COMMENT TPM_CC_Test\n'
                  '_TYPE UINT16\n_NAME input\n'
                  '_OUTPUT_START TPM2_Test\n_END\n')

  def testStructureParserWithBadData(self):
    """Test the structure parser with invalid data."""
    input_data = 'bad_data'
    in_file = StringIO.StringIO(input_data)
    parser = generator.StructureParser(in_file)
    types, constants, structs, defines, typemap = parser.Parse()
    self.assertIsNotNone(types)
    self.assertIsNotNone(constants)
    self.assertIsNotNone(structs)
    self.assertIsNotNone(defines)
    self.assertIsNotNone(typemap)

  def testStructureParser(self):
    """Test the structure parser with valid data."""
    input_data = (self.FAKE_TYPEDEF + self.FAKE_CONSTANT + self.FAKE_STRUCTURE +
                  self.FAKE_DEFINE)
    in_file = StringIO.StringIO(input_data)
    parser = generator.StructureParser(in_file)
    types, constants, structs, defines, typemap = parser.Parse()
    # Be flexible on these counts because the parser may add special cases.
    self.assertGreaterEqual(len(types), 2)
    self.assertGreaterEqual(len(constants), 1)
    self.assertGreaterEqual(len(structs), 1)
    self.assertGreaterEqual(len(defines), 1)
    self.assertGreaterEqual(len(typemap), 3)
    self.assertEqual(types[0].old_type, 'type1')
    self.assertEqual(types[0].new_type, 'type2')
    self.assertEqual(types[1].old_type, 'base_type')
    self.assertEqual(types[1].new_type, 'const_type')
    self.assertEqual(constants[0].const_type, 'const_type')
    self.assertEqual(constants[0].name, 'const_name')
    self.assertEqual(constants[0].value, 'const_value')
    self.assertEqual(structs[0].name, 'struct_type')
    self.assertEqual(structs[0].is_union, False)
    self.assertEqual(len(structs[0].fields), 1)
    self.assertEqual(structs[0].fields[0][0], 'field_type')
    self.assertEqual(structs[0].fields[0][1], 'field_name[sizeof(depend_type)]')
    self.assertEqual(len(structs[0].depends_on), 1)
    self.assertEqual(structs[0].depends_on[0], 'depend_type')
    self.assertEqual(defines[0].name, 'define_name')
    self.assertEqual(defines[0].value, 'define_value')

  def testCommandParserWithBadData(self):
    """Test the command parser with invalid data."""
    input_data = 'bad_data'
    in_file = StringIO.StringIO(input_data)
    parser = generator.CommandParser(in_file)
    commands = parser.Parse()
    self.assertIsNotNone(commands)

  def testCommandParser(self):
    """Test the command parser with valid data."""
    input_data = self.FAKE_COMMAND
    in_file = StringIO.StringIO(input_data)
    parser = generator.CommandParser(in_file)
    commands = parser.Parse()
    self.assertEqual(len(commands), 1)
    self.assertEqual(commands[0].name, 'TPM2_Test')
    self.assertEqual(commands[0].command_code, 'TPM_CC_Test')
    # We expect the 'commandSize' and 'commandCode' args to be filtered out.
    self.assertEqual(len(commands[0].request_args), 1)
    self.assertEqual(commands[0].request_args[0]['type'], 'UINT16')
    self.assertEqual(commands[0].request_args[0]['name'], 'input')
    self.assertIsNotNone(commands[0].response_args)
    self.assertFalse(commands[0].response_args)


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