From d568a3d769f9cf14b8a972cd93e12b8b280e1387 Mon Sep 17 00:00:00 2001 From: Joe Ferner Date: Sun, 18 May 2025 17:45:47 +0000 Subject: [PATCH] prettier and lint --- .clang-format | 2 + .devcontainer/Dockerfile | 2 +- .github/workflows/master.yml | 6 + .github/workflows/pull-requests.yml | 6 + .prettierignore | 23 + .prettierrc | 10 + eslint.config.mjs | 25 + examples/lucene/example.js | 84 +- examples/mixJavaAndNode/runMyClass.js | 8 +- findJavaHome.js | 6 +- index.js | 1 - lib/nodeJavaBridge.js | 290 ++--- package-lock.json | 1038 ++++++++++++++++- package.json | 10 +- postInstall.js | 77 +- src/java.cpp | 464 ++++---- src/java.h | 22 +- src/javaObject.cpp | 126 +- src/javaObject.h | 23 +- src/javaScope.cpp | 4 +- src/methodCallBaton.cpp | 92 +- src/methodCallBaton.h | 26 +- src/nodeJavaBridge.cpp | 14 +- src/node_NodeDynamicProxyClass.h | 6 +- src/utils.cpp | 774 ++++++------ src/utils.h | 173 +-- test/TestLambda.test.js | 15 +- test/awt.test.js | 7 +- test/dynamicProxy.test.js | 97 +- test/importClass.test.js | 16 +- test/instanceof.test.js | 2 +- test/java-ambiguousMethod.test.js | 34 +- test/java-callStaticMethod.test.js | 51 +- test/java-newInstance.test.js | 22 +- test/java-staticField.test.js | 2 +- test/javaObject.test.js | 4 +- test/promises.test.js | 19 +- test/simple.test.js | 88 +- test/utils-types.test.js | 21 +- test/varargs.test.js | 112 +- testAsyncOptions/allThreeSuffix.test.js | 64 +- .../asyncSuffixSyncDefault.test.js | 57 +- testAsyncOptions/clientBeforeError.test.js | 12 +- .../clientBeforeSyncThrows.test.js | 14 +- testAsyncOptions/clientBeforeThrows.test.js | 16 +- testAsyncOptions/clientPBeforeError.test.js | 20 +- testAsyncOptions/clientPBeforeThrows.test.js | 22 +- testAsyncOptions/defacto.test.js | 51 +- testAsyncOptions/defactoPlusPromise.test.js | 67 +- testAsyncOptions/default.test.js | 45 +- testAsyncOptions/invalidLaunch.test.js | 30 +- testAsyncOptions/noAsync.test.js | 84 +- .../syncDefaultPlusPromise.test.js | 53 +- testAsyncOptions/unusableMethodName.test.js | 52 +- testHelpers.js | 4 +- testIntegration/jdbc/enduranceTest.js | 89 +- testIntegration/jdbc/enduranceTestAsync.js | 127 +- testIntegration/poi/poi-3.9-20121203.jar | Bin 1869093 -> 1869113 bytes .../poi/poi-scratchpad-3.9-20121203.jar | Bin 1226497 -> 1226511 bytes testIntegration/poi/poiTest.js | 25 +- testIntegration/webkit/main.js | 6 +- testRunner.js | 26 +- 62 files changed, 2912 insertions(+), 1754 deletions(-) create mode 100644 .clang-format create mode 100644 .prettierignore create mode 100644 .prettierrc create mode 100644 eslint.config.mjs diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..173f8a6a --- /dev/null +++ b/.clang-format @@ -0,0 +1,2 @@ +BasedOnStyle: LLVM +ColumnLimit: 120 diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 46e593f1..af983c75 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -1,4 +1,4 @@ FROM mcr.microsoft.com/devcontainers/javascript-node:22 RUN apt-get update -RUN apt-get install -y openjdk-17-jdk gdb +RUN apt-get install -y openjdk-17-jdk gdb clang-format diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml index 4fb4d569..074ca8e8 100644 --- a/.github/workflows/master.yml +++ b/.github/workflows/master.yml @@ -19,5 +19,11 @@ jobs: node-version: ${{ matrix.nodeVersion }} - name: npm ci run: npm ci + - name: npm run format-cpp + run: npm run format-cpp + - name: npm run format + run: npm run format + - name: npm run lint + run: npm run lint - name: Unit test run: npm test diff --git a/.github/workflows/pull-requests.yml b/.github/workflows/pull-requests.yml index 07e69021..e45d2380 100644 --- a/.github/workflows/pull-requests.yml +++ b/.github/workflows/pull-requests.yml @@ -20,5 +20,11 @@ jobs: node-version: ${{ matrix.nodeVersion }} - name: npm ci run: npm ci + - name: npm run format-cpp + run: npm run format-cpp + - name: npm run format + run: npm run format + - name: npm run lint + run: npm run lint - name: Unit test run: npm test diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 00000000..60c971ca --- /dev/null +++ b/.prettierignore @@ -0,0 +1,23 @@ +**/*.cpp +**/*.h +**/*.ppt +**/*.jar +**/*.class +**/*.java +**/*.sh +**/*.html +**/*.json +**/*.png +**/*.md +**/*.rule +**/*.rules +**/*.gyp +**/*.yml +**/Dockerfile +.clang-format +.prettierrc +.prettierignore +.npmignore +.gitignore +.gitattributes +LICENSE diff --git a/.prettierrc b/.prettierrc new file mode 100644 index 00000000..53fee0e9 --- /dev/null +++ b/.prettierrc @@ -0,0 +1,10 @@ +{ + "parser": "typescript", + "semi": true, + "singleQuote": false, + "tabWidth": 2, + "trailingComma": "es5", + "useTabs": false, + "printWidth": 120, + "endOfLine": "lf" +} diff --git a/eslint.config.mjs b/eslint.config.mjs new file mode 100644 index 00000000..68c91e14 --- /dev/null +++ b/eslint.config.mjs @@ -0,0 +1,25 @@ +import js from "@eslint/js"; +import globals from "globals"; +import { defineConfig } from "eslint/config"; + +export default defineConfig([ + { + files: ["**/*.{js,mjs,cjs}"], + plugins: { js }, + extends: ["js/recommended"], + languageOptions: { globals: globals.node }, + rules: { + "no-var": ["error"], + curly: ["error"], + "no-unused-vars": [ + "warn", + { + varsIgnorePattern: "^_", + argsIgnorePattern: "^_", + caughtErrorsIgnorePattern: "^_", + destructuredArrayIgnorePattern: "^_", + }, + ], + }, + }, +]); diff --git a/examples/lucene/example.js b/examples/lucene/example.js index f3478112..b531969f 100755 --- a/examples/lucene/example.js +++ b/examples/lucene/example.js @@ -1,60 +1,74 @@ #!/usr/bin/env node -var java = require("../../"); +const java = require("../../"); java.classpath.push("./lucene-lib/lucene-core-7.4.0.jar"); java.classpath.push("./lucene-lib/lucene-analyzers-common-7.4.0.jar"); java.classpath.push("./lucene-lib/lucene-queryparser-7.4.0.jar"); +const idx = java.newInstanceSync("org.apache.lucene.store.RAMDirectory"); +const analyzer = java.newInstanceSync("org.apache.lucene.analysis.standard.StandardAnalyzer"); +const writerConfig = java.newInstanceSync("org.apache.lucene.index.IndexWriterConfig", analyzer); +const writer = java.newInstanceSync("org.apache.lucene.index.IndexWriter", idx, writerConfig); +const queryParser = java.newInstanceSync("org.apache.lucene.queryparser.classic.QueryParser", "content", analyzer); -var idx = java.newInstanceSync("org.apache.lucene.store.RAMDirectory"); -var analyzer = java.newInstanceSync("org.apache.lucene.analysis.standard.StandardAnalyzer"); -var writerConfig = java.newInstanceSync("org.apache.lucene.index.IndexWriterConfig", analyzer); -var writer = java.newInstanceSync("org.apache.lucene.index.IndexWriter", idx, writerConfig); -var queryParser = java.newInstanceSync("org.apache.lucene.queryparser.classic.QueryParser", "content", analyzer); - -writer.addDocumentSync(createDocument("Theodore Roosevelt", - "It behooves every man to remember that the work of the " + - "critic, is of altogether secondary importance, and that, " + - "in the end, progress is accomplished by the man who does " + - "things.")); -writer.addDocumentSync(createDocument("Friedrich Hayek", - "The case for individual freedom rests largely on the " + - "recognition of the inevitable and universal ignorance " + - "of all of us concerning a great many of the factors on " + - "which the achievements of our ends and welfare depend.")); -writer.addDocumentSync(createDocument("Ayn Rand", - "There is nothing to take a man's freedom away from " + - "him, save other men. To be free, a man must be free " + - "of his brothers.")); -writer.addDocumentSync(createDocument("Mohandas Gandhi", - "Freedom is not worth having if it does not connote " + - "freedom to err.")); +writer.addDocumentSync( + createDocument( + "Theodore Roosevelt", + "It behooves every man to remember that the work of the " + + "critic, is of altogether secondary importance, and that, " + + "in the end, progress is accomplished by the man who does " + + "things." + ) +); +writer.addDocumentSync( + createDocument( + "Friedrich Hayek", + "The case for individual freedom rests largely on the " + + "recognition of the inevitable and universal ignorance " + + "of all of us concerning a great many of the factors on " + + "which the achievements of our ends and welfare depend." + ) +); +writer.addDocumentSync( + createDocument( + "Ayn Rand", + "There is nothing to take a man's freedom away from " + + "him, save other men. To be free, a man must be free " + + "of his brothers." + ) +); +writer.addDocumentSync( + createDocument("Mohandas Gandhi", "Freedom is not worth having if it does not connote " + "freedom to err.") +); writer.closeSync(); -var searcher = java.newInstanceSync("org.apache.lucene.search.IndexSearcher", java.callStaticMethodSync("org.apache.lucene.index.DirectoryReader", "open", idx)); +const searcher = java.newInstanceSync( + "org.apache.lucene.search.IndexSearcher", + java.callStaticMethodSync("org.apache.lucene.index.DirectoryReader", "open", idx) +); search(searcher, "freedom"); search(searcher, "free"); search(searcher, "progress or achievements"); function createDocument(title, content) { - var fieldStoreYes = java.callStaticMethodSync("org.apache.lucene.document.Field$Store", "valueOf", "YES"); - var doc = java.newInstanceSync("org.apache.lucene.document.Document"); + const fieldStoreYes = java.callStaticMethodSync("org.apache.lucene.document.Field$Store", "valueOf", "YES"); + const doc = java.newInstanceSync("org.apache.lucene.document.Document"); doc.addSync(java.newInstanceSync("org.apache.lucene.document.TextField", "title", title, fieldStoreYes)); doc.addSync(java.newInstanceSync("org.apache.lucene.document.TextField", "content", content, fieldStoreYes)); return doc; } function search(searcher, queryString) { - var query = queryParser.parseSync(queryString); - var topDocs = searcher.searchSync(query, 10); - - console.log("Found " + topDocs.totalHits + " hits for query \"" + queryString + "\"."); - var scoreDocs = topDocs.scoreDocs; - for(var i=0; i { + cb(); + }, + (err) => { + cb(err); + } + ); + } else { cb(); } - } - catch (err) { + } catch (err) { cb(err); } } @@ -147,20 +164,19 @@ function initializeAll(done) { // This function may be called multiple times -- the 2nd and subsequent calls are no-ops. // However, once this method has been called (or the JVM is launched as a side effect of calling other java // methods), then clients can no longer use the registerClient API. -java.ensureJvm = function(callback) { - +java.ensureJvm = function (callback) { // First see if the promise-style API should be used. // This must be done first in order to ensure the proper API is used. - if (typeof callback === 'undefined' && java.asyncOptions && typeof java.asyncOptions.promisify === 'function') { + if (typeof callback === "undefined" && java.asyncOptions && typeof java.asyncOptions.promisify === "function") { // Create a promisified version of this function. - var launchJvmPromise = java.asyncOptions.promisify(java.ensureJvm.bind(java)); + const launchJvmPromise = java.asyncOptions.promisify(java.ensureJvm.bind(java)); // Call the promisified function, returning its result, which should be a promise. return launchJvmPromise(); } // If we get here, callback must be a node-style callback function. If not, throw an error. - else if (typeof callback !== 'function') { - throw new Error('java.launchJvm(cb) requires its one argument to be a callback function.'); + else if (typeof callback !== "function") { + throw new Error("java.launchJvm(cb) requires its one argument to be a callback function."); } // Now check if the JVM has already been created. If so, we assume that the jvm was already successfully @@ -173,39 +189,39 @@ java.ensureJvm = function(callback) { else { return setImmediate(initializeAll, callback); } -} +}; -java.onJvmCreated = function() { +java.onJvmCreated = function () { if (java.asyncOptions) { syncSuffix = java.asyncOptions.syncSuffix; asyncSuffix = java.asyncOptions.asyncSuffix; - if (typeof syncSuffix !== 'string') { - throw new Error('In asyncOptions, syncSuffix must be defined and must a string'); + if (typeof syncSuffix !== "string") { + throw new Error("In asyncOptions, syncSuffix must be defined and must a string"); } - var promiseSuffix = java.asyncOptions.promiseSuffix; - var promisify = java.asyncOptions.promisify; - if (typeof promiseSuffix === 'string' && typeof promisify === 'function') { - var methods = ['newInstance', 'callMethod', 'callStaticMethod']; + const promiseSuffix = java.asyncOptions.promiseSuffix; + const promisify = java.asyncOptions.promisify; + if (typeof promiseSuffix === "string" && typeof promisify === "function") { + const methods = ["newInstance", "callMethod", "callStaticMethod"]; methods.forEach(function (name) { java[name + promiseSuffix] = promisify(java[name]); }); - } else if (typeof promiseSuffix === 'undefined' && typeof promisify === 'undefined') { + } else if (typeof promiseSuffix === "undefined" && typeof promisify === "undefined") { // no promises } else { - throw new Error('In asyncOptions, if either promiseSuffix or promisify is defined, both most be.'); + throw new Error("In asyncOptions, if either promiseSuffix or promisify is defined, both most be."); } - if (typeof java.asyncOptions.ifReadOnlySuffix === 'string' && java.asyncOptions.ifReadOnlySuffix !== '') { + if (typeof java.asyncOptions.ifReadOnlySuffix === "string" && java.asyncOptions.ifReadOnlySuffix !== "") { ifReadOnlySuffix = java.asyncOptions.ifReadOnlySuffix; } } else { - syncSuffix = 'Sync'; - asyncSuffix = ''; + syncSuffix = "Sync"; + asyncSuffix = ""; } -} +}; -var MODIFIER_PUBLIC = 1; -var MODIFIER_STATIC = 8; +const MODIFIER_PUBLIC = 1; +const MODIFIER_STATIC = 8; function isWritable(prop) { // If the property has no descriptor, or wasn't explicitly marked as not writable or not configurable, assume it is. @@ -213,10 +229,12 @@ function isWritable(prop) { // (e.g. for either .caller or .arguments). // It may be that checking desc.configurable is sufficient, but the specification doesn't make this definitive, // and there is no harm in checking both. - if (prop === 'caller' || prop === 'arguments') { return false; } + if (prop === "caller" || prop === "arguments") { + return false; + } - var desc = Object.getOwnPropertyDescriptor(function() {}, prop) || {}; - return desc.writable !== false && desc.configurable !== false; + const desc = Object.getOwnPropertyDescriptor(function () {}, prop) || {}; + return desc.writable !== false && desc.configurable !== false; } function usableName(name) { @@ -226,89 +244,93 @@ function usableName(name) { return name; } -java.import = function(name) { - var clazz = java.findClassSync(name); // TODO: change to Class.forName when classloader issue is resolved. - var result = function javaClassConstructorProxy() { - var args = [name]; - for (var i = 0; i < arguments.length; i++) { +java.import = function (name) { + const clazz = java.findClassSync(name); // TODO: change to Class.forName when classloader issue is resolved. + const result = function javaClassConstructorProxy() { + const args = [name]; + for (let i = 0; i < arguments.length; i++) { args.push(arguments[i]); } return newInstanceSync.apply(java, args); }; - var i; result.class = clazz; // copy static fields - var fields = SyncCall(clazz, 'getDeclaredFields')(); - for (i = 0; i < fields.length; i++) { - var modifiers = SyncCall(fields[i], 'getModifiers')(); - if (((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC) - && ((modifiers & MODIFIER_STATIC) === MODIFIER_STATIC)) { - var fieldName = SyncCall(fields[i], 'getName')(); - var jsfieldName = usableName(fieldName); - result.__defineGetter__(jsfieldName, function(name, fieldName) { - return java.getStaticFieldValue(name, fieldName); - }.bind(this, name, fieldName)); - result.__defineSetter__(jsfieldName, function(name, fieldName, val) { - java.setStaticFieldValue(name, fieldName, val); - }.bind(this, name, fieldName)); + const fields = SyncCall(clazz, "getDeclaredFields")(); + for (let i = 0; i < fields.length; i++) { + const modifiers = SyncCall(fields[i], "getModifiers")(); + if ((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC && (modifiers & MODIFIER_STATIC) === MODIFIER_STATIC) { + const fieldName = SyncCall(fields[i], "getName")(); + const jsfieldName = usableName(fieldName); + result.__defineGetter__( + jsfieldName, + function (name, fieldName) { + return java.getStaticFieldValue(name, fieldName); + }.bind(this, name, fieldName) + ); + result.__defineSetter__( + jsfieldName, + function (name, fieldName, val) { + java.setStaticFieldValue(name, fieldName, val); + }.bind(this, name, fieldName) + ); } } - var promisify = undefined; - var promiseSuffix; + let promisify = undefined; + let promiseSuffix; if (java.asyncOptions && java.asyncOptions.promisify) { promisify = java.asyncOptions.promisify; promiseSuffix = java.asyncOptions.promiseSuffix; } // copy static methods - var methods = SyncCall(clazz, 'getDeclaredMethods')(); - for (i = 0; i < methods.length; i++) { - var modifiers = SyncCall(methods[i], 'getModifiers')(); - if (((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC) - && ((modifiers & MODIFIER_STATIC) === MODIFIER_STATIC)) { - var methodName = SyncCall(methods[i], 'getName')(); - - if (typeof syncSuffix === 'string') { - var syncName = usableName(methodName + syncSuffix); + const methods = SyncCall(clazz, "getDeclaredMethods")(); + for (let i = 0; i < methods.length; i++) { + const modifiers = SyncCall(methods[i], "getModifiers")(); + if ((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC && (modifiers & MODIFIER_STATIC) === MODIFIER_STATIC) { + const methodName = SyncCall(methods[i], "getName")(); + + if (typeof syncSuffix === "string") { + const syncName = usableName(methodName + syncSuffix); result[syncName] = callStaticMethodSync.bind(java, name, methodName); } - if (typeof asyncSuffix === 'string') { - var asyncName = usableName(methodName + asyncSuffix); + if (typeof asyncSuffix === "string") { + const asyncName = usableName(methodName + asyncSuffix); result[asyncName] = callStaticMethod.bind(java, name, methodName); } - if (promisify && typeof promiseSuffix === 'string') { - var promiseName = usableName(methodName + promiseSuffix); + if (promisify && typeof promiseSuffix === "string") { + const promiseName = usableName(methodName + promiseSuffix); result[promiseName] = promisify(callStaticMethod.bind(java, name, methodName)); } } } // copy static classes/enums - var classes = SyncCall(clazz, 'getDeclaredClasses')(); - for (i = 0; i < classes.length; i++) { - var modifiers = SyncCall(classes[i], 'getModifiers')(); - if (((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC) - && ((modifiers & MODIFIER_STATIC) === MODIFIER_STATIC)) { - var className = SyncCall(classes[i], 'getName')(); - var simpleName = SyncCall(classes[i], 'getSimpleName')(); + const classes = SyncCall(clazz, "getDeclaredClasses")(); + for (let i = 0; i < classes.length; i++) { + const modifiers = SyncCall(classes[i], "getModifiers")(); + if ((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC && (modifiers & MODIFIER_STATIC) === MODIFIER_STATIC) { + const className = SyncCall(classes[i], "getName")(); + const simpleName = SyncCall(classes[i], "getSimpleName")(); Object.defineProperty(result, simpleName, { - get: function(result, simpleName, className) { - var c = java.import(className); + get: function (result, simpleName, className) { + const c = java.import(className); // memoize the import - var d = Object.getOwnPropertyDescriptor(result, simpleName); - d.get = function(c) { return c; }.bind(null, c); + const d = Object.getOwnPropertyDescriptor(result, simpleName); + d.get = function (c) { + return c; + }.bind(null, c); Object.defineProperty(result, simpleName, d); return c; }.bind(this, result, simpleName, className), enumerable: true, - configurable: true + configurable: true, }); } } diff --git a/package-lock.json b/package-lock.json index ec23bb14..a596ce1d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -17,7 +17,11 @@ "node-gyp": "^10.3.1" }, "devDependencies": { + "@eslint/js": "^9.27.0", "chalk": "2.4.2", + "eslint": "^9.27.0", + "globals": "^16.1.0", + "prettier": "^3.5.3", "vitest": "^3.1.3", "when": "3.7.8" }, @@ -450,6 +454,226 @@ "node": ">=18" } }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz", + "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.1", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz", + "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/config-array": { + "version": "0.20.0", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.20.0.tgz", + "integrity": "sha512-fxlS1kkIjx8+vy2SjuCB94q3htSNrufYTXubwiBFeaQHbH6Ipi43gFJq2zCMt6PHhImH3Xmr0NksKDvchWlpQQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^2.1.6", + "debug": "^4.3.1", + "minimatch": "^3.1.2" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.2.2.tgz", + "integrity": "sha512-+GPzk8PlG0sPpzdU5ZvIRMPidzAnZDl/s9L+y13iodqvb8leL53bTannOrQ/Im7UkpsmFU5Ily5U60LWixnmLg==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/core": { + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.14.0.tgz", + "integrity": "sha512-qIbV0/JZr7iSDjqAc60IqbLdsj9GDt16xQtWD+B78d/HAlvysGdZZ6rpJHGAc2T0FQx1X6thsSPdnoiGKdNtdg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz", + "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^10.0.1", + "globals": "^14.0.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "9.27.0", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.27.0.tgz", + "integrity": "sha512-G5JD9Tu5HJEu4z2Uo4aHY2sLV64B7CDMXxFzqzjl3NKd6RVzSXNoE80jk7Y0lJkTTkjiIhBAqmlYwjuBY3tvpA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/@eslint/object-schema": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz", + "integrity": "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.3.1.tgz", + "integrity": "sha512-0J+zgWxHN+xXONWIyPWKFMgVuJoZuGiIFu8yxk7RJjxkzpGmyja5wRFqZIVtjDVOQpV+Rw0iOAjYPE2eQyjr0w==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.14.0", + "levn": "^0.4.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@humanfs/core": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", + "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node": { + "version": "0.16.6", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz", + "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/core": "^0.19.1", + "@humanwhocodes/retry": "^0.3.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz", + "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, "node_modules/@isaacs/cliui": { "version": "8.0.2", "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", @@ -884,6 +1108,13 @@ "dev": true, "license": "MIT" }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" + }, "node_modules/@vitest/expect": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.1.3.tgz", @@ -1006,6 +1237,29 @@ "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, + "node_modules/acorn": { + "version": "8.14.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz", + "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, "node_modules/agent-base": { "version": "7.1.3", "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz", @@ -1028,6 +1282,23 @@ "node": ">=8" } }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, "node_modules/ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", @@ -1050,6 +1321,13 @@ "node": ">=4" } }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, "node_modules/assertion-error": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", @@ -1071,6 +1349,17 @@ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, "node_modules/cac": { "version": "6.7.14", "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", @@ -1119,6 +1408,16 @@ "node": ">=16 || 14 >=14.17" } }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/chai": { "version": "5.2.0", "resolved": "https://registry.npmjs.org/chai/-/chai-5.2.0.tgz", @@ -1219,6 +1518,42 @@ "dev": true, "license": "MIT" }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/cross-spawn/node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, "node_modules/debug": { "version": "4.4.1", "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", @@ -1246,6 +1581,13 @@ "node": ">=6" } }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, "node_modules/eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", @@ -1324,6 +1666,217 @@ "@esbuild/win32-x64": "0.25.4" } }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "9.27.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.27.0.tgz", + "integrity": "sha512-ixRawFQuMB9DZ7fjU3iGGganFDp3+45bPOdaRurcFHSXO1e/sYwUX/FtQZpLZJR6SjMoJH8hR2pPEAfDyCoU2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.12.1", + "@eslint/config-array": "^0.20.0", + "@eslint/config-helpers": "^0.2.1", + "@eslint/core": "^0.14.0", + "@eslint/eslintrc": "^3.3.1", + "@eslint/js": "9.27.0", + "@eslint/plugin-kit": "^0.3.1", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "@types/json-schema": "^7.0.15", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^8.3.0", + "eslint-visitor-keys": "^4.2.0", + "espree": "^10.3.0", + "esquery": "^1.5.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-scope": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.3.0.tgz", + "integrity": "sha512-pUNxi75F8MJ/GdeKtVLSbYg4ZI34J6C0C7sbL4YOp2exGwen7ZsuBqKzUhXd0qMQ362yET3z+uPwKeg/0C2XCQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz", + "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/eslint/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/eslint/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/eslint/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/espree": { + "version": "10.3.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.3.0.tgz", + "integrity": "sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.14.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^4.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", + "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, "node_modules/estree-walker": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", @@ -1334,6 +1887,16 @@ "@types/estree": "^1.0.0" } }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/expect-type": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.2.1.tgz", @@ -1349,6 +1912,27 @@ "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.1.tgz", "integrity": "sha512-dX7e/LHVJ6W3DE1MHWi9S1EYzDESENfLrYohG2G++ovZrYOkm4Knwa0mc1cn84xJOR4KEU0WSchhLbd0UklbHw==" }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, "node_modules/fdir": { "version": "6.4.4", "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.4.tgz", @@ -1364,6 +1948,19 @@ } } }, + "node_modules/file-entry-cache": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^4.0.0" + }, + "engines": { + "node": ">=16.0.0" + } + }, "node_modules/find-java-home": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/find-java-home/-/find-java-home-2.0.0.tgz", @@ -1373,6 +1970,44 @@ "winreg": "~1.2.2" } }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/flatted": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", + "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", + "dev": true, + "license": "ISC" + }, "node_modules/fs-minipass": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz", @@ -1429,6 +2064,19 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, "node_modules/glob/node_modules/brace-expansion": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", @@ -1438,20 +2086,6 @@ "balanced-match": "^1.0.0" } }, - "node_modules/glob/node_modules/cross-spawn": { - "version": "7.0.6", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", - "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", - "license": "MIT", - "dependencies": { - "path-key": "^3.1.0", - "shebang-command": "^2.0.0", - "which": "^2.0.1" - }, - "engines": { - "node": ">= 8" - } - }, "node_modules/glob/node_modules/foreground-child": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.1.1.tgz", @@ -1502,18 +2136,17 @@ "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/glob/node_modules/which": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", - "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", - "dependencies": { - "isexe": "^2.0.0" - }, - "bin": { - "node-which": "bin/node-which" - }, + "node_modules/globals": { + "version": "16.1.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-16.1.0.tgz", + "integrity": "sha512-aibexHNbb/jiUSObBgpHLj+sIuUmJnYcgXBlrfsiDZ9rt4aF2TFRbyLgZ2iFQuVZ1K5Mx3FVkbKRSgKrbK3K2g==", + "dev": true, + "license": "MIT", "engines": { - "node": ">= 8" + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/graceful-fs": { @@ -1577,6 +2210,33 @@ "node": ">=0.10.0" } }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/imurmurhash": { "version": "0.1.4", "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", @@ -1619,6 +2279,29 @@ "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", "license": "BSD-3-Clause" }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/is-lambda": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/is-lambda/-/is-lambda-1.0.1.tgz", @@ -1628,7 +2311,8 @@ "node_modules/isexe": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=" + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "license": "ISC" }, "node_modules/jackspeak": { "version": "3.4.3", @@ -1645,6 +2329,87 @@ "@pkgjs/parseargs": "^0.11.0" } }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, "node_modules/loupe": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.3.tgz", @@ -1694,6 +2459,19 @@ "node": ">=16 || 14 >=14.17" } }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, "node_modules/minipass-collect": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz", @@ -1893,6 +2671,13 @@ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" } }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, "node_modules/negotiator": { "version": "0.6.4", "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz", @@ -1965,6 +2750,56 @@ "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/p-map": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", @@ -1986,6 +2821,29 @@ "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", "license": "BlueOak-1.0.0" }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/path-key": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", @@ -2091,6 +2949,32 @@ "node": "^10 || ^12 || >=14" } }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prettier": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.3.tgz", + "integrity": "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, "node_modules/proc-log": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-4.2.0.tgz", @@ -2113,6 +2997,26 @@ "node": ">=10" } }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "node_modules/retry": { "version": "0.12.0", "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", @@ -2344,6 +3248,42 @@ "node": ">=8" } }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-color/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/tar": { "version": "6.2.1", "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz", @@ -2473,6 +3413,19 @@ "node": ">=14.0.0" } }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, "node_modules/unique-filename": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz", @@ -2497,6 +3450,16 @@ "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, "node_modules/vite": { "version": "6.3.5", "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.5.tgz", @@ -2702,6 +3665,16 @@ "resolved": "https://registry.npmjs.org/winreg/-/winreg-1.2.4.tgz", "integrity": "sha1-ugZWKbepJRMOFXeRCM9UCZDpjRs=" }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/wrap-ansi-cjs": { "name": "wrap-ansi", "version": "7.0.0", @@ -2793,6 +3766,19 @@ "engines": { "node": ">=8" } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } } } } diff --git a/package.json b/package.json index 4f4943f3..1d20298b 100644 --- a/package.json +++ b/package.json @@ -33,14 +33,22 @@ "node-gyp": "^10.3.1" }, "devDependencies": { + "@eslint/js": "^9.27.0", "chalk": "2.4.2", + "eslint": "^9.27.0", + "globals": "^16.1.0", + "prettier": "^3.5.3", "vitest": "^3.1.3", "when": "3.7.8" }, "scripts": { "install": "node-gyp rebuild", "test": "node testRunner.js", - "postinstall": "node postInstall.js" + "postinstall": "node postInstall.js", + "lint": "eslint --ext js,ts,tsx --report-unused-disable-directives --max-warnings 0 .", + "format": "prettier --write .", + "format-cpp": "clang-format --version; find src/ -iname '*.h' -o -iname '*.cpp' | xargs clang-format -i", + "precommit": "npm run format-cpp && npm run format && npm run lint && npm test" }, "main": "./index.js" } diff --git a/postInstall.js b/postInstall.js index 2701913c..7a61dec3 100644 --- a/postInstall.js +++ b/postInstall.js @@ -1,69 +1,60 @@ -var glob = require('glob'); -var fs = require('fs'); -var path = require('path'); -var os = require('os'); - -require('find-java-home')(function(err, home){ - var dll; - var dylib; - var so,soFiles; - var binary; - - if(home){ - dll = glob.sync('**/jvm.dll', {cwd: home})[0]; - dylib = glob.sync('**/libjli.dylib', {cwd: home})[0]; - soFiles = glob.sync('**/libjvm.so', {cwd: home}); - - if(soFiles.length>0) +const glob = require("glob"); +const fs = require("fs"); +const path = require("path"); +const os = require("os"); + +require("find-java-home")((err, home) => { + if (home) { + const dll = glob.sync("**/jvm.dll", { cwd: home })[0]; + const dylib = glob.sync("**/libjli.dylib", { cwd: home })[0]; + const soFiles = glob.sync("**/libjvm.so", { cwd: home }); + + let so; + if (soFiles.length > 0) { so = getCorrectSoForPlatform(soFiles); + } - binary = dll || dylib || so; + const binary = dll ?? dylib ?? so; fs.writeFileSync( - path.resolve(__dirname, './build/jvm_dll_path.json'), - binary - ? JSON.stringify( - path.delimiter - + path.dirname(path.resolve(home, binary)) - ) - : '""' + path.resolve(__dirname, "./build/jvm_dll_path.json"), + binary ? JSON.stringify(path.delimiter + path.dirname(path.resolve(home, binary))) : '""' ); } }); -function getCorrectSoForPlatform(soFiles){ - var so = _getCorrectSoForPlatform(soFiles); +function getCorrectSoForPlatform(soFiles) { + let so = _getCorrectSoForPlatform(soFiles); if (so) { so = removeDuplicateJre(so); } return so; } -function removeDuplicateJre(filePath){ - while(filePath.indexOf('jre/jre')>=0){ - filePath = filePath.replace('jre/jre','jre'); +function removeDuplicateJre(filePath) { + while (filePath.indexOf("jre/jre") >= 0) { + filePath = filePath.replace("jre/jre", "jre"); } return filePath; } -function _getCorrectSoForPlatform(soFiles){ - - var architectureFolderNames = { - 'ia32': 'i386', - 'x64': 'amd64' +function _getCorrectSoForPlatform(soFiles) { + const architectureFolderNames = { + ia32: "i386", + x64: "amd64", }; - if(os.platform() != 'sunos') + if (os.platform() != "sunos") { return soFiles[0]; + } - var requiredFolderName = architectureFolderNames[os.arch()]; - - for (var i = 0; i < soFiles.length; i++) { - var so = soFiles[i]; + const requiredFolderName = architectureFolderNames[os.arch()]; - if(so.indexOf('server')>0) - if(so.indexOf(requiredFolderName)>0) - return so; + for (let i = 0; i < soFiles.length; i++) { + const so = soFiles[i]; + if (so.indexOf("server") > 0 && so.indexOf(requiredFolderName) > 0) { + return so; + } } return soFiles[0]; diff --git a/src/java.cpp b/src/java.cpp index 990f5a9a..17743cc9 100644 --- a/src/java.cpp +++ b/src/java.cpp @@ -2,23 +2,23 @@ #include #ifdef WIN32 #else - #include +#include #endif #include "javaObject.h" #include "javaScope.h" #include "methodCallBaton.h" #include "node_NodeDynamicProxyClass.h" +#include #include #include #include -#include #define DYNAMIC_PROXY_JS_ERROR -4 #ifdef WIN32 - typedef long threadId; +typedef long threadId; #else - typedef pthread_t threadId; +typedef pthread_t threadId; #endif threadId v8ThreadId; @@ -61,7 +61,7 @@ void uvAsyncCb_dynamicProxyJsCall(uv_async_t *handle) { DynamicProxyJsCallData *callData; do { uv_mutex_lock(&uvMutex_dynamicProxyJsCall); - if(!queue_dynamicProxyJsCallData.empty()) { + if (!queue_dynamicProxyJsCallData.empty()) { callData = queue_dynamicProxyJsCallData.front(); queue_dynamicProxyJsCallData.pop(); } else { @@ -69,17 +69,17 @@ void uvAsyncCb_dynamicProxyJsCall(uv_async_t *handle) { } uv_mutex_unlock(&uvMutex_dynamicProxyJsCall); - if(callData) { + if (callData) { EIO_CallJs(callData); } - } while(callData); + } while (callData); } /*static*/ void Java::Init(v8::Local target) { Nan::HandleScope scope; v8ThreadId = my_getThreadId(); - isDefaultLoopRunning = false; //init as false + isDefaultLoopRunning = false; // init as false uv_mutex_init(&uvMutex_dynamicProxyJsCall); @@ -127,7 +127,8 @@ NAN_METHOD(Java::New) { Nan::Set(self->handle(), Nan::New("classpath").ToLocalChecked(), Nan::New()); Nan::Set(self->handle(), Nan::New("options").ToLocalChecked(), Nan::New()); - Nan::Set(self->handle(), Nan::New("nativeBindingLocation").ToLocalChecked(), Nan::New("Not Set").ToLocalChecked()); + Nan::Set(self->handle(), Nan::New("nativeBindingLocation").ToLocalChecked(), + Nan::New("Not Set").ToLocalChecked()); Nan::Set(self->handle(), Nan::New("asyncOptions").ToLocalChecked(), Nan::Null()); info.GetReturnValue().Set(info.This()); @@ -144,12 +145,10 @@ Java::Java() { doPromise = false; } -Java::~Java() { - this->destroyJVM(&this->m_jvm, &this->m_env); -} +Java::~Java() { this->destroyJVM(&this->m_jvm, &this->m_env); } v8::Local Java::ensureJvm() { - if(!m_jvm) { + if (!m_jvm) { v8::Local result = createJVM(&this->m_jvm, &this->m_env); assert(result->IsNull()); return result; @@ -158,7 +157,7 @@ v8::Local Java::ensureJvm() { return Nan::Null(); } -void Java::configureAsync(v8::Local& asyncOptions) { +void Java::configureAsync(v8::Local &asyncOptions) { v8::Local asyncOptionsObj = asyncOptions.As(); m_SyncSuffix = "invalid"; @@ -168,7 +167,8 @@ void Java::configureAsync(v8::Local& asyncOptions) { doAsync = false; doPromise = false; - v8::MaybeLocal maybeSuffixValue = Nan::Get(asyncOptionsObj, Nan::New("syncSuffix").ToLocalChecked()); + v8::MaybeLocal maybeSuffixValue = + Nan::Get(asyncOptionsObj, Nan::New("syncSuffix").ToLocalChecked()); v8::Local suffixValue; if (maybeSuffixValue.ToLocal(&suffixValue) && suffixValue->IsString()) { v8::Local suffix = suffixValue->ToString(Nan::GetCurrentContext()).ToLocalChecked(); @@ -190,7 +190,8 @@ void Java::configureAsync(v8::Local& asyncOptions) { v8::Local suffix = suffixValue->ToString(Nan::GetCurrentContext()).ToLocalChecked(); Nan::Utf8String utf8(suffix); m_PromiseSuffix.assign(*utf8); - v8::MaybeLocal maybePromisify = Nan::Get(asyncOptionsObj, Nan::New("promisify").ToLocalChecked()); + v8::MaybeLocal maybePromisify = + Nan::Get(asyncOptionsObj, Nan::New("promisify").ToLocalChecked()); v8::Local promisify; if (maybePromisify.ToLocal(&promisify) && !promisify->IsFunction()) { fprintf(stderr, "asyncOptions.promisify must be a function"); @@ -212,8 +213,9 @@ void Java::configureAsync(v8::Local& asyncOptions) { m_asyncOptions.Reset(asyncOptionsObj); } -v8::Local Java::createJVM(JavaVM** jvm, JNIEnv** env) { - v8::MaybeLocal maybeAsyncOptions = Nan::Get(this->handle(), Nan::New("asyncOptions").ToLocalChecked()); +v8::Local Java::createJVM(JavaVM **jvm, JNIEnv **env) { + v8::MaybeLocal maybeAsyncOptions = + Nan::Get(this->handle(), Nan::New("asyncOptions").ToLocalChecked()); v8::Local asyncOptions; if (maybeAsyncOptions.ToLocal(&asyncOptions) && asyncOptions->IsObject()) { configureAsync(asyncOptions); @@ -223,23 +225,24 @@ v8::Local Java::createJVM(JavaVM** jvm, JNIEnv** env) { std::ostringstream classPath; classPath << "-Djava.class.path="; - v8::MaybeLocal maybeClassPathValue = Nan::Get(this->handle(), Nan::New("classpath").ToLocalChecked()); + v8::MaybeLocal maybeClassPathValue = + Nan::Get(this->handle(), Nan::New("classpath").ToLocalChecked()); v8::Local classPathValue; - if(!maybeClassPathValue.ToLocal(&classPathValue) || !classPathValue->IsArray()) { + if (!maybeClassPathValue.ToLocal(&classPathValue) || !classPathValue->IsArray()) { return Nan::TypeError("Classpath must be an array"); } v8::Local classPathArrayTemp = v8::Local::Cast(classPathValue); m_classPathArray.Reset(classPathArrayTemp); - for(uint32_t i=0; iLength(); i++) { - if(i != 0) { - #ifdef WIN32 - classPath << ";"; - #else - classPath << ":"; - #endif + for (uint32_t i = 0; i < classPathArrayTemp->Length(); i++) { + if (i != 0) { +#ifdef WIN32 + classPath << ";"; +#else + classPath << ":"; +#endif } v8::Local arrayItemValue = classPathArrayTemp->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); - if(!arrayItemValue->IsString()) { + if (!arrayItemValue->IsString()) { return Nan::TypeError("Classpath must only contain strings"); } v8::Local arrayItem = arrayItemValue->ToString(Nan::GetCurrentContext()).ToLocalChecked(); @@ -248,13 +251,16 @@ v8::Local Java::createJVM(JavaVM** jvm, JNIEnv** env) { } // set the native binding location - v8::Local v8NativeBindingLocation = Nan::Get(this->handle(), Nan::New("nativeBindingLocation").ToLocalChecked()).FromMaybe(v8::Local()); + v8::Local v8NativeBindingLocation = + Nan::Get(this->handle(), Nan::New("nativeBindingLocation").ToLocalChecked()) + .FromMaybe(v8::Local()); Nan::Utf8String nativeBindingLocationStr(v8NativeBindingLocation); s_nativeBindingLocation = *nativeBindingLocationStr; // get other options - v8::Local optionsValue = Nan::Get(this->handle(), Nan::New("options").ToLocalChecked()).FromMaybe(v8::Local()); - if(!optionsValue->IsArray()) { + v8::Local optionsValue = + Nan::Get(this->handle(), Nan::New("options").ToLocalChecked()).FromMaybe(v8::Local()); + if (!optionsValue->IsArray()) { return Nan::TypeError("options must be an array"); } v8::Local optionsArrayTemp = v8::Local::Cast(optionsValue); @@ -262,18 +268,18 @@ v8::Local Java::createJVM(JavaVM** jvm, JNIEnv** env) { // create vm options int vmOptionsCount = optionsArrayTemp->Length() + 1; - JavaVMOption* vmOptions = new JavaVMOption[vmOptionsCount]; - //printf("classPath: %s\n", classPath.str().c_str()); + JavaVMOption *vmOptions = new JavaVMOption[vmOptionsCount]; + // printf("classPath: %s\n", classPath.str().c_str()); vmOptions[0].optionString = strdup(classPath.str().c_str()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < optionsArrayTemp->Length(); i++) { v8::Local arrayItemValue = optionsArrayTemp->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); - if(!arrayItemValue->IsString()) { + if (!arrayItemValue->IsString()) { delete[] vmOptions; return Nan::TypeError("options must only contain strings"); } v8::Local arrayItem = arrayItemValue->ToString(Nan::GetCurrentContext()).ToLocalChecked(); Nan::Utf8String arrayItemStr(arrayItem); - vmOptions[i+1].optionString = strdup(*arrayItemStr); + vmOptions[i + 1].optionString = strdup(*arrayItemStr); } JavaVMInitArgs args; @@ -297,22 +303,29 @@ v8::Local Java::createJVM(JavaVM** jvm, JNIEnv** env) { args.options = vmOptions; args.nOptions = vmOptionsCount; - JavaVM* jvmTemp; + JavaVM *jvmTemp; JNI_CreateJavaVM(&jvmTemp, (void **)env, &args); *jvm = jvmTemp; - delete [] vmOptions; + delete[] vmOptions; m_classLoader = getSystemClassLoader(*env); - v8::Local onJvmCreated = Nan::Get(this->handle(), Nan::New("onJvmCreated").ToLocalChecked()).FromMaybe(v8::Local()); - - // TODO: this handles sets put doesn't prevent modifing the underlying data. So java.classpath.push will still work which is invalid. - Nan::SetAccessor(this->handle(), Nan::New("classpath").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); - Nan::SetAccessor(this->handle(), Nan::New("options").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); - Nan::SetAccessor(this->handle(), Nan::New("nativeBindingLocation").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); - Nan::SetAccessor(this->handle(), Nan::New("asyncOptions").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); - Nan::SetAccessor(this->handle(), Nan::New("onJvmCreated").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); + v8::Local onJvmCreated = + Nan::Get(this->handle(), Nan::New("onJvmCreated").ToLocalChecked()).FromMaybe(v8::Local()); + + // TODO: this handles sets put doesn't prevent modifing the underlying data. So java.classpath.push will still work + // which is invalid. + Nan::SetAccessor(this->handle(), Nan::New("classpath").ToLocalChecked(), + AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); + Nan::SetAccessor(this->handle(), Nan::New("options").ToLocalChecked(), AccessorProhibitsOverwritingGetter, + AccessorProhibitsOverwritingSetter); + Nan::SetAccessor(this->handle(), Nan::New("nativeBindingLocation").ToLocalChecked(), + AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); + Nan::SetAccessor(this->handle(), Nan::New("asyncOptions").ToLocalChecked(), + AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); + Nan::SetAccessor(this->handle(), Nan::New("onJvmCreated").ToLocalChecked(), + AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter); if (onJvmCreated->IsFunction()) { v8::Local onJvmCreatedFunc = onJvmCreated.As(); @@ -324,22 +337,22 @@ v8::Local Java::createJVM(JavaVM** jvm, JNIEnv** env) { } NAN_GETTER(Java::AccessorProhibitsOverwritingGetter) { - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); Nan::HandleScope scope; Nan::Utf8String nameStr(property); - if(!strcmp("classpath", *nameStr)) { + if (!strcmp("classpath", *nameStr)) { info.GetReturnValue().Set(Nan::New(self->m_classPathArray)); return; - } else if(!strcmp("options", *nameStr)) { + } else if (!strcmp("options", *nameStr)) { info.GetReturnValue().Set(Nan::New(self->m_optionsArray)); return; - } else if(!strcmp("nativeBindingLocation", *nameStr)) { + } else if (!strcmp("nativeBindingLocation", *nameStr)) { info.GetReturnValue().Set(Nan::New(Java::s_nativeBindingLocation.c_str()).ToLocalChecked()); return; - } else if(!strcmp("asyncOptions", *nameStr)) { + } else if (!strcmp("asyncOptions", *nameStr)) { info.GetReturnValue().Set(Nan::New(self->m_asyncOptions)); return; - } else if(!strcmp("onJvmCreated", *nameStr)) { + } else if (!strcmp("onJvmCreated", *nameStr)) { // There is no good reason to get onJvmCreated, so just fall through to error below. } @@ -355,7 +368,7 @@ NAN_SETTER(Java::AccessorProhibitsOverwritingSetter) { Nan::ThrowError(errStr.str().c_str()); } -void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) { +void Java::destroyJVM(JavaVM **jvm, JNIEnv **env) { (*jvm)->DestroyJavaVM(); *jvm = NULL; *env = NULL; @@ -363,17 +376,18 @@ void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) { NAN_METHOD(Java::getClassLoader) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); jclass classClazz = env->FindClass("java/lang/ClassLoader"); - jmethodID class_getClassLoader = env->GetStaticMethodID(classClazz, "getSystemClassLoader", "()Ljava/lang/ClassLoader;"); + jmethodID class_getClassLoader = + env->GetStaticMethodID(classClazz, "getSystemClassLoader", "()Ljava/lang/ClassLoader;"); jobject classLoader = env->CallStaticObjectMethod(classClazz, class_getClassLoader); checkJavaException(env); @@ -383,13 +397,13 @@ NAN_METHOD(Java::getClassLoader) { NAN_METHOD(Java::newInstance) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -401,7 +415,7 @@ NAN_METHOD(Java::newInstance) { // find class jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { EXCEPTION_CALL_CALLBACK(self, "Could not find class " << className.c_str()); info.GetReturnValue().SetUndefined(); return; @@ -410,7 +424,7 @@ NAN_METHOD(Java::newInstance) { // get method jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindConstructor(env, clazz, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, clazz, className, true, info, argsStart, argsEnd); EXCEPTION_CALL_CALLBACK(self, msg); info.GetReturnValue().SetUndefined(); @@ -418,21 +432,22 @@ NAN_METHOD(Java::newInstance) { } // run - NewInstanceBaton* baton = new NewInstanceBaton(self, clazz, method, methodArgs, callback); + NewInstanceBaton *baton = new NewInstanceBaton(self, clazz, method, methodArgs, callback); baton->run(); - END_CALLBACK_FUNCTION("\"Constructor for class '" << className << "' called without a callback did you mean to use the Sync version?\""); + END_CALLBACK_FUNCTION("\"Constructor for class '" + << className << "' called without a callback did you mean to use the Sync version?\""); } NAN_METHOD(Java::newInstanceSync) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -443,7 +458,7 @@ NAN_METHOD(Java::newInstanceSync) { // find class jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { std::ostringstream errStr; errStr << "Could not create class " << className.c_str(); return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -452,17 +467,17 @@ NAN_METHOD(Java::newInstanceSync) { // find method jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindConstructor(env, clazz, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, clazz, className, true, info, argsStart, argsEnd); return Nan::ThrowError(javaExceptionToV8(self, env, msg)); } // run v8::Local callback = Nan::Null(); - NewInstanceBaton* baton = new NewInstanceBaton(self, clazz, method, methodArgs, callback); + NewInstanceBaton *baton = new NewInstanceBaton(self, clazz, method, methodArgs, callback); v8::Local result = baton->runSync(); delete baton; - if(result->IsNativeError()) { + if (result->IsNativeError()) { return Nan::ThrowError(result); } info.GetReturnValue().Set(result); @@ -470,13 +485,13 @@ NAN_METHOD(Java::newInstanceSync) { NAN_METHOD(Java::newProxy) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -484,7 +499,7 @@ NAN_METHOD(Java::newProxy) { ARGS_FRONT_STRING(interfaceName); ARGS_FRONT_OBJECT(functions); - DynamicProxyData* dynamicProxyData = new DynamicProxyData(); + DynamicProxyData *dynamicProxyData = new DynamicProxyData(); dynamicProxyData->markerStart = DYNAMIC_PROXY_DATA_MARKER_START; dynamicProxyData->markerEnd = DYNAMIC_PROXY_DATA_MARKER_END; dynamicProxyData->java = self; @@ -494,7 +509,7 @@ NAN_METHOD(Java::newProxy) { // find NodeDynamicProxyClass std::string className = "node.NodeDynamicProxyClass"; jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { std::ostringstream errStr; errStr << "Could not create class node/NodeDynamicProxyClass"; delete dynamicProxyData; @@ -504,10 +519,11 @@ NAN_METHOD(Java::newProxy) { // find constructor jclass objectClazz = env->FindClass("java/lang/Object"); jobjectArray methodArgs = env->NewObjectArray(2, objectClazz, NULL); - env->SetObjectArrayElement(methodArgs, 0, v8ToJava(env, Nan::New(s_nativeBindingLocation.c_str()).ToLocalChecked())); + env->SetObjectArrayElement(methodArgs, 0, + v8ToJava(env, Nan::New(s_nativeBindingLocation.c_str()).ToLocalChecked())); env->SetObjectArrayElement(methodArgs, 1, longToJavaLongObj(env, (jlong)dynamicProxyData)); jobject method = javaFindConstructor(env, clazz, methodArgs); - if(method == NULL) { + if (method == NULL) { std::ostringstream errStr; errStr << "Could not find constructor for class node/NodeDynamicProxyClass"; return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -515,20 +531,21 @@ NAN_METHOD(Java::newProxy) { // create the NodeDynamicProxyClass jclass constructorClazz = env->FindClass("java/lang/reflect/Constructor"); - jmethodID constructor_newInstance = env->GetMethodID(constructorClazz, "newInstance", "([Ljava/lang/Object;)Ljava/lang/Object;"); + jmethodID constructor_newInstance = + env->GetMethodID(constructorClazz, "newInstance", "([Ljava/lang/Object;)Ljava/lang/Object;"); - //printf("invoke: %s\n", javaMethodCallToString(env, m_method, constructor_newInstance, m_args).c_str()); + // printf("invoke: %s\n", javaMethodCallToString(env, m_method, constructor_newInstance, m_args).c_str()); // run constructor jobject dynamicProxy = env->CallObjectMethod(method, constructor_newInstance, methodArgs); - if(env->ExceptionCheck()) { + if (env->ExceptionCheck()) { std::ostringstream errStr; errStr << "Error creating class"; return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); } jclass dynamicInterface = javaFindClass(env, interfaceName); - if(dynamicInterface == NULL) { + if (dynamicInterface == NULL) { std::ostringstream errStr; errStr << "Could not find interface "; errStr << interfaceName; @@ -536,7 +553,7 @@ NAN_METHOD(Java::newProxy) { } jclass classClazz = env->FindClass("java/lang/Class"); jobjectArray classArray = env->NewObjectArray(1, classClazz, NULL); - if(classArray == NULL) { + if (classArray == NULL) { std::ostringstream errStr; errStr << "Could not create class array for Proxy"; return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -547,7 +564,7 @@ NAN_METHOD(Java::newProxy) { jobject classLoader = env->CallObjectMethod(dynamicInterface, class_getClassLoader); assertNoException(env); - if(classLoader == NULL) { + if (classLoader == NULL) { jclass objectClazz = env->FindClass("java/lang/Object"); jmethodID object_getClass = env->GetMethodID(objectClazz, "getClass", "()Ljava/lang/Class;"); jobject jobjClass = env->CallObjectMethod(dynamicProxy, object_getClass); @@ -555,7 +572,7 @@ NAN_METHOD(Java::newProxy) { classLoader = env->CallObjectMethod(jobjClass, class_getClassLoader); checkJavaException(env); } - if(classLoader == NULL) { + if (classLoader == NULL) { std::ostringstream errStr; errStr << "Could not get classloader for Proxy"; return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -563,9 +580,12 @@ NAN_METHOD(Java::newProxy) { // create proxy instance jclass proxyClass = env->FindClass("java/lang/reflect/Proxy"); - jmethodID proxy_newProxyInstance = env->GetStaticMethodID(proxyClass, "newProxyInstance", "(Ljava/lang/ClassLoader;[Ljava/lang/Class;Ljava/lang/reflect/InvocationHandler;)Ljava/lang/Object;"); - jobject proxyInstance = env->CallStaticObjectMethod(proxyClass, proxy_newProxyInstance, classLoader, classArray, dynamicProxy); - if(env->ExceptionCheck()) { + jmethodID proxy_newProxyInstance = env->GetStaticMethodID( + proxyClass, "newProxyInstance", + "(Ljava/lang/ClassLoader;[Ljava/lang/Class;Ljava/lang/reflect/InvocationHandler;)Ljava/lang/Object;"); + jobject proxyInstance = + env->CallStaticObjectMethod(proxyClass, proxy_newProxyInstance, classLoader, classArray, dynamicProxy); + if (env->ExceptionCheck()) { std::ostringstream errStr; errStr << "Error creating java.lang.reflect.Proxy"; return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -579,13 +599,13 @@ NAN_METHOD(Java::newProxy) { NAN_METHOD(Java::callStaticMethod) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -598,7 +618,7 @@ NAN_METHOD(Java::callStaticMethod) { // find class jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { EXCEPTION_CALL_CALLBACK(self, "Could not create class " << className.c_str()); info.GetReturnValue().SetUndefined(); return; @@ -607,7 +627,7 @@ NAN_METHOD(Java::callStaticMethod) { // find method jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindMethod(env, clazz, methodName, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd); EXCEPTION_CALL_CALLBACK(self, msg); info.GetReturnValue().SetUndefined(); @@ -615,21 +635,22 @@ NAN_METHOD(Java::callStaticMethod) { } // run - StaticMethodCallBaton* baton = new StaticMethodCallBaton(self, clazz, method, methodArgs, callback); + StaticMethodCallBaton *baton = new StaticMethodCallBaton(self, clazz, method, methodArgs, callback); baton->run(); - END_CALLBACK_FUNCTION("\"Static method '" << methodName << "' called without a callback did you mean to use the Sync version?\""); + END_CALLBACK_FUNCTION("\"Static method '" << methodName + << "' called without a callback did you mean to use the Sync version?\""); } NAN_METHOD(Java::callStaticMethodSync) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -641,7 +662,7 @@ NAN_METHOD(Java::callStaticMethodSync) { // find class jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { std::ostringstream errStr; errStr << "Could not create class " << className.c_str(); return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -650,17 +671,17 @@ NAN_METHOD(Java::callStaticMethodSync) { // find method jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindMethod(env, clazz, methodName, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd); return Nan::ThrowError(javaExceptionToV8(self, env, msg)); } // run v8::Local callback = Nan::Null(); - StaticMethodCallBaton* baton = new StaticMethodCallBaton(self, clazz, method, methodArgs, callback); + StaticMethodCallBaton *baton = new StaticMethodCallBaton(self, clazz, method, methodArgs, callback); v8::Local result = baton->runSync(); delete baton; - if(result->IsNativeError()) { + if (result->IsNativeError()) { Nan::ThrowError(result); return; } @@ -669,13 +690,13 @@ NAN_METHOD(Java::callStaticMethodSync) { NAN_METHOD(Java::callMethodSync) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -685,23 +706,23 @@ NAN_METHOD(Java::callMethodSync) { ARGS_FRONT_OBJECT(instanceObj); ARGS_FRONT_STRING(methodName); - JavaObject* javaObj = Nan::ObjectWrap::Unwrap(instanceObj); + JavaObject *javaObj = Nan::ObjectWrap::Unwrap(instanceObj); // find method jclass clazz = javaObj->getClass(); jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindMethod(env, clazz, methodName, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd); return Nan::ThrowError(javaExceptionToV8(self, env, msg)); } // run v8::Local callback = Nan::Null(); - InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self, javaObj, method, methodArgs, callback); + InstanceMethodCallBaton *baton = new InstanceMethodCallBaton(self, javaObj, method, methodArgs, callback); v8::Local result = baton->runSync(); delete baton; - if(result->IsNativeError()) { + if (result->IsNativeError()) { return Nan::ThrowError(result); } info.GetReturnValue().Set(result); @@ -709,13 +730,13 @@ NAN_METHOD(Java::callMethodSync) { NAN_METHOD(Java::callMethod) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -726,13 +747,13 @@ NAN_METHOD(Java::callMethod) { ARGS_FRONT_STRING(methodName); ARGS_BACK_CALLBACK(); - JavaObject* javaObj = Nan::ObjectWrap::Unwrap(instanceObj); + JavaObject *javaObj = Nan::ObjectWrap::Unwrap(instanceObj); // find method jclass clazz = javaObj->getClass(); jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindMethod(env, clazz, methodName, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd); EXCEPTION_CALL_CALLBACK(self, msg); info.GetReturnValue().SetUndefined(); @@ -740,21 +761,22 @@ NAN_METHOD(Java::callMethod) { } // run - InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self, javaObj, method, methodArgs, callback); + InstanceMethodCallBaton *baton = new InstanceMethodCallBaton(self, javaObj, method, methodArgs, callback); baton->run(); - END_CALLBACK_FUNCTION("\"method '" << methodName << "' called without a callback did you mean to use the Sync version?\""); + END_CALLBACK_FUNCTION("\"method '" << methodName + << "' called without a callback did you mean to use the Sync version?\""); } NAN_METHOD(Java::findClassSync) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -764,7 +786,7 @@ NAN_METHOD(Java::findClassSync) { // find class jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { std::ostringstream errStr; errStr << "Could not create class " << className.c_str(); return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -777,13 +799,13 @@ NAN_METHOD(Java::findClassSync) { NAN_METHOD(Java::newArray) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -792,18 +814,18 @@ NAN_METHOD(Java::newArray) { ARGS_FRONT_CLASSNAME(); // argument - array - if(info.Length() < argsStart+1 || !info[argsStart]->IsArray()) { + if (info.Length() < argsStart + 1 || !info[argsStart]->IsArray()) { std::ostringstream errStr; - errStr << "Argument " << (argsStart+1) << " must be an array"; + errStr << "Argument " << (argsStart + 1) << " must be an array"; return Nan::ThrowError(Nan::TypeError(errStr.str().c_str())); } v8::Local arrayObj = v8::Local::Cast(info[argsStart]); // find class and method jarray results; - if(strcmp(className.c_str(), "byte") == 0) { + if (strcmp(className.c_str(), "byte") == 0) { results = env->NewByteArray(arrayObj->Length()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); jclass byteClazz = env->FindClass("java/lang/Byte"); @@ -815,9 +837,9 @@ NAN_METHOD(Java::newArray) { } } - else if(strcmp(className.c_str(), "char") == 0) { + else if (strcmp(className.c_str(), "char") == 0) { results = env->NewCharArray(arrayObj->Length()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); jclass stringClazz = env->FindClass("java/lang/String"); @@ -829,9 +851,9 @@ NAN_METHOD(Java::newArray) { } } - else if(strcmp(className.c_str(), "short") == 0) { + else if (strcmp(className.c_str(), "short") == 0) { results = env->NewShortArray(arrayObj->Length()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); jclass shortClazz = env->FindClass("java/lang/Short"); @@ -843,9 +865,9 @@ NAN_METHOD(Java::newArray) { } } - else if(strcmp(className.c_str(), "double") == 0) { + else if (strcmp(className.c_str(), "double") == 0) { results = env->NewDoubleArray(arrayObj->Length()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); jclass doubleClazz = env->FindClass("java/lang/Double"); @@ -857,9 +879,9 @@ NAN_METHOD(Java::newArray) { } } - else if(strcmp(className.c_str(), "int") == 0) { + else if (strcmp(className.c_str(), "int") == 0) { results = env->NewIntArray(arrayObj->Length()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); jclass integerClazz = env->FindClass("java/lang/Integer"); @@ -871,9 +893,9 @@ NAN_METHOD(Java::newArray) { } } - else if(strcmp(className.c_str(), "float") == 0) { + else if (strcmp(className.c_str(), "float") == 0) { results = env->NewFloatArray(arrayObj->Length()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); jclass floatClazz = env->FindClass("java/lang/Float"); @@ -885,9 +907,9 @@ NAN_METHOD(Java::newArray) { } } - else if(strcmp(className.c_str(), "boolean") == 0) { + else if (strcmp(className.c_str(), "boolean") == 0) { results = env->NewBooleanArray(arrayObj->Length()); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); jclass booleanClazz = env->FindClass("java/lang/Boolean"); @@ -899,10 +921,9 @@ NAN_METHOD(Java::newArray) { } } - else - { + else { jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { std::ostringstream errStr; errStr << "Could not create class " << className.c_str(); return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -911,11 +932,11 @@ NAN_METHOD(Java::newArray) { // create array results = env->NewObjectArray(arrayObj->Length(), clazz, NULL); - for(uint32_t i=0; iLength(); i++) { + for (uint32_t i = 0; i < arrayObj->Length(); i++) { v8::Local item = arrayObj->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); jobject val = v8ToJava(env, item); env->SetObjectArrayElement((jobjectArray)results, i, val); - if(env->ExceptionOccurred()) { + if (env->ExceptionOccurred()) { std::ostringstream errStr; Nan::Utf8String valStr(item); errStr << "Could not add item \"" << *valStr << "\" to array."; @@ -929,21 +950,21 @@ NAN_METHOD(Java::newArray) { NAN_METHOD(Java::newByte) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); - if(info.Length() != 1) { + if (info.Length() != 1) { return Nan::ThrowError(Nan::TypeError("newByte only takes 1 argument")); } // argument - value - if(!info[0]->IsNumber()) { + if (!info[0]->IsNumber()) { return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number")); } @@ -959,21 +980,21 @@ NAN_METHOD(Java::newByte) { NAN_METHOD(Java::newShort) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); - if(info.Length() != 1) { + if (info.Length() != 1) { return Nan::ThrowError(Nan::TypeError("newShort only takes 1 argument")); } // argument - value - if(!info[0]->IsNumber()) { + if (!info[0]->IsNumber()) { return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number")); } @@ -988,21 +1009,21 @@ NAN_METHOD(Java::newShort) { NAN_METHOD(Java::newLong) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); - if(info.Length() != 1) { + if (info.Length() != 1) { return Nan::ThrowError(Nan::TypeError("newLong only takes 1 argument")); } // argument - value - if(!info[0]->IsNumber()) { + if (!info[0]->IsNumber()) { return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number")); } @@ -1017,26 +1038,26 @@ NAN_METHOD(Java::newLong) { NAN_METHOD(Java::newChar) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); - if(info.Length() != 1) { + if (info.Length() != 1) { return Nan::ThrowError(Nan::TypeError("newChar only takes 1 argument")); } // argument - value jchar charVal; - if(info[0]->IsNumber()) { + if (info[0]->IsNumber()) { charVal = (jchar)Nan::To(info[0]).FromJust(); - } else if(info[0]->IsString()) { + } else if (info[0]->IsString()) { v8::Local val = info[0]->ToString(Nan::GetCurrentContext()).ToLocalChecked(); - if(val->Length() != 1) { + if (val->Length() != 1) { return Nan::ThrowError(Nan::TypeError("Argument 1 must be a string of 1 character.")); } std::string strVal = std::string(*Nan::Utf8String(val)); @@ -1054,18 +1075,18 @@ NAN_METHOD(Java::newChar) { NAN_METHOD(Java::newFloat) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); - if(info.Length() != 1) { + if (info.Length() != 1) { return Nan::ThrowError(Nan::TypeError("newFloat only takes 1 argument")); - } else if(!info[0]->IsNumber()) { + } else if (!info[0]->IsNumber()) { return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number")); } jfloat val = (jfloat)Nan::To(info[0]).FromJust(); @@ -1079,18 +1100,18 @@ NAN_METHOD(Java::newFloat) { NAN_METHOD(Java::newDouble) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); - if(info.Length() != 1) { + if (info.Length() != 1) { return Nan::ThrowError(Nan::TypeError("newDouble only takes 1 argument")); - } else if(!info[0]->IsNumber()) { + } else if (!info[0]->IsNumber()) { return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number")); } @@ -1105,13 +1126,13 @@ NAN_METHOD(Java::newDouble) { NAN_METHOD(Java::getStaticFieldValue) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -1122,7 +1143,7 @@ NAN_METHOD(Java::getStaticFieldValue) { // find the class jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { std::ostringstream errStr; errStr << "Could not create class " << className.c_str(); return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -1130,7 +1151,7 @@ NAN_METHOD(Java::getStaticFieldValue) { // get the field jobject field = javaFindField(env, clazz, fieldName); - if(field == NULL) { + if (field == NULL) { std::ostringstream errStr; errStr << "Could not find field \"" << fieldName.c_str() << "\" on class \"" << className.c_str() << "\""; return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -1141,7 +1162,7 @@ NAN_METHOD(Java::getStaticFieldValue) { // get field value jobject val = env->CallObjectMethod(field, field_get, NULL); - if(env->ExceptionOccurred()) { + if (env->ExceptionOccurred()) { std::ostringstream errStr; errStr << "Could not get field " << fieldName.c_str() << " on class " << className.c_str(); return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -1152,13 +1173,13 @@ NAN_METHOD(Java::getStaticFieldValue) { NAN_METHOD(Java::setStaticFieldValue) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -1168,9 +1189,9 @@ NAN_METHOD(Java::setStaticFieldValue) { ARGS_FRONT_STRING(fieldName); // argument - new value - if(info.Length() < argsStart+1) { + if (info.Length() < argsStart + 1) { std::ostringstream errStr; - errStr << "setStaticFieldValue requires " << (argsStart+1) << " arguments"; + errStr << "setStaticFieldValue requires " << (argsStart + 1) << " arguments"; Nan::ThrowError(Nan::TypeError(errStr.str().c_str())); return; } @@ -1179,7 +1200,7 @@ NAN_METHOD(Java::setStaticFieldValue) { // find the class jclass clazz = javaFindClass(env, className); - if(clazz == NULL) { + if (clazz == NULL) { std::ostringstream errStr; errStr << "Could not create class " << className.c_str(); Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -1188,7 +1209,7 @@ NAN_METHOD(Java::setStaticFieldValue) { // get the field jobject field = javaFindField(env, clazz, fieldName); - if(field == NULL) { + if (field == NULL) { std::ostringstream errStr; errStr << "Could not find field \"" << fieldName.c_str() << "\" on class \"" << className.c_str() << "\""; Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -1198,11 +1219,11 @@ NAN_METHOD(Java::setStaticFieldValue) { jclass fieldClazz = env->FindClass("java/lang/reflect/Field"); jmethodID field_set = env->GetMethodID(fieldClazz, "set", "(Ljava/lang/Object;Ljava/lang/Object;)V"); - //printf("newValue: %s\n", javaObjectToString(env, newValue).c_str()); + // printf("newValue: %s\n", javaObjectToString(env, newValue).c_str()); // set field value env->CallObjectMethod(field, field_set, NULL, newValue); - if(env->ExceptionOccurred()) { + if (env->ExceptionOccurred()) { std::ostringstream errStr; errStr << "Could not set field " << fieldName.c_str() << " on class " << className.c_str(); Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -1214,13 +1235,13 @@ NAN_METHOD(Java::setStaticFieldValue) { NAN_METHOD(Java::instanceOf) { Nan::HandleScope scope; - Java* self = Nan::ObjectWrap::Unwrap(info.This()); + Java *self = Nan::ObjectWrap::Unwrap(info.This()); v8::Local ensureJvmResults = self->ensureJvm(); - if(!ensureJvmResults->IsNull()) { + if (!ensureJvmResults->IsNull()) { info.GetReturnValue().Set(ensureJvmResults); return; } - JNIEnv* env = self->getJavaEnv(); + JNIEnv *env = self->getJavaEnv(); JavaScope javaScope(env); int argsStart = 0; @@ -1235,7 +1256,7 @@ NAN_METHOD(Java::instanceOf) { } jclass clazz = javaFindClass(env, className); - if(!clazz) { + if (!clazz) { std::ostringstream errStr; errStr << "Could not find class " << className.c_str(); Nan::ThrowError(javaExceptionToV8(self, env, errStr.str())); @@ -1252,25 +1273,24 @@ NAN_METHOD(Java::stop) { } } -template -std::string to_string(T value) { +template std::string to_string(T value) { std::ostringstream os; os << value; return os.str(); } void EIO_CallJs(DynamicProxyJsCallData *callData) { - DynamicProxyData* dynamicProxyData = callData->dynamicProxyData; + DynamicProxyData *dynamicProxyData = callData->dynamicProxyData; assert(callData->done == 0); - if(!dynamicProxyDataVerify(dynamicProxyData)) { + if (!dynamicProxyDataVerify(dynamicProxyData)) { return; } callData->result = NULL; - JNIEnv* env; - int ret = dynamicProxyData->java->getJvm()->GetEnv((void**)&env, JNI_BEST_VERSION); + JNIEnv *env; + int ret = dynamicProxyData->java->getJvm()->GetEnv((void **)&env, JNI_BEST_VERSION); if (ret != JNI_OK) { callData->throwableClass = "java/lang/IllegalStateException"; callData->throwableMessage = "Could not retrieve JNIEnv: jvm->GetEnv returned " + to_string(ret); @@ -1279,23 +1299,26 @@ void EIO_CallJs(DynamicProxyJsCallData *callData) { } Nan::HandleScope scope; - v8::Array* v8Args; + v8::Array *v8Args; v8::Local fn; - v8::Local* argv; + v8::Local *argv; int argc; int i; v8::Local v8Result; jobject javaResult; v8::Local dynamicProxyDataFunctions = Nan::New(dynamicProxyData->functions); - v8::Local fnObj = dynamicProxyDataFunctions->Get(Nan::GetCurrentContext(), Nan::New(callData->methodName.c_str()).ToLocalChecked()).ToLocalChecked(); - if(fnObj->IsUndefined() || fnObj->IsNull()) { + v8::Local fnObj = + dynamicProxyDataFunctions + ->Get(Nan::GetCurrentContext(), Nan::New(callData->methodName.c_str()).ToLocalChecked()) + .ToLocalChecked(); + if (fnObj->IsUndefined() || fnObj->IsNull()) { callData->throwableClass = "java/lang/NoSuchMethodError"; callData->throwableMessage = "Could not find js function " + callData->methodName; callData->done = DYNAMIC_PROXY_JS_ERROR; return; } - if(!fnObj->IsFunction()) { + if (!fnObj->IsFunction()) { callData->throwableClass = "java/lang/IllegalStateException"; callData->throwableMessage = callData->methodName + " is not a function"; callData->done = DYNAMIC_PROXY_JS_ERROR; @@ -1304,14 +1327,14 @@ void EIO_CallJs(DynamicProxyJsCallData *callData) { fn = fnObj.As(); - if(callData->args) { + if (callData->args) { v8Args = v8::Array::Cast(*javaArrayToV8(dynamicProxyData->java, env, callData->args)); argc = v8Args->Length(); } else { argc = 0; } argv = new v8::Local[argc]; - for(i=0; iGet(Nan::GetCurrentContext(), i).ToLocalChecked(); } @@ -1328,12 +1351,12 @@ void EIO_CallJs(DynamicProxyJsCallData *callData) { return; } - if(!dynamicProxyDataVerify(dynamicProxyData)) { + if (!dynamicProxyDataVerify(dynamicProxyData)) { return; } javaResult = v8ToJava(env, v8Result); - if(javaResult == NULL) { + if (javaResult == NULL) { callData->result = NULL; } else { callData->result = env->NewGlobalRef(javaResult); @@ -1342,7 +1365,7 @@ void EIO_CallJs(DynamicProxyJsCallData *callData) { callData->done = true; } -void throwNewThrowable(JNIEnv* env, const char * excClassName, std::string msg) { +void throwNewThrowable(JNIEnv *env, const char *excClassName, std::string msg) { jclass newExcCls = env->FindClass(excClassName); jthrowable throwable = env->ExceptionOccurred(); if (throwable != NULL) { @@ -1351,12 +1374,13 @@ void throwNewThrowable(JNIEnv* env, const char * excClassName, std::string msg) env->ThrowNew(newExcCls, msg.c_str()); } -JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jobject src, jlong ptr, jobject method, jobjectArray args) { +JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jobject src, jlong ptr, jobject method, + jobjectArray args) { threadId myThreadId = my_getThreadId(); bool hasArgsGlobalRef = false; - DynamicProxyData* dynamicProxyData = (DynamicProxyData*)ptr; + DynamicProxyData *dynamicProxyData = (DynamicProxyData *)ptr; // args needs to be global, you can't send env across thread boundaries DynamicProxyJsCallData callData; @@ -1372,12 +1396,12 @@ JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jo callData.methodName = javaObjectToString(env, env->CallObjectMethod(method, method_getName)); assertNoException(env); - if(v8ThreadIdEquals(myThreadId, v8ThreadId)) { + if (v8ThreadIdEquals(myThreadId, v8ThreadId)) { EIO_CallJs(&callData); } else { if (args) { // if args is not null and we have to kick this across the thread boundary, make it a global ref - callData.args = (jobjectArray) env->NewGlobalRef(args); + callData.args = (jobjectArray)env->NewGlobalRef(args); hasArgsGlobalRef = true; } @@ -1386,15 +1410,15 @@ JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jo uv_mutex_unlock(&uvMutex_dynamicProxyJsCall); uv_async_send(&uvAsync_dynamicProxyJsCall); - while(!callData.done) { + while (!callData.done) { my_sleep(100); } } - if(!dynamicProxyDataVerify(dynamicProxyData)) { + if (!dynamicProxyDataVerify(dynamicProxyData)) { throwNewThrowable(env, "java/lang/IllegalStateException", "dynamicProxyData was corrupted"); } - if(hasArgsGlobalRef) { + if (hasArgsGlobalRef) { env->DeleteGlobalRef(callData.args); } @@ -1403,7 +1427,7 @@ JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jo } jobject result = NULL; - if(callData.result) { + if (callData.result) { // need to retain a local ref so that we can return it, otherwise the returned object gets corrupted result = env->NewLocalRef(callData.result); env->DeleteGlobalRef(callData.result); @@ -1412,6 +1436,6 @@ JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jo } JNIEXPORT void JNICALL Java_node_NodeDynamicProxyClass_unref(JNIEnv *env, jobject src, jlong ptr) { - DynamicProxyData* dynamicProxyData = (DynamicProxyData*)ptr; + DynamicProxyData *dynamicProxyData = (DynamicProxyData *)ptr; unref(dynamicProxyData); } diff --git a/src/java.h b/src/java.h index f3a0bc9d..83c5cfcd 100644 --- a/src/java.h +++ b/src/java.h @@ -2,11 +2,11 @@ #ifndef _node_java_h_ #define _node_java_h_ -#include -#include #include -#include #include +#include +#include +#include #ifdef JNI_VERSION_1_8 #define JNI_BEST_VERSION JNI_VERSION_1_8 @@ -17,8 +17,10 @@ class Java : public Nan::ObjectWrap { public: static void Init(v8::Local target); - JavaVM* getJvm() { return m_jvm; } - JNIEnv* getJavaEnv() { return m_env; } // can only be used safely by the main thread as this is the thread it belongs to + JavaVM *getJvm() { return m_jvm; } + JNIEnv *getJavaEnv() { + return m_env; + } // can only be used safely by the main thread as this is the thread it belongs to jobject getClassLoader() { return m_classLoader; } public: @@ -32,9 +34,9 @@ class Java : public Nan::ObjectWrap { private: Java(); ~Java(); - v8::Local createJVM(JavaVM** jvm, JNIEnv** env); - void destroyJVM(JavaVM** jvm, JNIEnv** env); - void configureAsync(v8::Local& asyncOptions); + v8::Local createJVM(JavaVM **jvm, JNIEnv **env); + void destroyJVM(JavaVM **jvm, JNIEnv **env); + void configureAsync(v8::Local &asyncOptions); static NAN_METHOD(New); static NAN_METHOD(getClassLoader); @@ -62,8 +64,8 @@ class Java : public Nan::ObjectWrap { v8::Local ensureJvm(); static Nan::Persistent s_ct; - JavaVM* m_jvm; - JNIEnv* m_env; // can only be used safely by the main thread as this is the thread it belongs to + JavaVM *m_jvm; + JNIEnv *m_env; // can only be used safely by the main thread as this is the thread it belongs to jobject m_classLoader; std::string m_classPath; static std::string s_nativeBindingLocation; diff --git a/src/javaObject.cpp b/src/javaObject.cpp index 338a86f5..d9384264 100644 --- a/src/javaObject.cpp +++ b/src/javaObject.cpp @@ -2,13 +2,12 @@ #include "java.h" #include "javaScope.h" #include "utils.h" -#include #include +#include -/*static*/ std::map*> JavaObject::sFunctionTemplates; +/*static*/ std::map *> JavaObject::sFunctionTemplates; -/*static*/ void JavaObject::Init(v8::Local target) { -} +/*static*/ void JavaObject::Init(v8::Local target) {} /*static*/ v8::Local JavaObject::New(Java *java, jobject obj) { Nan::EscapableHandleScope scope; @@ -28,18 +27,24 @@ className = "nodeJava_" + className; v8::Local promisify; - if(java->DoPromise()) { - v8::Local asyncOptions = java->handle()->Get(Nan::GetCurrentContext(), Nan::New("asyncOptions").ToLocalChecked()).ToLocalChecked().As(); - v8::Local promisifyValue = asyncOptions->Get(Nan::GetCurrentContext(), Nan::New("promisify").ToLocalChecked()).ToLocalChecked(); + if (java->DoPromise()) { + v8::Local asyncOptions = + java->handle() + ->Get(Nan::GetCurrentContext(), Nan::New("asyncOptions").ToLocalChecked()) + .ToLocalChecked() + .As(); + v8::Local promisifyValue = + asyncOptions->Get(Nan::GetCurrentContext(), Nan::New("promisify").ToLocalChecked()) + .ToLocalChecked(); promisify = promisifyValue.As(); } v8::Local funcTemplate; - if(sFunctionTemplates.find(className) != sFunctionTemplates.end()) { - //printf("existing className: %s\n", className.c_str()); + if (sFunctionTemplates.find(className) != sFunctionTemplates.end()) { + // printf("existing className: %s\n", className.c_str()); funcTemplate = Nan::New(*sFunctionTemplates[className]); } else { - //printf("create className: %s\n", className.c_str()); + // printf("create className: %s\n", className.c_str()); funcTemplate = Nan::New(); funcTemplate->InstanceTemplate()->SetInternalFieldCount(1); @@ -50,7 +55,7 @@ javaReflectionGetMethods(env, objClazz, &methods, false); jclass methodClazz = env->FindClass("java/lang/reflect/Method"); jmethodID method_getName = env->GetMethodID(methodClazz, "getName", "()Ljava/lang/String;"); - for(std::list::iterator it = methods.begin(); it != methods.end(); ++it) { + for (std::list::iterator it = methods.begin(); it != methods.end(); ++it) { jstring methodNameJava = (jstring)env->CallObjectMethod(*it, method_getName); assertNoException(env); std::string methodNameStr = javaToString(env, methodNameJava); @@ -58,27 +63,29 @@ v8::Local baseMethodName = Nan::New(methodNameStr.c_str()).ToLocalChecked(); std::string methodNameAsyncStr = methodNameStr; - const char* methodNameAsync = methodNameAsyncStr.append(java->AsyncSuffix()).c_str(); + const char *methodNameAsync = methodNameAsyncStr.append(java->AsyncSuffix()).c_str(); v8::Local methodCallTemplate = Nan::New(methodCall, baseMethodName); Nan::SetPrototypeTemplate(funcTemplate, methodNameAsync, methodCallTemplate); std::string methodNameSyncStr = methodNameStr; - const char* methodNameSync = methodNameSyncStr.append(java->SyncSuffix()).c_str(); - v8::Local methodCallSyncTemplate = Nan::New(methodCallSync, baseMethodName); + const char *methodNameSync = methodNameSyncStr.append(java->SyncSuffix()).c_str(); + v8::Local methodCallSyncTemplate = + Nan::New(methodCallSync, baseMethodName); Nan::SetPrototypeTemplate(funcTemplate, methodNameSync, methodCallSyncTemplate); if (java->DoPromise()) { v8::Local recv = Nan::New(); - v8::Local argv[] = { methodCallTemplate->GetFunction(Nan::GetCurrentContext()).ToLocalChecked() }; + v8::Local argv[] = {methodCallTemplate->GetFunction(Nan::GetCurrentContext()).ToLocalChecked()}; v8::Local result = Nan::Call(promisify, recv, 1, argv).FromMaybe(v8::Local()); if (!result->IsFunction()) { fprintf(stderr, "Promisified result is not a function -- asyncOptions.promisify must return a function.\n"); assert(result->IsFunction()); } v8::Local promFunction = result.As(); - v8::Local promFunctionTemplate = Nan::New(methodCallPromise, promFunction); + v8::Local promFunctionTemplate = + Nan::New(methodCallPromise, promFunction); std::string methodNamePromiseStr = methodNameStr; - const char* methodNamePromise = methodNamePromiseStr.append(java->PromiseSuffix()).c_str(); + const char *methodNamePromise = methodNamePromiseStr.append(java->PromiseSuffix()).c_str(); Nan::SetPrototypeTemplate(funcTemplate, methodNamePromise, promFunctionTemplate); } } @@ -88,7 +95,7 @@ javaReflectionGetFields(env, objClazz, &fields); jclass fieldClazz = env->FindClass("java/lang/reflect/Field"); jmethodID field_getName = env->GetMethodID(fieldClazz, "getName", "()Ljava/lang/String;"); - for(std::list::iterator it = fields.begin(); it != fields.end(); ++it) { + for (std::list::iterator it = fields.begin(); it != fields.end(); ++it) { jstring fieldNameJava = (jstring)env->CallObjectMethod(*it, field_getName); checkJavaException(env); std::string fieldNameStr = javaToString(env, fieldNameJava); @@ -100,21 +107,22 @@ // copy array methods to template jmethodID class_isArray = env->GetMethodID(classClazz, "isArray", "()Z"); jboolean isArray = env->CallBooleanMethod(objClazz, class_isArray); - if(isArray) { + if (isArray) { v8::Local fieldName = Nan::New("length").ToLocalChecked(); Nan::SetAccessor(funcTemplate->InstanceTemplate(), fieldName, fieldGetter, NULL); Nan::SetIndexedPropertyHandler(funcTemplate->InstanceTemplate(), indexGetter); } - Nan::Persistent* persistentFuncTemplate = new Nan::Persistent(); + Nan::Persistent *persistentFuncTemplate = new Nan::Persistent(); persistentFuncTemplate->Reset(funcTemplate); sFunctionTemplates[className] = persistentFuncTemplate; } v8::Local ctor = Nan::GetFunction(funcTemplate).ToLocalChecked(); v8::Local javaObjectObj = Nan::NewInstance(ctor).ToLocalChecked(); - SetHiddenValue(javaObjectObj, Nan::New(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), Nan::New(true)); + SetHiddenValue(javaObjectObj, Nan::New(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), + Nan::New(true)); JavaObject *self = new JavaObject(java, obj); self->Wrap(javaObjectObj); @@ -136,7 +144,7 @@ JavaObject::~JavaObject() { NAN_METHOD(JavaObject::methodCall) { Nan::HandleScope scope; - JavaObject* self = Nan::ObjectWrap::Unwrap(info.This()); + JavaObject *self = Nan::ObjectWrap::Unwrap(info.This()); JNIEnv *env = self->m_java->getJavaEnv(); JavaScope javaScope(env); @@ -149,14 +157,14 @@ NAN_METHOD(JavaObject::methodCall) { // arguments ARGS_BACK_CALLBACK(); - if(!callbackProvided && methodNameStr == "toString") { + if (!callbackProvided && methodNameStr == "toString") { return methodCallSync(info); } jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindMethod(env, self->m_class, methodNameStr, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, info, argsStart, argsEnd); EXCEPTION_CALL_CALLBACK(self->m_java, msg); info.GetReturnValue().SetUndefined(); @@ -164,15 +172,16 @@ NAN_METHOD(JavaObject::methodCall) { } // run - InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback); + InstanceMethodCallBaton *baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback); baton->run(); - END_CALLBACK_FUNCTION("\"Method '" << methodNameStr << "' called without a callback did you mean to use the Sync version?\""); + END_CALLBACK_FUNCTION("\"Method '" << methodNameStr + << "' called without a callback did you mean to use the Sync version?\""); } NAN_METHOD(JavaObject::methodCallSync) { Nan::HandleScope scope; - JavaObject* self = Nan::ObjectWrap::Unwrap(info.This()); + JavaObject *self = Nan::ObjectWrap::Unwrap(info.This()); JNIEnv *env = self->m_java->getJavaEnv(); JavaScope javaScope(env); @@ -185,7 +194,7 @@ NAN_METHOD(JavaObject::methodCallSync) { jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd); jobject method = javaFindMethod(env, self->m_class, methodNameStr, methodArgs); - if(method == NULL) { + if (method == NULL) { std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, info, argsStart, argsEnd); v8::Local ex = javaExceptionToV8(self->m_java, env, msg); Nan::ThrowError(ex); @@ -194,11 +203,11 @@ NAN_METHOD(JavaObject::methodCallSync) { // run v8::Local callback = Nan::Undefined(); - InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback); + InstanceMethodCallBaton *baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback); v8::Local result = baton->runSync(); delete baton; - if(result->IsNativeError()) { + if (result->IsNativeError()) { Nan::ThrowError(result); return; } @@ -209,15 +218,15 @@ NAN_METHOD(JavaObject::methodCallSync) { NAN_METHOD(JavaObject::methodCallPromise) { Nan::HandleScope scope; v8::Local fn = info.Data().As(); - v8::Local* argv = new v8::Local[info.Length()]; - for (int i = 0 ; i < info.Length(); i++) { + v8::Local *argv = new v8::Local[info.Length()]; + for (int i = 0; i < info.Length(); i++) { argv[i] = info[i]; } - + v8::MaybeLocal result = Nan::Call(fn, info.This(), info.Length(), argv); - + delete[] argv; - + if (!result.IsEmpty()) { info.GetReturnValue().Set(result.ToLocalChecked()); } @@ -225,19 +234,19 @@ NAN_METHOD(JavaObject::methodCallPromise) { NAN_GETTER(JavaObject::fieldGetter) { Nan::HandleScope scope; - JavaObject* self = Nan::ObjectWrap::Unwrap(info.This()); + JavaObject *self = Nan::ObjectWrap::Unwrap(info.This()); JNIEnv *env = self->m_java->getJavaEnv(); JavaScope javaScope(env); Nan::Utf8String propertyCStr(property); std::string propertyStr = *propertyCStr; jobject field = javaFindField(env, self->m_class, propertyStr); - if(field == NULL) { - if(propertyStr == "length") { + if (field == NULL) { + if (propertyStr == "length") { jclass classClazz = env->FindClass("java/lang/Class"); jmethodID class_isArray = env->GetMethodID(classClazz, "isArray", "()Z"); jboolean isArray = env->CallBooleanMethod(self->m_class, class_isArray); - if(isArray) { + if (isArray) { jclass arrayClass = env->FindClass("java/lang/reflect/Array"); jmethodID array_getLength = env->GetStaticMethodID(arrayClass, "getLength", "(Ljava/lang/Object;)I"); jint arrayLength = env->CallStaticIntMethod(arrayClass, array_getLength, self->m_obj); @@ -259,7 +268,7 @@ NAN_GETTER(JavaObject::fieldGetter) { // get field value jobject val = env->CallObjectMethod(field, field_get, self->m_obj); - if(env->ExceptionOccurred()) { + if (env->ExceptionOccurred()) { std::ostringstream errStr; errStr << "Could not get field " << propertyStr; v8::Local ex = javaExceptionToV8(self->m_java, env, errStr.str()); @@ -274,7 +283,7 @@ NAN_GETTER(JavaObject::fieldGetter) { NAN_SETTER(JavaObject::fieldSetter) { Nan::HandleScope scope; - JavaObject* self = Nan::ObjectWrap::Unwrap(info.This()); + JavaObject *self = Nan::ObjectWrap::Unwrap(info.This()); JNIEnv *env = self->m_java->getJavaEnv(); JavaScope javaScope(env); @@ -283,7 +292,7 @@ NAN_SETTER(JavaObject::fieldSetter) { Nan::Utf8String propertyCStr(property); std::string propertyStr = *propertyCStr; jobject field = javaFindField(env, self->m_class, propertyStr); - if(field == NULL) { + if (field == NULL) { std::ostringstream errStr; errStr << "Could not find field \"" << propertyStr << "\" for set"; v8::Local error = javaExceptionToV8(self->m_java, env, errStr.str()); @@ -294,11 +303,11 @@ NAN_SETTER(JavaObject::fieldSetter) { jclass fieldClazz = env->FindClass("java/lang/reflect/Field"); jmethodID field_set = env->GetMethodID(fieldClazz, "set", "(Ljava/lang/Object;Ljava/lang/Object;)V"); - //printf("newValue: %s\n", javaObjectToString(env, newValue).c_str()); + // printf("newValue: %s\n", javaObjectToString(env, newValue).c_str()); // set field value env->CallObjectMethod(field, field_set, self->m_obj, newValue); - if(env->ExceptionOccurred()) { + if (env->ExceptionOccurred()) { std::ostringstream errStr; errStr << "Could not set field " << propertyStr; v8::Local error = javaExceptionToV8(self->m_java, env, errStr.str()); @@ -309,7 +318,7 @@ NAN_SETTER(JavaObject::fieldSetter) { NAN_INDEX_GETTER(JavaObject::indexGetter) { Nan::HandleScope scope; - JavaObject* self = Nan::ObjectWrap::Unwrap(info.This()); + JavaObject *self = Nan::ObjectWrap::Unwrap(info.This()); JNIEnv *env = self->m_java->getJavaEnv(); JavaScope javaScope(env); @@ -344,30 +353,31 @@ NAN_INDEX_GETTER(JavaObject::indexGetter) { Nan::SetAccessor(t->InstanceTemplate(), fieldName, invocationHandlerGetter); } -v8::Local JavaProxyObject::New(Java *java, jobject obj, DynamicProxyData* dynamicProxyData) { +v8::Local JavaProxyObject::New(Java *java, jobject obj, DynamicProxyData *dynamicProxyData) { Nan::EscapableHandleScope scope; v8::Local ctor = Nan::New(s_proxyCt)->GetFunction(Nan::GetCurrentContext()).ToLocalChecked(); v8::Local javaObjectObj = Nan::NewInstance(ctor).ToLocalChecked(); - SetHiddenValue(javaObjectObj, Nan::New(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), Nan::New(true)); + SetHiddenValue(javaObjectObj, Nan::New(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), + Nan::New(true)); JavaProxyObject *self = new JavaProxyObject(java, obj, dynamicProxyData); self->Wrap(javaObjectObj); return scope.Escape(javaObjectObj); } -JavaProxyObject::JavaProxyObject(Java *java, jobject obj, DynamicProxyData* dynamicProxyData) : JavaObject(java, obj) { +JavaProxyObject::JavaProxyObject(Java *java, jobject obj, DynamicProxyData *dynamicProxyData) : JavaObject(java, obj) { m_dynamicProxyData = dynamicProxyData; } JavaProxyObject::~JavaProxyObject() { - if(dynamicProxyDataVerify(m_dynamicProxyData)) { + if (dynamicProxyDataVerify(m_dynamicProxyData)) { unref(m_dynamicProxyData); } } NAN_METHOD(JavaProxyObject::doUnref) { - JavaProxyObject* self = Nan::ObjectWrap::Unwrap(info.This()); + JavaProxyObject *self = Nan::ObjectWrap::Unwrap(info.This()); if (dynamicProxyDataVerify(self->m_dynamicProxyData)) { unref(self->m_dynamicProxyData); } @@ -375,12 +385,12 @@ NAN_METHOD(JavaProxyObject::doUnref) { } NAN_GETTER(JavaProxyObject::invocationHandlerGetter) { - Nan::HandleScope scope; - - JavaProxyObject* self = Nan::ObjectWrap::Unwrap(info.This()); - if (!dynamicProxyDataVerify(self->m_dynamicProxyData)) { - Nan::ThrowError("dynamicProxyData has been destroyed or corrupted"); - return; - } - info.GetReturnValue().Set(Nan::New(self->m_dynamicProxyData->functions)); + Nan::HandleScope scope; + + JavaProxyObject *self = Nan::ObjectWrap::Unwrap(info.This()); + if (!dynamicProxyDataVerify(self->m_dynamicProxyData)) { + Nan::ThrowError("dynamicProxyData has been destroyed or corrupted"); + return; + } + info.GetReturnValue().Set(Nan::New(self->m_dynamicProxyData->functions)); } diff --git a/src/javaObject.h b/src/javaObject.h index 14b5dfd7..b3dc6529 100644 --- a/src/javaObject.h +++ b/src/javaObject.h @@ -2,20 +2,20 @@ #ifndef _javaobject_h_ #define _javaobject_h_ -#include -#include +#include "methodCallBaton.h" #include #include #include -#include "methodCallBaton.h" +#include +#include class Java; class JavaObject : public Nan::ObjectWrap { public: static void Init(v8::Local target); - static v8::Local New(Java* java, jobject obj); - static v8::Local NewProxy(Java* java, jobject obj, DynamicProxyData* dynamicProxyData); + static v8::Local New(Java *java, jobject obj); + static v8::Local NewProxy(Java *java, jobject obj, DynamicProxyData *dynamicProxyData); jobject getObject() { return m_obj; } jclass getClass() { return m_class; } @@ -24,7 +24,7 @@ class JavaObject : public Nan::ObjectWrap { void Unref() { Nan::ObjectWrap::Unref(); } protected: - JavaObject(Java* java, jobject obj); + JavaObject(Java *java, jobject obj); ~JavaObject(); private: @@ -35,8 +35,8 @@ class JavaObject : public Nan::ObjectWrap { static NAN_SETTER(fieldSetter); static NAN_INDEX_GETTER(indexGetter); - static std::map*> sFunctionTemplates; - Java* m_java; + static std::map *> sFunctionTemplates; + Java *m_java; jobject m_obj; jclass m_class; }; @@ -44,17 +44,16 @@ class JavaObject : public Nan::ObjectWrap { class JavaProxyObject : public JavaObject { public: static void init(); - static v8::Local New(Java* java, jobject obj, DynamicProxyData* dynamicProxyData); + static v8::Local New(Java *java, jobject obj, DynamicProxyData *dynamicProxyData); private: - JavaProxyObject(Java* java, jobject obj, DynamicProxyData* dynamicProxyData); + JavaProxyObject(Java *java, jobject obj, DynamicProxyData *dynamicProxyData); ~JavaProxyObject(); static NAN_METHOD(doUnref); static NAN_GETTER(invocationHandlerGetter); static Nan::Persistent s_proxyCt; - DynamicProxyData* m_dynamicProxyData; + DynamicProxyData *m_dynamicProxyData; }; #endif - diff --git a/src/javaScope.cpp b/src/javaScope.cpp index 7074fb64..5c8b46bb 100644 --- a/src/javaScope.cpp +++ b/src/javaScope.cpp @@ -7,9 +7,7 @@ JavaScope::JavaScope(JNIEnv *env) { m_env->PushLocalFrame(LOCAL_FRAME_SIZE); } -JavaScope::~JavaScope() { - m_env->PopLocalFrame(m_result); -} +JavaScope::~JavaScope() { m_env->PopLocalFrame(m_result); } jobject JavaScope::Close(jobject result) { m_result = result; diff --git a/src/methodCallBaton.cpp b/src/methodCallBaton.cpp index c2a10159..7f2d1836 100644 --- a/src/methodCallBaton.cpp +++ b/src/methodCallBaton.cpp @@ -6,15 +6,15 @@ jmethodID MethodCallBaton::m_methodInvokeMethodId = 0; -Nan::Callback* toNanCallback(v8::Local& callback) { - if(callback->IsFunction()) { +Nan::Callback *toNanCallback(v8::Local &callback) { + if (callback->IsFunction()) { return new Nan::Callback(callback.As()); } return NULL; } -MethodCallBaton::MethodCallBaton(Java* java, jobject method, jarray args, v8::Local& callback) : - Nan::AsyncWorker(toNanCallback(callback)) { +MethodCallBaton::MethodCallBaton(Java *java, jobject method, jarray args, v8::Local &callback) + : Nan::AsyncWorker(toNanCallback(callback)) { JNIEnv *env = java->getJavaEnv(); m_java = java; m_args = (jarray)env->NewGlobalRef(args); @@ -26,12 +26,12 @@ MethodCallBaton::MethodCallBaton(Java* java, jobject method, jarray args, v8::Lo MethodCallBaton::~MethodCallBaton() { JNIEnv *env = m_java->getJavaEnv(); - if(m_result) { + if (m_result) { env->DeleteGlobalRef(m_result); m_result = NULL; } - if(m_error) { + if (m_error) { env->DeleteGlobalRef(m_error); m_error = NULL; } @@ -44,26 +44,25 @@ MethodCallBaton::~MethodCallBaton() { } jmethodID MethodCallBaton::getMethodInvokeMethodId(JNIEnv *env) { - if(m_methodInvokeMethodId == 0) { + if (m_methodInvokeMethodId == 0) { jclass methodClazz = env->FindClass("java/lang/reflect/Method"); - m_methodInvokeMethodId = env->GetMethodID(methodClazz, "invoke", "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"); + m_methodInvokeMethodId = + env->GetMethodID(methodClazz, "invoke", "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"); } return m_methodInvokeMethodId; } -void MethodCallBaton::run() { - Nan::AsyncQueueWorker(this); -} +void MethodCallBaton::run() { Nan::AsyncQueueWorker(this); } v8::Local MethodCallBaton::runSync() { - JNIEnv* env = m_java->getJavaEnv(); + JNIEnv *env = m_java->getJavaEnv(); ExecuteInternal(env); return resultsToV8(env); } // called by NanAsyncWorker. This will be on a worker thread void MethodCallBaton::Execute() { - JNIEnv* env = javaGetEnv(this->m_java->getJvm(), this->m_java->getClassLoader()); + JNIEnv *env = javaGetEnv(this->m_java->getJvm(), this->m_java->getClassLoader()); JavaScope javaScope(env); ExecuteInternal(env); } @@ -72,20 +71,15 @@ void MethodCallBaton::Execute() { void MethodCallBaton::WorkComplete() { Nan::HandleScope scope; - if(callback) { - JNIEnv* env = javaGetEnv(this->m_java->getJvm(), this->m_java->getClassLoader()); + if (callback) { + JNIEnv *env = javaGetEnv(this->m_java->getJvm(), this->m_java->getClassLoader()); JavaScope javaScope(env); v8::Local result = resultsToV8(env); if (result->IsNativeError()) { - v8::Local argv[] = { - result - }; + v8::Local argv[] = {result}; callback->Call(1, argv, async_resource); } else { - v8::Local argv[] = { - Nan::Undefined(), - result - }; + v8::Local argv[] = {Nan::Undefined(), result}; callback->Call(2, argv, async_resource); } @@ -97,7 +91,7 @@ void MethodCallBaton::WorkComplete() { v8::Local MethodCallBaton::resultsToV8(JNIEnv *env) { Nan::EscapableHandleScope scope; - if(m_error) { + if (m_error) { jthrowable cause = m_error; // if we've caught an InvocationTargetException exception, @@ -118,14 +112,15 @@ v8::Local MethodCallBaton::resultsToV8(JNIEnv *env) { return scope.Escape(javaToV8(m_java, env, m_result)); } -void NewInstanceBaton::ExecuteInternal(JNIEnv* env) { +void NewInstanceBaton::ExecuteInternal(JNIEnv *env) { jclass batonClazz = env->FindClass("node/MethodCallBaton"); - jmethodID newInstance = env->GetStaticMethodID(batonClazz, "newInstance", "(Ljava/lang/reflect/Constructor;[Ljava/lang/Object;)Ljava/lang/Object;"); + jmethodID newInstance = env->GetStaticMethodID( + batonClazz, "newInstance", "(Ljava/lang/reflect/Constructor;[Ljava/lang/Object;)Ljava/lang/Object;"); jarray args = javaGetArgsForConstructor(env, m_method, m_args); jobject result = env->CallStaticObjectMethod(batonClazz, newInstance, m_method, args); - if(env->ExceptionCheck()) { + if (env->ExceptionCheck()) { jthrowable ex = env->ExceptionOccurred(); env->ExceptionClear(); m_error = (jthrowable)env->NewGlobalRef(ex); @@ -136,7 +131,7 @@ void NewInstanceBaton::ExecuteInternal(JNIEnv* env) { m_result = env->NewGlobalRef(result); } -void StaticMethodCallBaton::ExecuteInternal(JNIEnv* env) { +void StaticMethodCallBaton::ExecuteInternal(JNIEnv *env) { /* printf("calling %s\n", javaObjectToString(env, m_method).c_str()); printf("arguments\n"); @@ -148,12 +143,14 @@ void StaticMethodCallBaton::ExecuteInternal(JNIEnv* env) { */ jclass batonClazz = env->FindClass("node/MethodCallBaton"); - jmethodID invokeMethod = env->GetStaticMethodID(batonClazz, env->GetVersion() >= 0x90000 ? "invokeMethod9" : "invokeMethod", "(Ljava/lang/reflect/Method;Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"); + jmethodID invokeMethod = + env->GetStaticMethodID(batonClazz, env->GetVersion() >= 0x90000 ? "invokeMethod9" : "invokeMethod", + "(Ljava/lang/reflect/Method;Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"); jarray args = javaGetArgsForMethod(env, m_method, m_args); jobject result = env->CallStaticObjectMethod(batonClazz, invokeMethod, m_method, NULL, args); - if(env->ExceptionCheck()) { + if (env->ExceptionCheck()) { jthrowable ex = env->ExceptionOccurred(); env->ExceptionClear(); m_error = (jthrowable)env->NewGlobalRef(ex); @@ -164,7 +161,7 @@ void StaticMethodCallBaton::ExecuteInternal(JNIEnv* env) { m_result = env->NewGlobalRef(result); } -void InstanceMethodCallBaton::ExecuteInternal(JNIEnv* env) { +void InstanceMethodCallBaton::ExecuteInternal(JNIEnv *env) { /* printf("calling %s\n", javaObjectToString(env, m_method).c_str()); printf("arguments\n"); @@ -174,12 +171,14 @@ void InstanceMethodCallBaton::ExecuteInternal(JNIEnv* env) { */ jclass batonClazz = env->FindClass("node/MethodCallBaton"); - jmethodID invokeMethod = env->GetStaticMethodID(batonClazz, env->GetVersion() >= 0x90000 ? "invokeMethod9" : "invokeMethod", "(Ljava/lang/reflect/Method;Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"); + jmethodID invokeMethod = + env->GetStaticMethodID(batonClazz, env->GetVersion() >= 0x90000 ? "invokeMethod9" : "invokeMethod", + "(Ljava/lang/reflect/Method;Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"); jarray args = javaGetArgsForMethod(env, m_method, m_args); jobject result = env->CallStaticObjectMethod(batonClazz, invokeMethod, m_method, m_javaObject->getObject(), args); - if(env->ExceptionCheck()) { + if (env->ExceptionCheck()) { jthrowable ex = env->ExceptionOccurred(); env->ExceptionClear(); m_error = (jthrowable)env->NewGlobalRef(ex); @@ -187,19 +186,16 @@ void InstanceMethodCallBaton::ExecuteInternal(JNIEnv* env) { return; } - if(result == NULL) { + if (result == NULL) { m_result = NULL; } else { m_result = env->NewGlobalRef(result); } } -NewInstanceBaton::NewInstanceBaton( - Java* java, - jclass clazz, - jobject method, - jarray args, - v8::Local& callback) : MethodCallBaton(java, method, args, callback) { +NewInstanceBaton::NewInstanceBaton(Java *java, jclass clazz, jobject method, jarray args, + v8::Local &callback) + : MethodCallBaton(java, method, args, callback) { JNIEnv *env = m_java->getJavaEnv(); m_clazz = (jclass)env->NewGlobalRef(clazz); } @@ -210,12 +206,9 @@ NewInstanceBaton::~NewInstanceBaton() { m_clazz = NULL; } -StaticMethodCallBaton::StaticMethodCallBaton( - Java* java, - jclass clazz, - jobject method, - jarray args, - v8::Local& callback) : MethodCallBaton(java, method, args, callback) { +StaticMethodCallBaton::StaticMethodCallBaton(Java *java, jclass clazz, jobject method, jarray args, + v8::Local &callback) + : MethodCallBaton(java, method, args, callback) { JNIEnv *env = m_java->getJavaEnv(); m_clazz = (jclass)env->NewGlobalRef(clazz); } @@ -226,12 +219,9 @@ StaticMethodCallBaton::~StaticMethodCallBaton() { m_clazz = NULL; } -InstanceMethodCallBaton::InstanceMethodCallBaton( - Java* java, - JavaObject* obj, - jobject method, - jarray args, - v8::Local& callback) : MethodCallBaton(java, method, args, callback) { +InstanceMethodCallBaton::InstanceMethodCallBaton(Java *java, JavaObject *obj, jobject method, jarray args, + v8::Local &callback) + : MethodCallBaton(java, method, args, callback) { m_javaObject = obj; m_javaObject->Ref(); } diff --git a/src/methodCallBaton.h b/src/methodCallBaton.h index 504d00d8..ee4102fa 100644 --- a/src/methodCallBaton.h +++ b/src/methodCallBaton.h @@ -3,18 +3,18 @@ #define _methodcallbaton_h_ #include "utils.h" -#include -#include -#include #include #include +#include +#include +#include class Java; class JavaObject; class MethodCallBaton : public Nan::AsyncWorker { public: - MethodCallBaton(Java* java, jobject method, jarray args, v8::Local& callback); + MethodCallBaton(Java *java, jobject method, jarray args, v8::Local &callback); virtual ~MethodCallBaton(); void run(); @@ -24,10 +24,10 @@ class MethodCallBaton : public Nan::AsyncWorker { v8::Local resultsToV8(JNIEnv *env); virtual void Execute(); virtual void WorkComplete(); - virtual void ExecuteInternal(JNIEnv* env) = 0; + virtual void ExecuteInternal(JNIEnv *env) = 0; static jmethodID getMethodInvokeMethodId(JNIEnv *env); - Java* m_java; + Java *m_java; jthrowable m_error; std::string m_errorString; jarray m_args; @@ -40,33 +40,33 @@ class MethodCallBaton : public Nan::AsyncWorker { class InstanceMethodCallBaton : public MethodCallBaton { public: - InstanceMethodCallBaton(Java* java, JavaObject* obj, jobject method, jarray args, v8::Local& callback); + InstanceMethodCallBaton(Java *java, JavaObject *obj, jobject method, jarray args, v8::Local &callback); virtual ~InstanceMethodCallBaton(); protected: - virtual void ExecuteInternal(JNIEnv* env); + virtual void ExecuteInternal(JNIEnv *env); - JavaObject* m_javaObject; + JavaObject *m_javaObject; }; class NewInstanceBaton : public MethodCallBaton { public: - NewInstanceBaton(Java* java, jclass clazz, jobject method, jarray args, v8::Local& callback); + NewInstanceBaton(Java *java, jclass clazz, jobject method, jarray args, v8::Local &callback); virtual ~NewInstanceBaton(); protected: - virtual void ExecuteInternal(JNIEnv* env); + virtual void ExecuteInternal(JNIEnv *env); jclass m_clazz; }; class StaticMethodCallBaton : public MethodCallBaton { public: - StaticMethodCallBaton(Java* java, jclass clazz, jobject method, jarray args, v8::Local& callback); + StaticMethodCallBaton(Java *java, jclass clazz, jobject method, jarray args, v8::Local &callback); virtual ~StaticMethodCallBaton(); protected: - virtual void ExecuteInternal(JNIEnv* env); + virtual void ExecuteInternal(JNIEnv *env); jclass m_clazz; }; diff --git a/src/nodeJavaBridge.cpp b/src/nodeJavaBridge.cpp index 51124401..55b6bb41 100644 --- a/src/nodeJavaBridge.cpp +++ b/src/nodeJavaBridge.cpp @@ -3,18 +3,16 @@ #include "javaObject.h" extern "C" { - static void init(v8::Local target, v8::Local, void*) { - Java::Init(target); - JavaObject::Init(target); - } +static void init(v8::Local target, v8::Local, void *) { + Java::Init(target); + JavaObject::Init(target); +} - NODE_MODULE(nodejavabridge_bindings, init); +NODE_MODULE(nodejavabridge_bindings, init); } #ifdef WIN32 -BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) { - return TRUE; -} +BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) { return TRUE; } #endif diff --git a/src/node_NodeDynamicProxyClass.h b/src/node_NodeDynamicProxyClass.h index 93b414d2..d201a5d0 100644 --- a/src/node_NodeDynamicProxyClass.h +++ b/src/node_NodeDynamicProxyClass.h @@ -12,16 +12,14 @@ extern "C" { * Method: callJs * Signature: (JLjava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object; */ -JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs - (JNIEnv *, jobject, jlong, jobject, jobjectArray); +JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *, jobject, jlong, jobject, jobjectArray); /* * Class: node_NodeDynamicProxyClass * Method: unref * Signature: (J)V */ -JNIEXPORT void JNICALL Java_node_NodeDynamicProxyClass_unref - (JNIEnv *, jobject, jlong); +JNIEXPORT void JNICALL Java_node_NodeDynamicProxyClass_unref(JNIEnv *, jobject, jlong); #ifdef __cplusplus } diff --git a/src/utils.cpp b/src/utils.cpp index 39c543d3..8b3784c5 100644 --- a/src/utils.cpp +++ b/src/utils.cpp @@ -1,15 +1,15 @@ #include "utils.h" -#include +#include "java.h" +#include "javaObject.h" #include -#include #include -#include "javaObject.h" -#include "java.h" +#include +#include #define MODIFIER_STATIC 9 -jobject v8ToJava_javaObject(JNIEnv* env, v8::Local obj); -jobject v8ToJava_javaLong(JNIEnv* env, v8::Local obj); +jobject v8ToJava_javaObject(JNIEnv *env, v8::Local obj); +jobject v8ToJava_javaLong(JNIEnv *env, v8::Local obj); bool hasSetFailed(Nan::Maybe v) { if (v.IsNothing()) { @@ -18,7 +18,7 @@ bool hasSetFailed(Nan::Maybe v) { return v.ToChecked() == false; } -void javaReflectionGetMethods(JNIEnv *env, jclass clazz, std::list* methods, bool includeStatic) { +void javaReflectionGetMethods(JNIEnv *env, jclass clazz, std::list *methods, bool includeStatic) { jclass clazzclazz = env->FindClass("java/lang/Class"); jmethodID clazz_getMethods = env->GetMethodID(clazzclazz, "getMethods", "()[Ljava/lang/reflect/Method;"); jclass methodClazz = env->FindClass("java/lang/reflect/Method"); @@ -27,31 +27,32 @@ void javaReflectionGetMethods(JNIEnv *env, jclass clazz, std::list* met jobjectArray methodObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getMethods); checkJavaException(env); jsize methodCount = env->GetArrayLength(methodObjects); - for(jsize i=0; iGetObjectArrayElement(methodObjects, i); jint methodModifiers = env->CallIntMethod(method, method_getModifiers); assertNoException(env); - if(!includeStatic && (methodModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) { + if (!includeStatic && (methodModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) { continue; } methods->push_back(method); } } -void javaReflectionGetConstructors(JNIEnv *env, jclass clazz, std::list* methods) { +void javaReflectionGetConstructors(JNIEnv *env, jclass clazz, std::list *methods) { jclass clazzclazz = env->FindClass("java/lang/Class"); - jmethodID clazz_getConstructors = env->GetMethodID(clazzclazz, "getConstructors", "()[Ljava/lang/reflect/Constructor;"); + jmethodID clazz_getConstructors = + env->GetMethodID(clazzclazz, "getConstructors", "()[Ljava/lang/reflect/Constructor;"); jobjectArray constructorObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getConstructors); checkJavaException(env); jsize constructorCount = env->GetArrayLength(constructorObjects); - for(jsize i=0; iGetObjectArrayElement(constructorObjects, i); methods->push_back(constructor); } } -void javaReflectionGetFields(JNIEnv *env, jclass clazz, std::list* fields) { +void javaReflectionGetFields(JNIEnv *env, jclass clazz, std::list *fields) { jclass clazzclazz = env->FindClass("java/lang/Class"); jmethodID clazz_getFields = env->GetMethodID(clazzclazz, "getFields", "()[Ljava/lang/reflect/Field;"); jclass fieldClazz = env->FindClass("java/lang/reflect/Field"); @@ -60,11 +61,11 @@ void javaReflectionGetFields(JNIEnv *env, jclass clazz, std::list* fiel jobjectArray fieldObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getFields); assertNoException(env); jsize fieldCount = env->GetArrayLength(fieldObjects); - for(jsize i=0; iGetObjectArrayElement(fieldObjects, i); jint fieldModifiers = env->CallIntMethod(field, field_getModifiers); checkJavaException(env); - if((fieldModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) { + if ((fieldModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) { continue; } fields->push_back(field); @@ -79,10 +80,10 @@ std::string javaToString(JNIEnv *env, jstring str) { jbyteArray stringJbytes = (jbyteArray)env->CallObjectMethod(str, methodId, charsetName); env->DeleteLocalRef(charsetName); - jbyte* pBytes = env->GetByteArrayElements(stringJbytes, NULL); + jbyte *pBytes = env->GetByteArrayElements(stringJbytes, NULL); const jsize length = env->GetArrayLength(stringJbytes); - std::string results((const char*)pBytes, length); + std::string results((const char *)pBytes, length); env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT); env->DeleteLocalRef(stringJbytes); @@ -91,15 +92,15 @@ std::string javaToString(JNIEnv *env, jstring str) { } std::string javaArrayToString(JNIEnv *env, jobjectArray arr) { - if(arr == NULL) { + if (arr == NULL) { return "(null)"; } std::ostringstream result; result << "["; jsize count = env->GetArrayLength(arr); - for(jsize i=0; iGetObjectArrayElement(arr, i); @@ -110,7 +111,7 @@ std::string javaArrayToString(JNIEnv *env, jobjectArray arr) { } std::string javaObjectToString(JNIEnv *env, jobject obj) { - if(obj == NULL) { + if (obj == NULL) { return "(null)"; } jclass objClazz = env->GetObjectClass(obj); @@ -133,8 +134,8 @@ std::string javaMethodCallToString(JNIEnv *env, jobject obj, jmethodID methodId, result << temp; result << ": ("; jsize arraySize = env->GetArrayLength(args); - for(int i=0; iGetObjectArrayElement((jobjectArray)args, i); @@ -145,20 +146,21 @@ std::string javaMethodCallToString(JNIEnv *env, jobject obj, jmethodID methodId, return result.str(); } -JNIEnv* javaGetEnv(JavaVM* jvm, jobject classLoader) { +JNIEnv *javaGetEnv(JavaVM *jvm, jobject classLoader) { JNIEnv *env = NULL; - int ret = jvm->GetEnv((void**)&env, JNI_BEST_VERSION); + int ret = jvm->GetEnv((void **)&env, JNI_BEST_VERSION); if (ret == JNI_EDETACHED) { JavaVMAttachArgs attachArgs; attachArgs.version = JNI_BEST_VERSION; attachArgs.name = NULL; attachArgs.group = NULL; - jvm->AttachCurrentThread((void**)&env, &attachArgs); + jvm->AttachCurrentThread((void **)&env, &attachArgs); jclass threadClazz = env->FindClass("java/lang/Thread"); jmethodID thread_currentThread = env->GetStaticMethodID(threadClazz, "currentThread", "()Ljava/lang/Thread;"); - jmethodID thread_setContextClassLoader = env->GetMethodID(threadClazz, "setContextClassLoader", "(Ljava/lang/ClassLoader;)V"); + jmethodID thread_setContextClassLoader = + env->GetMethodID(threadClazz, "setContextClassLoader", "(Ljava/lang/ClassLoader;)V"); jobject currentThread = env->CallStaticObjectMethod(threadClazz, thread_currentThread); checkJavaException(env); env->CallObjectMethod(currentThread, thread_setContextClassLoader, classLoader); @@ -174,7 +176,8 @@ JNIEnv* javaGetEnv(JavaVM* jvm, jobject classLoader) { jobject getSystemClassLoader(JNIEnv *env) { jclass threadClazz = env->FindClass("java/lang/Thread"); jmethodID thread_currentThread = env->GetStaticMethodID(threadClazz, "currentThread", "()Ljava/lang/Thread;"); - jmethodID thread_getContextClassLoader = env->GetMethodID(threadClazz, "getContextClassLoader", "()Ljava/lang/ClassLoader;"); + jmethodID thread_getContextClassLoader = + env->GetMethodID(threadClazz, "getContextClassLoader", "()Ljava/lang/ClassLoader;"); jobject currentThread = env->CallStaticObjectMethod(threadClazz, thread_currentThread); checkJavaException(env); jobject result = env->CallObjectMethod(currentThread, thread_getContextClassLoader); @@ -188,60 +191,62 @@ jvalueType javaGetType(JNIEnv *env, jclass type) { jboolean isArray = env->CallBooleanMethod(type, class_isArray); assertNoException(env); - if(isArray) { + if (isArray) { return TYPE_ARRAY; } else { // TODO: has to be a better way std::string str = javaObjectToString(env, type); const char *typeStr = str.c_str(); - //printf("javaGetType: %s\n", typeStr); - if(strcmp(typeStr, "void") == 0) { + // printf("javaGetType: %s\n", typeStr); + if (strcmp(typeStr, "void") == 0) { return TYPE_VOID; - } else if(strcmp(typeStr, "char") == 0 || strcmp(typeStr, "class java.lang.Character") == 0) { + } else if (strcmp(typeStr, "char") == 0 || strcmp(typeStr, "class java.lang.Character") == 0) { return TYPE_CHAR; - } else if(strcmp(typeStr, "int") == 0 || strcmp(typeStr, "class java.lang.Integer") == 0) { + } else if (strcmp(typeStr, "int") == 0 || strcmp(typeStr, "class java.lang.Integer") == 0) { return TYPE_INT; - } else if(strcmp(typeStr, "double") == 0 || strcmp(typeStr, "class java.lang.Double") == 0) { + } else if (strcmp(typeStr, "double") == 0 || strcmp(typeStr, "class java.lang.Double") == 0) { return TYPE_DOUBLE; - } else if(strcmp(typeStr, "float") == 0 || strcmp(typeStr, "class java.lang.Float") == 0) { + } else if (strcmp(typeStr, "float") == 0 || strcmp(typeStr, "class java.lang.Float") == 0) { return TYPE_FLOAT; - } else if(strcmp(typeStr, "long") == 0 || strcmp(typeStr, "class java.lang.Long") == 0) { + } else if (strcmp(typeStr, "long") == 0 || strcmp(typeStr, "class java.lang.Long") == 0) { return TYPE_LONG; - } else if(strcmp(typeStr, "boolean") == 0 || strcmp(typeStr, "class java.lang.Boolean") == 0) { + } else if (strcmp(typeStr, "boolean") == 0 || strcmp(typeStr, "class java.lang.Boolean") == 0) { return TYPE_BOOLEAN; - } else if(strcmp(typeStr, "short") == 0 || strcmp(typeStr, "class java.lang.Short") == 0) { + } else if (strcmp(typeStr, "short") == 0 || strcmp(typeStr, "class java.lang.Short") == 0) { return TYPE_SHORT; - } else if(strcmp(typeStr, "byte") == 0 || strcmp(typeStr, "class java.lang.Byte") == 0) { + } else if (strcmp(typeStr, "byte") == 0 || strcmp(typeStr, "class java.lang.Byte") == 0) { return TYPE_BYTE; - } else if(strcmp(typeStr, "class java.lang.String") == 0) { + } else if (strcmp(typeStr, "class java.lang.String") == 0) { return TYPE_STRING; } return TYPE_OBJECT; } } -jclass javaFindClass(JNIEnv* env, const std::string& className) { +jclass javaFindClass(JNIEnv *env, const std::string &className) { std::string searchClassName = className; std::replace(searchClassName.begin(), searchClassName.end(), '.', '/'); -// Alternate find class trying to fix Class.forName -// jclass threadClazz = env->FindClass("java/lang/Thread"); -// jmethodID thread_getCurrentThread = env->GetStaticMethodID(threadClazz, "currentThread", "()Ljava/lang/Thread;"); -// jmethodID thread_getContextClassLoader = env->GetMethodID(threadClazz, "getContextClassLoader", "()Ljava/lang/ClassLoader;"); -// -// jclass classLoaderClazz = env->FindClass("java/lang/ClassLoader"); -// jmethodID classLoader_loadClass = env->GetMethodID(classLoaderClazz, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;"); -// -// jobject currentThread = env->CallObjectMethod(threadClazz, thread_getCurrentThread); -// jobject classLoader = env->CallObjectMethod(currentThread, thread_getContextClassLoader); -// jstring searchClassNameJava = env->NewStringUTF(className.c_str()); -// jclass clazz = (jclass)env->CallObjectMethod(classLoader, classLoader_loadClass, searchClassNameJava); + // Alternate find class trying to fix Class.forName + // jclass threadClazz = env->FindClass("java/lang/Thread"); + // jmethodID thread_getCurrentThread = env->GetStaticMethodID(threadClazz, "currentThread", "()Ljava/lang/Thread;"); + // jmethodID thread_getContextClassLoader = env->GetMethodID(threadClazz, "getContextClassLoader", + // "()Ljava/lang/ClassLoader;"); + // + // jclass classLoaderClazz = env->FindClass("java/lang/ClassLoader"); + // jmethodID classLoader_loadClass = env->GetMethodID(classLoaderClazz, "loadClass", + // "(Ljava/lang/String;)Ljava/lang/Class;"); + // + // jobject currentThread = env->CallObjectMethod(threadClazz, thread_getCurrentThread); + // jobject classLoader = env->CallObjectMethod(currentThread, thread_getContextClassLoader); + // jstring searchClassNameJava = env->NewStringUTF(className.c_str()); + // jclass clazz = (jclass)env->CallObjectMethod(classLoader, classLoader_loadClass, searchClassNameJava); jclass clazz = env->FindClass(searchClassName.c_str()); return clazz; } -jobject javaFindField(JNIEnv* env, jclass clazz, const std::string& fieldName) { +jobject javaFindField(JNIEnv *env, jclass clazz, const std::string &fieldName) { jobject result = NULL; jclass clazzclazz = env->GetObjectClass(clazz); jclass fieldClazz = env->FindClass("java/lang/reflect/Field"); @@ -251,13 +256,13 @@ jobject javaFindField(JNIEnv* env, jclass clazz, const std::string& fieldName) { checkJavaException(env); jsize fieldCount = env->GetArrayLength(fieldObjects); - for(jsize i=0; iGetObjectArrayElement(fieldObjects, i); jstring fieldNameJava = (jstring)env->CallObjectMethod(field, field_getName); checkJavaException(env); std::string itFieldName = javaToString(env, fieldNameJava); - if(strcmp(itFieldName.c_str(), fieldName.c_str()) == 0) { + if (strcmp(itFieldName.c_str(), fieldName.c_str()) == 0) { result = field; break; } @@ -281,71 +286,66 @@ static std::string getArrayElementType(v8::Local array, uint32_t arra return kObject; } - for(uint32_t i=0; i arg = array->Get(Nan::GetCurrentContext(), i).ToLocalChecked(); if (arg->IsArray()) { return kObject; // We can exit as soon as we know java/lang/Object is required. - } - else if(arg->IsString()) { + } else if (arg->IsString()) { types.insert(kString); - } - else if(arg->IsInt32() || arg->IsUint32()) { + } else if (arg->IsInt32() || arg->IsUint32()) { types.insert(kInteger); - } - else if(arg->IsNumber()) { + } else if (arg->IsNumber()) { types.insert(kDouble); - } - else if(arg->IsBoolean()) { + } else if (arg->IsBoolean()) { types.insert(kBoolean); - } - else if(arg->IsObject()) { + } else if (arg->IsObject()) { v8::Local obj = v8::Local::Cast(arg); - v8::Local isJavaLong = GetHiddenValue(obj, Nan::New(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked()); - if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) { + v8::Local isJavaLong = + GetHiddenValue(obj, Nan::New(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked()); + if (!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) { types.insert(kLong); - } - else { + } else { return kObject; // We can exit as soon as we know java/lang/Object is required. } } } - if(types.size() == 1) { + if (types.size() == 1) { return *(types.begin()); } assert(types.size() >= 1); - assert(types.find(kObject)==types.end()); + assert(types.find(kObject) == types.end()); // We have an array with two or more types. All types can be converted to Object, but there is one other // case we support, which is when all the types are numeric types. // We currently have only two non-numeric types. If neither is present in the set, the rest must be numeric. - if (types.find(kString)==types.end() && types.find(kBoolean)==types.end()) { + if (types.find(kString) == types.end() && types.find(kBoolean) == types.end()) { return kNumber; } return kObject; } -jobject v8ToJava(JNIEnv* env, v8::Local arg) { - if(arg.IsEmpty() || arg->IsNull() || arg->IsUndefined()) { +jobject v8ToJava(JNIEnv *env, v8::Local arg) { + if (arg.IsEmpty() || arg->IsNull() || arg->IsUndefined()) { return NULL; } - if(arg->IsArray()) { + if (arg->IsArray()) { v8::Local array = v8::Local::Cast(arg); uint32_t arraySize = array->Length(); std::string arrayType = getArrayElementType(array, arraySize); jclass objectClazz = env->FindClass(arrayType.c_str()); jobjectArray result = env->NewObjectArray(arraySize, objectClazz, NULL); - for(uint32_t i=0; iGet(Nan::GetCurrentContext(), i).ToLocalChecked()); env->SetObjectArrayElement(result, i, val); } return result; } - if(arg->IsString()) { + if (arg->IsString()) { #if NODE_MAJOR_VERSION > 7 v8::String::Value val(v8::Isolate::GetCurrent(), arg->ToString(Nan::GetCurrentContext()).ToLocalChecked()); #else @@ -354,37 +354,39 @@ jobject v8ToJava(JNIEnv* env, v8::Local arg) { return env->NewString(*val, val.length()); } - if(arg->IsInt32() || arg->IsUint32()) { + if (arg->IsInt32() || arg->IsUint32()) { jint val = Nan::To(arg).FromJust(); jclass clazz = env->FindClass("java/lang/Integer"); jmethodID constructor = env->GetMethodID(clazz, "", "(I)V"); return env->NewObject(clazz, constructor, val); } - if(arg->IsNumber()) { + if (arg->IsNumber()) { jdouble val = Nan::To(arg).FromJust(); jclass clazz = env->FindClass("java/lang/Double"); jmethodID constructor = env->GetMethodID(clazz, "", "(D)V"); return env->NewObject(clazz, constructor, val); } - if(arg->IsBoolean()) { + if (arg->IsBoolean()) { jboolean val = Nan::To(arg).FromJust(); jclass clazz = env->FindClass("java/lang/Boolean"); jmethodID constructor = env->GetMethodID(clazz, "", "(Z)V"); return env->NewObject(clazz, constructor, val); } - if(arg->IsObject()) { + if (arg->IsObject()) { v8::Local obj = v8::Local::Cast(arg); - v8::Local isJavaObject = GetHiddenValue(obj, Nan::New(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked()); - if(!isJavaObject.IsEmpty() && isJavaObject->IsBoolean()) { + v8::Local isJavaObject = + GetHiddenValue(obj, Nan::New(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked()); + if (!isJavaObject.IsEmpty() && isJavaObject->IsBoolean()) { return v8ToJava_javaObject(env, obj); } - v8::Local isJavaLong = GetHiddenValue(obj, Nan::New(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked()); - if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) { + v8::Local isJavaLong = + GetHiddenValue(obj, Nan::New(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked()); + if (!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) { return v8ToJava_javaLong(env, obj); } } @@ -395,13 +397,13 @@ jobject v8ToJava(JNIEnv* env, v8::Local arg) { return NULL; } -jobject v8ToJava_javaObject(JNIEnv* env, v8::Local obj) { - JavaObject* javaObject = Nan::ObjectWrap::Unwrap(obj); +jobject v8ToJava_javaObject(JNIEnv *env, v8::Local obj) { + JavaObject *javaObject = Nan::ObjectWrap::Unwrap(obj); return javaObject->getObject(); } -void checkJavaException(JNIEnv* env) { - if(env->ExceptionCheck()) { +void checkJavaException(JNIEnv *env) { + if (env->ExceptionCheck()) { jthrowable ex = env->ExceptionOccurred(); env->ExceptionClear(); @@ -411,19 +413,20 @@ void checkJavaException(JNIEnv* env) { } } -jobject v8ToJava_javaLong(JNIEnv* env, v8::Local obj) { - jobject longValue = v8ToJava(env, obj->Get(Nan::GetCurrentContext(), Nan::New("longValue").ToLocalChecked()).ToLocalChecked()); +jobject v8ToJava_javaLong(JNIEnv *env, v8::Local obj) { + jobject longValue = v8ToJava( + env, obj->Get(Nan::GetCurrentContext(), Nan::New("longValue").ToLocalChecked()).ToLocalChecked()); jclass longClazz = env->FindClass("java/lang/Long"); jmethodID long_constructor = env->GetMethodID(longClazz, "", "(Ljava/lang/String;)V"); jobject jobj = env->NewObject(longClazz, long_constructor, longValue); return jobj; } -jobjectArray v8ToJava(JNIEnv* env, Nan::NAN_METHOD_ARGS_TYPE args, int start, int end) { +jobjectArray v8ToJava(JNIEnv *env, Nan::NAN_METHOD_ARGS_TYPE args, int start, int end) { jclass clazz = env->FindClass("java/lang/Object"); - jobjectArray results = env->NewObjectArray(end-start, clazz, NULL); + jobjectArray results = env->NewObjectArray(end - start, clazz, NULL); - for(int i=start; iSetObjectArrayElement(results, i - start, val); } @@ -431,7 +434,7 @@ jobjectArray v8ToJava(JNIEnv* env, Nan::NAN_METHOD_ARGS_TYPE args, int start, in return results; } -std::string javaExceptionToString(JNIEnv* env, jthrowable ex) { +std::string javaExceptionToString(JNIEnv *env, jthrowable ex) { jclass stringWriterClazz = env->FindClass("java/io/StringWriter"); jmethodID stringWriter_constructor = env->GetMethodID(stringWriterClazz, "", "()V"); jmethodID stringWriter_toString = env->GetMethodID(stringWriterClazz, "toString", "()Ljava/lang/String;"); @@ -451,15 +454,17 @@ std::string javaExceptionToString(JNIEnv* env, jthrowable ex) { return javaToString(env, strObj); } -v8::Local javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex, const std::string& alternateMessage) { +v8::Local javaExceptionToV8(Java *java, JNIEnv *env, jthrowable ex, const std::string &alternateMessage) { std::ostringstream msg; msg << alternateMessage; - if(ex) { + if (ex) { msg << "\n" << javaExceptionToString(env, ex); v8::Local v8ex = v8::Exception::Error(Nan::New(msg.str().c_str()).ToLocalChecked()); - if (hasSetFailed(((v8::Object*)*v8ex)->Set(Nan::GetCurrentContext(), Nan::New("cause").ToLocalChecked(), javaToV8(java, env, ex)))) { + if (hasSetFailed(((v8::Object *)*v8ex) + ->Set(Nan::GetCurrentContext(), Nan::New("cause").ToLocalChecked(), + javaToV8(java, env, ex)))) { return v8::Exception::Error(Nan::New("could not set cause").ToLocalChecked()); } return v8ex; @@ -468,7 +473,7 @@ v8::Local javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex, c return v8::Exception::Error(Nan::New(msg.str().c_str()).ToLocalChecked()); } -v8::Local javaExceptionToV8(Java* java, JNIEnv* env, const std::string& alternateMessage) { +v8::Local javaExceptionToV8(Java *java, JNIEnv *env, const std::string &alternateMessage) { jthrowable ex = env->ExceptionOccurred(); env->ExceptionClear(); return javaExceptionToV8(java, env, ex, alternateMessage); @@ -491,17 +496,17 @@ jvalueType javaGetArrayComponentType(JNIEnv *env, jobjectArray array) { } #if NODE_VERSION_AT_LEAST(13, 0, 0) - v8::Local newArrayBuffer(void* elems, size_t length) { - v8::Local ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), length); - memcpy(ab->GetBackingStore()->Data(), elems, length); - return ab; - } +v8::Local newArrayBuffer(void *elems, size_t length) { + v8::Local ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), length); + memcpy(ab->GetBackingStore()->Data(), elems, length); + return ab; +} #elif NODE_VERSION_AT_LEAST(4, 0, 0) - v8::Local newArrayBuffer(void* elems, size_t length) { - v8::Local ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), length); - memcpy(ab->GetContents().Data(), elems, length); - return ab; - } +v8::Local newArrayBuffer(void *elems, size_t length) { + v8::Local ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), length); + memcpy(ab->GetContents().Data(), elems, length); + return ab; +} #endif v8::Local javaCharToV8String(jchar c) { @@ -514,156 +519,140 @@ v8::Local javaCharToV8String(jchar c) { #endif } -v8::Local javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArray) { - if(objArray == NULL) { +v8::Local javaArrayToV8(Java *java, JNIEnv *env, jobjectArray objArray) { + if (objArray == NULL) { return Nan::Null(); } jvalueType arrayComponentType = javaGetArrayComponentType(env, objArray); - //printf("javaArrayToV8: %d %s\n", arrayComponentType, javaObjectToString(env, objArray).c_str()); + // printf("javaArrayToV8: %d %s\n", arrayComponentType, javaObjectToString(env, objArray).c_str()); jsize arraySize = env->GetArrayLength(objArray); - //printf("array size: %d\n", arraySize); + // printf("array size: %d\n", arraySize); v8::Local result = Nan::New(arraySize); // http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/types.html - switch(arrayComponentType) { - case TYPE_CHAR: - { - jchar* elems = env->GetCharArrayElements((jcharArray)objArray, 0); + switch (arrayComponentType) { + case TYPE_CHAR: { + jchar *elems = env->GetCharArrayElements((jcharArray)objArray, 0); #if (NODE_VERSION_AT_LEAST(4, 0, 0)) - size_t byteLength = arraySize * 2; - v8::Local ab = newArrayBuffer(elems, byteLength); - env->ReleaseCharArrayElements((jcharArray)objArray, elems, 0); - return v8::Uint16Array::New(ab, 0, arraySize); + size_t byteLength = arraySize * 2; + v8::Local ab = newArrayBuffer(elems, byteLength); + env->ReleaseCharArrayElements((jcharArray)objArray, elems, 0); + return v8::Uint16Array::New(ab, 0, arraySize); #else - jchar str; - for(jsize i=0; iSet(i, javaCharToV8String(str)); - } - env->ReleaseCharArrayElements((jcharArray)objArray, elems, 0); -#endif + jchar str; + for (jsize i = 0; i < arraySize; i++) { + str = elems[i]; + result->Set(i, javaCharToV8String(str)); } - break; + env->ReleaseCharArrayElements((jcharArray)objArray, elems, 0); +#endif + } break; - case TYPE_INT: - { - jint* elems = env->GetIntArrayElements((jintArray)objArray, 0); + case TYPE_INT: { + jint *elems = env->GetIntArrayElements((jintArray)objArray, 0); #if (NODE_VERSION_AT_LEAST(4, 0, 0)) - size_t byteLength = arraySize * 4; - v8::Local ab = newArrayBuffer(elems, byteLength); - env->ReleaseIntArrayElements((jintArray)objArray, elems, 0); - return v8::Int32Array::New(ab, 0, arraySize); + size_t byteLength = arraySize * 4; + v8::Local ab = newArrayBuffer(elems, byteLength); + env->ReleaseIntArrayElements((jintArray)objArray, elems, 0); + return v8::Int32Array::New(ab, 0, arraySize); #else - for(jsize i=0; iSet(i, Nan::New(elems[i])); - } - env->ReleaseIntArrayElements((jintArray)objArray, elems, 0); -#endif + for (jsize i = 0; i < arraySize; i++) { + result->Set(i, Nan::New(elems[i])); } - break; + env->ReleaseIntArrayElements((jintArray)objArray, elems, 0); +#endif + } break; - case TYPE_BYTE: - { - jbyte* elems = env->GetByteArrayElements((jbyteArray)objArray, 0); + case TYPE_BYTE: { + jbyte *elems = env->GetByteArrayElements((jbyteArray)objArray, 0); #if (NODE_VERSION_AT_LEAST(4, 0, 0)) - size_t byteLength = arraySize; - v8::Local ab = newArrayBuffer(elems, byteLength); - env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0); - return v8::Int8Array::New(ab, 0, arraySize); + size_t byteLength = arraySize; + v8::Local ab = newArrayBuffer(elems, byteLength); + env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0); + return v8::Int8Array::New(ab, 0, arraySize); #else - for(jsize i=0; iSet(i, Nan::New(elems[i])); - } - env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0); -#endif + for (jsize i = 0; i < arraySize; i++) { + result->Set(i, Nan::New(elems[i])); } - break; + env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0); +#endif + } break; - case TYPE_BOOLEAN: - { - jboolean* elems = env->GetBooleanArrayElements((jbooleanArray)objArray, 0); - for(jsize i=0; iSet(Nan::GetCurrentContext(), i, Nan::New(elems[i])))) { - return v8::Exception::Error(Nan::New("set array element failed").ToLocalChecked()); - } + case TYPE_BOOLEAN: { + jboolean *elems = env->GetBooleanArrayElements((jbooleanArray)objArray, 0); + for (jsize i = 0; i < arraySize; i++) { + if (hasSetFailed(result->Set(Nan::GetCurrentContext(), i, Nan::New(elems[i])))) { + return v8::Exception::Error(Nan::New("set array element failed").ToLocalChecked()); } - env->ReleaseBooleanArrayElements((jbooleanArray)objArray, elems, 0); } - break; + env->ReleaseBooleanArrayElements((jbooleanArray)objArray, elems, 0); + } break; - case TYPE_SHORT: - { - jshort* elems = env->GetShortArrayElements((jshortArray)objArray, 0); + case TYPE_SHORT: { + jshort *elems = env->GetShortArrayElements((jshortArray)objArray, 0); #if (NODE_VERSION_AT_LEAST(4, 0, 0)) - size_t byteLength = arraySize * 2; - v8::Local ab = newArrayBuffer(elems, byteLength); - env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0); - return v8::Int16Array::New(ab, 0, arraySize); + size_t byteLength = arraySize * 2; + v8::Local ab = newArrayBuffer(elems, byteLength); + env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0); + return v8::Int16Array::New(ab, 0, arraySize); #else - for(jsize i=0; iSet(i, Nan::New(elems[i])); - } - env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0); -#endif + for (jsize i = 0; i < arraySize; i++) { + result->Set(i, Nan::New(elems[i])); } - break; + env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0); +#endif + } break; - case TYPE_DOUBLE: - { - jdouble* elems = env->GetDoubleArrayElements((jdoubleArray)objArray, 0); + case TYPE_DOUBLE: { + jdouble *elems = env->GetDoubleArrayElements((jdoubleArray)objArray, 0); #if (NODE_VERSION_AT_LEAST(4, 0, 0)) - size_t byteLength = arraySize * 8; - v8::Local ab = newArrayBuffer(elems, byteLength); - env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0); - return v8::Float64Array::New(ab, 0, arraySize); + size_t byteLength = arraySize * 8; + v8::Local ab = newArrayBuffer(elems, byteLength); + env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0); + return v8::Float64Array::New(ab, 0, arraySize); #else - for(jsize i=0; iSet(i, Nan::New(elems[i])); - } - env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0); -#endif + for (jsize i = 0; i < arraySize; i++) { + result->Set(i, Nan::New(elems[i])); } - break; + env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0); +#endif + } break; - case TYPE_FLOAT: - { - jfloat* elems = env->GetFloatArrayElements((jfloatArray)objArray, 0); + case TYPE_FLOAT: { + jfloat *elems = env->GetFloatArrayElements((jfloatArray)objArray, 0); #if (NODE_VERSION_AT_LEAST(4, 0, 0)) - size_t byteLength = arraySize * 4; - v8::Local ab = newArrayBuffer(elems, byteLength); - env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0); - return v8::Float32Array::New(ab, 0, arraySize); + size_t byteLength = arraySize * 4; + v8::Local ab = newArrayBuffer(elems, byteLength); + env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0); + return v8::Float32Array::New(ab, 0, arraySize); #else - for(jsize i=0; iSet(i, Nan::New(elems[i])); - } - env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0); -#endif + for (jsize i = 0; i < arraySize; i++) { + result->Set(i, Nan::New(elems[i])); } - break; - - case TYPE_LONG: - { - jlong* elems = env->GetLongArrayElements((jlongArray)objArray, 0); - for(jsize i=0; iSet(Nan::GetCurrentContext(), i, JavaObject::New(java, obj)))) { - return v8::Exception::Error(Nan::New("could not set array element").ToLocalChecked()); - } + env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0); +#endif + } break; + + case TYPE_LONG: { + jlong *elems = env->GetLongArrayElements((jlongArray)objArray, 0); + for (jsize i = 0; i < arraySize; i++) { + jobject obj = longToJavaLongObj(env, elems[i]); + if (hasSetFailed(result->Set(Nan::GetCurrentContext(), i, JavaObject::New(java, obj)))) { + return v8::Exception::Error(Nan::New("could not set array element").ToLocalChecked()); } - env->ReleaseLongArrayElements((jlongArray)objArray, elems, 0); } - break; + env->ReleaseLongArrayElements((jlongArray)objArray, elems, 0); + } break; default: - for(jsize i=0; iGetObjectArrayElement(objArray, i); - v8::Local item = javaToV8(java, env, obj); - if(hasSetFailed(result->Set(Nan::GetCurrentContext(), i, item))) { - return v8::Exception::Error(Nan::New("could not set array element").ToLocalChecked()); - } + for (jsize i = 0; i < arraySize; i++) { + jobject obj = env->GetObjectArrayElement(objArray, i); + v8::Local item = javaToV8(java, env, obj); + if (hasSetFailed(result->Set(Nan::GetCurrentContext(), i, item))) { + return v8::Exception::Error(Nan::New("could not set array element").ToLocalChecked()); + } } break; } @@ -671,113 +660,104 @@ v8::Local javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArra return result; } -v8::Local javaToV8(Java* java, JNIEnv* env, jobject obj) { - return javaToV8(java, env, obj, NULL); -} +v8::Local javaToV8(Java *java, JNIEnv *env, jobject obj) { return javaToV8(java, env, obj, NULL); } -v8::Local javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProxyData* dynamicProxyData) { - if(obj == NULL) { +v8::Local javaToV8(Java *java, JNIEnv *env, jobject obj, DynamicProxyData *dynamicProxyData) { + if (obj == NULL) { return Nan::Null(); } jclass objClazz = env->GetObjectClass(obj); jvalueType resultType = javaGetType(env, objClazz); - //printf("javaToV8: %d %s\n", resultType, javaObjectToString(env, obj).c_str()); + // printf("javaToV8: %d %s\n", resultType, javaObjectToString(env, obj).c_str()); - switch(resultType) { - case TYPE_ARRAY: - { - v8::Local result = javaArrayToV8(java, env, (jobjectArray)obj); - return result; - } - case TYPE_VOID: - return Nan::Undefined(); - case TYPE_CHAR: - { - jclass charClazz = env->FindClass("java/lang/Character"); - jmethodID char_charValue = env->GetMethodID(charClazz, "charValue", "()C"); - jchar c = env->CallCharMethod(obj, char_charValue); - checkJavaException(env); - return javaCharToV8String(c); - } - case TYPE_BOOLEAN: - { - jclass booleanClazz = env->FindClass("java/lang/Boolean"); - jmethodID boolean_booleanValue = env->GetMethodID(booleanClazz, "booleanValue", "()Z"); - bool result = env->CallBooleanMethod(obj, boolean_booleanValue); - assertNoException(env); - return Nan::New(result); - } - case TYPE_BYTE: - { - jclass byteClazz = env->FindClass("java/lang/Byte"); - jmethodID byte_byteValue = env->GetMethodID(byteClazz, "byteValue", "()B"); - jbyte result = env->CallByteMethod(obj, byte_byteValue); - checkJavaException(env); - return Nan::New(result); - } - case TYPE_LONG: - { - jclass longClazz = env->FindClass("java/lang/Long"); - jmethodID long_longValue = env->GetMethodID(longClazz, "longValue", "()J"); - jlong result = env->CallLongMethod(obj, long_longValue); - checkJavaException(env); - std::string strValue = javaObjectToString(env, obj); - v8::Local v8Result = Nan::New((double)result); - v8::NumberObject* v8ResultNumberObject = v8::NumberObject::Cast(*v8Result); - if(hasSetFailed(v8ResultNumberObject->Set(Nan::GetCurrentContext(), Nan::New("longValue").ToLocalChecked(), Nan::New(strValue.c_str()).ToLocalChecked()))) { - return v8::Exception::Error(Nan::New("could not set longValue").ToLocalChecked()); - } - SetHiddenValue(v8ResultNumberObject, Nan::New(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked(), Nan::New(true)); - return v8Result; - } - case TYPE_INT: - { - jclass integerClazz = env->FindClass("java/lang/Integer"); - jmethodID integer_intValue = env->GetMethodID(integerClazz, "intValue", "()I"); - jint result = env->CallIntMethod(obj, integer_intValue); - checkJavaException(env); - // <-- use the Int32 factory, not the generic Integer one - return Nan::New(static_cast(result)); - } - case TYPE_SHORT: - { - jclass shortClazz = env->FindClass("java/lang/Short"); - jmethodID short_shortValue = env->GetMethodID(shortClazz, "shortValue", "()S"); - jshort result = env->CallShortMethod(obj, short_shortValue); - assertNoException(env); - return Nan::New(result); - } - case TYPE_DOUBLE: - { - jclass doubleClazz = env->FindClass("java/lang/Double"); - jmethodID double_doubleValue = env->GetMethodID(doubleClazz, "doubleValue", "()D"); - jdouble result = env->CallDoubleMethod(obj, double_doubleValue); - checkJavaException(env); - return Nan::New(result); - } - case TYPE_FLOAT: - { - jclass floatClazz = env->FindClass("java/lang/Float"); - jmethodID float_floatValue = env->GetMethodID(floatClazz, "floatValue", "()F"); - jfloat result = env->CallFloatMethod(obj, float_floatValue); - assertNoException(env); - return Nan::New(result); - } - case TYPE_STRING: - { - std::string str = javaObjectToString(env, obj); - return Nan::New(str.c_str(), str.length()).ToLocalChecked(); - } - case TYPE_OBJECT: - if (dynamicProxyData != NULL) { - return JavaProxyObject::New(java, obj, dynamicProxyData); - } - return JavaObject::New(java, obj); - default: - printf("javaToV8: unhandled type: 0x%03x\n", resultType); - return JavaObject::New(java, obj); + switch (resultType) { + case TYPE_ARRAY: { + v8::Local result = javaArrayToV8(java, env, (jobjectArray)obj); + return result; + } + case TYPE_VOID: + return Nan::Undefined(); + case TYPE_CHAR: { + jclass charClazz = env->FindClass("java/lang/Character"); + jmethodID char_charValue = env->GetMethodID(charClazz, "charValue", "()C"); + jchar c = env->CallCharMethod(obj, char_charValue); + checkJavaException(env); + return javaCharToV8String(c); + } + case TYPE_BOOLEAN: { + jclass booleanClazz = env->FindClass("java/lang/Boolean"); + jmethodID boolean_booleanValue = env->GetMethodID(booleanClazz, "booleanValue", "()Z"); + bool result = env->CallBooleanMethod(obj, boolean_booleanValue); + assertNoException(env); + return Nan::New(result); + } + case TYPE_BYTE: { + jclass byteClazz = env->FindClass("java/lang/Byte"); + jmethodID byte_byteValue = env->GetMethodID(byteClazz, "byteValue", "()B"); + jbyte result = env->CallByteMethod(obj, byte_byteValue); + checkJavaException(env); + return Nan::New(result); + } + case TYPE_LONG: { + jclass longClazz = env->FindClass("java/lang/Long"); + jmethodID long_longValue = env->GetMethodID(longClazz, "longValue", "()J"); + jlong result = env->CallLongMethod(obj, long_longValue); + checkJavaException(env); + std::string strValue = javaObjectToString(env, obj); + v8::Local v8Result = Nan::New((double)result); + v8::NumberObject *v8ResultNumberObject = v8::NumberObject::Cast(*v8Result); + if (hasSetFailed(v8ResultNumberObject->Set(Nan::GetCurrentContext(), + Nan::New("longValue").ToLocalChecked(), + Nan::New(strValue.c_str()).ToLocalChecked()))) { + return v8::Exception::Error(Nan::New("could not set longValue").ToLocalChecked()); + } + SetHiddenValue(v8ResultNumberObject, Nan::New(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked(), + Nan::New(true)); + return v8Result; + } + case TYPE_INT: { + jclass integerClazz = env->FindClass("java/lang/Integer"); + jmethodID integer_intValue = env->GetMethodID(integerClazz, "intValue", "()I"); + jint result = env->CallIntMethod(obj, integer_intValue); + checkJavaException(env); + // <-- use the Int32 factory, not the generic Integer one + return Nan::New(static_cast(result)); + } + case TYPE_SHORT: { + jclass shortClazz = env->FindClass("java/lang/Short"); + jmethodID short_shortValue = env->GetMethodID(shortClazz, "shortValue", "()S"); + jshort result = env->CallShortMethod(obj, short_shortValue); + assertNoException(env); + return Nan::New(result); + } + case TYPE_DOUBLE: { + jclass doubleClazz = env->FindClass("java/lang/Double"); + jmethodID double_doubleValue = env->GetMethodID(doubleClazz, "doubleValue", "()D"); + jdouble result = env->CallDoubleMethod(obj, double_doubleValue); + checkJavaException(env); + return Nan::New(result); + } + case TYPE_FLOAT: { + jclass floatClazz = env->FindClass("java/lang/Float"); + jmethodID float_floatValue = env->GetMethodID(floatClazz, "floatValue", "()F"); + jfloat result = env->CallFloatMethod(obj, float_floatValue); + assertNoException(env); + return Nan::New(result); + } + case TYPE_STRING: { + std::string str = javaObjectToString(env, obj); + return Nan::New(str.c_str(), str.length()).ToLocalChecked(); + } + case TYPE_OBJECT: + if (dynamicProxyData != NULL) { + return JavaProxyObject::New(java, obj, dynamicProxyData); + } + return JavaObject::New(java, obj); + default: + printf("javaToV8: unhandled type: 0x%03x\n", resultType); + return JavaObject::New(java, obj); } return Nan::Undefined(); @@ -787,9 +767,9 @@ jobjectArray javaObjectArrayToClasses(JNIEnv *env, jobjectArray objs) { jclass clazzClazz = env->FindClass("java/lang/Class"); jsize objsLength = env->GetArrayLength(objs); jobjectArray results = env->NewObjectArray(objsLength, clazzClazz, NULL); - for(jsize i=0; iGetObjectArrayElement(objs, i); - if(elem == NULL) { + if (elem == NULL) { env->SetObjectArrayElement(results, i, NULL); } else { jclass objClazz = env->GetObjectClass(elem); @@ -800,29 +780,31 @@ jobjectArray javaObjectArrayToClasses(JNIEnv *env, jobjectArray objs) { return results; } -jobject javaFindMethod(JNIEnv *env, jclass clazz, const std::string& methodName, jobjectArray methodArgs) { +jobject javaFindMethod(JNIEnv *env, jclass clazz, const std::string &methodName, jobjectArray methodArgs) { std::string::size_type parenLoc = methodName.find("("); - if(parenLoc != std::string::npos) { + if (parenLoc != std::string::npos) { jobject method = NULL; std::string methodSig = methodName.substr(parenLoc); std::string methodRealName = methodName.substr(0, parenLoc); jmethodID methodID = env->GetStaticMethodID(clazz, methodRealName.c_str(), methodSig.c_str()); - env->ExceptionClear(); // If GetStaticMethodID can't find the method it throws an exception and we need to just return NULL - if(methodID != 0) { + env->ExceptionClear(); // If GetStaticMethodID can't find the method it throws an exception and we need to just + // return NULL + if (methodID != 0) { method = env->ToReflectedMethod(clazz, methodID, true); } else { methodID = env->GetMethodID(clazz, methodRealName.c_str(), methodSig.c_str()); - env->ExceptionClear(); // If GetMethodID can't find the method it throws an exception and we need to just return NULL - if(methodID != 0) { + env->ExceptionClear(); // If GetMethodID can't find the method it throws an exception and we need to just return + // NULL + if (methodID != 0) { method = env->ToReflectedMethod(clazz, methodID, true); } } // cast arguments - if(method != NULL) { + if (method != NULL) { javaCastArguments(env, methodArgs, method); - if(env->ExceptionCheck()) { + if (env->ExceptionCheck()) { env->ExceptionClear(); method = NULL; } @@ -831,11 +813,14 @@ jobject javaFindMethod(JNIEnv *env, jclass clazz, const std::string& methodName, return method; } else { jclass methodUtilsClazz = env->FindClass("nodejava/org/apache/commons/lang3/reflect/MethodUtils"); - jmethodID methodUtils_getMatchingAccessibleMethod = env->GetStaticMethodID(methodUtilsClazz, "getMatchingAccessibleMethod", "(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;"); + jmethodID methodUtils_getMatchingAccessibleMethod = + env->GetStaticMethodID(methodUtilsClazz, "getMatchingAccessibleMethod", + "(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;"); const char *methodNameCStr = methodName.c_str(); jstring methodNameJavaStr = env->NewStringUTF(methodNameCStr); jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs); - jobject method = env->CallStaticObjectMethod(methodUtilsClazz, methodUtils_getMatchingAccessibleMethod, clazz, methodNameJavaStr, methodArgClasses); + jobject method = env->CallStaticObjectMethod(methodUtilsClazz, methodUtils_getMatchingAccessibleMethod, clazz, + methodNameJavaStr, methodArgClasses); checkJavaException(env); return method; } @@ -843,15 +828,19 @@ jobject javaFindMethod(JNIEnv *env, jclass clazz, const std::string& methodName, void javaCastArguments(JNIEnv *env, jobjectArray methodArgs, jobject method) { jclass castingUtilsClazz = env->FindClass("node/CastingUtils"); - jmethodID castingUtilsClazz_cast = env->GetStaticMethodID(castingUtilsClazz, "cast", "(Ljava/lang/reflect/Method;[Ljava/lang/Object;)V"); + jmethodID castingUtilsClazz_cast = + env->GetStaticMethodID(castingUtilsClazz, "cast", "(Ljava/lang/reflect/Method;[Ljava/lang/Object;)V"); env->CallStaticObjectMethod(castingUtilsClazz, castingUtilsClazz_cast, method, methodArgs); } jobject javaFindConstructor(JNIEnv *env, jclass clazz, jobjectArray methodArgs) { jclass constructorUtilsClazz = env->FindClass("nodejava/org/apache/commons/lang3/reflect/ConstructorUtils"); - jmethodID constructorUtils_getMatchingAccessibleConstructor = env->GetStaticMethodID(constructorUtilsClazz, "getMatchingAccessibleConstructor", "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;"); + jmethodID constructorUtils_getMatchingAccessibleConstructor = + env->GetStaticMethodID(constructorUtilsClazz, "getMatchingAccessibleConstructor", + "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;"); jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs); - jobject method = env->CallStaticObjectMethod(constructorUtilsClazz, constructorUtils_getMatchingAccessibleConstructor, clazz, methodArgClasses); + jobject method = env->CallStaticObjectMethod(constructorUtilsClazz, constructorUtils_getMatchingAccessibleConstructor, + clazz, methodArgClasses); assertNoException(env); return method; } @@ -863,16 +852,19 @@ jobject longToJavaLongObj(JNIEnv *env, jlong val) { return result; } -int dynamicProxyDataVerify(DynamicProxyData* data) { - if(data->markerStart == DYNAMIC_PROXY_DATA_MARKER_START && data->markerEnd == DYNAMIC_PROXY_DATA_MARKER_END) { +int dynamicProxyDataVerify(DynamicProxyData *data) { + if (data->markerStart == DYNAMIC_PROXY_DATA_MARKER_START && data->markerEnd == DYNAMIC_PROXY_DATA_MARKER_END) { return 1; } - printf("*** ERROR: Lost reference to the dynamic proxy. You must maintain a reference in javascript land using ref() and unref(). (%p) ***\n", data); + printf("*** ERROR: Lost reference to the dynamic proxy. You must maintain a reference in javascript land using ref() " + "and unref(). (%p) ***\n", + data); return 0; } -std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string& methodNameSig, bool constructor, Nan::NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd) { +std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string &methodNameSig, bool constructor, + Nan::NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd) { std::ostringstream startOfMessage; std::ostringstream msg; std::string methodName = methodNameSig.substr(0, methodNameSig.find('(')); @@ -886,12 +878,12 @@ std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string& startOfMessage << "Could not find method \"" << methodName.c_str() << "("; } - for(int i=argStart; iGetObjectClass(val); @@ -902,7 +894,7 @@ std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string& } } - startOfMessage << ")\" on class \""<< javaObjectToString(env, clazz).c_str() << "\"."; + startOfMessage << ")\" on class \"" << javaObjectToString(env, clazz).c_str() << "\"."; msg << startOfMessage.str() << " Possible matches:\n"; @@ -910,24 +902,24 @@ std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string& jmethodID member_getName = env->GetMethodID(memberClazz, "getName", "()Ljava/lang/String;"); std::list methods; - if(constructor) { + if (constructor) { javaReflectionGetConstructors(env, clazz, &methods); } else { javaReflectionGetMethods(env, clazz, &methods, true); } int count = 0; - for(std::list::iterator it = methods.begin(); it != methods.end(); ++it) { + for (std::list::iterator it = methods.begin(); it != methods.end(); ++it) { jstring methodNameTestJava = (jstring)env->CallObjectMethod(*it, member_getName); assertNoException(env); std::string methodNameTest = javaToString(env, methodNameTestJava); - if(methodNameTest == methodName) { + if (methodNameTest == methodName) { msg << " " << javaObjectToString(env, *it).c_str() << "\n"; count++; } } - if(count == 0) { + if (count == 0) { std::ostringstream noMethodsMsg; noMethodsMsg << startOfMessage.str() << " No methods with that name."; return noMethodsMsg.str(); @@ -936,8 +928,8 @@ std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string& return msg.str(); } -void unref(DynamicProxyData* dynamicProxyData) { - if(!dynamicProxyDataVerify(dynamicProxyData)) { +void unref(DynamicProxyData *dynamicProxyData) { + if (!dynamicProxyDataVerify(dynamicProxyData)) { return; } dynamicProxyData->jsObject.Reset(); @@ -949,7 +941,8 @@ void unref(DynamicProxyData* dynamicProxyData) { jarray javaGetArgsForMethod(JNIEnv *env, jobject method, jarray args) { jclass varArgsClazz = env->FindClass("node/VarArgs"); - jmethodID method_getVarArgs = env->GetStaticMethodID(varArgsClazz, "getVarArgs", "(Ljava/lang/reflect/Method;[Ljava/lang/Object;)[Ljava/lang/Object;"); + jmethodID method_getVarArgs = env->GetStaticMethodID( + varArgsClazz, "getVarArgs", "(Ljava/lang/reflect/Method;[Ljava/lang/Object;)[Ljava/lang/Object;"); jarray result = (jarray)env->CallStaticObjectMethod(varArgsClazz, method_getVarArgs, method, args); checkJavaException(env); return result; @@ -957,55 +950,56 @@ jarray javaGetArgsForMethod(JNIEnv *env, jobject method, jarray args) { jarray javaGetArgsForConstructor(JNIEnv *env, jobject method, jarray args) { jclass varArgsClazz = env->FindClass("node/VarArgs"); - jmethodID method_getVarArgs = env->GetStaticMethodID(varArgsClazz, "getVarArgs", "(Ljava/lang/reflect/Constructor;[Ljava/lang/Object;)[Ljava/lang/Object;"); + jmethodID method_getVarArgs = env->GetStaticMethodID( + varArgsClazz, "getVarArgs", "(Ljava/lang/reflect/Constructor;[Ljava/lang/Object;)[Ljava/lang/Object;"); jarray result = (jarray)env->CallStaticObjectMethod(varArgsClazz, method_getVarArgs, method, args); checkJavaException(env); return result; } #if (NODE_MODULE_VERSION > 48) - // The two methods below were copied from - // https://github.com/electron/electron?branch=master&filepath=atom/common/api/atom_api_v8_util.cc - // Copyright (c) 2013 GitHub, Inc. - // Use of this source code is governed by the MIT license. - - v8::Local GetHiddenValue(v8::Local object, v8::Local key) { - v8::Local context = v8::Isolate::GetCurrent()->GetCurrentContext(); - v8::Local privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), key); - v8::Local value; - v8::Maybe result = object->HasPrivate(context, privateKey); - if (!(result.IsJust() && result.FromJust())) - return v8::Local(); - if (object->GetPrivate(context, privateKey).ToLocal(&value)) - return value; +// The two methods below were copied from +// https://github.com/electron/electron?branch=master&filepath=atom/common/api/atom_api_v8_util.cc +// Copyright (c) 2013 GitHub, Inc. +// Use of this source code is governed by the MIT license. + +v8::Local GetHiddenValue(v8::Local object, v8::Local key) { + v8::Local context = v8::Isolate::GetCurrent()->GetCurrentContext(); + v8::Local privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), key); + v8::Local value; + v8::Maybe result = object->HasPrivate(context, privateKey); + if (!(result.IsJust() && result.FromJust())) return v8::Local(); - } + if (object->GetPrivate(context, privateKey).ToLocal(&value)) + return value; + return v8::Local(); +} - void SetHiddenValue(v8::NumberObject* object, v8::Local key, v8::Local value) { - if (value.IsEmpty()) - return; - v8::Local context = v8::Isolate::GetCurrent()->GetCurrentContext(); - v8::Local privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), key); - object->SetPrivate(context, privateKey, value); - } +void SetHiddenValue(v8::NumberObject *object, v8::Local key, v8::Local value) { + if (value.IsEmpty()) + return; + v8::Local context = v8::Isolate::GetCurrent()->GetCurrentContext(); + v8::Local privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), key); + object->SetPrivate(context, privateKey, value); +} - void SetHiddenValue(v8::Local object, v8::Local key, v8::Local value) { - if (value.IsEmpty()) - return; - v8::Local context = v8::Isolate::GetCurrent()->GetCurrentContext(); - v8::Local privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), key); - object->SetPrivate(context, privateKey, value); - } +void SetHiddenValue(v8::Local object, v8::Local key, v8::Local value) { + if (value.IsEmpty()) + return; + v8::Local context = v8::Isolate::GetCurrent()->GetCurrentContext(); + v8::Local privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), key); + object->SetPrivate(context, privateKey, value); +} #else - v8::Local GetHiddenValue(v8::Local object, v8::Local key) { - return object->GetHiddenValue(key); - } +v8::Local GetHiddenValue(v8::Local object, v8::Local key) { + return object->GetHiddenValue(key); +} - void SetHiddenValue(v8::NumberObject* object, v8::Local key, v8::Local value) { - object->SetHiddenValue(key, value); - } +void SetHiddenValue(v8::NumberObject *object, v8::Local key, v8::Local value) { + object->SetHiddenValue(key, value); +} - void SetHiddenValue(v8::Local object, v8::Local key, v8::Local value) { - object->SetHiddenValue(key, value); - } +void SetHiddenValue(v8::Local object, v8::Local key, v8::Local value) { + object->SetHiddenValue(key, value); +} #endif diff --git a/src/utils.h b/src/utils.h index 6b96b60c..b3ad608a 100644 --- a/src/utils.h +++ b/src/utils.h @@ -3,37 +3,37 @@ #define _utils_h_ #define BUILDING_NODE_EXTENSION 1 -#include #include #include -#include +#include #include #include -#include +#include +#include class Java; -#define V8_HIDDEN_MARKER_JAVA_LONG "__isJavaLong" +#define V8_HIDDEN_MARKER_JAVA_LONG "__isJavaLong" #define V8_HIDDEN_MARKER_JAVA_OBJECT "__isJavaObject" typedef enum _jvalueType { - TYPE_VOID = 1, - TYPE_INT = 2, - TYPE_LONG = 3, - TYPE_OBJECT = 4, - TYPE_STRING = 5, + TYPE_VOID = 1, + TYPE_INT = 2, + TYPE_LONG = 3, + TYPE_OBJECT = 4, + TYPE_STRING = 5, TYPE_BOOLEAN = 6, - TYPE_SHORT = 7, - TYPE_BYTE = 8, - TYPE_DOUBLE = 9, - TYPE_FLOAT = 10, - TYPE_ARRAY = 11, - TYPE_CHAR = 12 + TYPE_SHORT = 7, + TYPE_BYTE = 8, + TYPE_DOUBLE = 9, + TYPE_FLOAT = 10, + TYPE_ARRAY = 11, + TYPE_CHAR = 12 } jvalueType; struct DynamicProxyData { unsigned int markerStart; - Java* java; + Java *java; std::string interfaceName; Nan::Persistent functions; Nan::Persistent jsObject; @@ -51,116 +51,117 @@ struct DynamicProxyJsCallData { }; #define DYNAMIC_PROXY_DATA_MARKER_START 0x12345678 -#define DYNAMIC_PROXY_DATA_MARKER_END 0x87654321 +#define DYNAMIC_PROXY_DATA_MARKER_END 0x87654321 -int dynamicProxyDataVerify(DynamicProxyData* data); +int dynamicProxyDataVerify(DynamicProxyData *data); -void javaReflectionGetMethods(JNIEnv *env, jclass clazz, std::list* methods, bool includeStatic); -void javaReflectionGetConstructors(JNIEnv *env, jclass clazz, std::list* methods); -void javaReflectionGetFields(JNIEnv *env, jclass clazz, std::list* fields); +void javaReflectionGetMethods(JNIEnv *env, jclass clazz, std::list *methods, bool includeStatic); +void javaReflectionGetConstructors(JNIEnv *env, jclass clazz, std::list *methods); +void javaReflectionGetFields(JNIEnv *env, jclass clazz, std::list *fields); std::string javaToString(JNIEnv *env, jstring str); std::string javaObjectToString(JNIEnv *env, jobject obj); std::string javaArrayToString(JNIEnv *env, jobjectArray arr); std::string javaMethodCallToString(JNIEnv *env, jobject obj, jmethodID methodId, jarray args); -JNIEnv* javaGetEnv(JavaVM* jvm, jobject classLoader); +JNIEnv *javaGetEnv(JavaVM *jvm, jobject classLoader); jobject getSystemClassLoader(JNIEnv *env); jvalueType javaGetArrayComponentType(JNIEnv *env, jobjectArray array); jvalueType javaGetType(JNIEnv *env, jclass type); -jobjectArray v8ToJava(JNIEnv* env, Nan::NAN_METHOD_ARGS_TYPE args, int start, int end); -jobject v8ToJava(JNIEnv* env, v8::Local arg); -v8::Local javaExceptionToV8(Java* java, JNIEnv* env, const std::string& alternateMessage); -v8::Local javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex, const std::string& alternateMessage); -std::string javaExceptionToString(JNIEnv* env, jthrowable ex); -void checkJavaException(JNIEnv* env); -v8::Local javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArray); -v8::Local javaToV8(Java* java, JNIEnv* env, jobject obj); -v8::Local javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProxyData* dynamicProxyData); +jobjectArray v8ToJava(JNIEnv *env, Nan::NAN_METHOD_ARGS_TYPE args, int start, int end); +jobject v8ToJava(JNIEnv *env, v8::Local arg); +v8::Local javaExceptionToV8(Java *java, JNIEnv *env, const std::string &alternateMessage); +v8::Local javaExceptionToV8(Java *java, JNIEnv *env, jthrowable ex, const std::string &alternateMessage); +std::string javaExceptionToString(JNIEnv *env, jthrowable ex); +void checkJavaException(JNIEnv *env); +v8::Local javaArrayToV8(Java *java, JNIEnv *env, jobjectArray objArray); +v8::Local javaToV8(Java *java, JNIEnv *env, jobject obj); +v8::Local javaToV8(Java *java, JNIEnv *env, jobject obj, DynamicProxyData *dynamicProxyData); jobjectArray javaObjectArrayToClasses(JNIEnv *env, jobjectArray objs); jobject longToJavaLongObj(JNIEnv *env, jlong l); jarray javaGetArgsForMethod(JNIEnv *env, jobject method, jarray args); jarray javaGetArgsForConstructor(JNIEnv *env, jobject method, jarray args); -jclass javaFindClass(JNIEnv* env, const std::string& className); -jobject javaFindField(JNIEnv* env, jclass clazz, const std::string& fieldName); -jobject javaFindMethod(JNIEnv *env, jclass clazz, const std::string& methodName, jobjectArray methodArgs); +jclass javaFindClass(JNIEnv *env, const std::string &className); +jobject javaFindField(JNIEnv *env, jclass clazz, const std::string &fieldName); +jobject javaFindMethod(JNIEnv *env, jclass clazz, const std::string &methodName, jobjectArray methodArgs); jobject javaFindConstructor(JNIEnv *env, jclass clazz, jobjectArray methodArgs); void javaCastArguments(JNIEnv *env, jobjectArray methodArgs, jobject method); // TODO remove these functions after node nan gets updated v8::Local GetHiddenValue(v8::Local object, v8::Local key); void SetHiddenValue(v8::Local object, v8::Local key, v8::Local value); -void SetHiddenValue(v8::NumberObject*, v8::Local key, v8::Local value); +void SetHiddenValue(v8::NumberObject *, v8::Local key, v8::Local value); -#define assertNoException(env) \ - if (env->ExceptionCheck()) { \ - env->ExceptionDescribe(); \ - assert(false); \ +#define assertNoException(env) \ + if (env->ExceptionCheck()) { \ + env->ExceptionDescribe(); \ + assert(false); \ } -std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string& methodNameSig, bool constructor, Nan::NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd); +std::string methodNotFoundToString(JNIEnv *env, jclass clazz, const std::string &methodNameSig, bool constructor, + Nan::NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd); -void unref(DynamicProxyData* dynamicProxyData); +void unref(DynamicProxyData *dynamicProxyData); #define UNUSED_VARIABLE(var) var = var; -#define ARGS_FRONT_OBJECT(ARGNAME) \ - if(info.Length() < argsStart+1 || !info[argsStart]->IsObject()) { \ - std::ostringstream errStr; \ - errStr << "Argument " << (argsStart+1) << " must be an object"; \ - Nan::ThrowError(Nan::TypeError(errStr.str().c_str())); \ - return; \ - } \ - v8::Local ARGNAME = v8::Local::Cast(info[argsStart]); \ +#define ARGS_FRONT_OBJECT(ARGNAME) \ + if (info.Length() < argsStart + 1 || !info[argsStart]->IsObject()) { \ + std::ostringstream errStr; \ + errStr << "Argument " << (argsStart + 1) << " must be an object"; \ + Nan::ThrowError(Nan::TypeError(errStr.str().c_str())); \ + return; \ + } \ + v8::Local ARGNAME = v8::Local::Cast(info[argsStart]); \ argsStart++; -#define ARGS_FRONT_STRING(ARGNAME) \ - if(info.Length() < argsStart+1 || !info[argsStart]->IsString()) { \ - std::ostringstream errStr; \ - errStr << "Argument " << (argsStart+1) << " must be a string"; \ - Nan::ThrowError(Nan::TypeError(errStr.str().c_str())); \ - return; \ - } \ - v8::Local _##ARGNAME##_obj = v8::Local::Cast(info[argsStart]); \ - Nan::Utf8String _##ARGNAME##_val(_##ARGNAME##_obj); \ - std::string ARGNAME = *_##ARGNAME##_val; \ +#define ARGS_FRONT_STRING(ARGNAME) \ + if (info.Length() < argsStart + 1 || !info[argsStart]->IsString()) { \ + std::ostringstream errStr; \ + errStr << "Argument " << (argsStart + 1) << " must be a string"; \ + Nan::ThrowError(Nan::TypeError(errStr.str().c_str())); \ + return; \ + } \ + v8::Local _##ARGNAME##_obj = v8::Local::Cast(info[argsStart]); \ + Nan::Utf8String _##ARGNAME##_val(_##ARGNAME##_obj); \ + std::string ARGNAME = *_##ARGNAME##_val; \ argsStart++; #define ARGS_FRONT_CLASSNAME() ARGS_FRONT_STRING(className) -#define ARGS_BACK_CALLBACK() \ - bool callbackProvided; \ - v8::Local callback; \ - if(info[info.Length()-1]->IsFunction()) { \ - callback = info[argsEnd-1]; \ - argsEnd--; \ - callbackProvided = true; \ - } else { \ - callback = Nan::Null(); \ - callbackProvided = false; \ +#define ARGS_BACK_CALLBACK() \ + bool callbackProvided; \ + v8::Local callback; \ + if (info[info.Length() - 1]->IsFunction()) { \ + callback = info[argsEnd - 1]; \ + argsEnd--; \ + callbackProvided = true; \ + } else { \ + callback = Nan::Null(); \ + callbackProvided = false; \ } -#define EXCEPTION_CALL_CALLBACK(JAVA, STRBUILDER) \ - std::ostringstream errStr; \ - errStr << STRBUILDER; \ - v8::Local error = javaExceptionToV8(JAVA, env, errStr.str()); \ - v8::Local argv[2]; \ - argv[0] = error; \ - argv[1] = Nan::Undefined(); \ +#define EXCEPTION_CALL_CALLBACK(JAVA, STRBUILDER) \ + std::ostringstream errStr; \ + errStr << STRBUILDER; \ + v8::Local error = javaExceptionToV8(JAVA, env, errStr.str()); \ + v8::Local argv[2]; \ + argv[0] = error; \ + argv[1] = Nan::Undefined(); \ Nan::Call(callback.As(), Nan::GetCurrentContext()->Global(), 2, argv); -#define END_CALLBACK_FUNCTION(MSG) \ - if(callbackProvided) { \ - info.GetReturnValue().SetUndefined(); \ - return; \ - } else { \ - std::ostringstream str; \ - str << MSG; \ - info.GetReturnValue().Set(Nan::New(str.str().c_str()).ToLocalChecked()); \ - return; \ +#define END_CALLBACK_FUNCTION(MSG) \ + if (callbackProvided) { \ + info.GetReturnValue().SetUndefined(); \ + return; \ + } else { \ + std::ostringstream str; \ + str << MSG; \ + info.GetReturnValue().Set(Nan::New(str.str().c_str()).ToLocalChecked()); \ + return; \ } #ifndef UNUSED_VARIABLE - #define UNUSED_VARIABLE(a) a = a; +#define UNUSED_VARIABLE(a) a = a; #endif #endif diff --git a/test/TestLambda.test.js b/test/TestLambda.test.js index 423170b1..f2b7b135 100644 --- a/test/TestLambda.test.js +++ b/test/TestLambda.test.js @@ -3,22 +3,21 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Java8', () => { - test('call methods of a class that uses lambda expressions', () => { +describe("Java8", () => { + test("call methods of a class that uses lambda expressions", () => { try { - const TestLambda = java.import('TestLambda'); + const TestLambda = java.import("TestLambda"); const lambda = new TestLambda(); const sum = lambda.testLambdaAdditionSync(23, 42); expect(sum).toBe(65); const diff = lambda.testLambdaSubtractionSync(23, 42); expect(diff).toBe(-19); - } - catch (err) { - const unsupportedVersion = java.instanceOf(err.cause, 'java.lang.UnsupportedClassVersionError'); + } catch (err) { + const unsupportedVersion = java.instanceOf(err.cause, "java.lang.UnsupportedClassVersionError"); if (unsupportedVersion) { - console.log('JRE 1.8 not available'); + console.log("JRE 1.8 not available"); } else { - console.error('Java8 test failed with unknown error:', err); + console.error("Java8 test failed with unknown error:", err); throw err; } } diff --git a/test/awt.test.js b/test/awt.test.js index 5d13d78c..34d1f004 100644 --- a/test/awt.test.js +++ b/test/awt.test.js @@ -1,15 +1,14 @@ - -import path from 'node:path'; +import path from "node:path"; import { describe, expect, test } from "vitest"; import { getJava } from "../testHelpers"; const java = getJava(); -describe('AWT', () => { +describe("AWT", () => { test("calling AWT method (see issue 1)", () => { const headlessVal = java.callStaticMethodSync("java.lang.System", "getProperty", "java.awt.headless"); console.log("java.awt.headless =", headlessVal); - expect(headlessVal).toBe('true'); + expect(headlessVal).toBe("true"); const filename = path.join(path.dirname(__filename), "nodejs.png"); const file = java.newInstanceSync("java.io.File", filename); const image = java.callStaticMethodSync("javax.imageio.ImageIO", "read", file); diff --git a/test/dynamicProxy.test.js b/test/dynamicProxy.test.js index 997a2396..aee05436 100644 --- a/test/dynamicProxy.test.js +++ b/test/dynamicProxy.test.js @@ -3,14 +3,14 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Dynamic Proxy', () => { +describe("Dynamic Proxy", () => { test("0 Arguments", () => { let callCount = 0; - const myProxy = java.newProxy('RunInterface$Interface0Arg', { + const myProxy = java.newProxy("RunInterface$Interface0Arg", { run: function () { callCount++; - } + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -20,25 +20,25 @@ describe('Dynamic Proxy', () => { }); test("1 Arguments", () => { - let runData = ''; + let runData = ""; - const myProxy = java.newProxy('RunInterface$Interface1Arg', { + const myProxy = java.newProxy("RunInterface$Interface1Arg", { run: function (str) { runData += str; - } + }, }); const runInterface = java.newInstanceSync("RunInterface"); runInterface.run1ArgsSync(myProxy); - expect(runData).toBe('test1test1'); + expect(runData).toBe("test1test1"); }); test("1 Arguments with return data", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { run: function (i) { return i + 1; - } + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -48,29 +48,29 @@ describe('Dynamic Proxy', () => { }); test("Listener test", () => { - let runData = ''; + let runData = ""; - const myProxy = java.newProxy('ListenerInterface', { - onEvent: function (list, runtime) { - runData = 'onEvent'; - } + const myProxy = java.newProxy("ListenerInterface", { + onEvent: function (_list, _runtime) { + runData = "onEvent"; + }, }); const listenerTester = java.newInstanceSync("ListenerTester"); listenerTester.setListenerSync(myProxy); listenerTester.raiseEventSync(); - expect(runData).toBe('onEvent'); + expect(runData).toBe("onEvent"); }); test("thread", async () => { await new Promise((resolve, reject) => { let callCount = 0; - const myProxy = java.newProxy('java.lang.Runnable', { + const myProxy = java.newProxy("java.lang.Runnable", { run: function () { callCount++; - } + }, }); const thread = java.newInstanceSync("java.lang.Thread", myProxy); @@ -94,11 +94,11 @@ describe('Dynamic Proxy', () => { }); test("thread issue #143", async () => { - await new Promise(resolve => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { + await new Promise((resolve) => { + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { run: function (i) { return i - 1; - } + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -110,8 +110,7 @@ describe('Dynamic Proxy', () => { }); test("java equals()", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - }); + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", {}); const runInterface = java.newInstanceSync("RunInterface"); const result = runInterface.runEqualsSync(myProxy); @@ -120,8 +119,7 @@ describe('Dynamic Proxy', () => { }); test("java equals() same instance", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - }); + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", {}); const runInterface = java.newInstanceSync("RunInterface"); runInterface.setInstanceSync(myProxy); @@ -131,8 +129,8 @@ describe('Dynamic Proxy', () => { }); test("java equals() different instance", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', {}); - const myProxy2 = java.newProxy('RunInterface$InterfaceWithReturn', {}); + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", {}); + const myProxy2 = java.newProxy("RunInterface$InterfaceWithReturn", {}); const runInterface = java.newInstanceSync("RunInterface"); runInterface.setInstanceSync(myProxy); @@ -142,10 +140,10 @@ describe('Dynamic Proxy', () => { }); test("js equals()", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - equals: function (obj) { + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { + equals: function (_obj) { return true; - } + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -155,8 +153,7 @@ describe('Dynamic Proxy', () => { }); test("java hashCode()", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - }); + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", {}); const runInterface = java.newInstanceSync("RunInterface"); const result = runInterface.runHashCodeSync(myProxy); @@ -168,10 +165,10 @@ describe('Dynamic Proxy', () => { }); test("js hashCode()", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { hashCode: function () { return 1234; - } + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -181,7 +178,7 @@ describe('Dynamic Proxy', () => { }); test("java toString()", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', {}); + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", {}); const runInterface = java.newInstanceSync("RunInterface"); const result = runInterface.runToStringSync(myProxy); @@ -190,10 +187,10 @@ describe('Dynamic Proxy', () => { }); test("js toString()", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - toString: function () { + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { + toString: () => { return "myRunInterface"; - } + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -203,10 +200,10 @@ describe('Dynamic Proxy', () => { }); test("js string error", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - run: function (i) { - throw 'myError'; - } + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { + run: (_i) => { + throw "myError"; + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -220,10 +217,10 @@ describe('Dynamic Proxy', () => { }); test("js Error", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - run: function (i) { - throw new Error('newError'); - } + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { + run: function (_i) { + throw new Error("newError"); + }, }); const runInterface = java.newInstanceSync("RunInterface"); @@ -237,10 +234,10 @@ describe('Dynamic Proxy', () => { }); test("invocationHandler", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { - run: function (i) { + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { + run: (i) => { return i + 2; - } + }, }); const result = myProxy.invocationHandler.run(42); @@ -249,10 +246,10 @@ describe('Dynamic Proxy', () => { }); test("unref", () => { - const myProxy = java.newProxy('RunInterface$InterfaceWithReturn', { + const myProxy = java.newProxy("RunInterface$InterfaceWithReturn", { run: function (i) { return i + 1; - } + }, }); myProxy.unref(); diff --git a/test/importClass.test.js b/test/importClass.test.js index 72466712..63e64481 100644 --- a/test/importClass.test.js +++ b/test/importClass.test.js @@ -3,19 +3,19 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Import Class', () => { +describe("Import Class", () => { afterEach(() => { java.setStaticFieldValue("Test", "staticFieldInt", 42); }); test("import", async () => { - const Test = java.import('Test'); + const Test = java.import("Test"); expect(Test.staticFieldInt).toBe(42); Test.staticFieldInt = 200; expect(Test.staticFieldInt).toBe(200); expect(Test.staticMethodSync(99)).toBe(100); - await new Promise(resolve => { + await new Promise((resolve) => { Test.staticMethod(99, (err, result) => { expect(err).toBeFalsy(); expect(result).toBe(100); @@ -28,23 +28,23 @@ describe('Import Class', () => { }); test("import TestEnum with unsable name", () => { - const TestEnum = java.import('Test$Enum'); + const TestEnum = java.import("Test$Enum"); // 'foo' and 'bar' are valid enum names expect(TestEnum.foo.toStringSync()).toBe("foo"); expect(TestEnum.bar.toStringSync()).toBe("bar"); - ['name', 'arguments', 'caller'].forEach(function (prop) { + ["name", "arguments", "caller"].forEach(function (prop) { expect(() => { // The enum also defines 'name', 'caller', and 'attributes', but Javascript prevents us from using them, // since these are unwritable properties of Function. - const x = TestEnum[prop].toStringSync(); - }).toThrow(TypeError) + TestEnum[prop].toStringSync(); + }).toThrow(TypeError); }); }); test("import TestEnum and use alternate name", () => { - const TestEnum = java.import('Test$Enum'); + const TestEnum = java.import("Test$Enum"); // 'foo' and 'bar' are valid enum names expect(TestEnum.foo.toStringSync()).toBe("foo"); diff --git a/test/instanceof.test.js b/test/instanceof.test.js index d04e33c1..4f8f3ceb 100644 --- a/test/instanceof.test.js +++ b/test/instanceof.test.js @@ -3,7 +3,7 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('instanceOf', () => { +describe("instanceOf", () => { test("working", () => { const subclass = java.newInstanceSync("Test$SubClass"); if (!java.instanceOf(subclass, "Test$SuperClass")) { diff --git a/test/java-ambiguousMethod.test.js b/test/java-ambiguousMethod.test.js index efbdfa01..c1a367ce 100644 --- a/test/java-ambiguousMethod.test.js +++ b/test/java-ambiguousMethod.test.js @@ -3,32 +3,32 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Java - Call Ambiguous Method', () => { +describe("Java - Call Ambiguous Method", () => { test("staticMethodAmbiguous (sync) - int passed to double", () => { - const result = java.callStaticMethodSync('Test', 'staticMethodAmbiguous(Ljava/lang/Double;)I', 1); + const result = java.callStaticMethodSync("Test", "staticMethodAmbiguous(Ljava/lang/Double;)I", 1); expect(result).toBe(1); }); test("staticMethodAmbiguous (sync) - double passed to int", () => { - const result = java.callStaticMethodSync('Test', 'staticMethodAmbiguous(Ljava/lang/Integer;)I', 1.1); + const result = java.callStaticMethodSync("Test", "staticMethodAmbiguous(Ljava/lang/Integer;)I", 1.1); expect(result).toBe(2); }); test("staticMethodAmbiguous (sync) - method not found wrong argument type", () => { expect(() => { - java.callStaticMethodSync('Test', 'staticMethodAmbiguous(Ljava/lang/String;)I', 1); + java.callStaticMethodSync("Test", "staticMethodAmbiguous(Ljava/lang/String;)I", 1); }).toThrow(); }); test("staticMethodAmbiguous (sync) - method failed because argument count mismatch", () => { expect(() => { - java.callStaticMethodSync('Test', 'staticMethodAmbiguous(Ljava/lang/Integer;)I', 1, 2); + java.callStaticMethodSync("Test", "staticMethodAmbiguous(Ljava/lang/Integer;)I", 1, 2); }).toThrow(); }); test("staticMethodAmbiguous - int passed to double", async () => { - await new Promise(resolve => { - java.callStaticMethod('Test', 'staticMethodAmbiguous(Ljava/lang/Double;)I', 1, function (err, result) { + await new Promise((resolve) => { + java.callStaticMethod("Test", "staticMethodAmbiguous(Ljava/lang/Double;)I", 1, function (err, result) { expect(err).toBeFalsy(); expect(result).toBe(1); resolve(); @@ -37,8 +37,8 @@ describe('Java - Call Ambiguous Method', () => { }); test("staticMethodAmbiguous - double passed to int", async () => { - await new Promise(resolve => { - java.callStaticMethod('Test', 'staticMethodAmbiguous(Ljava/lang/Integer;)I', 1.1, function (err, result) { + await new Promise((resolve) => { + java.callStaticMethod("Test", "staticMethodAmbiguous(Ljava/lang/Integer;)I", 1.1, function (err, result) { expect(err).toBeFalsy(); expect(result).toBe(2); resolve(); @@ -47,8 +47,8 @@ describe('Java - Call Ambiguous Method', () => { }); test("staticMethodAmbiguous - method not found", async () => { - await new Promise(resolve => { - java.callStaticMethod('Test', 'staticMethodAmbiguous(Ljava/lang/String;)I', 1, function (err, result) { + await new Promise((resolve) => { + java.callStaticMethod("Test", "staticMethodAmbiguous(Ljava/lang/String;)I", 1, function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); resolve(); @@ -57,8 +57,8 @@ describe('Java - Call Ambiguous Method', () => { }); test("staticMethodAmbiguous - method argument count mismatch", async () => { - await new Promise(resolve => { - java.callStaticMethod('Test', 'staticMethodAmbiguous(Ljava/lang/Integer;)I', 1, 2, function (err, result) { + await new Promise((resolve) => { + java.callStaticMethod("Test", "staticMethodAmbiguous(Ljava/lang/Integer;)I", 1, 2, function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); resolve(); @@ -68,27 +68,27 @@ describe('Java - Call Ambiguous Method', () => { test("methodAmbiguous (sync) - int passed to double", () => { const myTest = java.newInstanceSync("Test"); - const result = java.callMethodSync(myTest, 'methodAmbiguous(Ljava/lang/Double;)I', 1); + const result = java.callMethodSync(myTest, "methodAmbiguous(Ljava/lang/Double;)I", 1); expect(result).toBe(1); }); test("methodAmbiguous (sync) - double passed to int", () => { const myTest = java.newInstanceSync("Test"); - const result = java.callMethodSync(myTest, 'methodAmbiguous(Ljava/lang/Integer;)I', 1.1); + const result = java.callMethodSync(myTest, "methodAmbiguous(Ljava/lang/Integer;)I", 1.1); expect(result).toBe(2); }); test("methodAmbiguous (sync) - method not found wrong argument type", () => { const myTest = java.newInstanceSync("Test"); expect(() => { - java.callMethodSync(myTest, 'methodAmbiguous(Ljava/lang/String;)I', 1); + java.callMethodSync(myTest, "methodAmbiguous(Ljava/lang/String;)I", 1); }).toThrow(); }); test("methodAmbiguous (sync) - method failed because argument count mismatch", () => { const myTest = java.newInstanceSync("Test"); expect(() => { - java.callMethodSync(myTest, 'methodAmbiguous(Ljava/lang/Integer;)I', 1, 2); + java.callMethodSync(myTest, "methodAmbiguous(Ljava/lang/Integer;)I", 1, 2); }).toThrow(); }); }); diff --git a/test/java-callStaticMethod.test.js b/test/java-callStaticMethod.test.js index d6885e47..fd4978d8 100644 --- a/test/java-callStaticMethod.test.js +++ b/test/java-callStaticMethod.test.js @@ -3,9 +3,9 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Java - Call Static Method', () => { +describe("Java - Call Static Method", () => { test("callStaticMethod", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethod", (err, result) => { expect(err).toBeFalsy(); expect(result).toBeTruthy(); @@ -17,7 +17,9 @@ describe('Java - Call Static Method', () => { test("callStaticMethod without a callback", () => { const result = java.callStaticMethod("Test", "staticMethod"); - expect(result).toBe(`"Static method 'staticMethod' called without a callback did you mean to use the Sync version?"`); + expect(result).toBe( + `"Static method 'staticMethod' called without a callback did you mean to use the Sync version?"` + ); }); test("callStaticMethodSync", () => { @@ -27,7 +29,7 @@ describe('Java - Call Static Method', () => { }); test("callStaticMethod with args", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethod", 42, (err, result) => { expect(err).toBeFalsy(); expect(result).toBeTruthy(); @@ -51,7 +53,7 @@ describe('Java - Call Static Method', () => { }); test("callStaticMethod bad class name", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("BadClassName", "staticMethod", function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); @@ -60,7 +62,6 @@ describe('Java - Call Static Method', () => { }); }); - test("callStaticMethodSync bad class name", () => { expect(() => { java.callStaticMethodSync("BadClassName", "staticMethod"); @@ -68,7 +69,7 @@ describe('Java - Call Static Method', () => { }); test("callStaticMethod bad arg types", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethod", "z", function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); @@ -84,7 +85,7 @@ describe('Java - Call Static Method', () => { }); test("callStaticMethod bad number of args", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethod", 42, "z", function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); @@ -100,7 +101,7 @@ describe('Java - Call Static Method', () => { }); test("callStaticMethod bad method name", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "badMethodName", function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); @@ -120,9 +121,9 @@ describe('Java - Call Static Method', () => { let result; try { result = java.callStaticMethodSync("Test", "staticMethodThrows", ex); - throw new Error('expected error'); + throw new Error("expected error"); } catch (err) { - expect(err.cause.getMessageSync()).toBe('my exception'); + expect(err.cause.getMessageSync()).toBe("my exception"); expect(err.toString()).toMatch(/my exception/); expect(result).toBeFalsy(); } @@ -140,10 +141,10 @@ describe('Java - Call Static Method', () => { test("staticMethodThrows exception thrown from method", async () => { const ex = java.newInstanceSync("java.lang.Exception", "my exception"); - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethodThrows", ex, function (err, result) { expect(err).toBeTruthy(); - expect(err.cause.getMessageSync()).toBe('my exception'); + expect(err.cause.getMessageSync()).toBe("my exception"); expect(err.toString()).toMatch(/my exception/); expect(result).toBeFalsy(); resolve(); @@ -161,10 +162,10 @@ describe('Java - Call Static Method', () => { }); test("staticMethodThrowsNewException exception thrown from method", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethodThrowsNewException", function (err, result) { expect(err).toBeTruthy(); - expect(err.cause.getMessageSync()).toBe('my exception'); + expect(err.cause.getMessageSync()).toBe("my exception"); expect(err.toString()).toMatch(/my exception/); expect(result).toBeFalsy(); resolve(); @@ -186,7 +187,7 @@ describe('Java - Call Static Method', () => { test("methodThrows exception thrown from method", async () => { const ex = java.newInstanceSync("java.lang.Exception", "my exception"); const myTest = java.newInstanceSync("Test"); - await new Promise(resolve => { + await new Promise((resolve) => { return myTest.methodThrows(ex, function (err) { expect(err.toString()).toMatch(/my exception/); resolve(); @@ -206,7 +207,7 @@ describe('Java - Call Static Method', () => { test("methodThrowsNewException exception thrown from method", async () => { const myTest = java.newInstanceSync("Test"); - await new Promise(resolve => { + await new Promise((resolve) => { myTest.methodThrowsNewException((err) => { expect(err.toString()).toMatch(/my exception/); resolve(); @@ -215,8 +216,8 @@ describe('Java - Call Static Method', () => { }); test("char array", async () => { - const charArray = java.newArray("char", "hello world\n".split('')); - await new Promise(resolve => { + const charArray = java.newArray("char", "hello world\n".split("")); + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethodCharArrayToString", charArray, function (err, result) { expect(err).toBeFalsy(); expect(result).toBeTruthy(); @@ -227,7 +228,7 @@ describe('Java - Call Static Method', () => { }); test("String passed in for Object", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "static2Objects", "1", "2", function (err, result) { expect(err).toBeFalsy(); expect(result).toBe(false); @@ -238,14 +239,14 @@ describe('Java - Call Static Method', () => { test("java.lang.Long addition", () => { const javaLong = java.newInstanceSync("java.lang.Long", 5); - expect(javaLong.toString()).toBe('5'); + expect(javaLong.toString()).toBe("5"); const result = javaLong + 1; expect(result).toBe(6); }); test("java.lang.Long calls (java Long)", async () => { const javaLong = java.newInstanceSync("java.lang.Long", 5); - await new Promise(resolve => { + await new Promise((resolve) => { java.callStaticMethod("Test", "staticMethodLongToString", javaLong, function (err, result) { expect(err).toBeFalsy(); expect(result).toBeTruthy(); @@ -273,15 +274,15 @@ describe('Java - Call Static Method', () => { test("Call static method with varargs", () => { const Test = java.import("Test"); - let str = Test.staticVarargsSync(5, java.newArray('java.lang.String', ['a', 'b', 'c'])); + let str = Test.staticVarargsSync(5, java.newArray("java.lang.String", ["a", "b", "c"])); expect(str).toBe("5abc"); - str = Test.staticVarargsSync(5, 'a', 'b', 'c'); + str = Test.staticVarargsSync(5, "a", "b", "c"); expect(str).toBe("5abc"); }); test("Call static method named name_", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { const Test = java.import("Test"); Test.name_((err) => { expect(err).toBeFalsy(); diff --git a/test/java-newInstance.test.js b/test/java-newInstance.test.js index 2e7c4df3..038373ee 100644 --- a/test/java-newInstance.test.js +++ b/test/java-newInstance.test.js @@ -3,9 +3,9 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Java - New Instance', () => { +describe("Java - New Instance", () => { test("newInstance", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.newInstance("Test", (err, result) => { expect(err).toBeFalsy(); expect(result).toBeTruthy(); @@ -27,14 +27,14 @@ describe('Java - New Instance', () => { }); test("newInstance with args", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.newInstance("Test", 42, function (err, result) { expect(err).toBeFalsy(); expect(result).toBeTruthy(); expect(result.getIntSync()).toBe(42); resolve(); }); - }) + }); }); test("newInstanceSync with args", () => { @@ -44,7 +44,7 @@ describe('Java - New Instance', () => { }); test("newInstance bad class name", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.newInstance("BadClassName", (err, result) => { expect(err).toBeTruthy(); expect(result).toBeFalsy(); @@ -60,8 +60,8 @@ describe('Java - New Instance', () => { }); test("newInstance bad arg types", async () => { - await new Promise(resolve => { - java.newInstance("Test", 'a', function (err, result) { + await new Promise((resolve) => { + java.newInstance("Test", "a", function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); resolve(); @@ -71,12 +71,12 @@ describe('Java - New Instance', () => { test("newInstanceSync bad arg types", () => { expect(() => { - java.newInstanceSync("Test", 'a'); + java.newInstanceSync("Test", "a"); }).toThrow(); }); test("newInstance bad number of args", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.newInstance("Test", 42, 15, function (err, result) { expect(err).toBeTruthy(); expect(result).toBeFalsy(); @@ -93,7 +93,7 @@ describe('Java - New Instance', () => { test("newInstance exception thrown from constructor", async () => { const ex = java.newInstanceSync("java.lang.Exception", "my exception"); - await new Promise(resolve => { + await new Promise((resolve) => { java.newInstance("TestExceptions", ex, function (err, result) { expect(err).toBeTruthy(); expect(err.toString()).toMatch(/my exception/); @@ -109,7 +109,7 @@ describe('Java - New Instance', () => { }); test("newInstanceSync with varargs", () => { - let result = java.newInstanceSync("Test", 42, java.newArray('java.lang.String', ["a", "b"])); + let result = java.newInstanceSync("Test", 42, java.newArray("java.lang.String", ["a", "b"])); expect(result).toBeTruthy(); result = java.newInstanceSync("Test", 42, "a"); diff --git a/test/java-staticField.test.js b/test/java-staticField.test.js index 1abe110f..aff3a4cd 100644 --- a/test/java-staticField.test.js +++ b/test/java-staticField.test.js @@ -3,7 +3,7 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Java - Static Field', () => { +describe("Java - Static Field", () => { afterEach(() => { java.setStaticFieldValue("Test", "staticFieldInt", 42); }); diff --git a/test/javaObject.test.js b/test/javaObject.test.js index 24ad054a..d3ddd627 100644 --- a/test/javaObject.test.js +++ b/test/javaObject.test.js @@ -3,12 +3,12 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Java Object', () => { +describe("Java Object", () => { let testObj; beforeEach(() => { testObj = java.newInstanceSync("Test"); - }) + }); test("field", () => { expect(testObj.nonstaticInt).toBe(42); diff --git a/test/promises.test.js b/test/promises.test.js index ceebc43c..9bb559a4 100644 --- a/test/promises.test.js +++ b/test/promises.test.js @@ -3,7 +3,7 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Promises', () => { +describe("Promises", () => { test("create an instance of a class and call methods (getClassPromise & getNamePromise)", async () => { // Adapted from a test in simple-test.js const list = await java.newInstancePromise("java.util.ArrayList"); @@ -17,7 +17,7 @@ describe('Promises', () => { }); test("import and execute promisified static method", async () => { - var Test = java.import('Test'); + const Test = java.import("Test"); const result = await Test.staticMethodPromise(99); expect(result).toBe(100); }); @@ -43,32 +43,31 @@ describe('Promises', () => { const name = await clazz.getNamePromise(); expect(name).toBe("java.util.ArrayList"); - await list.addPromise('hello'); - await list.addPromise('world'); - await list.addPromise('boo'); + await list.addPromise("hello"); + await list.addPromise("world"); + await list.addPromise("boo"); const it = await list.iteratorPromise(); expect(it).toBeTruthy(); let val = await it.nextPromise(); expect(val).toBeTruthy(); console.log(typeof val, val); - expect(val).toBe('hello'); // java.lang.InternalError exception thrown here with OpenJDK + expect(val).toBe("hello"); // java.lang.InternalError exception thrown here with OpenJDK val = await it.nextPromise(); expect(val).toBeTruthy(); console.log(typeof val, val); - expect(val).toBe('world'); + expect(val).toBe("world"); val = await it.nextPromise(); expect(val).toBeTruthy(); console.log(typeof val, val); - expect(val).toBe('boo'); + expect(val).toBe("boo"); const more = await it.hasNextPromise(); console.log(typeof more, more); expect(more).toBeFalsy(false); - expect(async () => await it.nextPromise()).rejects.toThrowError(); + await expect(async () => await it.nextPromise()).rejects.toThrowError(); }); }); - diff --git a/test/simple.test.js b/test/simple.test.js index fc908ccb..92aa8d4f 100644 --- a/test/simple.test.js +++ b/test/simple.test.js @@ -3,7 +3,7 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('Simple', () => { +describe("Simple", () => { test("test classpath commons lang", () => { const result = java.callStaticMethodSync("org.apache.commons.lang3.ObjectUtils", "toString", "test"); console.log("org.apache.commons.lang3.ObjectUtils.toString:", result); @@ -12,35 +12,26 @@ describe('Simple', () => { test("test adding to classpath after other calls are made", () => { java.callStaticMethodSync("java.lang.System", "currentTimeMillis"); - try { - console.log('classpath', java.classpath); + expect(() => { + console.log("classpath", java.classpath); java.classpath = ["test/"]; - throw new Error("Exception should be thrown"); - } catch (e) { - // ok - } + }).toThrow(); }); test("test changing options after other calls are made", () => { java.callStaticMethodSync("java.lang.System", "currentTimeMillis"); - try { - console.log('options', java.options); + expect(() => { + console.log("options", java.options); java.options = ["newoption"]; - throw new Error("Exception should be thrown"); - } catch (e) { - // ok - } + }).toThrow(); }); test("test changing nativeBindingLocation after other calls are made", () => { java.callStaticMethodSync("java.lang.System", "currentTimeMillis"); - try { - console.log('nativeBindingLocation', java.nativeBindingLocation); + expect(() => { + console.log("nativeBindingLocation", java.nativeBindingLocation); java.nativeBindingLocation = "newNativeBindingLocation"; - throw new Error("Exception should be thrown"); - } catch (e) { - // ok - } + }).toThrow(); }); test("test static calls", () => { @@ -62,9 +53,8 @@ describe('Simple', () => { }); test("test method does not exists (async)", () => { - java.callStaticMethod("java.lang.System", "badMethod", function (err, result) { + java.callStaticMethod("java.lang.System", "badMethod", (err) => { if (err) { - return; } test.done(new Error("should throw exception")); @@ -72,7 +62,7 @@ describe('Simple', () => { }); test("create an instance of a class and call methods (getName) (async)", async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.newInstance("java.util.ArrayList", (err, list) => { expect(err).toBeFalsy(); expect(list).toBeTruthy(); @@ -112,11 +102,13 @@ describe('Simple', () => { resolve(); }); }); - }) + }); }); test("passing objects to methods", () => { - const dataArray = "hello world\n".split('').map(function (c) { return java.newByte(c.charCodeAt(0)); }); + const dataArray = "hello world\n".split("").map(function (c) { + return java.newByte(c.charCodeAt(0)); + }); const data = java.newArray("byte", dataArray); const stream = java.newInstanceSync("java.io.ByteArrayInputStream", data); const reader = java.newInstanceSync("java.io.InputStreamReader", stream); @@ -181,11 +173,11 @@ describe('Simple', () => { return l.toStringSync(); }); expect(arr.length).toBe(5); - expect(arr[0]).toBe('9223372036854775807'); - expect(arr[1]).toBe('-9223372036854775808'); - expect(arr[2]).toBe('3'); - expect(arr[3]).toBe('4'); - expect(arr[4]).toBe('5'); + expect(arr[0]).toBe("9223372036854775807"); + expect(arr[1]).toBe("-9223372036854775808"); + expect(arr[2]).toBe("3"); + expect(arr[3]).toBe("4"); + expect(arr[4]).toBe("5"); }); test("method returning a string (Unicode BMP)", () => { @@ -206,56 +198,56 @@ describe('Simple', () => { test("method taking a byte", () => { const b = java.newByte(1); - expect(b.getClassSync().getNameSync()).toBe('java.lang.Byte'); - expect(b.toStringSync()).toBe('1'); + expect(b.getClassSync().getNameSync()).toBe("java.lang.Byte"); + expect(b.toStringSync()).toBe("1"); const r = java.callStaticMethodSync("Test", "staticByte", b); expect(r).toBe(1); }); test("method taking a short", () => { const s = java.newShort(1); - expect(s.getClassSync().getNameSync()).toBe('java.lang.Short'); - expect(s.toStringSync()).toBe('1'); + expect(s.getClassSync().getNameSync()).toBe("java.lang.Short"); + expect(s.toStringSync()).toBe("1"); const r = java.callStaticMethodSync("Test", "staticShort", s); expect(r).toBe(1); }); test("method taking a double", () => { const s = java.newDouble(3.14); - expect(s.getClassSync().getNameSync()).toBe('java.lang.Double'); - expect(s.toStringSync()).toBe('3.14'); + expect(s.getClassSync().getNameSync()).toBe("java.lang.Double"); + expect(s.toStringSync()).toBe("3.14"); const r = java.callStaticMethodSync("Test", "staticDouble", s); expect(Math.abs(r - 3.14) < 0.0001, r + " != 3.14").toBeTruthy(); }); test("method taking a float", () => { const s = java.newFloat(3.14); - expect(s.getClassSync().getNameSync()).toBe('java.lang.Float'); - expect(s.toStringSync()).toBe('3.14'); + expect(s.getClassSync().getNameSync()).toBe("java.lang.Float"); + expect(s.toStringSync()).toBe("3.14"); const r = java.callStaticMethodSync("Test", "staticFloat", s); expect(Math.abs(r - 3.14) < 0.0001, r + " != 3.14").toBeTruthy(); }); test("method taking a long", () => { const l = java.newLong(1); - expect(l.getClassSync().getNameSync()).toBe('java.lang.Long'); - expect(l.toStringSync()).toBe('1'); + expect(l.getClassSync().getNameSync()).toBe("java.lang.Long"); + expect(l.toStringSync()).toBe("1"); const r = java.callStaticMethodSync("Test", "staticLong", l); expect(r).toBe(1); }); test("method taking a char (number)", () => { const ch = java.newChar(97); // 'a' - expect(ch.getClassSync().getNameSync()).toBe('java.lang.Character'); - expect(ch.toStringSync()).toBe('a'); + expect(ch.getClassSync().getNameSync()).toBe("java.lang.Character"); + expect(ch.toStringSync()).toBe("a"); const r = java.callStaticMethodSync("Test", "staticChar", ch); expect(r).toBe(97); }); test("method taking a char (string)", () => { - const ch = java.newChar('a'); - expect(ch.getClassSync().getNameSync()).toBe('java.lang.Character'); - expect(ch.toStringSync()).toBe('a'); + const ch = java.newChar("a"); + expect(ch.getClassSync().getNameSync()).toBe("java.lang.Character"); + expect(ch.toStringSync()).toBe("a"); const r = java.callStaticMethodSync("Test", "staticChar", ch); expect(r).toBe(97); }); @@ -320,7 +312,12 @@ describe('Simple', () => { }); test("new short array objects", () => { - const shortArray = java.newArray("java.lang.Short", [1, 2].map(function (c) { return java.newShort(c); })); + const shortArray = java.newArray( + "java.lang.Short", + [1, 2].map(function (c) { + return java.newShort(c); + }) + ); const r = java.callStaticMethodSync("Test", "staticShortArray", shortArray); expect(r.length).toBe(2); expect(r[0]).toBe(1); @@ -335,4 +332,3 @@ describe('Simple', () => { expect(r[1]).toBe(2); }); }); - diff --git a/test/utils-types.test.js b/test/utils-types.test.js index ac3036c0..7ad40d70 100644 --- a/test/utils-types.test.js +++ b/test/utils-types.test.js @@ -1,19 +1,22 @@ - import { describe, expect, test } from "vitest"; import { getJava } from "../testHelpers"; const java = getJava(); -describe('Utils - Types', () => { +describe("Utils - Types", () => { test("Array of Objects", () => { let val = java.getStaticFieldValue("Test", "staticArrayObjects"); expect(val).toBeNull(); - java.setStaticFieldValue("Test", "staticArrayObjects", java.newArray("Test", [ - java.newInstanceSync("Test", 1), - java.newInstanceSync("Test", 2), - java.newInstanceSync("Test", 3) - ])); + java.setStaticFieldValue( + "Test", + "staticArrayObjects", + java.newArray("Test", [ + java.newInstanceSync("Test", 1), + java.newInstanceSync("Test", 2), + java.newInstanceSync("Test", 3), + ]) + ); val = java.getStaticFieldValue("Test", "staticArrayObjects"); expect(val).toBeTruthy(); @@ -47,14 +50,14 @@ describe('Utils - Types', () => { }); test("Char array", () => { - const originalArray = "hello 世界\n".split(''); + const originalArray = "hello 世界\n".split(""); const Arrays = java.import("java.util.Arrays"); const arr1 = java.newArray("char", originalArray); const list = Arrays.asListSync(arr1); const arr2 = list.toArraySync(); expect(arr2.length).toBe(1); expect(arr2[0].length).toBe(9); - const isTypedArrayReturn = !(typeof arr2[0][0] === 'string'); + const isTypedArrayReturn = !(typeof arr2[0][0] === "string"); for (let i = 0; i < originalArray.length; i++) { if (isTypedArrayReturn) { expect(arr2[0][i]).toBe(originalArray[i].charCodeAt(0)); diff --git a/test/varargs.test.js b/test/varargs.test.js index a7f69e70..cd5fe753 100644 --- a/test/varargs.test.js +++ b/test/varargs.test.js @@ -3,81 +3,81 @@ import { getJava } from "../testHelpers"; const java = getJava(); -describe('varargs', () => { - test('array signature inference', () => { - const Test = java.import('Test'); - expect(Test.varArgsSignatureSync([])).toBe('Object...'); - expect(Test.varArgsSignatureSync(['a', 'b'])).toBe('String...'); - expect(Test.varArgsSignatureSync([1, 2])).toBe('Integer...'); - expect(Test.varArgsSignatureSync([1.1, 2])).toBe('Number...'); - expect(Test.varArgsSignatureSync([1.1, 'a'])).toBe('Object...'); - expect(Test.varArgsSignatureSync([true, 'a'])).toBe('Object...'); - expect(Test.varArgsSignatureSync([true, 1])).toBe('Object...'); - expect(Test.varArgsSignatureSync([true, 1.1])).toBe('Object...'); - expect(Test.varArgsSignatureSync([true, false])).toBe('Boolean...'); +describe("varargs", () => { + test("array signature inference", () => { + const Test = java.import("Test"); + expect(Test.varArgsSignatureSync([])).toBe("Object..."); + expect(Test.varArgsSignatureSync(["a", "b"])).toBe("String..."); + expect(Test.varArgsSignatureSync([1, 2])).toBe("Integer..."); + expect(Test.varArgsSignatureSync([1.1, 2])).toBe("Number..."); + expect(Test.varArgsSignatureSync([1.1, "a"])).toBe("Object..."); + expect(Test.varArgsSignatureSync([true, "a"])).toBe("Object..."); + expect(Test.varArgsSignatureSync([true, 1])).toBe("Object..."); + expect(Test.varArgsSignatureSync([true, 1.1])).toBe("Object..."); + expect(Test.varArgsSignatureSync([true, false])).toBe("Boolean..."); }); - test('variadic signature inference', () => { - const Test = java.import('Test'); - expect(Test.varArgsSignatureSync()).toBe('Object...'); - expect(Test.varArgsSignatureSync('a', 'b')).toBe('String...'); - expect(Test.varArgsSignatureSync(1, 2)).toBe('Integer...'); - expect(Test.varArgsSignatureSync(1.1, 2)).toBe('Number...'); - expect(Test.varArgsSignatureSync(1.1, 'a')).toBe('Object...'); - expect(Test.varArgsSignatureSync(true, 'a')).toBe('Object...'); - expect(Test.varArgsSignatureSync(true, 1)).toBe('Object...'); - expect(Test.varArgsSignatureSync(true, 1.1)).toBe('Object...'); - expect(Test.varArgsSignatureSync(true, false)).toBe('Boolean...'); + test("variadic signature inference", () => { + const Test = java.import("Test"); + expect(Test.varArgsSignatureSync()).toBe("Object..."); + expect(Test.varArgsSignatureSync("a", "b")).toBe("String..."); + expect(Test.varArgsSignatureSync(1, 2)).toBe("Integer..."); + expect(Test.varArgsSignatureSync(1.1, 2)).toBe("Number..."); + expect(Test.varArgsSignatureSync(1.1, "a")).toBe("Object..."); + expect(Test.varArgsSignatureSync(true, "a")).toBe("Object..."); + expect(Test.varArgsSignatureSync(true, 1)).toBe("Object..."); + expect(Test.varArgsSignatureSync(true, 1.1)).toBe("Object..."); + expect(Test.varArgsSignatureSync(true, false)).toBe("Boolean..."); }); - test('variadic no args', () => { - const String = java.import('java.lang.String'); - expect(String.formatSync('nothing')).toBe('nothing'); + test("variadic no args", () => { + const String = java.import("java.lang.String"); + expect(String.formatSync("nothing")).toBe("nothing"); }); - test('variadic one args', () => { - const String = java.import('java.lang.String'); - expect(String.formatSync('%s', 'hello')).toBe('hello'); + test("variadic one args", () => { + const String = java.import("java.lang.String"); + expect(String.formatSync("%s", "hello")).toBe("hello"); }); - test('variadic two args', () => { - const String = java.import('java.lang.String'); - expect(String.formatSync('%s--%s', 'hello', 'world')).toBe('hello--world'); + test("variadic two args", () => { + const String = java.import("java.lang.String"); + expect(String.formatSync("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('newArray(Object) no args passed', () => { - const String = java.import('java.lang.String'); - expect(String.formatSync('nothing', java.newArray('java.lang.Object', []))).toBe('nothing'); + test("newArray(Object) no args passed", () => { + const String = java.import("java.lang.String"); + expect(String.formatSync("nothing", java.newArray("java.lang.Object", []))).toBe("nothing"); }); - test('newArray(Object) one args', () => { - const String = java.import('java.lang.String'); - expect(String.formatSync('%s', java.newArray('java.lang.Object', ['hello']))).toBe('hello'); + test("newArray(Object) one args", () => { + const String = java.import("java.lang.String"); + expect(String.formatSync("%s", java.newArray("java.lang.Object", ["hello"]))).toBe("hello"); }); - test('newArray(Object) two args', () => { - const String = java.import('java.lang.String'); - expect(String.formatSync('%s--%s', java.newArray('java.lang.Object', ['hello', 'world']))).toBe('hello--world'); + test("newArray(Object) two args", () => { + const String = java.import("java.lang.String"); + expect(String.formatSync("%s--%s", java.newArray("java.lang.Object", ["hello", "world"]))).toBe("hello--world"); }); - test('Call static method with variadic varargs', () => { - const Test = java.import('Test'); - expect(Test.staticVarargsSync(5)).toBe('5'); - expect(Test.staticVarargsSync(5, 'a')).toBe('5a'); - expect(Test.staticVarargsSync(5, 'a', 'b')).toBe('5ab'); - expect(Test.staticVarargsSync(5, 'a', 'b', 'c')).toBe('5abc'); + test("Call static method with variadic varargs", () => { + const Test = java.import("Test"); + expect(Test.staticVarargsSync(5)).toBe("5"); + expect(Test.staticVarargsSync(5, "a")).toBe("5a"); + expect(Test.staticVarargsSync(5, "a", "b")).toBe("5ab"); + expect(Test.staticVarargsSync(5, "a", "b", "c")).toBe("5abc"); }); - test('Call static varargs method with plain array', () => { - const Test = java.import('Test'); - expect(Test.staticVarargsSync(5, ['a'])).toBe('5a'); - expect(Test.staticVarargsSync(5, ['a', 'b'])).toBe('5ab'); - expect(Test.staticVarargsSync(5, ['a', 'b', 'c'])).toBe('5abc'); + test("Call static varargs method with plain array", () => { + const Test = java.import("Test"); + expect(Test.staticVarargsSync(5, ["a"])).toBe("5a"); + expect(Test.staticVarargsSync(5, ["a", "b"])).toBe("5ab"); + expect(Test.staticVarargsSync(5, ["a", "b", "c"])).toBe("5abc"); }); - test('Call static varags method with newArray', () => { - const Test = java.import('Test'); - expect(Test.staticVarargsSync(5, java.newArray('java.lang.String', ['a']))).toBe('5a'); - expect(Test.staticVarargsSync(5, java.newArray('java.lang.String', ['a', 'b', 'c']))).toBe('5abc'); + test("Call static varags method with newArray", () => { + const Test = java.import("Test"); + expect(Test.staticVarargsSync(5, java.newArray("java.lang.String", ["a"]))).toBe("5a"); + expect(Test.staticVarargsSync(5, java.newArray("java.lang.String", ["a", "b", "c"]))).toBe("5abc"); }); }); diff --git a/testAsyncOptions/allThreeSuffix.test.js b/testAsyncOptions/allThreeSuffix.test.js index 6a0dd13b..f9f7cafc 100644 --- a/testAsyncOptions/allThreeSuffix.test.js +++ b/testAsyncOptions/allThreeSuffix.test.js @@ -6,23 +6,26 @@ import { describe, test, expect } from "vitest"; const java = getJava({ syncSuffix: "Sync", asyncSuffix: "Async", - promiseSuffix: 'Promise', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "Promise", + promisify: require("when/node").lift, // https://github.com/cujojs/when }); -describe('allThreeSuffix', () => { - test('api', () => { +describe("allThreeSuffix", () => { + test("api", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); expect(arrayList).toBeDefined(); expect(java.instanceOf(arrayList, "java.util.ArrayList")).toBeTruthy(); - expect(typeof arrayList.addSync !== 'undefined', 'Expected `addSync` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addAsync !== 'undefined', 'Expected `addAsync` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addPromise !== 'undefined', 'Expected `addPromise` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.add === 'undefined', 'Expected `add` to NOT be present, but it is.').toBeTruthy(); + expect(typeof arrayList.addSync !== "undefined", "Expected `addSync` to be present, but it is NOT.").toBeTruthy(); + expect(typeof arrayList.addAsync !== "undefined", "Expected `addAsync` to be present, but it is NOT.").toBeTruthy(); + expect( + typeof arrayList.addPromise !== "undefined", + "Expected `addPromise` to be present, but it is NOT." + ).toBeTruthy(); + expect(typeof arrayList.add === "undefined", "Expected `add` to NOT be present, but it is.").toBeTruthy(); }); - test('importClass', () => { + test("importClass", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. const ArrayList = java.import("java.util.ArrayList"); expect(ArrayList).toBeTruthy(); @@ -31,38 +34,38 @@ describe('allThreeSuffix', () => { expect(arrayList.sizeSync()).toBe(0); }); - test('staticAPI', () => { + test("staticAPI", () => { const String = java.import("java.lang.String"); expect(String).toBeTruthy(); - const api = Object.keys(String).filter((key) => typeof String[key] === 'function'); - expect(api.includes('formatSync'), 'Expected `formatSync` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatAsync'), 'Expected `formatAsync` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatPromise'), 'Expected `formatPromise` to be present, but it is NOT.').toBeTruthy(); - expect(!api.includes('format'), 'Expected `format` to NOT be present, but it is.').toBeTruthy(); - expect(!api.includes('formatundefined'), 'Expected `formatundefined` to NOT be present, but it is.').toBeTruthy(); + const api = Object.keys(String).filter((key) => typeof String[key] === "function"); + expect(api.includes("formatSync"), "Expected `formatSync` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatAsync"), "Expected `formatAsync` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatPromise"), "Expected `formatPromise` to be present, but it is NOT.").toBeTruthy(); + expect(!api.includes("format"), "Expected `format` to NOT be present, but it is.").toBeTruthy(); + expect(!api.includes("formatundefined"), "Expected `formatundefined` to NOT be present, but it is.").toBeTruthy(); }); - test('syncCalls', () => { + test("syncCalls", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); arrayList.addSync("hello"); arrayList.addSync("world"); expect(arrayList.sizeSync()).toBe(2); }); - test('staticSyncCalls', () => { + test("staticSyncCalls", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // Among other things, java.import creates Sync functions for static methods. const String = java.import("java.lang.String"); - expect(String.formatSync('%s--%s', "hello", "world")).toBe("hello--world"); + expect(String.formatSync("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('asyncCalls', async () => { + test("asyncCalls", async () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - await new Promise(resolve => { - arrayList.addAsync("hello", function (err, result) { + await new Promise((resolve) => { + arrayList.addAsync("hello", function (err) { expect(err).toBeUndefined(); - arrayList.addAsync("world", function (err, result) { + arrayList.addAsync("world", function (err) { expect(err).toBeUndefined(); arrayList.sizeAsync(function (err, size) { expect(err).toBeUndefined(); @@ -74,13 +77,18 @@ describe('allThreeSuffix', () => { }); }); - test('promiseCalls', async () => { + test("promiseCalls", async () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - await arrayList.addPromise("hello") - .then(() => { return arrayList.addPromise("world"); }) - .then(() => { return arrayList.sizePromise(); }) + await arrayList + .addPromise("hello") + .then(() => { + return arrayList.addPromise("world"); + }) + .then(() => { + return arrayList.sizePromise(); + }) .then((size) => { expect(size).toBe(2); }); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/asyncSuffixSyncDefault.test.js b/testAsyncOptions/asyncSuffixSyncDefault.test.js index 67e8d240..dfd93544 100644 --- a/testAsyncOptions/asyncSuffixSyncDefault.test.js +++ b/testAsyncOptions/asyncSuffixSyncDefault.test.js @@ -3,17 +3,17 @@ import { beforeAll, describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('asyncSuffixSyncDefault', () => { +describe("asyncSuffixSyncDefault", () => { beforeAll(async () => { - await new Promise(resolve => { + await new Promise((resolve) => { java.asyncOptions = { syncSuffix: "", asyncSuffix: "Async", - ifReadOnlySuffix: "_alt" + ifReadOnlySuffix: "_alt", }; function before(callback) { - java.classpath.push('test/'); + java.classpath.push("test/"); expect(java.isJvmCreated()).toBeFalsy(); callback(); } @@ -33,17 +33,20 @@ describe('asyncSuffixSyncDefault', () => { }); }); - test('api', () => { + test("api", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); expect(arrayList).toBeTruthy(); expect(java.instanceOf(arrayList, "java.util.ArrayList")).toBeTruthy(); - expect(typeof arrayList.addAsync !== 'undefined', 'Expected `addAsync` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.add !== 'undefined', 'Expected `add` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addPromise === 'undefined', 'Expected `addPromise` to NOT be present, but it is.').toBeTruthy(); + expect(typeof arrayList.addAsync !== "undefined", "Expected `addAsync` to be present, but it is NOT.").toBeTruthy(); + expect(typeof arrayList.add !== "undefined", "Expected `add` to be present, but it is NOT.").toBeTruthy(); + expect( + typeof arrayList.addPromise === "undefined", + "Expected `addPromise` to NOT be present, but it is." + ).toBeTruthy(); }); - test('importClass', () => { + test("importClass", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. const ArrayList = java.import("java.util.ArrayList"); expect(ArrayList).toBeTruthy(); @@ -52,38 +55,38 @@ describe('asyncSuffixSyncDefault', () => { expect(arrayList.size()).toBe(0); }); - test('staticAPI', () => { + test("staticAPI", () => { const String = java.import("java.lang.String"); expect(String).toBeTruthy(); - const api = Object.keys(String).filter((key) => typeof String[key] === 'function'); - expect(api.includes('format'), 'Expected `format` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatAsync'), 'Expected `formatAsync` to be present, but it is NOT.').toBeTruthy(); - expect(!api.includes('formatSync'), 'Expected `formatSync` to NOT be present, but it is.').toBeTruthy(); - expect(!api.includes('formatPromise'), 'Expected `formatPromise` to NOT be present, but it is.').toBeTruthy(); - expect(!api.includes('formatundefined'), 'Expected `formatundefined` to NOT be present, but it is.').toBeTruthy(); + const api = Object.keys(String).filter((key) => typeof String[key] === "function"); + expect(api.includes("format"), "Expected `format` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatAsync"), "Expected `formatAsync` to be present, but it is NOT.").toBeTruthy(); + expect(!api.includes("formatSync"), "Expected `formatSync` to NOT be present, but it is.").toBeTruthy(); + expect(!api.includes("formatPromise"), "Expected `formatPromise` to NOT be present, but it is.").toBeTruthy(); + expect(!api.includes("formatundefined"), "Expected `formatundefined` to NOT be present, but it is.").toBeTruthy(); }); - test('syncCalls', () => { + test("syncCalls", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); arrayList.add("hello"); arrayList.add("world"); expect(arrayList.size()).toBe(2); }); - test('staticSyncCalls', () => { + test("staticSyncCalls", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // Among other things, java.import creates Sync functions for static methods. const String = java.import("java.lang.String"); - expect(String.format('%s--%s', "hello", "world")).toBe("hello--world"); + expect(String.format("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('asyncCalls', async () => { + test("asyncCalls", async () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - await new Promise(resolve => { - arrayList.addAsync("hello", function (err, result) { + await new Promise((resolve) => { + arrayList.addAsync("hello", function (err) { expect(err).toBeUndefined(); - arrayList.addAsync("world", function (err, result) { + arrayList.addAsync("world", function (err) { expect(err).toBeUndefined(); arrayList.sizeAsync(function (err, size) { expect(err).toBeUndefined(); @@ -98,13 +101,13 @@ describe('asyncSuffixSyncDefault', () => { // See testUnusableMethodName.js for the purpose of these last two tests. // In that test, Test.name_alt() is an async method. // In this test, it is a sync method. - test('unusableMethodNameThrows', () => { + test("unusableMethodNameThrows", () => { const Test = java.import("Test"); expect(Test).toBeTruthy(); expect(() => Test.name()).toThrowError(TypeError); }); - test('alternateMethodNameWorks', () => { + test("alternateMethodNameWorks", () => { const Test = java.import("Test"); expect(Test).toBeTruthy(); expect(Test.name_alt()).toBe("name"); @@ -112,7 +115,7 @@ describe('asyncSuffixSyncDefault', () => { expect(Test.arguments_alt()).toBe("arguments"); }); - test('reservedFieldName', () => { + test("reservedFieldName", () => { const TestEnum = java.import("Test$Enum"); expect(TestEnum).toBeTruthy(); @@ -128,4 +131,4 @@ describe('asyncSuffixSyncDefault', () => { expect(TestEnum.caller_alt.toString()).toBe("caller"); expect(TestEnum.arguments_alt.toString()).toBe("arguments"); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/clientBeforeError.test.js b/testAsyncOptions/clientBeforeError.test.js index 24b165fc..7c6980cd 100644 --- a/testAsyncOptions/clientBeforeError.test.js +++ b/testAsyncOptions/clientBeforeError.test.js @@ -1,9 +1,9 @@ import { describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('clientBeforeError', () => { - test('clientBeforeError', async () => { - await new Promise(resolve => { +describe("clientBeforeError", () => { + test("clientBeforeError", async () => { + await new Promise((resolve) => { expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { @@ -12,15 +12,15 @@ describe('clientBeforeError', () => { function before(callback) { expect(java.isJvmCreated()).toBeFalsy(); - callback(new Error('dummy error')); + callback(new Error("dummy error")); } java.registerClient(before); java.ensureJvm(function (err) { - expect(err && typeof err === 'object').toBeTruthy(); + expect(err && typeof err === "object").toBeTruthy(); expect(err).toBeInstanceOf(Error); - expect(err.message).toBe('dummy error'); + expect(err.message).toBe("dummy error"); expect(java.isJvmCreated()).toBeFalsy(); resolve(); }); diff --git a/testAsyncOptions/clientBeforeSyncThrows.test.js b/testAsyncOptions/clientBeforeSyncThrows.test.js index 43fa4277..19fc62e6 100644 --- a/testAsyncOptions/clientBeforeSyncThrows.test.js +++ b/testAsyncOptions/clientBeforeSyncThrows.test.js @@ -1,9 +1,9 @@ import { describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('clientBeforeSyncThrows', () => { - test('clientBeforeSyncThrows', async () => { - await new Promise(resolve => { +describe("clientBeforeSyncThrows", () => { + test("clientBeforeSyncThrows", async () => { + await new Promise((resolve) => { expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { @@ -12,18 +12,18 @@ describe('clientBeforeSyncThrows', () => { function before() { expect(java.isJvmCreated()).toBeFalsy(); - throw new Error('dummy error'); + throw new Error("dummy error"); } java.registerClient(before); java.ensureJvm(function (err) { - expect(err && typeof err === 'object').toBeTruthy(); + expect(err && typeof err === "object").toBeTruthy(); expect(err).instanceOf(Error); - expect(err.message).toBe('dummy error'); + expect(err.message).toBe("dummy error"); expect(java.isJvmCreated()).toBeFalsy(); resolve(); }); }); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/clientBeforeThrows.test.js b/testAsyncOptions/clientBeforeThrows.test.js index 9072cb67..7cf6e6e5 100644 --- a/testAsyncOptions/clientBeforeThrows.test.js +++ b/testAsyncOptions/clientBeforeThrows.test.js @@ -1,29 +1,29 @@ import { describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('clientBeforeThrows', () => { - test('clientBeforeThrows', async () => { - await new Promise(resolve => { +describe("clientBeforeThrows", () => { + test("clientBeforeThrows", async () => { + await new Promise((resolve) => { expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "Sync", }; - function before(callback) { + function before() { expect(java.isJvmCreated()).toBeFalsy(); - throw new Error('dummy error'); + throw new Error("dummy error"); } java.registerClient(before); java.ensureJvm(function (err) { - expect(err && typeof err === 'object').toBeTruthy(); + expect(err && typeof err === "object").toBeTruthy(); expect(err).instanceOf(Error); - expect(err.message).toBe('dummy error'); + expect(err.message).toBe("dummy error"); expect(java.isJvmCreated()).toBeFalsy(); resolve(); }); }); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/clientPBeforeError.test.js b/testAsyncOptions/clientPBeforeError.test.js index ee5037c2..032ce239 100644 --- a/testAsyncOptions/clientPBeforeError.test.js +++ b/testAsyncOptions/clientPBeforeError.test.js @@ -1,22 +1,22 @@ import { describe, expect, test } from "vitest"; -import when from 'when'; +import when from "when"; import { java } from "../testHelpers"; -describe('clientPBeforeError', () => { - test('clientPBeforeError', async () => { +describe("clientPBeforeError", () => { + test("clientPBeforeError", async () => { await new Promise((resolve) => { expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "Sync", - promiseSuffix: 'Promise', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "Promise", + promisify: require("when/node").lift, // https://github.com/cujojs/when }; function beforeP() { - var promise = when.promise((_resolve, reject) => { + const promise = when.promise((_resolve, reject) => { expect(java.isJvmCreated()).toBeFalsy(); - reject(new Error('dummy error')); + reject(new Error("dummy error")); }); return promise; } @@ -25,12 +25,12 @@ describe('clientPBeforeError', () => { java.ensureJvm().done( () => { - throw new Error('expect error'); + throw new Error("expect error"); }, (err) => { - expect(err && typeof err === 'object').toBeTruthy(); + expect(err && typeof err === "object").toBeTruthy(); expect(err).instanceOf(Error); - expect(err.message).toBe('dummy error'); + expect(err.message).toBe("dummy error"); expect(java.isJvmCreated()).toBeFalsy(); resolve(); } diff --git a/testAsyncOptions/clientPBeforeThrows.test.js b/testAsyncOptions/clientPBeforeThrows.test.js index d731cde1..86e45e60 100644 --- a/testAsyncOptions/clientPBeforeThrows.test.js +++ b/testAsyncOptions/clientPBeforeThrows.test.js @@ -1,22 +1,22 @@ import { describe, expect, test } from "vitest"; -import when from 'when'; +import when from "when"; import { java } from "../testHelpers"; -describe('clientPBeforeThrows', () => { - test('clientPBeforeThrows', async () => { - await new Promise(resolve => { +describe("clientPBeforeThrows", () => { + test("clientPBeforeThrows", async () => { + await new Promise((resolve) => { expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "Sync", - promiseSuffix: 'Promise', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "Promise", + promisify: require("when/node").lift, // https://github.com/cujojs/when }; function beforeP() { - var promise = when.promise(function (resolve, reject) { + const promise = when.promise(() => { expect(java.isJvmCreated()).toBeFalsy(); - throw new Error('dummy error'); + throw new Error("dummy error"); }); return promise; } @@ -25,12 +25,12 @@ describe('clientPBeforeThrows', () => { java.ensureJvm().done( () => { - throw new Error('expected error'); + throw new Error("expected error"); }, (err) => { - expect(err && typeof err === 'object').toBeTruthy(); + expect(err && typeof err === "object").toBeTruthy(); expect(err).instanceOf(Error); - expect(err.message).toBe('dummy error'); + expect(err.message).toBe("dummy error"); expect(java.isJvmCreated()).toBeFalsy(); resolve(); } diff --git a/testAsyncOptions/defacto.test.js b/testAsyncOptions/defacto.test.js index 5364bb69..5bcebd4d 100644 --- a/testAsyncOptions/defacto.test.js +++ b/testAsyncOptions/defacto.test.js @@ -3,16 +3,16 @@ import { beforeAll, describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('defacto', () => { +describe("defacto", () => { beforeAll(async () => { - await new Promise(resolve => { - const api = Object.keys(java).filter((key) => typeof java[key] === 'function'); - expect(api.includes('isJvmCreated'), 'Expected `isJvmCreated` to be present, but it is NOT.').toBeTruthy(); + await new Promise((resolve) => { + const api = Object.keys(java).filter((key) => typeof java[key] === "function"); + expect(api.includes("isJvmCreated"), "Expected `isJvmCreated` to be present, but it is NOT.").toBeTruthy(); expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "Sync", - asyncSuffix: "" + asyncSuffix: "", }; function before() { @@ -40,17 +40,20 @@ describe('defacto', () => { }); }); - test('api', () => { + test("api", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); expect(arrayList).toBeTruthy(); expect(java.instanceOf(arrayList, "java.util.ArrayList")).toBeTruthy(); - expect(typeof arrayList.addSync !== 'undefined', 'Expected `addSync` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.add !== 'undefined', 'Expected `add` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addPromise === 'undefined', 'Expected `addPromise` to NOT be present, but it is.').toBeTruthy(); + expect(typeof arrayList.addSync !== "undefined", "Expected `addSync` to be present, but it is NOT.").toBeTruthy(); + expect(typeof arrayList.add !== "undefined", "Expected `add` to be present, but it is NOT.").toBeTruthy(); + expect( + typeof arrayList.addPromise === "undefined", + "Expected `addPromise` to NOT be present, but it is." + ).toBeTruthy(); }); - test('importClass', () => { + test("importClass", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. const ArrayList = java.import("java.util.ArrayList"); expect(ArrayList).toBeTruthy(); @@ -59,38 +62,38 @@ describe('defacto', () => { expect(arrayList.sizeSync()).toBe(0); }); - test('staticAPI', () => { + test("staticAPI", () => { const String = java.import("java.lang.String"); expect(String).toBeTruthy(); - const api = Object.keys(String).filter((key) => typeof String[key] === 'function'); - expect(api.includes('format'), 'Expected `format` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatSync'), 'Expected `formatSync` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatAsync'), 'Expected `formatAsync` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatPromise'), 'Expected `formatPromise` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatundefined'), 'Expected `formatundefined` to NOT be present, but it is.').toBeFalsy(); + const api = Object.keys(String).filter((key) => typeof String[key] === "function"); + expect(api.includes("format"), "Expected `format` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatSync"), "Expected `formatSync` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatAsync"), "Expected `formatAsync` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatPromise"), "Expected `formatPromise` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatundefined"), "Expected `formatundefined` to NOT be present, but it is.").toBeFalsy(); }); - test('syncCalls', () => { + test("syncCalls", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); arrayList.addSync("hello"); arrayList.addSync("world"); expect(arrayList.sizeSync()).toBe(2); }); - test('staticSyncCalls', () => { + test("staticSyncCalls", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // Among other things, java.import creates Sync functions for static methods. const String = java.import("java.lang.String"); - expect(String.formatSync('%s--%s', "hello", "world")).toBe("hello--world"); + expect(String.formatSync("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('asyncCalls', async () => { - await new Promise(resolve => { + test("asyncCalls", async () => { + await new Promise((resolve) => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - arrayList.add("hello", function (err, result) { + arrayList.add("hello", function (err) { expect(err).toBeFalsy(); - arrayList.add("world", function (err, result) { + arrayList.add("world", function (err) { expect(err).toBeFalsy(); arrayList.size(function (err, size) { expect(err).toBeFalsy(); diff --git a/testAsyncOptions/defactoPlusPromise.test.js b/testAsyncOptions/defactoPlusPromise.test.js index 4da19c40..346dd9e4 100644 --- a/testAsyncOptions/defactoPlusPromise.test.js +++ b/testAsyncOptions/defactoPlusPromise.test.js @@ -3,18 +3,18 @@ import { beforeAll, describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('defactoPlusPromise', () => { +describe("defactoPlusPromise", () => { beforeAll(async () => { - await new Promise(resolve => { - const api = Object.keys(java).filter((key) => typeof java[key] === 'function'); - expect(api.includes('isJvmCreated'), 'Expected `isJvmCreated` to be present, but it is NOT.').toBeTruthy(); + await new Promise((resolve) => { + const api = Object.keys(java).filter((key) => typeof java[key] === "function"); + expect(api.includes("isJvmCreated"), "Expected `isJvmCreated` to be present, but it is NOT.").toBeTruthy(); expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "Sync", asyncSuffix: "", - promiseSuffix: 'Promise', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "Promise", + promisify: require("when/node").lift, // https://github.com/cujojs/when }; function before(callback) { @@ -38,17 +38,17 @@ describe('defactoPlusPromise', () => { }); }); - test('api', () => { + test("api", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); expect(arrayList).toBeTruthy(); expect(java.instanceOf(arrayList, "java.util.ArrayList")).toBeTruthy(); - expect(arrayList.addSync !== 'undefined', 'Expected `addSync` to be present, but it is NOT.').toBeTruthy(); - expect(arrayList.add !== 'undefined', 'Expected `add` to be present, but it is NOT.').toBeTruthy(); - expect(arrayList.addPromise !== 'undefined', 'Expected `addPromise` to be present, but it is NOT.').toBeTruthy(); + expect(arrayList.addSync !== "undefined", "Expected `addSync` to be present, but it is NOT.").toBeTruthy(); + expect(arrayList.add !== "undefined", "Expected `add` to be present, but it is NOT.").toBeTruthy(); + expect(arrayList.addPromise !== "undefined", "Expected `addPromise` to be present, but it is NOT.").toBeTruthy(); }); - test('importClass', () => { + test("importClass", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. const ArrayList = java.import("java.util.ArrayList"); expect(ArrayList).toBeTruthy(); @@ -57,38 +57,38 @@ describe('defactoPlusPromise', () => { expect(arrayList.sizeSync()).toBe(0); }); - test('staticAPI', () => { + test("staticAPI", () => { const String = java.import("java.lang.String"); expect(String).toBeTruthy(); - const api = Object.keys(String).filter((key) => typeof String[key] === 'function'); - expect(api.includes('format'), 'Expected `format` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatSync'), 'Expected `formatSync` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatPromise'), 'Expected `formatPromise` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatAsync'), 'Expected `formatAsync` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatundefined'), 'Expected `formatundefined` to NOT be present, but it is.').toBeFalsy(); + const api = Object.keys(String).filter((key) => typeof String[key] === "function"); + expect(api.includes("format"), "Expected `format` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatSync"), "Expected `formatSync` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatPromise"), "Expected `formatPromise` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatAsync"), "Expected `formatAsync` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatundefined"), "Expected `formatundefined` to NOT be present, but it is.").toBeFalsy(); }); - test('syncCalls', () => { + test("syncCalls", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); arrayList.addSync("hello"); arrayList.addSync("world"); expect(arrayList.sizeSync()).toBe(2); }); - test('staticSyncCalls', () => { + test("staticSyncCalls", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // Among other things, java.import creates Sync functions for static methods. const String = java.import("java.lang.String"); - expect(String.formatSync('%s--%s', "hello", "world")).toBe("hello--world"); + expect(String.formatSync("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('asyncCalls', async () => { - await new Promise(resolve => { + test("asyncCalls", async () => { + await new Promise((resolve) => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - arrayList.add("hello", function (err, result) { + arrayList.add("hello", function (err) { expect(err).toBeFalsy(); - arrayList.add("world", function (err, result) { + arrayList.add("world", function (err) { expect(err).toBeFalsy(); arrayList.size(function (err, size) { expect(err).toBeFalsy(); @@ -100,16 +100,21 @@ describe('defactoPlusPromise', () => { }); }); - test('promiseCalls', async () => { - await new Promise(resolve => { + test("promiseCalls", async () => { + await new Promise((resolve) => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - arrayList.addPromise("hello") - .then(() => { return arrayList.addPromise("world"); }) - .then(() => { return arrayList.sizePromise(); }) + arrayList + .addPromise("hello") + .then(() => { + return arrayList.addPromise("world"); + }) + .then(() => { + return arrayList.sizePromise(); + }) .then((size) => { expect(size).toBe(2); resolve(); }); }); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/default.test.js b/testAsyncOptions/default.test.js index dfe147f6..581ee824 100644 --- a/testAsyncOptions/default.test.js +++ b/testAsyncOptions/default.test.js @@ -4,18 +4,21 @@ import { describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('default', () => { - test('api', () => { +describe("default", () => { + test("api", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); expect(arrayList).toBeTruthy(); expect(java.instanceOf(arrayList, "java.util.ArrayList")).toBeTruthy(); - expect(typeof arrayList.addSync !== 'undefined', 'Expected `addSync` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.add !== 'undefined', 'Expected `add` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addPromise === 'undefined', 'Expected `addPromise` to NOT be present, but it is.').toBeTruthy(); + expect(typeof arrayList.addSync !== "undefined", "Expected `addSync` to be present, but it is NOT.").toBeTruthy(); + expect(typeof arrayList.add !== "undefined", "Expected `add` to be present, but it is NOT.").toBeTruthy(); + expect( + typeof arrayList.addPromise === "undefined", + "Expected `addPromise` to NOT be present, but it is." + ).toBeTruthy(); }); - test('importClass', () => { + test("importClass", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. const ArrayList = java.import("java.util.ArrayList"); expect(ArrayList).toBeTruthy(); @@ -24,38 +27,38 @@ describe('default', () => { expect(arrayList.sizeSync()).toBe(0); }); - test('staticAPI', () => { + test("staticAPI", () => { const String = java.import("java.lang.String"); expect(String).toBeTruthy(); - const api = Object.keys(String).filter((key) => typeof String[key] === 'function'); - expect(api.includes('format'), 'Expected `format` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatSync'), 'Expected `formatSync` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatAsync'), 'Expected `formatAsync` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatPromise'), 'Expected `formatPromise` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatundefined'), 'Expected `formatundefined` to NOT be present, but it is.').toBeFalsy(); + const api = Object.keys(String).filter((key) => typeof String[key] === "function"); + expect(api.includes("format"), "Expected `format` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatSync"), "Expected `formatSync` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatAsync"), "Expected `formatAsync` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatPromise"), "Expected `formatPromise` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatundefined"), "Expected `formatundefined` to NOT be present, but it is.").toBeFalsy(); }); - test('syncCalls', () => { + test("syncCalls", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); arrayList.addSync("hello"); arrayList.addSync("world"); expect(arrayList.sizeSync()).toBe(2); }); - test('staticSyncCalls', () => { + test("staticSyncCalls", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // Among other things, java.import creates Sync functions for static methods. const String = java.import("java.lang.String"); - expect(String.formatSync('%s--%s', "hello", "world")).toBe("hello--world"); + expect(String.formatSync("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('asyncCalls', async () => { - await new Promise(resolve => { + test("asyncCalls", async () => { + await new Promise((resolve) => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - arrayList.add("hello", function (err, result) { + arrayList.add("hello", function (err) { expect(err).toBeFalsy(); - arrayList.add("world", function (err, result) { + arrayList.add("world", function (err) { expect(err).toBeFalsy(); arrayList.size(function (err, size) { expect(err).toBeFalsy(); @@ -66,4 +69,4 @@ describe('default', () => { }); }); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/invalidLaunch.test.js b/testAsyncOptions/invalidLaunch.test.js index d88f181b..10b4f7b4 100644 --- a/testAsyncOptions/invalidLaunch.test.js +++ b/testAsyncOptions/invalidLaunch.test.js @@ -1,51 +1,55 @@ import { describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('invalidLaunch', () => { - test('failedLaunch', () => { +describe("invalidLaunch", () => { + test("failedLaunch", () => { expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "Sync", - asyncSuffix: "" + asyncSuffix: "", }; // First show that if asyncOptions.promisify is undefined, using the promise variant of ensureJvm throws an error. - expect(() => { java.ensureJvm(); }).toThrow(/requires its one argument to be a callback function/); + expect(() => { + java.ensureJvm(); + }).toThrow(/requires its one argument to be a callback function/); expect(java.isJvmCreated()).toBeFalsy(); }); - test('callbackNotAFunction', () => { + test("callbackNotAFunction", () => { expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "", - promiseSuffix: 'P', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "P", + promisify: require("when/node").lift, // https://github.com/cujojs/when }; - expect(() => { java.ensureJvm('foo') }).toThrow(/requires its one argument to be a callback function/); + expect(() => { + java.ensureJvm("foo"); + }).toThrow(/requires its one argument to be a callback function/); expect(java.isJvmCreated()).toBeFalsy(); }); - test('jvmCanStillBeLaunched', async () => { + test("jvmCanStillBeLaunched", async () => { // None of the previous tests should have caused the JVM to be created, so it should still be possible to create one. expect(java.isJvmCreated()).toBeFalsy(); java.asyncOptions = { syncSuffix: "", - promiseSuffix: 'P', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "P", + promisify: require("when/node").lift, // https://github.com/cujojs/when }; - await new Promise(resolve => { + await new Promise((resolve) => { java.ensureJvm().done(function () { expect(java.isJvmCreated()).toBeTruthy(); resolve(); }); }); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/noAsync.test.js b/testAsyncOptions/noAsync.test.js index 7b57fbde..569d69fc 100644 --- a/testAsyncOptions/noAsync.test.js +++ b/testAsyncOptions/noAsync.test.js @@ -1,17 +1,17 @@ // Just Sync and Promise, both with a non-empty suffix. import { beforeAll, describe, expect, test } from "vitest"; -import when from 'when'; +import when from "when"; import { java } from "../testHelpers"; -describe('noAsync', () => { +describe("noAsync", () => { beforeAll(async () => { - var api = Object.keys(java).filter((key) => typeof java[key] === 'function'); - expect(api.includes('isJvmCreated'), 'Expected `isJvmCreated` to be present, but it is NOT.').toBeTruthy(); + const api = Object.keys(java).filter((key) => typeof java[key] === "function"); + expect(api.includes("isJvmCreated"), "Expected `isJvmCreated` to be present, but it is NOT.").toBeTruthy(); expect(java.isJvmCreated()).toBeFalsy(); function before() { - var promise = when.promise(function (resolve) { + const promise = when.promise(function (resolve) { expect(java.isJvmCreated()).toBeFalsy(); resolve(); }); @@ -19,7 +19,7 @@ describe('noAsync', () => { } function after() { - var promise = when.promise(function (resolve) { + const promise = when.promise(function (resolve) { expect(java.isJvmCreated()).toBeTruthy(); resolve(); }); @@ -28,14 +28,14 @@ describe('noAsync', () => { java.asyncOptions = { syncSuffix: "Sync", - promiseSuffix: 'Promise', - promisify: require('when/node').lift + promiseSuffix: "Promise", + promisify: require("when/node").lift, }; java.registerClientP(before, after); java.registerClientP(null, after); java.registerClientP(before); - await new Promise(resolve => { + await new Promise((resolve) => { java.ensureJvm().done(function () { expect(java.isJvmCreated()).toBeTruthy(); resolve(); @@ -43,62 +43,70 @@ describe('noAsync', () => { }); }); - test('api', () => { - var arrayList = java.newInstanceSync("java.util.ArrayList"); + test("api", () => { + const arrayList = java.newInstanceSync("java.util.ArrayList"); expect(arrayList).toBeTruthy(); expect(java.instanceOf(arrayList, "java.util.ArrayList")).toBeTruthy(); - expect(typeof arrayList.addSync !== 'undefined', 'Expected `addSync` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addPromise !== 'undefined', 'Expected `addPromise` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.add === 'undefined', 'Expected `add` to NOT be present, but it is.').toBeTruthy(); - expect(typeof arrayList.addAsync === 'undefined', 'Expected `addAsync` to NOT be present, but it is.').toBeTruthy(); + expect(typeof arrayList.addSync !== "undefined", "Expected `addSync` to be present, but it is NOT.").toBeTruthy(); + expect( + typeof arrayList.addPromise !== "undefined", + "Expected `addPromise` to be present, but it is NOT." + ).toBeTruthy(); + expect(typeof arrayList.add === "undefined", "Expected `add` to NOT be present, but it is.").toBeTruthy(); + expect(typeof arrayList.addAsync === "undefined", "Expected `addAsync` to NOT be present, but it is.").toBeTruthy(); }); - test('importClass', () => { + test("importClass", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. - var ArrayList = java.import("java.util.ArrayList"); + const ArrayList = java.import("java.util.ArrayList"); expect(ArrayList).toBeTruthy(); - var arrayList = new ArrayList(); + const arrayList = new ArrayList(); expect(arrayList).toBeTruthy(); expect(arrayList.sizeSync()).toBe(0); }); - test('staticAPI', () => { - var String = java.import("java.lang.String"); + test("staticAPI", () => { + const String = java.import("java.lang.String"); expect(String).toBeTruthy(); - var api = Object.keys(String).filter((key) => typeof String[key] === 'function'); - expect(api.includes('formatSync'), 'Expected `formatSync` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatPromise'), 'Expected `formatPromise` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('format'), 'Expected `format` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatAsync'), 'Expected `formatAsync` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatundefined'), 'Expected `formatundefined` to NOT be present, but it is.').toBeFalsy(); + const api = Object.keys(String).filter((key) => typeof String[key] === "function"); + expect(api.includes("formatSync"), "Expected `formatSync` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatPromise"), "Expected `formatPromise` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("format"), "Expected `format` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatAsync"), "Expected `formatAsync` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatundefined"), "Expected `formatundefined` to NOT be present, but it is.").toBeFalsy(); }); - test('syncCalls', () => { - var arrayList = java.newInstanceSync("java.util.ArrayList"); + test("syncCalls", () => { + const arrayList = java.newInstanceSync("java.util.ArrayList"); arrayList.addSync("hello"); arrayList.addSync("world"); expect(arrayList.sizeSync()).toBe(2); }); - test('sStaticSyncCalls', () => { + test("sStaticSyncCalls", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // Among other things, java.import creates Sync functions for static methods. - var String = java.import("java.lang.String"); - expect(String.formatSync('%s--%s', "hello", "world")).toBe("hello--world"); + const String = java.import("java.lang.String"); + expect(String.formatSync("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('promiseCalls', async () => { - var arrayList = java.newInstanceSync("java.util.ArrayList"); - await new Promise(resolve => { - arrayList.addPromise("hello") - .then(() => { return arrayList.addPromise("world"); }) - .then(() => { return arrayList.sizePromise(); }) + test("promiseCalls", async () => { + const arrayList = java.newInstanceSync("java.util.ArrayList"); + await new Promise((resolve) => { + arrayList + .addPromise("hello") + .then(() => { + return arrayList.addPromise("world"); + }) + .then(() => { + return arrayList.sizePromise(); + }) .then((size) => { expect(size).toBe(2); resolve(); }); }); }); -}); \ No newline at end of file +}); diff --git a/testAsyncOptions/syncDefaultPlusPromise.test.js b/testAsyncOptions/syncDefaultPlusPromise.test.js index 18ee86ed..8b0d9f81 100644 --- a/testAsyncOptions/syncDefaultPlusPromise.test.js +++ b/testAsyncOptions/syncDefaultPlusPromise.test.js @@ -6,23 +6,23 @@ import { getJava } from "../testHelpers"; const java = getJava({ syncSuffix: "", - promiseSuffix: 'P', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "P", + promisify: require("when/node").lift, // https://github.com/cujojs/when }); -describe('syncDefaultPlusPromise', () => { - test('api', () => { +describe("syncDefaultPlusPromise", () => { + test("api", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); expect(arrayList).toBeTruthy(); expect(java.instanceOf(arrayList, "java.util.ArrayList")).toBeTruthy(); - expect(typeof arrayList.add !== 'undefined', 'Expected `add` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addP !== 'undefined', 'Expected `addP` to be present, but it is NOT.').toBeTruthy(); - expect(typeof arrayList.addSync === 'undefined', 'Expected `addSync` to NOT be present, but it is.').toBeTruthy(); - expect(typeof arrayList.addAsync === 'undefined', 'Expected `addAsync` to NOT be present, but it is.').toBeTruthy(); + expect(typeof arrayList.add !== "undefined", "Expected `add` to be present, but it is NOT.").toBeTruthy(); + expect(typeof arrayList.addP !== "undefined", "Expected `addP` to be present, but it is NOT.").toBeTruthy(); + expect(typeof arrayList.addSync === "undefined", "Expected `addSync` to NOT be present, but it is.").toBeTruthy(); + expect(typeof arrayList.addAsync === "undefined", "Expected `addAsync` to NOT be present, but it is.").toBeTruthy(); }); - test('importClass', () => { + test("importClass", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // This test verifies the import runs without error. const ArrayList = java.import("java.util.ArrayList"); @@ -32,38 +32,43 @@ describe('syncDefaultPlusPromise', () => { expect(arrayList.size()).toBe(0); }); - test('staticAPI', () => { + test("staticAPI", () => { const String = java.import("java.lang.String"); expect(String).toBeTruthy(); - const api = Object.keys(String).filter((key) => typeof String[key] === 'function'); - expect(api.includes('format'), 'Expected `format` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatP'), 'Expected `formatP` to be present, but it is NOT.').toBeTruthy(); - expect(api.includes('formatSync'), 'Expected `formatSync` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatAsync'), 'Expected `formatAsync` to NOT be present, but it is.').toBeFalsy(); - expect(api.includes('formatundefined'), 'Expected `formatundefined` to NOT be present, but it is.').toBeFalsy(); + const api = Object.keys(String).filter((key) => typeof String[key] === "function"); + expect(api.includes("format"), "Expected `format` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatP"), "Expected `formatP` to be present, but it is NOT.").toBeTruthy(); + expect(api.includes("formatSync"), "Expected `formatSync` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatAsync"), "Expected `formatAsync` to NOT be present, but it is.").toBeFalsy(); + expect(api.includes("formatundefined"), "Expected `formatundefined` to NOT be present, but it is.").toBeFalsy(); }); - test('syncCalls', () => { + test("syncCalls", () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); arrayList.add("hello"); arrayList.add("world"); expect(arrayList.size()).toBe(2); }); - test('staticSyncCalls', () => { + test("staticSyncCalls", () => { // Note: java.import executes javascript code in lib/nodeJavaBridge that makes sync calls to java classes. // Among other things, java.import creates Sync functions for static methods. const String = java.import("java.lang.String"); - expect(String.format('%s--%s', "hello", "world")).toBe("hello--world"); + expect(String.format("%s--%s", "hello", "world")).toBe("hello--world"); }); - test('promiseCalls', async () => { + test("promiseCalls", async () => { const arrayList = java.newInstanceSync("java.util.ArrayList"); - await new Promise(resolve => { - arrayList.addP("hello") - .then(() => { return arrayList.addP("world"); }) - .then(() => { return arrayList.sizeP(); }) + await new Promise((resolve) => { + arrayList + .addP("hello") + .then(() => { + return arrayList.addP("world"); + }) + .then(() => { + return arrayList.sizeP(); + }) .then((size) => { expect(size).toBe(2); resolve(); diff --git a/testAsyncOptions/unusableMethodName.test.js b/testAsyncOptions/unusableMethodName.test.js index 30ed9831..e1670e48 100644 --- a/testAsyncOptions/unusableMethodName.test.js +++ b/testAsyncOptions/unusableMethodName.test.js @@ -8,11 +8,11 @@ import { beforeAll, describe, expect, test } from "vitest"; import { java } from "../testHelpers"; -describe('unusableMethodName', () => { +describe("unusableMethodName", () => { beforeAll(async () => { - await new Promise(resolve => { + await new Promise((resolve) => { function before(callback) { - java.classpath.push('test/'); + java.classpath.push("test/"); expect(java.isJvmCreated()).toBeFalsy(); callback(); } @@ -25,8 +25,8 @@ describe('unusableMethodName', () => { java.asyncOptions = { syncSuffix: "Sync", asyncSuffix: "", - ifReadOnlySuffix: "_alt" - } + ifReadOnlySuffix: "_alt", + }; java.registerClient(before, after); java.ensureJvm(function (err) { @@ -37,40 +37,40 @@ describe('unusableMethodName', () => { }); }); - test('unusableMethodName_nameThrows', () => { - var Test = java.import("Test"); + test("unusableMethodName_nameThrows", () => { + const Test = java.import("Test"); expect(Test).toBeTruthy(); expect(() => { Test.name(function (_err) { - throw new Error('should not get here'); + throw new Error("should not get here"); }); }).toThrowError(TypeError); }); - test('unusableMethodName_callerThrows', () => { - var Test = java.import("Test"); + test("unusableMethodName_callerThrows", () => { + const Test = java.import("Test"); expect(Test).toBeTruthy(); expect(() => { Test.caller(function (_err) { - throw new Error('should not get here'); + throw new Error("should not get here"); }); }).toThrowError(TypeError); }); - test('unusableMethodName_argumentsThrows', () => { - var Test = java.import("Test"); + test("unusableMethodName_argumentsThrows", () => { + const Test = java.import("Test"); expect(Test).toBeTruthy(); expect(() => { Test.arguments(function (_err) { - throw new Error('should not get here'); + throw new Error("should not get here"); }); }).toThrowError(TypeError); }); - test('alternateMethodName_name_altWorks', async () => { - var Test = java.import("Test"); + test("alternateMethodName_name_altWorks", async () => { + const Test = java.import("Test"); expect(Test).toBeTruthy(); - await new Promise(resolve => { + await new Promise((resolve) => { Test.name_alt(function (err, val) { expect(err).toBeFalsy(); expect(val).toBe("name"); @@ -79,10 +79,10 @@ describe('unusableMethodName', () => { }); }); - test('alternateMethodName_caller_altWorks', async () => { - var Test = java.import("Test"); + test("alternateMethodName_caller_altWorks", async () => { + const Test = java.import("Test"); expect(Test).toBeTruthy(); - await new Promise(resolve => { + await new Promise((resolve) => { Test.caller_alt(function (err, val) { expect(err).toBeFalsy(); expect(val).toBe("caller"); @@ -91,10 +91,10 @@ describe('unusableMethodName', () => { }); }); - test('alternateMethodName_arguments_altWorks', async () => { - var Test = java.import("Test"); + test("alternateMethodName_arguments_altWorks", async () => { + const Test = java.import("Test"); expect(Test).toBeTruthy(); - await new Promise(resolve => { + await new Promise((resolve) => { Test.arguments_alt(function (err, val) { expect(err).toBeFalsy(); expect(val).toBe("arguments"); @@ -103,8 +103,8 @@ describe('unusableMethodName', () => { }); }); - test('reservedFieldName', () => { - var TestEnum = java.import("Test$Enum"); + test("reservedFieldName", () => { + const TestEnum = java.import("Test$Enum"); expect(TestEnum).toBeTruthy(); // 'foo' and 'bar' are valid enum names @@ -119,4 +119,4 @@ describe('unusableMethodName', () => { expect(TestEnum.caller_alt.toString()).toBe("caller"); expect(TestEnum.arguments_alt.toString()).toBe("arguments"); }); -}); \ No newline at end of file +}); diff --git a/testHelpers.js b/testHelpers.js index 7149b011..93e8fa0b 100644 --- a/testHelpers.js +++ b/testHelpers.js @@ -10,8 +10,8 @@ export function getJava(asyncOptions) { java.asyncOptions = asyncOptions ?? { syncSuffix: "Sync", asyncSuffix: "", - promiseSuffix: 'Promise', - promisify: require('when/node').lift // https://github.com/cujojs/when + promiseSuffix: "Promise", + promisify: require("when/node").lift, // https://github.com/cujojs/when }; // force initialization diff --git a/testIntegration/jdbc/enduranceTest.js b/testIntegration/jdbc/enduranceTest.js index 0a82e1c7..e1b2e0a6 100644 --- a/testIntegration/jdbc/enduranceTest.js +++ b/testIntegration/jdbc/enduranceTest.js @@ -1,66 +1,73 @@ -'use strict'; +"use strict"; -var memwatch = require('memwatch'); +const memwatch = require("memwatch"); -var dbServerName = '192.168.13.190'; -var dbPort = 1433; -var dbName = 'test'; -var dbUserId = 'test'; -var dbPassword = 'test'; -var dbConnectString = 'jdbc:sqlserver://' + dbServerName + ':' + dbPort + ';databaseName=' + dbName + ';selectMethod=direct;responseBuffering=adaptive;packetSize=0;programName=nodeJavaTest;hostProcess=nodeJavaTest;sendStringParametersAsUnicode=false;'; -var dbConnectionClass = 'com.microsoft.sqlserver.jdbc.SQLServerDriver'; +const dbServerName = "192.168.13.190"; +const dbPort = 1433; +const dbName = "test"; +const dbUserId = "test"; +const dbPassword = "test"; +const dbConnectString = + "jdbc:sqlserver://" + + dbServerName + + ":" + + dbPort + + ";databaseName=" + + dbName + + ";selectMethod=direct;responseBuffering=adaptive;packetSize=0;programName=nodeJavaTest;hostProcess=nodeJavaTest;sendStringParametersAsUnicode=false;"; +const dbConnectionClass = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; -//var dbUserId = 'test'; -//var dbPassword = 'test'; -//var dbConnectString = "jdbc:mysql://localhost/test"; -//var dbConnectionClass = 'com.mysql.jdbc.Driver'; +//const dbUserId = 'test'; +//const dbPassword = 'test'; +//const dbConnectString = "jdbc:mysql://localhost/test"; +//const dbConnectionClass = 'com.mysql.jdbc.Driver'; -var util = require('util'); -var path = require('path'); -var java = require('../../'); -java.classpath.push(path.join(__dirname, 'sqljdbc4.jar')); -java.classpath.push(path.join(__dirname, 'mysql-connector-java-5.1.22-bin.jar')); -var DriverManager = java.import('java.sql.DriverManager'); +const util = require("util"); +const path = require("path"); +const java = require("../../"); +java.classpath.push(path.join(__dirname, "sqljdbc4.jar")); +java.classpath.push(path.join(__dirname, "mysql-connector-java-5.1.22-bin.jar")); +const DriverManager = java.import("java.sql.DriverManager"); -setTimeout(function() { - console.log('start heap diff'); - var hd = new memwatch.HeapDiff(); - var loopStart = new Date(); - for (var loopCount = 0; loopCount < 500000; loopCount++) { - console.log('loopCount:', loopCount); +setTimeout(function () { + console.log("start heap diff"); + const hd = new memwatch.HeapDiff(); + const loopStart = new Date(); + for (let loopCount = 0; loopCount < 500000; loopCount++) { + console.log("loopCount:", loopCount); doLoop(); } - var loopEnd = new Date(); - console.log('end loop', loopEnd - loopStart); + const loopEnd = new Date(); + console.log("end loop", loopEnd - loopStart); memwatch.gc(); - var diff = hd.end(); + const diff = hd.end(); console.log(util.inspect(diff.change, false, 10, true)); console.log("done... waiting 30seconds"); - setTimeout(function() { + setTimeout(function () { console.log("really done"); }, 30 * 1000); }, 1); function doLoop() { java.findClassSync(dbConnectionClass); - var conn = DriverManager.getConnectionSync(dbConnectString, dbUserId, dbPassword); + const conn = DriverManager.getConnectionSync(dbConnectString, dbUserId, dbPassword); //console.log("connected"); - var statement = conn.createStatementSync(); - var queryString = "select * from Person"; - var rs = statement.executeQuerySync(queryString); - var metaData = rs.getMetaDataSync(); - var columnCount = metaData.getColumnCountSync(); + const statement = conn.createStatementSync(); + const queryString = "select * from Person"; + const rs = statement.executeQuerySync(queryString); + const metaData = rs.getMetaDataSync(); + const columnCount = metaData.getColumnCountSync(); while (rs.nextSync()) { - for (var i = 1; i <= columnCount; i++) { - var obj = rs.getObjectSync(i); + for (let i = 1; i <= columnCount; i++) { + const obj = rs.getObjectSync(i); if (obj) { - if (obj.hasOwnProperty('getClassSync')) { - if (obj.getClassSync().toString() == 'class java.math.BigDecimal') { + if (Object.prototype.hasOwnProperty.call(obj, "getClassSync")) { + if (obj.getClassSync().toString() == "class java.math.BigDecimal") { //console.log(obj.doubleValueSync()); continue; } - if (obj.getClassSync().toString() == 'class java.sql.Timestamp') { + if (obj.getClassSync().toString() == "class java.sql.Timestamp") { //console.log(obj.getTimeSync()); continue; } @@ -71,4 +78,4 @@ function doLoop() { } } conn.closeSync(); -} \ No newline at end of file +} diff --git a/testIntegration/jdbc/enduranceTestAsync.js b/testIntegration/jdbc/enduranceTestAsync.js index 039c52fe..87b8eea3 100644 --- a/testIntegration/jdbc/enduranceTestAsync.js +++ b/testIntegration/jdbc/enduranceTestAsync.js @@ -1,67 +1,67 @@ -'use strict'; +"use strict"; // Tests concurrent async jdbc connections. // TODO: a proper jdbc wrapper should be created to avoid ugly async code. -var memwatch = require('memwatch'); -var async = require('async'); +const memwatch = require("memwatch"); +const async = require("async"); // 1 - 23,305ms // 5 - 9,338ms // 10 - 8,846ms -var concurrency = 5; - -//var dbServerName = '192.168.13.190'; -//var dbPort = 1433; -//var dbName = 'test'; -//var dbUserId = 'test'; -//var dbPassword = 'test'; -//var dbConnectString = 'jdbc:sqlserver://' + dbServerName + ':' + dbPort + ';databaseName=' + dbName + ';selectMethod=direct;responseBuffering=adaptive;packetSize=0;programName=nodeJavaTest;hostProcess=nodeJavaTest;sendStringParametersAsUnicode=false;'; -//var dbConnectionClass = 'com.microsoft.sqlserver.jdbc.SQLServerDriver'; - -var dbUserId = 'test'; -var dbPassword = 'test'; -var dbConnectString = "jdbc:mysql://localhost/test"; -var dbConnectionClass = 'com.mysql.jdbc.Driver'; - -var util = require('util'); -var path = require('path'); -var java = require('../../'); -java.classpath.push(path.join(__dirname, 'sqljdbc4.jar')); -java.classpath.push(path.join(__dirname, 'mysql-connector-java-5.1.22-bin.jar')); -var DriverManager = java.import('java.sql.DriverManager'); - -setTimeout(function() { - console.log('start heap diff'); - var hd = new memwatch.HeapDiff(); - var loopStart = new Date(); +const concurrency = 5; + +//const dbServerName = '192.168.13.190'; +//const dbPort = 1433; +//const dbName = 'test'; +//const dbUserId = 'test'; +//const dbPassword = 'test'; +//const dbConnectString = 'jdbc:sqlserver://' + dbServerName + ':' + dbPort + ';databaseName=' + dbName + ';selectMethod=direct;responseBuffering=adaptive;packetSize=0;programName=nodeJavaTest;hostProcess=nodeJavaTest;sendStringParametersAsUnicode=false;'; +//const dbConnectionClass = 'com.microsoft.sqlserver.jdbc.SQLServerDriver'; + +const dbUserId = "test"; +const dbPassword = "test"; +const dbConnectString = "jdbc:mysql://localhost/test"; +const dbConnectionClass = "com.mysql.jdbc.Driver"; + +const util = require("util"); +const path = require("path"); +const java = require("../../"); +java.classpath.push(path.join(__dirname, "sqljdbc4.jar")); +java.classpath.push(path.join(__dirname, "mysql-connector-java-5.1.22-bin.jar")); +const DriverManager = java.import("java.sql.DriverManager"); + +setTimeout(function () { + console.log("start heap diff"); + const hd = new memwatch.HeapDiff(); + const loopStart = new Date(); java.findClassSync(dbConnectionClass); - var loopIterations = []; - for (var i = 0; i < 5000; i++) { + const loopIterations = []; + for (let i = 0; i < 5000; i++) { loopIterations.push(i); } async.forEachLimit( loopIterations, concurrency, - function(loopCount, callback) { - console.log('loopCount:', loopCount); + function (loopCount, callback) { + console.log("loopCount:", loopCount); return doLoop(callback); }, - function(err) { + function (err) { if (err) { console.log("fail", err); } - var loopEnd = new Date(); - console.log('end loop', loopEnd - loopStart); + const loopEnd = new Date(); + console.log("end loop", loopEnd - loopStart); memwatch.gc(); - var diff = hd.end(); + const diff = hd.end(); console.log(util.inspect(diff.change, false, 10, true)); console.log("done... waiting 30seconds"); - setTimeout(function() { + setTimeout(function () { console.log("really done"); }, 30 * 1000); } @@ -69,7 +69,7 @@ setTimeout(function() { }, 1); function doLoop(callback) { - var conn; + let conn; return DriverManager.getConnection(dbConnectString, dbUserId, dbPassword, getConnectionComplete); @@ -80,34 +80,41 @@ function doLoop(callback) { conn = _conn; //console.log("connected"); - var queryString = "select * from Person"; - return executeQuery(conn, queryString, function(row, callback) { - //console.log("row", row); - return callback(); - }, function(err) { - if (err) { - return callback(err); + const queryString = "select * from Person"; + return executeQuery( + conn, + queryString, + function (row, callback) { + //console.log("row", row); + return callback(); + }, + function (err) { + if (err) { + return callback(err); + } + //console.log("query complete"); + return callback(); } - //console.log("query complete"); - return callback(); - }); + ); } } function executeQuery(conn, sql, rowCallback, completeCallback) { - var statement = conn.createStatementSync(); - return statement.executeQuery(sql, function(err, rs) { + const statement = conn.createStatementSync(); + return statement.executeQuery(sql, function (err, rs) { if (err) { return completeCallback(err); } - var columnCount = rs.getMetaDataSync().getColumnCountSync(); + const columnCount = rs.getMetaDataSync().getColumnCountSync(); - var rsComplete = false; + let rsComplete = false; async.until( - function() { return rsComplete; }, - function(callback) { - return rs.next(function(err, rsNextResult) { + function () { + return rsComplete; + }, + function (callback) { + return rs.next(function (err, rsNextResult) { if (err) { return callback(err); } @@ -115,14 +122,14 @@ function executeQuery(conn, sql, rowCallback, completeCallback) { rsComplete = true; return callback(); } - var row = []; - for (var i = 1; i <= columnCount; i++) { + const row = []; + for (let i = 1; i <= columnCount; i++) { row.push(rs.getObjectSync(i)); } return rowCallback(row, callback); }); }, - function(err) { + function (err) { if (err) { return completeCallback(err); } @@ -130,4 +137,4 @@ function executeQuery(conn, sql, rowCallback, completeCallback) { } ); }); -} \ No newline at end of file +} diff --git a/testIntegration/poi/poi-3.9-20121203.jar b/testIntegration/poi/poi-3.9-20121203.jar index c5d731b09835acd9ced33f5fd0e66d55f462b5b7..0f462880ea30349656038eca3bc94320efef0179 100644 GIT binary patch delta 239 zcmZ45RkX9KXv4gIM&8Zy`VVn2@-`>T+MY0rvF{NhZ~MC%rtR-)n9FQ{?3A6%+f#P3 z2u)?=-CpL$DtZur|)eh~o3gjj@~ delta 152 zcmeBw=hgVmYr~9)%`+qJGmCT0+posOb^O7q%!M72PD^sawoI7Db$jaOi81F4HYfCU zy=Z@3$_T_v+h3P53vAr}M~%g*uHAeo3lOtzH($zTm9)KxoqfJUyO07q5OV-AClGUO z7gFH9YTy1Mo_qU?cpk|Y+nGFgC+ujQ%-1@Zf9qs{4`-IQoE6Y%Z~ZB-z4fPH*IocM CkU_Zs diff --git a/testIntegration/poi/poiTest.js b/testIntegration/poi/poiTest.js index ce516c0b..220a4a8a 100644 --- a/testIntegration/poi/poiTest.js +++ b/testIntegration/poi/poiTest.js @@ -1,20 +1,23 @@ -var java = require('../../'); +const java = require("../../"); java.classpath.push("poi-3.9-20121203.jar"); java.classpath.push("poi-scratchpad-3.9-20121203.jar"); -var stream = java.newInstanceSync("java.io.FileInputStream", 'presentation.ppt'); -var ppt = java.newInstanceSync('org.apache.poi.hslf.usermodel.SlideShow', stream); +const stream = java.newInstanceSync("java.io.FileInputStream", "presentation.ppt"); +const ppt = java.newInstanceSync("org.apache.poi.hslf.usermodel.SlideShow", stream); stream.close(); -var pgsize = ppt.getPageSizeSync(); +const pgsize = ppt.getPageSizeSync(); +console.log(`found page size ${pgsize.width}x${pgsize.height}`); -var slides = ppt.getSlidesSync(); +const slides = ppt.getSlidesSync(); +console.log(`found ${slides.length} slides`); -var TYPE_INT_RGB = java.getStaticFieldValue("java.awt.image.BufferedImage", "TYPE_INT_RGB"); +const TYPE_INT_RGB = java.getStaticFieldValue("java.awt.image.BufferedImage", "TYPE_INT_RGB"); -var img, graphics; -for (i = 0; i < slides.length; i++) { - img = java.newInstanceSync('java.awt.image.BufferedImage', pgsize.width, pgsize.height, TYPE_INT_RGB); - graphics = img.createGraphicsSync(); +for (let i = 0; i < slides.length; i++) { + console.log(`creating image: ${i}`); + const img = java.newInstanceSync("java.awt.image.BufferedImage", pgsize.width, pgsize.height, TYPE_INT_RGB); + img.createGraphicsSync(); } -console.log('done'); \ No newline at end of file +console.log("done"); +process.exit(0); diff --git a/testIntegration/webkit/main.js b/testIntegration/webkit/main.js index 403b5229..2cf9063e 100644 --- a/testIntegration/webkit/main.js +++ b/testIntegration/webkit/main.js @@ -1,5 +1,5 @@ -var java = require('../../'); +const java = require("../../"); -function runJavaMethod() { +export function runJavaMethod() { return java.callStaticMethodSync("java.lang.System", "getProperty", "java.version"); -} \ No newline at end of file +} diff --git a/testRunner.js b/testRunner.js index b47d5ee5..92031fe7 100644 --- a/testRunner.js +++ b/testRunner.js @@ -3,23 +3,25 @@ // This is a custom test runner. All tests are run with vitest, but in separate // processes, which allows us to test java with different configuration options. -const async = require('async'); -const chalk = require('chalk'); -const childProcess = require('child_process'); -const glob = require('glob'); -const path = require('path'); +const async = require("async"); +const chalk = require("chalk"); +const childProcess = require("node:child_process"); +const glob = require("glob"); +const path = require("node:path"); -const tests = glob.sync(path.join('testAsyncOptions', '*.test.js')).sort((a, b) => a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase())); +const tests = glob + .sync(path.join("testAsyncOptions", "*.test.js")) + .sort((a, b) => a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase())); -tests.unshift('test'); // Arrange to run the primary tests first, in a single process +tests.unshift("test"); // Arrange to run the primary tests first, in a single process function runTest(testArgs, done) { - const vitest = path.join('node_modules', '.bin', 'vitest'); - const cmd = testArgs === 'test' ? `vitest --dir test` : `${vitest} ${testArgs}`; + const vitest = path.join("node_modules", ".bin", "vitest"); + const cmd = testArgs === "test" ? `vitest --dir test` : `${vitest} ${testArgs}`; console.log(`running "${cmd}"...`); childProcess.exec(cmd, function (error, stdout, stderr) { - var errText = stderr.toString(); - if (errText !== '') { + const errText = stderr.toString(); + if (errText !== "") { console.error(chalk.bold.red(errText)); } @@ -34,5 +36,5 @@ async.eachSeries(tests, runTest, function (err) { process.exit(1); return; } - console.log(chalk.green('Tests completed successfully!')); + console.log(chalk.green("Tests completed successfully!")); });