Android: adds ptr_type to jni_generator.

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
@@ skipping 10 matching lines @@
 
 SCRIPT_NAME = 'base/android/jni_generator/jni_generator.py'
 
 
 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.ptr_type = 'int'
 
 
 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)):
@@ skipping 47 matching lines @@
     private static native OnFrameAvailableListener nativeGetInnerClass();
     private native Bitmap nativeQueryBitmap(
             int nativeChromeBrowserProvider,
             String[] projection, String selection,
             String[] selectionArgs, String sortOrder);
     private native void nativeGotOrientation(
             int nativeDataFetcherImplAndroid,
             double alpha, double beta, double gamma);
     """
     jni_generator.JniParams.ExtractImportsAndInnerClasses(test_data)
-    natives = jni_generator.ExtractNatives(test_data)
+    natives = jni_generator.ExtractNatives(test_data, TestOptions())
     golden_natives = [
         NativeMethod(return_type='int', static=False,
                      name='Init',
                      params=[],
                      java_class_name=None,
                      type='function'),
         NativeMethod(return_type='void', static=False, name='Destroy',
                      params=[Param(datatype='int',
                                    name='nativeChromeBrowserProvider')],
                      java_class_name=None,
@@ skipping 329 matching lines @@
 """
     self.assertTextEquals(golden_content, h.GetContent())
 
   def testInnerClassNatives(self):
     test_data = """
     class MyInnerClass {
       @NativeCall("MyInnerClass")
       private native int nativeInit();
     }
     """
-    natives = jni_generator.ExtractNatives(test_data)
+    natives = jni_generator.ExtractNatives(test_data, TestOptions())
     golden_natives = [
         NativeMethod(return_type='int', static=False,
                      name='Init', params=[],
                      java_class_name='MyInnerClass',
                      type='function')
     ]
     self.assertListEquals(golden_natives, natives)
     h = jni_generator.InlHeaderFileGenerator('', 'org/chromium/TestJni',
                                              natives, [], TestOptions())
     golden_content = """\
@@ skipping 62 matching lines @@
     test_data = """
     class MyInnerClass {
       @NativeCall("MyInnerClass")
       private native int nativeInit();
     }
     class MyOtherInnerClass {
       @NativeCall("MyOtherInnerClass")
       private native int nativeInit();
     }
     """
-    natives = jni_generator.ExtractNatives(test_data)
+    natives = jni_generator.ExtractNatives(test_data, TestOptions())
     golden_natives = [
         NativeMethod(return_type='int', static=False,
                      name='Init', params=[],
                      java_class_name='MyInnerClass',
                      type='function'),
         NativeMethod(return_type='int', static=False,
                      name='Init', params=[],
                      java_class_name='MyOtherInnerClass',
                      type='function')
     ]
@@ skipping 85 matching lines @@
   def testInnerClassNativesBothInnerAndOuter(self):
     test_data = """
     class MyOuterClass {
       private native int nativeInit();
       class MyOtherInnerClass {
         @NativeCall("MyOtherInnerClass")
         private native int nativeInit();
       }
     }
     """
-    natives = jni_generator.ExtractNatives(test_data)
+    natives = jni_generator.ExtractNatives(test_data, TestOptions())
     golden_natives = [
         NativeMethod(return_type='int', static=False,
                      name='Init', params=[],
                      java_class_name=None,
                      type='function'),
         NativeMethod(return_type='int', static=False,
                      name='Init', params=[],
                      java_class_name='MyOtherInnerClass',
                      type='function')
     ]
@@ skipping 1517 matching lines @@
     self.assertRaises(SyntaxError,
                       jni_generator.JniParams.JavaToJni,
                       'AnException')
 
   def testJniParamsJavaToJni(self):
     self.assertTextEquals('I', JniParams.JavaToJni('int'))
     self.assertTextEquals('[B', JniParams.JavaToJni('byte[]'))
     self.assertTextEquals(
         '[Ljava/nio/ByteBuffer;', JniParams.JavaToJni('java/nio/ByteBuffer[]'))
 
+  def testNativesLong(self):
+    test_options = TestOptions()
+    test_options.ptr_type = 'long'
+    test_data = """"
+    private native void nativeDestroy(long nativeChromeBrowserProvider);
+    """
+    jni_generator.JniParams.ExtractImportsAndInnerClasses(test_data)
+    natives = jni_generator.ExtractNatives(test_data, test_options)
+    golden_natives = [
+        NativeMethod(return_type='void', static=False, name='Destroy',
+                     params=[Param(datatype='long',
+                                   name='nativeChromeBrowserProvider')],
+                     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)
+    golden_content = """\
+// 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.
+
+// This file is autogenerated by
+//     base/android/jni_generator/jni_generator.py
+// For
+//     org/chromium/TestJni
+
+#ifndef org_chromium_TestJni_JNI
+#define org_chromium_TestJni_JNI
+
+#include <jni.h>
+
+#include "base/android/jni_android.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/basictypes.h"
+#include "base/logging.h"
+
+using base::android::ScopedJavaLocalRef;
+
+// Step 1: forward declarations.
+namespace {
+const char kTestJniClassPath[] = "org/chromium/TestJni";
+// Leaking this jclass as we cannot use LazyInstance from some threads.
+jclass g_TestJni_clazz = NULL;
+}  // namespace
+
+// Step 2: method stubs.
+static void Destroy(JNIEnv* env, jobject obj,
+    jlong nativeChromeBrowserProvider) {
+  DCHECK(nativeChromeBrowserProvider) << "Destroy";
+  ChromeBrowserProvider* native =
+      reinterpret_cast<ChromeBrowserProvider*>(nativeChromeBrowserProvider);
+  return native->Destroy(env, obj);
+}
+
+// Step 3: RegisterNatives.
+
+static bool RegisterNativesImpl(JNIEnv* env) {
+
+  g_TestJni_clazz = reinterpret_cast<jclass>(env->NewGlobalRef(
+      base::android::GetClass(env, kTestJniClassPath).obj()));
+  static const JNINativeMethod kMethodsTestJni[] = {

[Andrew Hayden (chromium.org), 2013/10/29 11:49:21]

It looks like this is the only part that we care about for the test. The rest -
specifically things like the copyright statement and comments - could change
with the template, and we wouldn't care. Perhaps just search for this substring
in the result instead of matching the entire text?

[bulach, 2013/10/29 18:22:20]

there are two aspects:
1. first, I agree that this is testing _more_ than necessary.. I should probably
tidy up the entire file, this same pattern is applied throughout the other
tests.

2. however :) this is not the only thing: 2226-2231 are also the target of this
test (i.e., the method takes a jlong and does a cast to the object...)...

if that's ok, I'd like to keep as is and then orthogonally cleanup all these
tests as a whole (without also changing the implementation)?

+    { "nativeDestroy",
+"("
+"J"
+")"
+"V", reinterpret_cast<void*>(Destroy) },
+  };
+  const int kMethodsTestJniSize = arraysize(kMethodsTestJni);
+
+  if (env->RegisterNatives(g_TestJni_clazz,
+                           kMethodsTestJni,
+                           kMethodsTestJniSize) < 0) {
+    LOG(ERROR) << "RegisterNatives failed in " << __FILE__;
+    return false;
+  }
+
+  return true;
+}
+
+#endif  // org_chromium_TestJni_JNI
+"""
+    self.assertTextEquals(golden_content, h.GetContent())
+
 
 if __name__ == '__main__':
   unittest.main()