How to use

close

method

in

com.eclipsesource.v8.V8Function

  @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();
  }
}

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();
    }
  }
}

private void setupEventHandler() {
  EventHandler handler = new EventHandler();
  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();
    }
  }
}

  @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();
  }
}

@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();
}

@Test
public void testTwinIsFunction() {
  v8.executeVoidScript("function add(x, y) {return x+y;}");
  V8Function v8Object = (V8Function) v8.getObject("add");
  V8Function twin = v8Object.twin();
  assertTrue(twin instanceof V8Function);
  v8Object.close();
  twin.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 testGetType_V8Function() {
  V8Function function = new V8Function(v8, mock(JavaCallback.class));
  assertEquals(V8Value.V8_FUNCTION, function.getV8Type());
  function.close();
}

@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 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();
}

@Test
public void testCallFunctionNullReceiver() {
  v8.executeVoidScript("function call() {return this;}");
  V8Function function = (V8Function) v8.getObject("call");
  Object result = function.call(null, null);
  assertEquals(v8, result);
  function.close();
  ((Releasable) result).release();
}

@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(expected = IllegalStateException.class)
public void testHandleReleasedReceiver() {
  V8Object object = v8.executeObjectScript("var x = { a: function() { return 10; } }; x;");
  V8Function function = (V8Function) object.get("a");
  object.close();
  V8Array parameters = new V8Array(v8);
  try {
    function.call(object, parameters);
  } finally {
    parameters.close();
    function.close();
  }
}

@Test(expected = IllegalStateException.class)
public void testHandleReleasedParameters() {
  V8Object object = v8.executeObjectScript("var x = { a: function() { return 10; } }; x;");
  V8Function function = (V8Function) object.get("a");
  V8Array parameters = new V8Array(v8);
  parameters.close();
  try {
    function.call(object, parameters);
  } finally {
    object.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 testCallFunction() {
  v8.executeVoidScript("function add(x, y) {return x+y;}");
  V8Function function = (V8Function) v8.getObject("add");
  V8Array parameters = new V8Array(v8);
  parameters.push(7).push(8);
  Object result = function.call(v8, parameters);
  assertEquals(15, result);
  function.close();
  parameters.close();
}

@Test
public void testCallFunctionOnUndefined() {
  v8.executeVoidScript("function add(x, y) {return x+y;}");
  V8Function function = (V8Function) v8.getObject("add");
  V8Array parameters = new V8Array(v8);
  parameters.push(7).push(8);
  Object result = function.call(new V8Object.Undefined(), parameters);
  assertEquals(15, result);
  function.close();
  parameters.close();
}