whereswaldon/jni
1
0
Fork 0
forked from gmp/jni
Code

Compare commits

base: whereswaldon:2e7d20a1b472a31f206c4dc12b63398c679844da
Branches Tags
whereswaldon:master
gmp:master
..
compare: whereswaldon:b380472956a0a3b6d927b1ccc5d6bae94cd0d1af
Branches Tags
whereswaldon:master
gmp:master

No commits in common. "2e7d20a1b472a31f206c4dc12b63398c679844da" and "b380472956a0a3b6d927b1ccc5d6bae94cd0d1af" have entirely different histories.
2e7d20a1b4 ... b380472956

13 changed files with 12 additions and 725 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +0,0 @@
*.go-old

3
go.mod
View File

@ -1,3 +0,0 @@
module git.wow.st/gmp/jni
go 1.14

18
gojni.h
View File

@ -1,7 +1,3 @@
#ifndef __ANDROID_API__
__attribute__ ((visibility ("hidden"))) JavaVM *_jni_CreateJavaVM(const char **options, int nOptions);
#endif /* __ANDROID_API__ */
__attribute__ ((visibility ("hidden"))) jint _jni_GetEnv(JavaVM *vm, JNIEnv **env, jint version);
__attribute__ ((visibility ("hidden"))) jint _jni_AttachCurrentThread(JavaVM *vm, JNIEnv **p_env, void *thr_args);
__attribute__ ((visibility ("hidden"))) jint _jni_DetachCurrentThread(JavaVM *vm);
@ -11,20 +7,15 @@ __attribute__ ((visibility ("hidden"))) void _jni_ExceptionClear(JNIEnv *env);
__attribute__ ((visibility ("hidden"))) jclass _jni_GetObjectClass(JNIEnv *env, jobject obj);
__attribute__ ((visibility ("hidden"))) jmethodID _jni_GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
__attribute__ ((visibility ("hidden"))) jmethodID _jni_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
__attribute__ ((visibility ("hidden"))) jfieldID _jni_GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
__attribute__ ((visibility ("hidden"))) jfieldID _jni_GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
__attribute__ ((visibility ("hidden"))) jsize _jni_GetStringLength(JNIEnv *env, jstring str);
__attribute__ ((visibility ("hidden"))) const jchar *_jni_GetStringChars(JNIEnv *env, jstring str);
__attribute__ ((visibility ("hidden"))) jstring _jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len);
__attribute__ ((visibility ("hidden"))) jboolean _jni_IsSameObject(JNIEnv *env, jobject ref1, jobject ref2);
__attribute__ ((visibility ("hidden"))) jboolean _jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass cls);
__attribute__ ((visibility ("hidden"))) jobject _jni_NewGlobalRef(JNIEnv *env, jobject obj);
__attribute__ ((visibility ("hidden"))) void _jni_DeleteGlobalRef(JNIEnv *env, jobject obj);
__attribute__ ((visibility ("hidden"))) jobject _jni_NewLocalRef(JNIEnv *env, jobject obj);
__attribute__ ((visibility ("hidden"))) void _jni_DeleteLocalRef(JNIEnv *env, jobject obj);
__attribute__ ((visibility ("hidden"))) jint _jni_CallStaticIntMethodA(JNIEnv *env, jclass cls, jmethodID method, jvalue *args);
__attribute__ ((visibility ("hidden"))) jobject _jni_CallStaticObjectMethodA(JNIEnv *env, jclass cls, jmethodID method, jvalue *args);
__attribute__ ((visibility ("hidden"))) jobject _jni_NewObjectA(JNIEnv *env, jclass cls, jmethodID method, jvalue *args);
__attribute__ ((visibility ("hidden"))) void _jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID method, jvalue *args);
__attribute__ ((visibility ("hidden"))) jobject _jni_CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID method, jvalue *args);
__attribute__ ((visibility ("hidden"))) jint _jni_CallIntMethodA(JNIEnv *env, jobject obj, jmethodID method, jvalue *args);
@ -42,12 +33,3 @@ __attribute__ ((visibility ("hidden"))) jint _jni_GetStaticIntField(JNIEnv *env,
__attribute__ ((visibility ("hidden"))) jlong _jni_GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jfloat _jni_GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jdouble _jni_GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jobject _jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jboolean _jni_GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jbyte _jni_GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jchar _jni_GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jshort _jni_GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jint _jni_GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jlong _jni_GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jfloat _jni_GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID);
__attribute__ ((visibility ("hidden"))) jdouble _jni_GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID);

82
jni.c
View File

@ -1,31 +1,5 @@
#include <stdlib.h>
#include <jni.h>
#ifndef __ANDROID_API__
JavaVM *_jni_CreateJavaVM(char **optstrings, int nOptions) {
JavaVM *vm;
JNIEnv *p_env;
JavaVMInitArgs vm_args;
JavaVMOption *options = (JavaVMOption *)malloc(sizeof(JavaVMOption)*nOptions);
if (options != 0) {
int i;
for (i = 0; i < nOptions; i++) {
options[i].optionString = optstrings[i];
}
vm_args.nOptions = nOptions;
vm_args.options = options;
}
vm_args.version = JNI_VERSION_1_6;
vm_args.ignoreUnrecognized = 0;
jint res = JNI_CreateJavaVM(&vm, &p_env, &vm_args);
if (res < 0) {
printf("Can't create Java VM\n");
return 0;
}
return vm;
}
#endif /* __ANDROID_API__ */
jint _jni_AttachCurrentThread(JavaVM *vm, JNIEnv **p_env, void *thr_args) {
return (*vm)->AttachCurrentThread(vm, p_env, thr_args);
}
@ -62,10 +36,6 @@ jmethodID _jni_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, co
return (*env)->GetStaticMethodID(env, clazz, name, sig);
}
jfieldID _jni_GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig) {
return (*env)->GetFieldID(env, clazz, name, sig);
}
jfieldID _jni_GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig) {
return (*env)->GetStaticFieldID(env, clazz, name, sig);
}
@ -86,10 +56,6 @@ jboolean _jni_IsSameObject(JNIEnv *env, jobject ref1, jobject ref2) {
return (*env)->IsSameObject(env, ref1, ref2);
}
jboolean _jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass cls) {
return (*env)->IsInstanceOf(env, obj, cls);
}
jobject _jni_NewGlobalRef(JNIEnv *env, jobject obj) {
return (*env)->NewGlobalRef(env, obj);
}
@ -98,18 +64,6 @@ void _jni_DeleteGlobalRef(JNIEnv *env, jobject obj) {
(*env)->DeleteGlobalRef(env, obj);
}
jobject _jni_NewLocalRef(JNIEnv *env, jobject obj) {
return (*env)->NewLocalRef(env, obj);
}
void _jni_DeleteLocalRef(JNIEnv *env, jobject obj) {
(*env)->DeleteLocalRef(env, obj);
}
jobject _jni_NewObjectA(JNIEnv *env, jclass cls, jmethodID method, jvalue *args) {
return (*env)->NewObject(env, cls, method, args);
}
void _jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID method, jvalue *args) {
(*env)->CallStaticVoidMethodA(env, cls, method, args);
}
@ -186,39 +140,3 @@ jdouble _jni_GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
return (*env)->GetStaticDoubleField(env, clazz, fieldID);
}
jobject _jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetObjectField(env, obj, fieldID);
}
jboolean _jni_GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetBooleanField(env, obj, fieldID);
}
jbyte _jni_GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetByteField(env, obj, fieldID);
}
jchar _jni_GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetCharField(env, obj, fieldID);
}
jshort _jni_GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetShortField(env, obj, fieldID);
}
jint _jni_GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetIntField(env, obj, fieldID);
}
jlong _jni_GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetLongField(env, obj, fieldID);
}
jfloat _jni_GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetFloatField(env, obj, fieldID);
}
jdouble _jni_GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID) {
return (*env)->GetDoubleField(env, obj, fieldID);
}

193
jni.go
View File

@ -2,19 +2,10 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package jni implements various helper functions for communicating with the
// Android JVM though JNI.
package jni
/*
#cgo CFLAGS: -Wall
#include <stdlib.h>
#include <jni.h>
#include "gojni.h"
*/
import "C"
// Package jni implements various helper functions for communicating with the Android JVM
// though JNI.
import (
"errors"
@ -25,6 +16,16 @@ import (
"unsafe"
)
/*
#cgo CFLAGS: -Wall
#include <jni.h>
#include <stdlib.h>
#include "gojni.h"
*/
import "C"
type JVM struct {
jvm *C.JavaVM
}
@ -43,21 +44,12 @@ type (
Value uint64 // All JNI types fit into 64-bits.
)
const (
TRUE = C.JNI_TRUE
FALSE = C.JNI_FALSE
)
// JVMFor creates a JVM object, interpreting the given uintptr as a pointer
// to a C.JavaVM object.
func JVMFor(jvmPtr uintptr) JVM {
return JVM{
jvm: (*C.JavaVM)(unsafe.Pointer(jvmPtr)),
}
}
// EnvFor creates an Env object, interpreting the given uintptr as a pointer
// to a C.JNIEnv object.
func EnvFor(envPtr uintptr) Env {
return Env{
env: (*C.JNIEnv)(unsafe.Pointer(envPtr)),
@ -90,66 +82,36 @@ func varArgs(args []Value) *C.jvalue {
return (*C.jvalue)(unsafe.Pointer(&args[0]))
}
// IsSameObject returns true if the two given objects refer to the same
// Java object.
func IsSameObject(e Env, ref1, ref2 Object) bool {
same := C._jni_IsSameObject(e.env, C.jobject(ref1), C.jobject(ref2))
return same == C.JNI_TRUE
}
// CallStaticIntMethod calls a static method on a Java class, returning an int.
func CallStaticIntMethod(e Env, cls Class, method MethodID, args ...Value) (int, error) {
res := C._jni_CallStaticIntMethodA(e.env, C.jclass(cls), C.jmethodID(method), varArgs(args))
return int(res), exception(e)
}
// FindClass returns a reference to a Java class with a given name, using the
// JVM's default class loader. Any exceptions caused by the underlying JNI call
// (for example if the class is not found) will result in a panic.
func FindClass(e Env, name string) Class {
mname := C.CString(name)
defer C.free(unsafe.Pointer(mname))
res := C._jni_FindClass(e.env, mname)
if err := exception(e); err != nil {
panic(err)
}
return Class(res)
}
// NewObject creates a new object given a class, initializer method, and
// initializer arguments (if any).
func NewObject(e Env, cls Class, method MethodID, args ...Value) (Object, error) {
res := C._jni_NewObjectA(e.env, C.jclass(cls), C.jmethodID(method), varArgs(args))
return Object(res), exception(e)
}
// CallStaticVoidMethod calls a static method on a Java class, returning
// nothing.
func CallStaticVoidMethod(e Env, cls Class, method MethodID, args ...Value) error {
C._jni_CallStaticVoidMethodA(e.env, C.jclass(cls), C.jmethodID(method), varArgs(args))
return exception(e)
}
// CallVoidMethod calls a method on an object, returning nothing.
func CallVoidMethod(e Env, obj Object, method MethodID, args ...Value) error {
C._jni_CallVoidMethodA(e.env, C.jobject(obj), C.jmethodID(method), varArgs(args))
return exception(e)
}
// CallStaticObjectMethod calls a static method on a class, returning a
// Java object
func CallStaticObjectMethod(e Env, cls Class, method MethodID, args ...Value) (Object, error) {
res := C._jni_CallStaticObjectMethodA(e.env, C.jclass(cls), C.jmethodID(method), varArgs(args))
return Object(res), exception(e)
}
// CallObjectMethod calls a method on an object, returning a Java object.
func CallObjectMethod(e Env, obj Object, method MethodID, args ...Value) (Object, error) {
res := C._jni_CallObjectMethodA(e.env, C.jobject(obj), C.jmethodID(method), varArgs(args))
return Object(res), exception(e)
}
// CallIntMethod calls a method on an object, returning an int32.
func CallIntMethod(e Env, obj Object, method MethodID, args ...Value) (int32, error) {
res := C._jni_CallIntMethodA(e.env, C.jobject(obj), C.jmethodID(method), varArgs(args))
return int32(res), exception(e)
@ -237,22 +199,6 @@ func GetObjectClass(e Env, obj Object) Class {
return Class(cls)
}
// IsInstanceOf returns true if the given object is an instance of the
// given class.
func IsInstanceOf(e Env, obj Object, cls Class) bool {
if obj == 0 {
panic("null object")
}
if cls == 0 {
panic("null class")
}
res := C._jni_IsInstanceOf(e.env, C.jobject(obj), C.jclass(cls))
if err := exception(e); err != nil {
panic(err)
}
return res == C.JNI_TRUE
}
// GetStaticMethodID returns the id for a static method. It panics if the method
// wasn't found.
func GetStaticMethodID(e Env, cls Class, name, signature string) MethodID {
@ -267,19 +213,6 @@ func GetStaticMethodID(e Env, cls Class, name, signature string) MethodID {
return MethodID(m)
}
// GetFieldID returns the id for a field. It panics if the field wasn't found.
func GetFieldID(e Env, cls Class, name, signature string) FieldID {
mname := C.CString(name)
defer C.free(unsafe.Pointer(mname))
msig := C.CString(signature)
defer C.free(unsafe.Pointer(msig))
m := C._jni_GetFieldID(e.env, C.jclass(cls), mname, msig)
if err := exception(e); err != nil {
panic(err)
}
return FieldID(m)
}
// GetStaticFieldID returns the id for a static field. It panics if the field
// wasn't found.
func GetStaticFieldID(e Env, cls Class, name, signature string) FieldID {
@ -308,26 +241,14 @@ func GetMethodID(e Env, cls Class, name, signature string) MethodID {
return MethodID(m)
}
// NewGlobalRef creates a new global reference.
func NewGlobalRef(e Env, obj Object) Object {
return Object(C._jni_NewGlobalRef(e.env, C.jobject(obj)))
}
// DeleteGlobalRef delets a global reference.
func DeleteGlobalRef(e Env, obj Object) {
C._jni_DeleteGlobalRef(e.env, C.jobject(obj))
}
// NewLocalRef creates a new local reference to the given object.
func NewLocalRef(e Env, obj Object) Object {
return Object(C._jni_NewLocalRef(e.env, C.jobject(obj)))
}
// DeleteLocalRef delets a local reference.
func DeleteLocalRef(e Env, obj Object) {
C._jni_DeleteLocalRef(e.env, C.jobject(obj))
}
// JavaString converts the string to a JVM jstring.
func JavaString(e Env, str string) String {
if str == "" {
@ -443,93 +364,3 @@ func GetStaticDoubleField(env Env, clazz Class, fieldID FieldID) float64 {
}
return float64(value)
}
// GetObjectField looks up the value of a static field of type Object.
// It panics if it is unable to find the field.
func GetObjectField(env Env, obj Object, fieldID FieldID) Object {
value := C._jni_GetObjectField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return Object(value)
}
// GetBooleanField looks up the value of a static field of type boolean.
// It panics if it is unable to find the field.
func GetBooleanField(env Env, obj Object, fieldID FieldID) bool {
value := C._jni_GetBooleanField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return value != 0
}
// GetByteField looks up the value of a static field of type byte.
// It panics if it is unable to find the field.
func GetByteField(env Env, obj Object, fieldID FieldID) byte {
value := C._jni_GetByteField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return byte(value)
}
// GetCharField looks up the value of a static field of type char.
// It panics if it is unable to find the field.
func GetCharField(env Env, obj Object, fieldID FieldID) byte {
value := C._jni_GetCharField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return byte(value)
}
// GetShortField looks up the value of a static field of type short.
// It panics if it is unable to find the field.
func GetShortField(env Env, obj Object, fieldID FieldID) int16 {
value := C._jni_GetShortField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return int16(value)
}
// GetIntField looks up the value of a static field of type int.
// It panics if it is unable to find the field.
func GetIntField(env Env, obj Object, fieldID FieldID) int32 {
value := C._jni_GetIntField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return int32(value)
}
// GetLongField looks up the value of a static field of type long.
// It panics if it is unable to find the field.
func GetLongField(env Env, obj Object, fieldID FieldID) int64 {
value := C._jni_GetLongField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return int64(value)
}
// GetFloatField looks up the value of a static field of type float.
// It panics if it is unable to find the field.
func GetFloatField(env Env, obj Object, fieldID FieldID) float32 {
value := C._jni_GetFloatField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return float32(value)
}
// GetDoubleField looks up the value of a static field of type double.
// It panics if it is unable to find the field.
func GetDoubleField(env Env, obj Object, fieldID FieldID) float64 {
value := C._jni_GetDoubleField(env.env, C.jobject(obj), C.jfieldID(fieldID))
if err := exception(env); err != nil {
panic(err)
}
return float64(value)
}

10
jni_darwin.go
View File

@ -1,10 +0,0 @@
// +build darwin
//Generated by scripts/find_macos_jnih
package jni
/*
#cgo CFLAGS: -I/Library/Java/JavaVirtualMachines/jdk1.8.0_162.jdk/Contents/Home/include -I/Library/Java/JavaVirtualMachines/jdk1.8.0_162.jdk/Contents/Home/include/darwin
#cgo LDFLAGS: -ljvm
*/
import "C"

10
jni_linux.go
View File

@ -1,10 +0,0 @@
// +build linux,!android
//Generated by scripts/find_linux_jnih
package jni
/*
#cgo CFLAGS: -I/usr/lib/jvm/java-11-openjdk-amd64/include -I/usr/lib/jvm/java-11-openjdk-amd64/include/linux
#cgo LDFLAGS: -L/usr/lib/jvm/java-11-openjdk-amd64/lib/server -ljvm
*/
import "C"

37
jni_notandroid.go
View File

@ -1,37 +0,0 @@
// +build !android
package jni
/*
#include <stdlib.h>
#include <jni.h>
#include "gojni.h"
*/
import "C"
import (
"unsafe"
)
// CreateJavaVM creates a new Java VM with the options specified (if any).
// This should not be called more than once as it can result in an error if
// a JVM already exists for a given process.
//
// This is not implemented on Android and is therefore excluded on that
// platform by build flags and C.
func CreateJavaVM(opts ...string) JVM {
nOptions := len(opts)
optstrings := make([]*C.char, nOptions)
for i, _ := range optstrings {
optstrings[i] = C.CString(opts[i])
defer C.free(unsafe.Pointer(optstrings[i]))
}
var jvm *C.JavaVM
if nOptions > 0 {
jvm = C._jni_CreateJavaVM(&optstrings[0], C.int(nOptions))
} else {
jvm = C._jni_CreateJavaVM((**C.char)(nil), 0)
}
return JVM{ jvm: jvm }
}

318
jni_test.go
View File

@ -1,318 +0,0 @@
// +build !android
//go:generate javac test/AClass.java
package jni
import (
"sync"
"testing"
)
var (
vm JVM
vmOnce sync.Once
)
func TestCreateJVM(t *testing.T) {
// Do not try to create more than one JVM
vmOnce.Do(func() {
res := CreateJavaVM()
if res.jvm == nil {
t.Errorf("CreateJavaVM() returned nil")
} else {
vm = res
}
})
}
func TestFindClass(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
if cls == 0 {
t.Errorf("Class is nil")
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestGetMethodID(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
if mid == nil {
t.Errorf("MethodID is nil")
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestNewObject(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, err := NewObject(env, cls, mid)
if err != nil {
t.Errorf("NewObject raised exception")
}
if inst == 0 {
t.Errorf("NewObject returned nil")
}
inst = NewGlobalRef(env, inst)
if inst == 0 {
t.Errorf("NewGlobalRef returned nil")
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestIsSameObject(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, err := NewObject(env, cls, mid)
if !IsSameObject(env, inst, inst) {
t.Errorf("Object is not the same as itself")
}
inst2, err := NewObject(env, cls, mid)
if err != nil {
t.Errorf("Object is nil")
}
if IsSameObject(env, inst, inst2) {
t.Errorf("Different objects are the same")
}
inst2 = NewLocalRef(env, inst)
if !IsSameObject(env, inst, inst2) {
t.Errorf("New local ref is not the same as original object")
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestStaticIntMethod(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
mid = GetStaticMethodID(env, cls, "GetStaticInt", "()I")
if mid == nil {
t.Errorf("MethodID is nil")
}
res, err := CallStaticIntMethod(env, cls, mid)
if err != nil {
t.Errorf("Method invocation failed")
}
if res != 100 {
t.Errorf("Method returned %d, not expected value of %d.", res, 100)
}
return err
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestIntMethod(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, err := NewObject(env, cls, mid)
mid = GetMethodID(env, cls, "GetInt", "()I")
if mid == nil {
t.Errorf("MethodID is nil")
}
res, err := CallIntMethod(env, inst, mid)
if err != nil {
t.Errorf("Method invocation failed")
}
if res != 0 {
t.Errorf("Method returned %d, not expected value of %d.", res, 0)
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestVoidMethod(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, err := NewObject(env, cls, mid)
mid = GetMethodID(env, cls, "IncInt", "()V")
if mid == nil {
t.Errorf("MethodID is nil")
}
err = CallVoidMethod(env, inst, mid)
if err != nil {
t.Errorf("Method invocation failed")
}
mid = GetMethodID(env, cls, "GetInt", "()I")
res, err := CallIntMethod(env, inst, mid)
if err != nil {
t.Errorf("Method invocation falied")
}
if res != 1 {
t.Errorf("Method returned %d, not expected value of %d.", res, 1)
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestVoidMethod2(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, err := NewObject(env, cls, mid)
mid = GetMethodID(env, cls, "SetInt", "(I)V")
if mid == nil {
t.Errorf("MethodID is nil")
}
err = CallVoidMethod(env, inst, mid, 5)
if err != nil {
t.Errorf("Method invocation failed")
}
mid = GetMethodID(env, cls, "GetInt", "()I")
res, err := CallIntMethod(env, inst, mid)
if err != nil {
t.Errorf("Method invocation falied")
}
if res != 5 {
t.Errorf("Method returned %d, not expected value of %d.", res, 5)
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestVoidMethod3(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, err := NewObject(env, cls, mid)
mid = GetMethodID(env, cls, "AddInts", "(II)V")
if mid == nil {
t.Errorf("MethodID is nil")
}
err = CallVoidMethod(env, inst, mid, 9, 11)
if err != nil {
t.Errorf("Method invocation failed")
}
mid = GetMethodID(env, cls, "GetInt", "()I")
res, err := CallIntMethod(env, inst, mid)
if err != nil {
t.Errorf("Method invocation falied")
}
if res != 20 {
t.Errorf("Method returned %d, not expected value of %d.", res, 20)
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestStaticVoidMethod(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetStaticMethodID(env, cls, "SetStaticInt", "(I)V")
if mid == nil {
t.Errorf("MethodID is nil")
}
err := CallStaticVoidMethod(env, cls, mid, 200)
if err != nil {
t.Errorf("Method invocation failed: %s", err)
}
mid = GetStaticMethodID(env, cls, "GetStaticInt", "()I")
res, err := CallStaticIntMethod(env, cls, mid)
if err != nil {
t.Errorf("Method invocation falied: %s", err)
}
if res != 200 {
t.Errorf("Method returned %d, not expected value of %d.", res, 200)
}
mid = GetStaticMethodID(env, cls, "SetStaticInt", "(I)V")
err = CallStaticVoidMethod(env, cls, mid, 100)
if err != nil {
t.Errorf("Method invocation failed: %s", err)
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestGetObjectClass(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, _ := NewObject(env, cls, mid)
cls2 := GetObjectClass(env, inst)
if cls2 == 0 {
t.Errorf("GetObjectClass returned nil")
}
if !IsInstanceOf(env, inst, cls2) {
t.Errorf("IsInstanceOf failed")
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestField(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
mid := GetMethodID(env, cls, "<init>", "()V")
inst, _ := NewObject(env, cls, mid)
fid := GetFieldID(env, cls, "intval", "I")
if fid == nil {
t.Errorf("FieldID is nil")
}
res := GetIntField(env, inst, fid)
if res != 0 {
t.Errorf("Method returned %d, not expected value of %d.", res, 0)
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}
func TestStaticField(t *testing.T) {
err := Do(vm, func(env Env) error {
cls := FindClass(env, "test/AClass")
fid := GetStaticFieldID(env, cls, "staticintval", "I")
if fid == nil {
t.Errorf("FieldID is nil")
}
res := GetStaticIntField(env, cls, fid)
if res != 100 {
t.Errorf("Method returned %d, not expected value of %d.", res, 100)
}
return nil
})
if err != nil {
t.Errorf("Error: %s", err)
}
}

17
scripts/find_linux_jnih
View File

@ -1,17 +0,0 @@
#!/bin/bash
JAVA_HOME=$(dirname $(readlink -f $(which java) | sed 's^jre/bin/^^'))
echo // +build linux > jni_linux.tmp
echo //Generated by scripts/find_linux_jnih >> jni_linux.tmp
echo >> jni_linux.tmp
echo package jni >> jni_linux.tmp
echo >> jni_linux.tmp
echo /\* >> jni_linux.tmp
echo \#cgo CFLAGS: -I$JAVA_HOME/include -I$JAVA_HOME/include/linux >> jni_linux.tmp
echo \#cgo LDFLAGS: -L$JAVA_HOME/lib/server -ljvm >> jni_linux.tmp
echo \*/ >> jni_linux.tmp
echo import \"C\" >> jni_linux.tmp
mv -f jni_linux.go jni_linux.go-old
mv jni_linux.tmp jni_linux.go

17
scripts/find_macos_jnih
View File

@ -1,17 +0,0 @@
#!/bin/bash
JAVA_HOME=`/usr/libexec/java_home`
echo // +build darwin > jni_darwin.tmp
echo //Generated by scripts/find_macos_jnih >> jni_darwin.tmp
echo >> jni_darwin.tmp
echo package jni >> jni_darwin.tmp
echo >> jni_darwin.tmp
echo /\* >> jni_darwin.tmp
echo \#cgo CFLAGS: -I$JAVA_HOME/include -I$JAVA_HOME/include/darwin >> jni_darwin.tmp
echo \#cgo LDFLAGS: -ljvm >> jni_darwin.tmp
echo \*/ >> jni_darwin.tmp
echo import \"C\" >> jni_darwin.tmp
mv -f jni_darwin.go jni_darwin.go-old
mv jni_darwin.tmp jni_darwin.go

BIN
test/AClass.class
View File

Binary file not shown.

31
test/AClass.java
View File

@ -1,31 +0,0 @@
package test;
public class AClass {
public static int staticintval = 100;
public int intval = 0;
public static int GetStaticInt() {
return staticintval;
}
public static void SetStaticInt(int val) {
staticintval = val;
}
public void IncInt() {
intval = intval + 1;
}
public int GetInt() {
return intval;
}
public void SetInt(int val) {
intval = val;
}
public void AddInts(int val1, int val2) {
intval = val1 + val2;
}
}