Android: sync up latest JNI generator changes from downstream.

base/android/jni_generator/jni_generator_tests.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.
 
 """Tests for jni_generator.py.
 
 This test suite contains various tests for the JNI generator.
 It exercises the low-level parser all the way up to the
 code generator and ensures the output matches a golden
 file.
 """
 
 import difflib
 import inspect
 import os
 import sys
 import unittest
 import jni_generator
 from jni_generator import CalledByNative, JniParams, NativeMethod, Param
 
 
 SCRIPT_NAME = 'base/android/jni_generator/jni_generator.py'
+INCLUDES = (
+    'base/android/jni_generator/jni_generator_helper.h'
+)
 
 # Set this environment variable in order to regenerate the golden text
 # files.
 REBASELINE_ENV = 'REBASELINE'
 
 class TestOptions(object):
   """The mock options object which is passed to the jni_generator.py script."""
 
   def __init__(self):
     self.namespace = None
     self.script_name = SCRIPT_NAME
+    self.includes = INCLUDES
+    self.pure_native_methods = False
     self.ptr_type = 'int'
+    self.jni_init_native_name = None
+    self.eager_called_by_natives = False
 
 
 class TestGenerator(unittest.TestCase):
   def assertObjEquals(self, first, second):
     dict_first = first.__dict__
     dict_second = second.__dict__
     self.assertEquals(dict_first.keys(), dict_second.keys())
     for key, value in dict_first.iteritems():
       if (type(value) is list and len(value) and
           isinstance(type(value[0]), object)):
         self.assertListEquals(value, second.__getattribute__(key))
       else:
         actual = second.__getattribute__(key)
         self.assertEquals(value, actual,
                           'Key ' + key + ': ' + str(value) + '!=' + str(actual))
 
   def assertListEquals(self, first, second):
     self.assertEquals(len(first), len(second))
     for i in xrange(len(first)):
       if isinstance(first[i], object):
         self.assertObjEquals(first[i], second[i])
       else:
         self.assertEquals(first[i], second[i])
 
   def assertTextEquals(self, golden_text, generated_text):
+    if not self.compareText(golden_text, generated_text):
+      self.fail('Golden text mismatch.')
+
+  def compareText(self, golden_text, generated_text):
     def FilterText(text):
       return [
           l.strip() for l in text.split('\n')
           if not l.startswith('// Copyright')
       ]
     stripped_golden = FilterText(golden_text)
     stripped_generated = FilterText(generated_text)
-    if stripped_golden != stripped_generated:
-      print self.id()
-      for line in difflib.context_diff(stripped_golden, stripped_generated):
-        print line
-      print '\n\nGenerated'
-      print '=' * 80
-      print generated_text
-      print '=' * 80
-      print 'Run with:'
-      print 'REBASELINE=1', sys.argv[0]
-      print 'to regenerate the data files.'
-      self.fail('Golden text mismatch.')
+    if stripped_golden == stripped_generated:
+      return True
+    print self.id()
+    for line in difflib.context_diff(stripped_golden, stripped_generated):
+      print line
+    print '\n\nGenerated'
+    print '=' * 80
+    print generated_text
+    print '=' * 80
+    print 'Run with:'
+    print 'REBASELINE=1', sys.argv[0]
+    print 'to regenerate the data files.'
 
   def _ReadGoldenFile(self, golden_file):
     if not os.path.exists(golden_file):
       return None
     with file(golden_file, 'r') as f:
       return f.read()
 
   def assertGoldenTextEquals(self, generated_text):
     script_dir = os.path.dirname(sys.argv[0])
     # This is the caller test method.
@@ skipping 702 matching lines @@
     """
     self.assertRaises(SyntaxError,
                       jni_generator.JNIFromJavaSource,
                       test_data, 'foo/bar', TestOptions())
 
   def testJniSelfDocumentingExample(self):
     script_dir = os.path.dirname(sys.argv[0])
     content = file(os.path.join(script_dir,
         'java/src/org/chromium/example/jni_generator/SampleForTests.java')
         ).read()
-    golden_content = file(os.path.join(script_dir,
-                                       'golden_sample_for_tests_jni.h')).read()
+    golden_file = os.path.join(script_dir, 'golden_sample_for_tests_jni.h')
+    golden_content = file(golden_file).read()
     jni_from_java = jni_generator.JNIFromJavaSource(
         content, 'org/chromium/example/jni_generator/SampleForTests',
         TestOptions())
-    self.assertTextEquals(golden_content, jni_from_java.GetContent())
+    generated_text = jni_from_java.GetContent()
+    if not self.compareText(golden_content, generated_text):
+      if os.environ.get(REBASELINE_ENV):
+        with file(golden_file, 'w') as f:
+          f.write(generated_text)
+        return
+      self.fail('testJniSelfDocumentingExample')
 
   def testNoWrappingPreprocessorLines(self):
     test_data = """
     package com.google.lookhowextremelylongiam.snarf.icankeepthisupallday;
 
     class ReallyLongClassNamesAreAllTheRage {
         private static native int nativeTest();
     }
     """
     jni_from_java = jni_generator.JNIFromJavaSource(
@@ skipping 102 matching lines @@
                      java_class_name=None,
                      type='method',
                      p0_type='ChromeBrowserProvider',
                      ptr_type=test_options.ptr_type),
     ]
     self.assertListEquals(golden_natives, natives)
     h = jni_generator.InlHeaderFileGenerator('', 'org/chromium/TestJni',
                                              natives, [], test_options)
     self.assertGoldenTextEquals(h.GetContent())
 
+  def testPureNativeMethodsOption(self):
+    test_data = """
+    package org.chromium.example.jni_generator;
+
+    /** The pointer to the native Test. */
+    int nativeTest;
+
+    class Test {
+        private static native int nativeMethod(int nativeTest, int arg1);
+    }
+    """
+    options = TestOptions()
+    options.pure_native_methods = True
+    jni_from_java = jni_generator.JNIFromJavaSource(
+        test_data, 'org/chromium/example/jni_generator/Test', options)
+    self.assertGoldenTextEquals(jni_from_java.GetContent())
+
+  def testJNIInitNativeNameOption(self):
+    test_data = """
+    package org.chromium.example.jni_generator;
+
+    /** The pointer to the native Test. */
+    int nativeTest;
+
+    class Test {
+        private static native boolean initNativeClass();
+        private static native int nativeMethod(int nativeTest, int arg1);
+    }
+    """
+    options = TestOptions()
+    options.jni_init_native_name = 'initNativeClass'
+    jni_from_java = jni_generator.JNIFromJavaSource(
+        test_data, 'org/chromium/example/jni_generator/Test', options)
+    self.assertGoldenTextEquals(jni_from_java.GetContent())
+
+  def testEagerCalledByNativesOption(self):
+    test_data = """
+    package org.chromium.example.jni_generator;
+
+    /** The pointer to the native Test. */
+    int nativeTest;
+
+    class Test {
+        private static native boolean initNativeClass();
+        private static native int nativeMethod(int nativeTest, int arg1);
+        @CalledByNative
+        private void testMethodWithParam(int iParam);
+        @CalledByNative
+        private static int testStaticMethodWithParam(int iParam);
+        @CalledByNative
+        private static double testMethodWithNoParam();
+        @CalledByNative
+        private static String testStaticMethodWithNoParam();
+    }
+    """
+    options = TestOptions()
+    options.jni_init_native_name = 'initNativeClass'
+    options.eager_called_by_natives = True
+    jni_from_java = jni_generator.JNIFromJavaSource(
+        test_data, 'org/chromium/example/jni_generator/Test', options)
+    self.assertGoldenTextEquals(jni_from_java.GetContent())
 
 if __name__ == '__main__':
   unittest.main()