Generate tests/Android.mk from gyp

platform_tools/android/tests/makefile_writer_tests.py

 #!/usr/bin/python
 
 # Copyright 2014 Google Inc.
 #
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 Test makefile_writer.py
 """
 
 import argparse
 import os
 import shutil
 import sys
 import tempfile
 import test_variables
 import unittest
 import utils
 
 sys.path.append(test_variables.GYP_GEN_DIR)
 
 import makefile_writer
+import tool_makefile_writer
 import vars_dict_lib
 
-MAKEFILE_NAME = 'Android.mk'
+MAKEFILE_NAME = test_variables.ANDROID_MK
 REBASELINE_MSG = ('If you\'ve modified makefile_writer.py, run '
                   '"makefile_writer_tests.py --rebaseline" to rebaseline')
+TOOL_DIR = 'tool'
 
 def generate_dummy_vars_dict(name):
   """Create a VarsDict and fill it with dummy entries.
 
   Args:
       name: string to be appended to each entry, if not None.
 
   Returns:
       A VarsDict with dummy entries.
   """
@@ skipping 63 matching lines @@
   common_vars_dict = generate_dummy_vars_dict(None)
 
   deviation_params = [('foo', 'COND'), ('bar', None)]
   deviations = [generate_dummy_vars_dict_data(name, condition)
                 for (name, condition) in deviation_params]
 
   makefile_writer.write_android_mk(target_dir=target_dir,
                                    common=common_vars_dict,
                                    deviations_from_common=deviations)
 
+def generate_dummy_tool_makefile(target_dir):
+  """Create a dummy makefile for a tool.
+
+  Args:
+      target_dir: directory in which to write the resulting Android.mk
+  """
+  vars_dict = generate_dummy_vars_dict(None)
+  tool_makefile_writer.write_tool_android_mk(target_dir=target_dir,
+                                             var_dict=vars_dict)
+
 
 class MakefileWriterTest(unittest.TestCase):
 
   def test_write_group_empty(self):
     f = tempfile.TemporaryFile()
     assert f.tell() == 0
     for empty in (None, []):
       for truth in (True, False):
         makefile_writer.write_group(f, 'name', empty, truth)
         self.assertEqual(f.tell(), 0)
@@ skipping 40 matching lines @@
 
   def test_write_android_mk(self):
     outdir = tempfile.mkdtemp()
     generate_dummy_makefile(outdir)
 
     utils.compare_to_expectation(os.path.join(outdir, MAKEFILE_NAME),
                                  MAKEFILE_NAME, self.assertTrue, REBASELINE_MSG)
 
     shutil.rmtree(outdir)
 
+  def test_tool_writer(self):
+    outdir = tempfile.mkdtemp()
+    tool_dir = os.path.join(outdir, TOOL_DIR)
+    os.mkdir(tool_dir)
+    generate_dummy_tool_makefile(tool_dir)
+
+    utils.compare_to_expectation(os.path.join(tool_dir, MAKEFILE_NAME),
+                                 os.path.join(TOOL_DIR, MAKEFILE_NAME),
+                                 self.assertTrue, REBASELINE_MSG)
 
 def main():
   loader = unittest.TestLoader()
   suite = loader.loadTestsFromTestCase(MakefileWriterTest)
   results = unittest.TextTestRunner(verbosity=2).run(suite)
   print repr(results)
   if not results.wasSuccessful():
     raise Exception('failed one or more unittests')
 
 
 def rebaseline():
   generate_dummy_makefile(utils.EXPECTATIONS_DIR)
 
   vars_dict = generate_dummy_vars_dict(None)
   for (filename, append, name) in generate_write_local_vars_params():
     with open(os.path.join(utils.EXPECTATIONS_DIR, filename), 'w') as f:
       makefile_writer.write_local_vars(f, vars_dict, append, name)
 
+  generate_dummy_tool_makefile(os.path.join(utils.EXPECTATIONS_DIR, TOOL_DIR))
+
 
 if __name__ == '__main__':
   parser = argparse.ArgumentParser()
   parser.add_argument('-r', '--rebaseline', help='Rebaseline expectations.',
                       action='store_true')
   args = parser.parse_args()
 
   if args.rebaseline:
     rebaseline()
   else:
     main()