tests/scripts/generate_code_ut.py - mirror/mbed-tls - TrustedFirmware Git Browser

 """
 mbed TLS
 Copyright (c) 2017 ARM Limited

 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.
 """
 from StringIO import StringIO
 from unittest import TestCase, main as unittest_main
 from mock import patch
 from generate_code import *


 """
 Unit tests for generate_code.py
 """


 class GenDep(TestCase):
     """
     Test suite for function gen_dep()
     """

     def test_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = ['DEP1', 'DEP2']
         dep_start, dep_end = gen_deps(deps)
         ifdef1, ifdef2 = dep_start.splitlines()
         endif1, endif2 = dep_end.splitlines()
         self.assertEqual(ifdef1, '#if defined(DEP1)', 'ifdef generated incorrectly')
         self.assertEqual(ifdef2, '#if defined(DEP2)', 'ifdef generated incorrectly')
         self.assertEqual(endif1, '#endif /* DEP2 */', 'endif generated incorrectly')
         self.assertEqual(endif2, '#endif /* DEP1 */', 'endif generated incorrectly')

     def test_disabled_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = ['!DEP1', '!DEP2']
         dep_start, dep_end = gen_deps(deps)
         ifdef1, ifdef2 = dep_start.splitlines()
         endif1, endif2 = dep_end.splitlines()
         self.assertEqual(ifdef1, '#if !defined(DEP1)', 'ifdef generated incorrectly')
         self.assertEqual(ifdef2, '#if !defined(DEP2)', 'ifdef generated incorrectly')
         self.assertEqual(endif1, '#endif /* !DEP2 */', 'endif generated incorrectly')
         self.assertEqual(endif2, '#endif /* !DEP1 */', 'endif generated incorrectly')

     def test_mixed_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = ['!DEP1', 'DEP2']
         dep_start, dep_end = gen_deps(deps)
         ifdef1, ifdef2 = dep_start.splitlines()
         endif1, endif2 = dep_end.splitlines()
         self.assertEqual(ifdef1, '#if !defined(DEP1)', 'ifdef generated incorrectly')
         self.assertEqual(ifdef2, '#if defined(DEP2)', 'ifdef generated incorrectly')
         self.assertEqual(endif1, '#endif /* DEP2 */', 'endif generated incorrectly')
         self.assertEqual(endif2, '#endif /* !DEP1 */', 'endif generated incorrectly')

     def test_empty_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = []
         dep_start, dep_end = gen_deps(deps)
         self.assertEqual(dep_start, '', 'ifdef generated incorrectly')
         self.assertEqual(dep_end, '', 'ifdef generated incorrectly')

     def test_large_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = []
         count = 10
         for i in range(count):
             deps.append('DEP%d' % i)
         dep_start, dep_end = gen_deps(deps)
         self.assertEqual(len(dep_start.splitlines()), count, 'ifdef generated incorrectly')
         self.assertEqual(len(dep_end.splitlines()), count, 'ifdef generated incorrectly')


 class GenDepOneLine(TestCase):
     """
     Test Suite for testing gen_deps_one_line()
     """

     def test_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = ['DEP1', 'DEP2']
         dep_str = gen_deps_one_line(deps)
         self.assertEqual(dep_str, '#if defined(DEP1) && defined(DEP2)', 'ifdef generated incorrectly')

     def test_disabled_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = ['!DEP1', '!DEP2']
         dep_str = gen_deps_one_line(deps)
         self.assertEqual(dep_str, '#if !defined(DEP1) && !defined(DEP2)', 'ifdef generated incorrectly')

     def test_mixed_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = ['!DEP1', 'DEP2']
         dep_str = gen_deps_one_line(deps)
         self.assertEqual(dep_str, '#if !defined(DEP1) && defined(DEP2)', 'ifdef generated incorrectly')

     def test_empty_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = []
         dep_str = gen_deps_one_line(deps)
         self.assertEqual(dep_str, '', 'ifdef generated incorrectly')

     def test_large_deps_list(self):
         """
         Test that gen_dep() correctly creates deps for given dependency list.
         :return:
         """
         deps = []
         count = 10
         for i in range(count):
             deps.append('DEP%d' % i)
         dep_str = gen_deps_one_line(deps)
         expected = '#if ' + ' && '.join(['defined(%s)' % x for x in deps])
         self.assertEqual(dep_str, expected, 'ifdef generated incorrectly')


 class GenFunctionWrapper(TestCase):
     """
     Test Suite for testing gen_function_wrapper()
     """

     def test_params_unpack(self):
         """
         Test that params are properly unpacked in the function call.

         :return:
         """
         code = gen_function_wrapper('test_a', '', ('a', 'b', 'c', 'd'))
         expected = '''
 void test_a_wrapper( void ** params )
 {


     test_a( a, b, c, d );
 }
 '''
         self.assertEqual(code, expected)

     def test_local(self):
         """
         Test that params are properly unpacked in the function call.

         :return:
         """
         code = gen_function_wrapper('test_a', 'int x = 1;', ('x', 'b', 'c', 'd'))
         expected = '''
 void test_a_wrapper( void ** params )
 {

 int x = 1;
     test_a( x, b, c, d );
 }
 '''
         self.assertEqual(code, expected)

     def test_empty_params(self):
         """
         Test that params are properly unpacked in the function call.

         :return:
         """
         code = gen_function_wrapper('test_a', '', ())
         expected = '''
 void test_a_wrapper( void ** params )
 {
     (void)params;

     test_a(  );
 }
 '''
         self.assertEqual(code, expected)


 class GenDispatch(TestCase):
     """
     Test suite for testing gen_dispatch()
     """

     def test_dispatch(self):
         """
         Test that dispatch table entry is generated correctly.
         :return:
         """
         code = gen_dispatch('test_a', ['DEP1', 'DEP2'])
         expected = '''
 #if defined(DEP1) && defined(DEP2)
     test_a_wrapper,
 #else
     NULL,
 #endif
 '''
         self.assertEqual(code, expected)

     def test_empty_deps(self):
         """
         Test empty dependency list.
         :return:
         """
         code = gen_dispatch('test_a', [])
         expected = '''
     test_a_wrapper,
 '''
         self.assertEqual(code, expected)


 class StringIOWrapper(StringIO, object):
     """
     file like class to mock file object in tests.
     """
     def __init__(self, file_name, data, line_no = 1):
         """
         Init file handle.

         :param file_name:
         :param data:
         :param line_no:
         """
         super(StringIOWrapper, self).__init__(data)
         self.line_no = line_no
         self.name = file_name

     def next(self):
         """
         Iterator return impl.
         :return:
         """
         line = super(StringIOWrapper, self).next()
         return line

     def readline(self, limit=0):
         """
         Wrap the base class readline.

         :param limit:
         :return:
         """
         line = super(StringIOWrapper, self).readline()
         if line:
             self.line_no += 1
         return line


 class ParseSuiteHeaders(TestCase):
     """
     Test Suite for testing parse_suite_headers().
     """

     def test_suite_headers(self):
         """
         Test that suite headers are parsed correctly.

         :return:
         """
         data = '''#include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 /* END_HEADER */
 '''
         expected = '''#line 1 "test_suite_ut.function"
 #include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 '''
         s = StringIOWrapper('test_suite_ut.function', data, line_no=0)
         headers = parse_suite_headers(s)
         self.assertEqual(headers, expected)

     def test_line_no(self):
         """
         Test that #line is set to correct line no. in source .function file.

         :return:
         """
         data = '''#include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 /* END_HEADER */
 '''
         offset_line_no = 5
         expected = '''#line %d "test_suite_ut.function"
 #include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 ''' % (offset_line_no + 1)
         s = StringIOWrapper('test_suite_ut.function', data, offset_line_no)
         headers = parse_suite_headers(s)
         self.assertEqual(headers, expected)

     def test_no_end_header_comment(self):
         """
         Test that InvalidFileFormat is raised when end header comment is missing.
         :return:
         """
         data = '''#include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1

 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(InvalidFileFormat, parse_suite_headers, s)


 class ParseSuiteDeps(TestCase):
     """
     Test Suite for testing parse_suite_deps().
     """

     def test_suite_deps(self):
         """

         :return:
         """
         data = '''
  * depends_on:MBEDTLS_ECP_C
  * END_DEPENDENCIES
  */
 '''
         expected = ['MBEDTLS_ECP_C']
         s = StringIOWrapper('test_suite_ut.function', data)
         deps = parse_suite_deps(s)
         self.assertEqual(deps, expected)

     def test_no_end_dep_comment(self):
         """
         Test that InvalidFileFormat is raised when end dep comment is missing.
         :return:
         """
         data = '''
 * depends_on:MBEDTLS_ECP_C
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(InvalidFileFormat, parse_suite_deps, s)

     def test_deps_split(self):
         """
         Test that InvalidFileFormat is raised when end dep comment is missing.
         :return:
         """
         data = '''
  * depends_on:MBEDTLS_ECP_C:A:B:   C  : D :F : G: !H
  * END_DEPENDENCIES
  */
 '''
         expected = ['MBEDTLS_ECP_C', 'A', 'B', 'C', 'D', 'F', 'G', '!H']
         s = StringIOWrapper('test_suite_ut.function', data)
         deps = parse_suite_deps(s)
         self.assertEqual(deps, expected)


 class ParseFuncDeps(TestCase):
     """
     Test Suite for testing parse_function_deps()
     """

     def test_function_deps(self):
         """
         Test that parse_function_deps() correctly parses function dependencies.
         :return:
         """
         line = '/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */'
         expected = ['MBEDTLS_ENTROPY_NV_SEED', 'MBEDTLS_FS_IO']
         deps = parse_function_deps(line)
         self.assertEqual(deps, expected)

     def test_no_deps(self):
         """
         Test that parse_function_deps() correctly parses function dependencies.
         :return:
         """
         line = '/* BEGIN_CASE */'
         deps = parse_function_deps(line)
         self.assertEqual(deps, [])

     def test_poorly_defined_deps(self):
         """
         Test that parse_function_deps() correctly parses function dependencies.
         :return:
         """
         line = '/* BEGIN_CASE depends_on:MBEDTLS_FS_IO: A : !B:C : F*/'
         deps = parse_function_deps(line)
         self.assertEqual(deps, ['MBEDTLS_FS_IO', 'A', '!B', 'C', 'F'])


 class ParseFuncSignature(TestCase):
     """
     Test Suite for parse_function_signature().
     """

     def test_int_and_char_params(self):
         """

         :return:
         """
         line = 'void entropy_threshold( char * a, int b, int result )'
         name, args, local, arg_dispatch = parse_function_signature(line)
         self.assertEqual(name, 'entropy_threshold')
         self.assertEqual(args, ['char*', 'int', 'int'])
         self.assertEqual(local, '')
         self.assertEqual(arg_dispatch, ['(char *) params[0]', '*( (int *) params[1] )', '*( (int *) params[2] )'])

     def test_hex_params(self):
         """

         :return:
         """
         line = 'void entropy_threshold( char * a, HexParam_t * h, int result )'
         name, args, local, arg_dispatch = parse_function_signature(line)
         self.assertEqual(name, 'entropy_threshold')
         self.assertEqual(args, ['char*', 'hex', 'int'])
         self.assertEqual(local, '    HexParam_t hex1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};\n')
         self.assertEqual(arg_dispatch, ['(char *) params[0]', '&hex1', '*( (int *) params[3] )'])

     def test_non_void_function(self):
         """

         :return:
         """
         line = 'int entropy_threshold( char * a, HexParam_t * h, int result )'
         self.assertRaises(ValueError, parse_function_signature, line)

     def test_unsupported_arg(self):
         """

         :return:
         """
         line = 'int entropy_threshold( char * a, HexParam_t * h, int * result )'
         self.assertRaises(ValueError, parse_function_signature, line)

     def test_no_params(self):
         """

         :return:
         """
         line = 'void entropy_threshold()'
         name, args, local, arg_dispatch = parse_function_signature(line)
         self.assertEqual(name, 'entropy_threshold')
         self.assertEqual(args, [])
         self.assertEqual(local, '')
         self.assertEqual(arg_dispatch, [])


 class ParseFunctionCode(TestCase):
     """
     Test suite for testing parse_function_code()
     """

     def test_no_function(self):
         """

         :return:
         """
         data = '''
 No
 test
 function
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])

     def test_no_end_case_comment(self):
         """

         :return:
         """
         data = '''
 void test_func()
 {
 }
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])

     @patch("generate_code.parse_function_signature")
     def test_parse_function_signature_called(self, parse_function_signature_mock):
         """

         :return:
         """
         parse_function_signature_mock.return_value = ('test_func', [], '', [])
         data = '''
 void test_func()
 {
 }
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])
         self.assertTrue(parse_function_signature_mock.called)
         parse_function_signature_mock.assert_called_with('void test_func()\n')

     @patch("generate_code.gen_dispatch")
     @patch("generate_code.gen_deps")
     @patch("generate_code.gen_function_wrapper")
     @patch("generate_code.parse_function_signature")
     def test_return(self, parse_function_signature_mock,
                                              gen_function_wrapper_mock,
                                              gen_deps_mock,
                                              gen_dispatch_mock):
         """

         :return:
         """
         parse_function_signature_mock.return_value = ('func', [], '', [])
         gen_function_wrapper_mock.return_value = ''
         gen_deps_mock.side_effect = gen_deps
         gen_dispatch_mock.side_effect = gen_dispatch
         data = '''
 void func()
 {
     ba ba black sheep
     have you any wool
 }
 /* END_CASE */
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         name, arg, code, dispatch_code = parse_function_code(s, [], [])

         #self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])
         self.assertTrue(parse_function_signature_mock.called)
         parse_function_signature_mock.assert_called_with('void func()\n')
         gen_function_wrapper_mock.assert_called_with('test_func', '', [])
         self.assertEqual(name, 'test_func')
         self.assertEqual(arg, [])
         expected = '''#line 2 "test_suite_ut.function"
 void test_func()
 {
     ba ba black sheep
     have you any wool
 exit:
     ;;
 }
 '''
         self.assertEqual(code, expected)
         self.assertEqual(dispatch_code, "\n    test_func_wrapper,\n")

     @patch("generate_code.gen_dispatch")
     @patch("generate_code.gen_deps")
     @patch("generate_code.gen_function_wrapper")
     @patch("generate_code.parse_function_signature")
     def test_with_exit_label(self, parse_function_signature_mock,
                            gen_function_wrapper_mock,
                            gen_deps_mock,
                            gen_dispatch_mock):
         """

         :return:
         """
         parse_function_signature_mock.return_value = ('func', [], '', [])
         gen_function_wrapper_mock.return_value = ''
         gen_deps_mock.side_effect = gen_deps
         gen_dispatch_mock.side_effect = gen_dispatch
         data = '''
 void func()
 {
     ba ba black sheep
     have you any wool
 exit:
     yes sir yes sir
     3 bags full
 }
 /* END_CASE */
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         name, arg, code, dispatch_code = parse_function_code(s, [], [])

         expected = '''#line 2 "test_suite_ut.function"
 void test_func()
 {
     ba ba black sheep
     have you any wool
 exit:
     yes sir yes sir
     3 bags full
 }
 '''
         self.assertEqual(code, expected)


 class ParseFunction(TestCase):
     """
     Test Suite for testing parse_functions()
     """

     @patch("generate_code.parse_suite_headers")
     def test_begin_header(self, parse_suite_headers_mock):
         """
         Test that begin header is checked and parse_suite_headers() is called.
         :return:
         """
         def stop(this):
             raise Exception
         parse_suite_headers_mock.side_effect = stop
         data = '''/* BEGIN_HEADER */
 #include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 /* END_HEADER */
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(Exception, parse_functions, s)
         parse_suite_headers_mock.assert_called_with(s)
         self.assertEqual(s.line_no, 2)

     @patch("generate_code.parse_suite_deps")
     def test_begin_dep(self, parse_suite_deps_mock):
         """
         Test that begin header is checked and parse_suite_headers() is called.
         :return:
         """
         def stop(this):
             raise Exception
         parse_suite_deps_mock.side_effect = stop
         data = '''/* BEGIN_DEPENDENCIES
  * depends_on:MBEDTLS_ECP_C
  * END_DEPENDENCIES
  */
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(Exception, parse_functions, s)
         parse_suite_deps_mock.assert_called_with(s)
         self.assertEqual(s.line_no, 2)

     @patch("generate_code.parse_function_deps")
     def test_begin_function_dep(self, parse_function_deps_mock):
         """
         Test that begin header is checked and parse_suite_headers() is called.
         :return:
         """
         def stop(this):
             raise Exception
         parse_function_deps_mock.side_effect = stop

         deps_str = '/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */\n'
         data = '''%svoid test_func()
 {
 }
 ''' % deps_str
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(Exception, parse_functions, s)
         parse_function_deps_mock.assert_called_with(deps_str)
         self.assertEqual(s.line_no, 2)

     @patch("generate_code.parse_function_code")
     @patch("generate_code.parse_function_deps")
     def test_return(self, parse_function_deps_mock, parse_function_code_mock):
         """
         Test that begin header is checked and parse_suite_headers() is called.
         :return:
         """
         def stop(this):
             raise Exception
         parse_function_deps_mock.return_value = []
         in_func_code= '''void test_func()
 {
 }
 '''
         func_dispatch = '''
     test_func_wrapper,
 '''
         parse_function_code_mock.return_value = 'test_func', [], in_func_code, func_dispatch
         deps_str = '/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */\n'
         data = '''%svoid test_func()
 {
 }
 ''' % deps_str
         s = StringIOWrapper('test_suite_ut.function', data)
         suite_deps, dispatch_code, func_code, func_info = parse_functions(s)
         parse_function_deps_mock.assert_called_with(deps_str)
         parse_function_code_mock.assert_called_with(s, [], [])
         self.assertEqual(s.line_no, 5)
         self.assertEqual(suite_deps, [])
         expected_dispatch_code = '''/* Function Id: 0 */

     test_func_wrapper,
 '''
         self.assertEqual(dispatch_code, expected_dispatch_code)
         self.assertEqual(func_code, in_func_code)
         self.assertEqual(func_info, {'test_func': (0, [])})

     def test_parsing(self):
         """
         Test that begin header is checked and parse_suite_headers() is called.
         :return:
         """
         data = '''/* BEGIN_HEADER */
 #include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 /* END_HEADER */

 /* BEGIN_DEPENDENCIES
  * depends_on:MBEDTLS_ECP_C
  * END_DEPENDENCIES
  */

 /* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
 void func1()
 {
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
 void func2()
 {
 }
 /* END_CASE */
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         suite_deps, dispatch_code, func_code, func_info = parse_functions(s)
         self.assertEqual(s.line_no, 23)
         self.assertEqual(suite_deps, ['MBEDTLS_ECP_C'])

         expected_dispatch_code = '''/* Function Id: 0 */

 #if defined(MBEDTLS_ECP_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
     test_func1_wrapper,
 #else
     NULL,
 #endif
 /* Function Id: 1 */

 #if defined(MBEDTLS_ECP_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
     test_func2_wrapper,
 #else
     NULL,
 #endif
 '''
         self.assertEqual(dispatch_code, expected_dispatch_code)
         expected_func_code = '''#if defined(MBEDTLS_ECP_C)
 #line 3 "test_suite_ut.function"
 #include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 #if defined(MBEDTLS_ENTROPY_NV_SEED)
 #if defined(MBEDTLS_FS_IO)
 #line 14 "test_suite_ut.function"
 void test_func1()
 {
 exit:
     ;;
 }

 void test_func1_wrapper( void ** params )
 {
     (void)params;

     test_func1(  );
 }
 #endif /* MBEDTLS_FS_IO */
 #endif /* MBEDTLS_ENTROPY_NV_SEED */
 #if defined(MBEDTLS_ENTROPY_NV_SEED)
 #if defined(MBEDTLS_FS_IO)
 #line 20 "test_suite_ut.function"
 void test_func2()
 {
 exit:
     ;;
 }

 void test_func2_wrapper( void ** params )
 {
     (void)params;

     test_func2(  );
 }
 #endif /* MBEDTLS_FS_IO */
 #endif /* MBEDTLS_ENTROPY_NV_SEED */
 #endif /* MBEDTLS_ECP_C */
 '''
         self.assertEqual(func_code, expected_func_code)
         self.assertEqual(func_info, {'test_func1': (0, []), 'test_func2': (1, [])})

     def test_same_function_name(self):
         """
         Test that begin header is checked and parse_suite_headers() is called.
         :return:
         """
         data = '''/* BEGIN_HEADER */
 #include "mbedtls/ecp.h"

 #define ECP_PF_UNKNOWN     -1
 /* END_HEADER */

 /* BEGIN_DEPENDENCIES
  * depends_on:MBEDTLS_ECP_C
  * END_DEPENDENCIES
  */

 /* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
 void func()
 {
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
 void func()
 {
 }
 /* END_CASE */
 '''
         s = StringIOWrapper('test_suite_ut.function', data)
         self.assertRaises(AssertionError, parse_functions, s)


 if __name__=='__main__':
     unittest_main()
	"""
	mbed TLS
	Copyright (c) 2017 ARM Limited

	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.
	"""
	from StringIO import StringIO
	from unittest import TestCase, main as unittest_main
	from mock import patch
	from generate_code import *


	"""
	Unit tests for generate_code.py
	"""


	class GenDep(TestCase):
	"""
	Test suite for function gen_dep()
	"""

	def test_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = ['DEP1', 'DEP2']
	dep_start, dep_end = gen_deps(deps)
	ifdef1, ifdef2 = dep_start.splitlines()
	endif1, endif2 = dep_end.splitlines()
	self.assertEqual(ifdef1, '#if defined(DEP1)', 'ifdef generated incorrectly')
	self.assertEqual(ifdef2, '#if defined(DEP2)', 'ifdef generated incorrectly')
	self.assertEqual(endif1, '#endif /* DEP2 */', 'endif generated incorrectly')
	self.assertEqual(endif2, '#endif /* DEP1 */', 'endif generated incorrectly')

	def test_disabled_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = ['!DEP1', '!DEP2']
	dep_start, dep_end = gen_deps(deps)
	ifdef1, ifdef2 = dep_start.splitlines()
	endif1, endif2 = dep_end.splitlines()
	self.assertEqual(ifdef1, '#if !defined(DEP1)', 'ifdef generated incorrectly')
	self.assertEqual(ifdef2, '#if !defined(DEP2)', 'ifdef generated incorrectly')
	self.assertEqual(endif1, '#endif /* !DEP2 */', 'endif generated incorrectly')
	self.assertEqual(endif2, '#endif /* !DEP1 */', 'endif generated incorrectly')

	def test_mixed_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = ['!DEP1', 'DEP2']
	dep_start, dep_end = gen_deps(deps)
	ifdef1, ifdef2 = dep_start.splitlines()
	endif1, endif2 = dep_end.splitlines()
	self.assertEqual(ifdef1, '#if !defined(DEP1)', 'ifdef generated incorrectly')
	self.assertEqual(ifdef2, '#if defined(DEP2)', 'ifdef generated incorrectly')
	self.assertEqual(endif1, '#endif /* DEP2 */', 'endif generated incorrectly')
	self.assertEqual(endif2, '#endif /* !DEP1 */', 'endif generated incorrectly')

	def test_empty_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = []
	dep_start, dep_end = gen_deps(deps)
	self.assertEqual(dep_start, '', 'ifdef generated incorrectly')
	self.assertEqual(dep_end, '', 'ifdef generated incorrectly')

	def test_large_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = []
	count = 10
	for i in range(count):
	deps.append('DEP%d' % i)
	dep_start, dep_end = gen_deps(deps)
	self.assertEqual(len(dep_start.splitlines()), count, 'ifdef generated incorrectly')
	self.assertEqual(len(dep_end.splitlines()), count, 'ifdef generated incorrectly')


	class GenDepOneLine(TestCase):
	"""
	Test Suite for testing gen_deps_one_line()
	"""

	def test_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = ['DEP1', 'DEP2']
	dep_str = gen_deps_one_line(deps)
	self.assertEqual(dep_str, '#if defined(DEP1) && defined(DEP2)', 'ifdef generated incorrectly')

	def test_disabled_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = ['!DEP1', '!DEP2']
	dep_str = gen_deps_one_line(deps)
	self.assertEqual(dep_str, '#if !defined(DEP1) && !defined(DEP2)', 'ifdef generated incorrectly')

	def test_mixed_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = ['!DEP1', 'DEP2']
	dep_str = gen_deps_one_line(deps)
	self.assertEqual(dep_str, '#if !defined(DEP1) && defined(DEP2)', 'ifdef generated incorrectly')

	def test_empty_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = []
	dep_str = gen_deps_one_line(deps)
	self.assertEqual(dep_str, '', 'ifdef generated incorrectly')

	def test_large_deps_list(self):
	"""
	Test that gen_dep() correctly creates deps for given dependency list.
	:return:
	"""
	deps = []
	count = 10
	for i in range(count):
	deps.append('DEP%d' % i)
	dep_str = gen_deps_one_line(deps)
	expected = '#if ' + ' && '.join(['defined(%s)' % x for x in deps])
	self.assertEqual(dep_str, expected, 'ifdef generated incorrectly')


	class GenFunctionWrapper(TestCase):
	"""
	Test Suite for testing gen_function_wrapper()
	"""

	def test_params_unpack(self):
	"""
	Test that params are properly unpacked in the function call.

	:return:
	"""
	code = gen_function_wrapper('test_a', '', ('a', 'b', 'c', 'd'))
	expected = '''
	void test_a_wrapper( void ** params )
	{


	test_a( a, b, c, d );
	}
	'''
	self.assertEqual(code, expected)

	def test_local(self):
	"""
	Test that params are properly unpacked in the function call.

	:return:
	"""
	code = gen_function_wrapper('test_a', 'int x = 1;', ('x', 'b', 'c', 'd'))
	expected = '''
	void test_a_wrapper( void ** params )
	{

	int x = 1;
	test_a( x, b, c, d );
	}
	'''
	self.assertEqual(code, expected)

	def test_empty_params(self):
	"""
	Test that params are properly unpacked in the function call.

	:return:
	"""
	code = gen_function_wrapper('test_a', '', ())
	expected = '''
	void test_a_wrapper( void ** params )
	{
	(void)params;

	test_a( );
	}
	'''
	self.assertEqual(code, expected)


	class GenDispatch(TestCase):
	"""
	Test suite for testing gen_dispatch()
	"""

	def test_dispatch(self):
	"""
	Test that dispatch table entry is generated correctly.
	:return:
	"""
	code = gen_dispatch('test_a', ['DEP1', 'DEP2'])
	expected = '''
	#if defined(DEP1) && defined(DEP2)
	test_a_wrapper,
	#else
	NULL,
	#endif
	'''
	self.assertEqual(code, expected)

	def test_empty_deps(self):
	"""
	Test empty dependency list.
	:return:
	"""
	code = gen_dispatch('test_a', [])
	expected = '''
	test_a_wrapper,
	'''
	self.assertEqual(code, expected)


	class StringIOWrapper(StringIO, object):
	"""
	file like class to mock file object in tests.
	"""
	def __init__(self, file_name, data, line_no = 1):
	"""
	Init file handle.

	:param file_name:
	:param data:
	:param line_no:
	"""
	super(StringIOWrapper, self).__init__(data)
	self.line_no = line_no
	self.name = file_name

	def next(self):
	"""
	Iterator return impl.
	:return:
	"""
	line = super(StringIOWrapper, self).next()
	return line

	def readline(self, limit=0):
	"""
	Wrap the base class readline.

	:param limit:
	:return:
	"""
	line = super(StringIOWrapper, self).readline()
	if line:
	self.line_no += 1
	return line


	class ParseSuiteHeaders(TestCase):
	"""
	Test Suite for testing parse_suite_headers().
	"""

	def test_suite_headers(self):
	"""
	Test that suite headers are parsed correctly.

	:return:
	"""
	data = '''#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	/* END_HEADER */
	'''
	expected = '''#line 1 "test_suite_ut.function"
	#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	'''
	s = StringIOWrapper('test_suite_ut.function', data, line_no=0)
	headers = parse_suite_headers(s)
	self.assertEqual(headers, expected)

	def test_line_no(self):
	"""
	Test that #line is set to correct line no. in source .function file.

	:return:
	"""
	data = '''#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	/* END_HEADER */
	'''
	offset_line_no = 5
	expected = '''#line %d "test_suite_ut.function"
	#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	''' % (offset_line_no + 1)
	s = StringIOWrapper('test_suite_ut.function', data, offset_line_no)
	headers = parse_suite_headers(s)
	self.assertEqual(headers, expected)

	def test_no_end_header_comment(self):
	"""
	Test that InvalidFileFormat is raised when end header comment is missing.
	:return:
	"""
	data = '''#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1

	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(InvalidFileFormat, parse_suite_headers, s)


	class ParseSuiteDeps(TestCase):
	"""
	Test Suite for testing parse_suite_deps().
	"""

	def test_suite_deps(self):
	"""

	:return:
	"""
	data = '''
	* depends_on:MBEDTLS_ECP_C
	* END_DEPENDENCIES
	*/
	'''
	expected = ['MBEDTLS_ECP_C']
	s = StringIOWrapper('test_suite_ut.function', data)
	deps = parse_suite_deps(s)
	self.assertEqual(deps, expected)

	def test_no_end_dep_comment(self):
	"""
	Test that InvalidFileFormat is raised when end dep comment is missing.
	:return:
	"""
	data = '''
	* depends_on:MBEDTLS_ECP_C
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(InvalidFileFormat, parse_suite_deps, s)

	def test_deps_split(self):
	"""
	Test that InvalidFileFormat is raised when end dep comment is missing.
	:return:
	"""
	data = '''
	* depends_on:MBEDTLS_ECP_C:A:B: C : D :F : G: !H
	* END_DEPENDENCIES
	*/
	'''
	expected = ['MBEDTLS_ECP_C', 'A', 'B', 'C', 'D', 'F', 'G', '!H']
	s = StringIOWrapper('test_suite_ut.function', data)
	deps = parse_suite_deps(s)
	self.assertEqual(deps, expected)


	class ParseFuncDeps(TestCase):
	"""
	Test Suite for testing parse_function_deps()
	"""

	def test_function_deps(self):
	"""
	Test that parse_function_deps() correctly parses function dependencies.
	:return:
	"""
	line = '/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */'
	expected = ['MBEDTLS_ENTROPY_NV_SEED', 'MBEDTLS_FS_IO']
	deps = parse_function_deps(line)
	self.assertEqual(deps, expected)

	def test_no_deps(self):
	"""
	Test that parse_function_deps() correctly parses function dependencies.
	:return:
	"""
	line = '/* BEGIN_CASE */'
	deps = parse_function_deps(line)
	self.assertEqual(deps, [])

	def test_poorly_defined_deps(self):
	"""
	Test that parse_function_deps() correctly parses function dependencies.
	:return:
	"""
	line = '/* BEGIN_CASE depends_on:MBEDTLS_FS_IO: A : !B:C : F*/'
	deps = parse_function_deps(line)
	self.assertEqual(deps, ['MBEDTLS_FS_IO', 'A', '!B', 'C', 'F'])


	class ParseFuncSignature(TestCase):
	"""
	Test Suite for parse_function_signature().
	"""

	def test_int_and_char_params(self):
	"""

	:return:
	"""
	line = 'void entropy_threshold( char * a, int b, int result )'
	name, args, local, arg_dispatch = parse_function_signature(line)
	self.assertEqual(name, 'entropy_threshold')
	self.assertEqual(args, ['char*', 'int', 'int'])
	self.assertEqual(local, '')
	self.assertEqual(arg_dispatch, ['(char ) params[0]', '( (int ) params[1] )', '( (int *) params[2] )'])

	def test_hex_params(self):
	"""

	:return:
	"""
	line = 'void entropy_threshold( char * a, HexParam_t * h, int result )'
	name, args, local, arg_dispatch = parse_function_signature(line)
	self.assertEqual(name, 'entropy_threshold')
	self.assertEqual(args, ['char*', 'hex', 'int'])
	self.assertEqual(local, ' HexParam_t hex1 = {(uint8_t ) params[1], ( (uint32_t *) params[2] )};\n')
	self.assertEqual(arg_dispatch, ['(char ) params[0]', '&hex1', '( (int *) params[3] )'])

	def test_non_void_function(self):
	"""

	:return:
	"""
	line = 'int entropy_threshold( char * a, HexParam_t * h, int result )'
	self.assertRaises(ValueError, parse_function_signature, line)

	def test_unsupported_arg(self):
	"""

	:return:
	"""
	line = 'int entropy_threshold( char * a, HexParam_t * h, int * result )'
	self.assertRaises(ValueError, parse_function_signature, line)

	def test_no_params(self):
	"""

	:return:
	"""
	line = 'void entropy_threshold()'
	name, args, local, arg_dispatch = parse_function_signature(line)
	self.assertEqual(name, 'entropy_threshold')
	self.assertEqual(args, [])
	self.assertEqual(local, '')
	self.assertEqual(arg_dispatch, [])


	class ParseFunctionCode(TestCase):
	"""
	Test suite for testing parse_function_code()
	"""

	def test_no_function(self):
	"""

	:return:
	"""
	data = '''
	No
	test
	function
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])

	def test_no_end_case_comment(self):
	"""

	:return:
	"""
	data = '''
	void test_func()
	{
	}
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])

	@patch("generate_code.parse_function_signature")
	def test_parse_function_signature_called(self, parse_function_signature_mock):
	"""

	:return:
	"""
	parse_function_signature_mock.return_value = ('test_func', [], '', [])
	data = '''
	void test_func()
	{
	}
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])
	self.assertTrue(parse_function_signature_mock.called)
	parse_function_signature_mock.assert_called_with('void test_func()\n')

	@patch("generate_code.gen_dispatch")
	@patch("generate_code.gen_deps")
	@patch("generate_code.gen_function_wrapper")
	@patch("generate_code.parse_function_signature")
	def test_return(self, parse_function_signature_mock,
	gen_function_wrapper_mock,
	gen_deps_mock,
	gen_dispatch_mock):
	"""

	:return:
	"""
	parse_function_signature_mock.return_value = ('func', [], '', [])
	gen_function_wrapper_mock.return_value = ''
	gen_deps_mock.side_effect = gen_deps
	gen_dispatch_mock.side_effect = gen_dispatch
	data = '''
	void func()
	{
	ba ba black sheep
	have you any wool
	}
	/* END_CASE */
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	name, arg, code, dispatch_code = parse_function_code(s, [], [])

	#self.assertRaises(InvalidFileFormat, parse_function_code, s, [], [])
	self.assertTrue(parse_function_signature_mock.called)
	parse_function_signature_mock.assert_called_with('void func()\n')
	gen_function_wrapper_mock.assert_called_with('test_func', '', [])
	self.assertEqual(name, 'test_func')
	self.assertEqual(arg, [])
	expected = '''#line 2 "test_suite_ut.function"
	void test_func()
	{
	ba ba black sheep
	have you any wool
	exit:
	;;
	}
	'''
	self.assertEqual(code, expected)
	self.assertEqual(dispatch_code, "\n test_func_wrapper,\n")

	@patch("generate_code.gen_dispatch")
	@patch("generate_code.gen_deps")
	@patch("generate_code.gen_function_wrapper")
	@patch("generate_code.parse_function_signature")
	def test_with_exit_label(self, parse_function_signature_mock,
	gen_function_wrapper_mock,
	gen_deps_mock,
	gen_dispatch_mock):
	"""

	:return:
	"""
	parse_function_signature_mock.return_value = ('func', [], '', [])
	gen_function_wrapper_mock.return_value = ''
	gen_deps_mock.side_effect = gen_deps
	gen_dispatch_mock.side_effect = gen_dispatch
	data = '''
	void func()
	{
	ba ba black sheep
	have you any wool
	exit:
	yes sir yes sir
	3 bags full
	}
	/* END_CASE */
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	name, arg, code, dispatch_code = parse_function_code(s, [], [])

	expected = '''#line 2 "test_suite_ut.function"
	void test_func()
	{
	ba ba black sheep
	have you any wool
	exit:
	yes sir yes sir
	3 bags full
	}
	'''
	self.assertEqual(code, expected)


	class ParseFunction(TestCase):
	"""
	Test Suite for testing parse_functions()
	"""

	@patch("generate_code.parse_suite_headers")
	def test_begin_header(self, parse_suite_headers_mock):
	"""
	Test that begin header is checked and parse_suite_headers() is called.
	:return:
	"""
	def stop(this):
	raise Exception
	parse_suite_headers_mock.side_effect = stop
	data = '''/* BEGIN_HEADER */
	#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	/* END_HEADER */
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(Exception, parse_functions, s)
	parse_suite_headers_mock.assert_called_with(s)
	self.assertEqual(s.line_no, 2)

	@patch("generate_code.parse_suite_deps")
	def test_begin_dep(self, parse_suite_deps_mock):
	"""
	Test that begin header is checked and parse_suite_headers() is called.
	:return:
	"""
	def stop(this):
	raise Exception
	parse_suite_deps_mock.side_effect = stop
	data = '''/* BEGIN_DEPENDENCIES
	* depends_on:MBEDTLS_ECP_C
	* END_DEPENDENCIES
	*/
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(Exception, parse_functions, s)
	parse_suite_deps_mock.assert_called_with(s)
	self.assertEqual(s.line_no, 2)

	@patch("generate_code.parse_function_deps")
	def test_begin_function_dep(self, parse_function_deps_mock):
	"""
	Test that begin header is checked and parse_suite_headers() is called.
	:return:
	"""
	def stop(this):
	raise Exception
	parse_function_deps_mock.side_effect = stop

	deps_str = '/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */\n'
	data = '''%svoid test_func()
	{
	}
	''' % deps_str
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(Exception, parse_functions, s)
	parse_function_deps_mock.assert_called_with(deps_str)
	self.assertEqual(s.line_no, 2)

	@patch("generate_code.parse_function_code")
	@patch("generate_code.parse_function_deps")
	def test_return(self, parse_function_deps_mock, parse_function_code_mock):
	"""
	Test that begin header is checked and parse_suite_headers() is called.
	:return:
	"""
	def stop(this):
	raise Exception
	parse_function_deps_mock.return_value = []
	in_func_code= '''void test_func()
	{
	}
	'''
	func_dispatch = '''
	test_func_wrapper,
	'''
	parse_function_code_mock.return_value = 'test_func', [], in_func_code, func_dispatch
	deps_str = '/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */\n'
	data = '''%svoid test_func()
	{
	}
	''' % deps_str
	s = StringIOWrapper('test_suite_ut.function', data)
	suite_deps, dispatch_code, func_code, func_info = parse_functions(s)
	parse_function_deps_mock.assert_called_with(deps_str)
	parse_function_code_mock.assert_called_with(s, [], [])
	self.assertEqual(s.line_no, 5)
	self.assertEqual(suite_deps, [])
	expected_dispatch_code = '''/* Function Id: 0 */

	test_func_wrapper,
	'''
	self.assertEqual(dispatch_code, expected_dispatch_code)
	self.assertEqual(func_code, in_func_code)
	self.assertEqual(func_info, {'test_func': (0, [])})

	def test_parsing(self):
	"""
	Test that begin header is checked and parse_suite_headers() is called.
	:return:
	"""
	data = '''/* BEGIN_HEADER */
	#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	/* END_HEADER */

	/* BEGIN_DEPENDENCIES
	* depends_on:MBEDTLS_ECP_C
	* END_DEPENDENCIES
	*/

	/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
	void func1()
	{
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
	void func2()
	{
	}
	/* END_CASE */
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	suite_deps, dispatch_code, func_code, func_info = parse_functions(s)
	self.assertEqual(s.line_no, 23)
	self.assertEqual(suite_deps, ['MBEDTLS_ECP_C'])

	expected_dispatch_code = '''/* Function Id: 0 */

	#if defined(MBEDTLS_ECP_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
	test_func1_wrapper,
	#else
	NULL,
	#endif
	/* Function Id: 1 */

	#if defined(MBEDTLS_ECP_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
	test_func2_wrapper,
	#else
	NULL,
	#endif
	'''
	self.assertEqual(dispatch_code, expected_dispatch_code)
	expected_func_code = '''#if defined(MBEDTLS_ECP_C)
	#line 3 "test_suite_ut.function"
	#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	#if defined(MBEDTLS_ENTROPY_NV_SEED)
	#if defined(MBEDTLS_FS_IO)
	#line 14 "test_suite_ut.function"
	void test_func1()
	{
	exit:
	;;
	}

	void test_func1_wrapper( void ** params )
	{
	(void)params;

	test_func1( );
	}
	#endif /* MBEDTLS_FS_IO */
	#endif /* MBEDTLS_ENTROPY_NV_SEED */
	#if defined(MBEDTLS_ENTROPY_NV_SEED)
	#if defined(MBEDTLS_FS_IO)
	#line 20 "test_suite_ut.function"
	void test_func2()
	{
	exit:
	;;
	}

	void test_func2_wrapper( void ** params )
	{
	(void)params;

	test_func2( );
	}
	#endif /* MBEDTLS_FS_IO */
	#endif /* MBEDTLS_ENTROPY_NV_SEED */
	#endif /* MBEDTLS_ECP_C */
	'''
	self.assertEqual(func_code, expected_func_code)
	self.assertEqual(func_info, {'test_func1': (0, []), 'test_func2': (1, [])})

	def test_same_function_name(self):
	"""
	Test that begin header is checked and parse_suite_headers() is called.
	:return:
	"""
	data = '''/* BEGIN_HEADER */
	#include "mbedtls/ecp.h"

	#define ECP_PF_UNKNOWN -1
	/* END_HEADER */

	/* BEGIN_DEPENDENCIES
	* depends_on:MBEDTLS_ECP_C
	* END_DEPENDENCIES
	*/

	/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
	void func()
	{
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
	void func()
	{
	}
	/* END_CASE */
	'''
	s = StringIOWrapper('test_suite_ut.function', data)
	self.assertRaises(AssertionError, parse_functions, s)


	if __name__=='__main__':
	unittest_main()