generate_stubs: Add a new option --export-macro.

tools/generate_stubs/generate_stubs_unittest.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Unittest for the generate_stubs.py.
 
 Since generate_stubs.py is a code generator, it is hard to do a very good
 test.  Instead of creating a golden-file test, which might be flakey, this
 test elects instead to verify that various components "exist" within the
@@ skipping 147 matching lines @@
                  '-c', 'print "line 1 and suffix\\nline 2"'],
                  filter='line 1', write_to=output)
     self.assertEqual('line 2\n', output.getvalue())
 
 
 class PosixStubWriterUnittest(unittest.TestCase):
   def setUp(self):
     self.module_name = 'my_module-1'
     self.signatures = [sig[1] for sig in SIMPLE_SIGNATURES]
     self.out_dir = 'out_dir'
-    self.writer = gs.PosixStubWriter(self.module_name, self.signatures)
+    self.writer = gs.PosixStubWriter(self.module_name, '', self.signatures)
 
   def testEnumName(self):
     self.assertEqual('kModuleMy_module1',
                      gs.PosixStubWriter.EnumName(self.module_name))
 
   def testIsInitializedName(self):
     self.assertEqual('IsMy_module1Initialized',
                      gs.PosixStubWriter.IsInitializedName(self.module_name))
 
   def testInitializeModuleName(self):
     self.assertEqual(
         'InitializeMy_module1',
         gs.PosixStubWriter.InitializeModuleName(self.module_name))
 
   def testUninitializeModuleName(self):
     self.assertEqual(
         'UninitializeMy_module1',
         gs.PosixStubWriter.UninitializeModuleName(self.module_name))
 
   def testStubFunctionPointer(self):
     self.assertEqual(
         'static int (*foo_ptr)(int a) = NULL;',
         gs.PosixStubWriter.StubFunctionPointer(SIMPLE_SIGNATURES[0][1]))
 
   def testStubFunction(self):
     # Test for a signature with a return value and a parameter.
     self.assertEqual("""extern int foo(int a) __attribute__((weak));
-int foo(int a) {
+int  foo(int a) {
   return foo_ptr(a);
 }""", gs.PosixStubWriter.StubFunction(SIMPLE_SIGNATURES[0][1]))
 
     # Test for a signature with a void return value and no parameters.
     self.assertEqual("""extern void waldo(void) __attribute__((weak));
-void waldo(void) {
+void  waldo(void) {
   waldo_ptr();
 }""", gs.PosixStubWriter.StubFunction(SIMPLE_SIGNATURES[4][1]))
 
+    # Test export macros.
+    sig = _MakeSignature('int*', 'foo', ['bool b'])
+    sig['export'] = 'TEST_EXPORT'
+    self.assertEqual("""extern int* foo(bool b) __attribute__((weak));
+int* TEST_EXPORT foo(bool b) {
+  return foo_ptr(b);
+}""", gs.PosixStubWriter.StubFunction(sig))
+
   def testWriteImplemenationContents(self):
     outfile = StringIO.StringIO()
     self.writer.WriteImplementationContents('my_namespace', outfile)
     contents = outfile.getvalue()
 
     # Verify namespace exists somewhere.
     self.assertTrue(contents.find('namespace my_namespace {') != -1)
 
     # Verify that each signature has an _ptr and a function call in the file.
     # Check that the signatures were exported.
@@ skipping 76 matching lines @@
                       msg='Expected "%s" in %s' % (decl, contents))
       decl = gs.PosixStubWriter.InitializeModuleName(name)
       self.assertTrue(contents.find(decl) != -1,
                       msg='Expected "%s" in %s' % (decl, contents))
       decl = gs.PosixStubWriter.UninitializeModuleName(name)
       self.assertTrue(contents.find(decl) != -1,
                       msg='Expected "%s" in %s' % (decl, contents))
 
 if __name__ == '__main__':
   unittest.main()