tests/embind/test_i64_binding.cpp

// Copyright 2021 The Emscripten Authors.  All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License.  Both these licenses can be
// found in the LICENSE file.

#include <stdio.h>
#include <iostream>
#include <cmath>
#include <emscripten/bind.h>
#include <emscripten/emscripten.h>
#include <emscripten/val.h>

using namespace emscripten;
using namespace std;

void fail()
{
  cout << "fail\n";
}

void pass()
{
  cout << "pass\n";
}

void test(string message)
{
  cout << "test:\n" << message << "\n";
}

void ensure(bool value)
{
  if (value)
    pass();
  else
    fail();
}

void execute_js(string js_code)
{
  js_code.append(";");
  const char* js_code_pointer = js_code.c_str();
  EM_ASM_INT({
    var js_code = UTF8ToString($0);
    return eval(js_code);
  }, js_code_pointer);
}

void ensure_js(string js_code)
{
  js_code.append(";");
  const char* js_code_pointer = js_code.c_str();
  ensure(EM_ASM_INT({
    var js_code = UTF8ToString($0);
    return eval(js_code);
  }, js_code_pointer));
}

void ensure_js_throws(string js_code, string error_type)
{
  js_code.append(";");
  const char* js_code_pointer = js_code.c_str();
  const char* error_type_pointer = error_type.c_str();
  ensure(EM_ASM_INT({
    var js_code = UTF8ToString($0);
    var error_type = UTF8ToString($1);
    try {
      eval(js_code);
    }
    catch(error_thrown)
    {
      return error_thrown.name === error_type;
    }
    return false;
  }, js_code_pointer, error_type_pointer));
}

EMSCRIPTEN_BINDINGS(tests) {
  register_vector<int64_t>("Int64Vector");
  register_vector<uint64_t>("UInt64Vector");
}

int main()
{
  const int64_t max_int64_t = numeric_limits<int64_t>::max();
  const int64_t min_int64_t = numeric_limits<int64_t>::min();
  const uint64_t max_uint64_t = numeric_limits<uint64_t>::max();

  printf("start\n");

  test("vector<int64_t>");
  val myval(std::vector<int64_t>{1, 2, 3, -4});
  val::global().set("v64", myval);
  ensure_js("v64.get(0) === 1n");
  ensure_js("v64.get(1) === 2n");
  ensure_js("v64.get(2) === 3n");
  ensure_js("v64.get(3) === -4n");

  execute_js("v64.push_back(1234n)");
  ensure_js("v64.size() === 5");
  ensure_js("v64.get(4) === 1234n");

  test("vector<int64_t> Cannot convert number to int64_t");
  ensure_js_throws("v64.push_back(1234)", "TypeError");

  test("vector<int64_t> Cannot convert bigint that is too big");
  ensure_js_throws("v64.push_back(12345678901234567890123456n)", "TypeError");

  test("vector<uint64_t>");
  val myval2(vector<uint64_t>{1, 2, 3, 4});
  val::global().set("vU64", myval2);
  ensure_js("vU64.get(0) === 1n");
  ensure_js("vU64.get(1) === 2n");
  ensure_js("vU64.get(2) === 3n");
  ensure_js("vU64.get(3) === 4n");

  execute_js("vU64.push_back(1234n)");
  ensure_js("vU64.size() === 5");
  ensure_js("vU64.get(4) === 1234n");

  test("vector<uint64_t> Cannot convert number to uint64_t");
  ensure_js_throws("vU64.push_back(1234)", "TypeError");

  test("vector<uint64_t> Cannot convert bigint that is too big");
  ensure_js_throws("vU64.push_back(12345678901234567890123456n)", "TypeError");

  test("vector<uint64_t> Cannot convert bigint that is negative");
  ensure_js_throws("vU64.push_back(-1n)", "TypeError");

  myval.call<void>("delete");
  myval2.call<void>("delete");
  printf("end\n");

  return 0;
}