How to use

V8Function

in

com.eclipsesource.v8

@Override
protected V8Value createTwin() {
  return new V8Function(v8);
}

  @Override
  public Object invoke(final V8Object receiver, final V8Array parameters) {
    V8Array requireParams = new V8Array(v8);
    try {
      requireParams.push(file.getAbsolutePath());
      return require.call(null, requireParams);
    } finally {
      requireParams.close();
    }
  }
});

  @Override
  public void invoke(final V8Object receiver, final V8Array parameters) {
    V8Function require = (V8Function) parameters.get(0);
    try {
      node.init(require.twin());
    } finally {
      require.close();
    }
  }
}, STARTUP_CALLBACK);

/**
 * Releases the NodeJS runtime.
 */
public void release() {
  v8.checkThread();
  if (!require.isReleased()) {
    require.close();
  }
  if (!v8.isReleased()) {
    v8.close();
  }
}

v8.add("svg2png", new V8Function(v8, (receiver, params) -> {
 String svgPath = params.get(0).toString();
 String pngPath = params.get(1).toString();
   .onSuccess(() -> callback.call(null, null))
   .onFailure(x -> {
    log.debug("png-fallback resulted in exception", x);
    callback.call(null, toV8Array(v8, Arrays.asList(x.getMessage())));
   });
 return V8.UNDEFINED;

@Test
public void testCreateV8Function() {
  V8Function function = new V8Function(v8, new JavaCallback() {
    @Override
    public Object invoke(final V8Object receiver, final V8Array parameters) {
      result = "passed";
      return null;
    }
  });
  function.call(null, null);
  assertEquals("passed", result);
  function.close();
}

@Test
public void testCallFunctionNullParameters() {
  v8.executeVoidScript("function call() {return true;}");
  V8Function function = (V8Function) v8.getObject("call");
  boolean result = (Boolean) function.call(v8, null);
  assertTrue(result);
  function.close();
}

@Test
public void testV8HandleCreated_V8Function() {
  ReferenceHandler referenceHandler = mock(ReferenceHandler.class);
  v8.addReferenceHandler(referenceHandler);
  V8Function object = new V8Function(v8);
  verify(referenceHandler, times(1)).v8HandleCreated(object);
  object.close();
}

/**
 * Releases the NodeJS runtime.
 */
public void release() {
  v8.checkThread();
  if (!require.isReleased()) {
    require.release();
  }
  if (!v8.isReleased()) {
    v8.release();
  }
}

@Test
public void testGetType_V8Function() {
  V8Function function = new V8Function(v8, mock(JavaCallback.class));
  assertEquals(V8Value.V8_FUNCTION, function.getV8Type());
  function.close();
}

  @Override
  public Object adapt(final Object value) {
    return ((V8Function) value).twin();
  }
});

  @Override
  public void invoke(final V8Object receiver, final V8Array parameters) {
    V8Function require = (V8Function) parameters.get(0);
    try {
      node.init(require.twin());
    } finally {
      require.release();
    }
  }
}, STARTUP_CALLBACK);

@Override
protected void initialize(final long runtimePtr, final Object data) {
  if (data == null) {
    super.initialize(runtimePtr, null);
    return;
  }
  JavaCallback javaCallback = (JavaCallback) data;
  long[] pointers = v8.initNewV8Function(runtimePtr);
  // position 0 is the object reference, position 1 is the function reference
  v8.createAndRegisterMethodDescriptor(javaCallback, pointers[1]);
  released = false;
  addObjectReference(pointers[0]);
}

/**
 * Invoke the JavaScript function on the current runtime.
 *
 * @param receiver The object on which to call the function on. The
 * receiver will be mapped to 'this' in JavaScript. If receiver is null
 * or undefined, then the V8 runtime will be used instead.
 * @param parameters The parameters passed to the JS Function.
 *
 * @return The result of JavaScript function.
 */
@SuppressWarnings("resource")
public Object call(V8Object receiver, final V8Array parameters) {
  v8.checkThread();
  checkReleased();
  v8.checkRuntime(receiver);
  v8.checkRuntime(parameters);
  receiver = receiver != null ? receiver : v8;
  long parametersHandle = parameters == null ? 0 : parameters.getHandle();
  long receiverHandle = receiver.isUndefined() ? v8.getHandle() : receiver.getHandle();
  return v8.executeFunction(v8.getV8RuntimePtr(), receiverHandle, objectHandle, parametersHandle);
}

@Test
public void testSetBreakpointByFunctionReturnsID() {
  DebugHandler handler = new DebugHandler(v8);
  v8.executeScript(script, "script", 0);
  V8Function function = (V8Function) v8.get("foo");
  int breakpointID = handler.setBreakpoint(function);
  assertEquals(1, breakpointID);
  handler.close();
  function.close();
}

@Test
public void testCallFunctionWithEmojiParamter() {
  V8Function v8Function = new V8Function(v8, new JavaCallback() {
    @Override
    public Object invoke(final V8Object receiver, final V8Array parameters) {
      return parameters.get(0);
    }
  });
  V8Array paramters = new V8Array(v8);
  paramters.push("👄");
  Object result = v8Function.call(null, paramters);
  assertEquals("👄", result);
  paramters.close();
  v8Function.close();
}

@Test
public void testSetBreakpointByFunction() {
  DebugHandler handler = new DebugHandler(v8);
  v8.executeScript(script, "script", 0);
  V8Function function = (V8Function) v8.get("foo");
  handler.setBreakpoint(function);
  BreakHandler breakHandler = mock(BreakHandler.class);
  handler.addBreakHandler(breakHandler);
  function.call(null, null);
  verify(breakHandler, times(1)).onBreak(eq(DebugEvent.Break), any(ExecutionState.class), any(EventData.class), any(V8Object.class));
  handler.close();
  function.close();
}

@Test
public void testExecuteJSFunction_Function() {
  v8.executeVoidScript("function add(p1, p2) {return p1();}");
  V8Function function = new V8Function(v8, new JavaCallback() {
    @Override
    public Object invoke(final V8Object receiver, final V8Array parameters) {
      return 7;
    }
  });
  int result = (Integer) v8.executeJSFunction("add", function);
  assertEquals(7, result);
  function.close();
}

private void setupBreakpointHandler() {
  BreakpointHandler handler = new BreakpointHandler();
  debugObject.registerJavaMethod(handler, DEBUG_BREAK_HANDLER);
  V8Function debugHandler = null;
  V8Array parameters = null;
  try {
    debugHandler = (V8Function) debugObject.getObject(DEBUG_BREAK_HANDLER);
    parameters = new V8Array(runtime);
    parameters.push(debugHandler);
    debugObject.executeFunction(SET_LISTENER, parameters);
  } finally {
    if ((debugHandler != null) && !debugHandler.isReleased()) {
      debugHandler.close();
    }
    if ((parameters != null) && !parameters.isReleased()) {
      parameters.close();
    }
  }
}

/**
 * Releases the NodeJS runtime.
 */
public void release() {
  v8.checkThread();
  if (!require.isReleased()) {
    require.release();
  }
  if (!v8.isReleased()) {
    v8.release();
  }
}