ffi test code

2 files changed, 247 insertions, 26 deletions

diff --git a/integration/bunjs-only-snippets/ffi-test.c b/integration/bunjs-only-snippets/ffi-test.c
index 249a8ca26..eb9e33fc3 100644
--- a/integration/bunjs-only-snippets/ffi-test.c
+++ b/integration/bunjs-only-snippets/ffi-test.c
@@ -1,50 +1,82 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+bool returns_true();
+bool returns_false();
+char returns_42_char();
+float returns_42_float();
+double returns_42_double();
+uint8_t returns_42_uint8_t();
+int8_t returns_neg_42_int8_t();
+uint16_t returns_42_uint16_t();
+uint32_t returns_42_uint32_t();
+uint64_t returns_42_uint64_t();
+int16_t returns_neg_42_int16_t();
+int32_t returns_neg_42_int32_t();
+int64_t returns_neg_42_int64_t();
+
+bool identity_bool_true();
+bool identity_bool_false();
 char identity_char(char a);
+float identity_float(float a);
+bool identity_bool(bool ident);
+double identity_double(double a);
 int8_t identity_int8_t(int8_t a);
-uint8_t identity_uint8_t(uint8_t a);
 int16_t identity_int16_t(int16_t a);
-uint16_t identity_uint16_t(uint16_t a);
 int32_t identity_int32_t(int32_t a);
-uint32_t identity_uint32_t(uint32_t a);
 int64_t identity_int64_t(int64_t a);
+uint8_t identity_uint8_t(uint8_t a);
+uint16_t identity_uint16_t(uint16_t a);
+uint32_t identity_uint32_t(uint32_t a);
 uint64_t identity_uint64_t(uint64_t a);
-double identity_double(double a);
-float identity_float(float a);
 
 char add_char(char a, char b);
+float add_float(float a, float b);
+double add_double(double a, double b);
 int8_t add_int8_t(int8_t a, int8_t b);
-uint8_t add_uint8_t(uint8_t a, uint8_t b);
 int16_t add_int16_t(int16_t a, int16_t b);
-uint16_t add_uint16_t(uint16_t a, uint16_t b);
 int32_t add_int32_t(int32_t a, int32_t b);
-uint32_t add_uint32_t(uint32_t a, uint32_t b);
 int64_t add_int64_t(int64_t a, int64_t b);
+uint8_t add_uint8_t(uint8_t a, uint8_t b);
+uint16_t add_uint16_t(uint16_t a, uint16_t b);
+uint32_t add_uint32_t(uint32_t a, uint32_t b);
 uint64_t add_uint64_t(uint64_t a, uint64_t b);
-double add_double(double a, double b);
-float add_float(float a, float b);
+
+int8_t returns_neg_42_int8_t() { return 42; }
+uint16_t returns_42_uint16_t() { return 42; }
+uint32_t returns_42_uint32_t() { return 42; }
+uint64_t returns_42_uint64_t() { return 42; }
+int16_t returns_neg_42_int16_t() { return -42; }
+int32_t returns_neg_42_int32_t() { return -42; }
+int64_t returns_neg_42_int64_t() { return -42; }
+bool returns_true() { return true; }
+bool returns_false() { return false; }
+char returns_42_char() { return '*'; }
+float returns_42_float() { return 42.0f; }
+double returns_42_double() { return (double)42.0; }
+uint8_t returns_42_uint8_t() { return (uint8_t)42; }
 
 char identity_char(char a) { return a; }
+float identity_float(float a) { return a; }
+double identity_double(double a) { return a; }
 int8_t identity_int8_t(int8_t a) { return a; }
-uint8_t identity_uint8_t(uint8_t a) { return a; }
 int16_t identity_int16_t(int16_t a) { return a; }
-uint16_t identity_uint16_t(uint16_t a) { return a; }
 int32_t identity_int32_t(int32_t a) { return a; }
-uint32_t identity_uint32_t(uint32_t a) { return a; }
 int64_t identity_int64_t(int64_t a) { return a; }
+uint8_t identity_uint8_t(uint8_t a) { return a; }
+uint16_t identity_uint16_t(uint16_t a) { return a; }
+uint32_t identity_uint32_t(uint32_t a) { return a; }
 uint64_t identity_uint64_t(uint64_t a) { return a; }
-double identity_double(double a) { return a; }
-float identity_float(float a) { return a; }
+bool identity_bool(bool ident) { return ident; }
 
 char add_char(char a, char b) { return a + b; }
+float add_float(float a, float b) { return a + b; }
+double add_double(double a, double b) { return a + b; }
 int8_t add_int8_t(int8_t a, int8_t b) { return a + b; }
-uint8_t add_uint8_t(uint8_t a, uint8_t b) { return a + b; }
 int16_t add_int16_t(int16_t a, int16_t b) { return a + b; }
-uint16_t add_uint16_t(uint16_t a, uint16_t b) { return a + b; }
 int32_t add_int32_t(int32_t a, int32_t b) { return a + b; }
-uint32_t add_uint32_t(uint32_t a, uint32_t b) { return a + b; }
 int64_t add_int64_t(int64_t a, int64_t b) { return a + b; }
+uint8_t add_uint8_t(uint8_t a, uint8_t b) { return a + b; }
+uint16_t add_uint16_t(uint16_t a, uint16_t b) { return a + b; }
+uint32_t add_uint32_t(uint32_t a, uint32_t b) { return a + b; }
 uint64_t add_uint64_t(uint64_t a, uint64_t b) { return a + b; }
-double add_double(double a, double b) { return a + b; }
-float add_float(float a, float b) { return a + b; }
diff --git a/integration/bunjs-only-snippets/ffi.test.js b/integration/bunjs-only-snippets/ffi.test.js
index bc3ac1f2a..83a6c8950 100644
--- a/integration/bunjs-only-snippets/ffi.test.js
+++ b/integration/bunjs-only-snippets/ffi.test.js
@@ -11,15 +11,204 @@ it("ffi print", () => {
 
 it("ffi run", () => {
   const {
-    symbols: { add },
+    symbols: {
+      returns_true,
+      returns_false,
+      returns_42_char,
+      returns_42_float,
+      returns_42_double,
+      returns_42_uint8_t,
+      returns_neg_42_int8_t,
+      returns_42_uint16_t,
+      returns_42_uint32_t,
+      returns_42_uint64_t,
+      returns_neg_42_int16_t,
+      returns_neg_42_int32_t,
+      returns_neg_42_int64_t,
+      identity_char,
+      identity_float,
+      identity_bool,
+      identity_double,
+      identity_int8_t,
+      identity_int16_t,
+      identity_int32_t,
+      identity_int64_t,
+      identity_uint8_t,
+      identity_uint16_t,
+      identity_uint32_t,
+      identity_uint64_t,
+      add_char,
+      add_float,
+      add_double,
+      add_int8_t,
+      add_int16_t,
+      add_int32_t,
+      add_int64_t,
+      add_uint8_t,
+      add_uint16_t,
+      add_uint32_t,
+      add_uint64_t,
+    },
     close,
-  } = Bun.dlopen("/tmp/libffi-test.dylib", {
-    add: {
-      params: ["int32_t", "int32_t"],
-      return_type: "int32_t",
+  } = Bun.dlopen("/tmp/bun-ffi-test.dylib", {
+    returns_true: {
+      returns: "bool",
+      expects: [],
+    },
+    returns_false: {
+      returns: "bool",
+      expects: [],
+    },
+    returns_42_char: {
+      returns: "char",
+      expects: [],
+    },
+    returns_42_float: {
+      returns: "float",
+      expects: [],
+    },
+    returns_42_double: {
+      returns: "double",
+      expects: [],
+    },
+    returns_42_uint8_t: {
+      returns: "uint8_t",
+      expects: [],
+    },
+    returns_neg_42_int8_t: {
+      returns: "int8_t",
+      expects: [],
+    },
+    returns_42_uint16_t: {
+      returns: "uint16_t",
+      expects: [],
+    },
+    returns_42_uint32_t: {
+      returns: "uint32_t",
+      expects: [],
+    },
+    returns_42_uint64_t: {
+      returns: "uint64_t",
+      expects: [],
+    },
+    returns_neg_42_int16_t: {
+      returns: "int16_t",
+      expects: [],
+    },
+    returns_neg_42_int32_t: {
+      returns: "int32_t",
+      expects: [],
+    },
+    returns_neg_42_int64_t: {
+      returns: "int64_t",
+      expects: [],
+    },
+
+    identity_char: {
+      returns: "char",
+      expects: ["char"],
+    },
+    identity_float: {
+      returns: "float",
+      expects: ["float"],
+    },
+    identity_bool: {
+      returns: "bool",
+      expects: ["bool"],
+    },
+    identity_double: {
+      returns: "double",
+      expects: ["double"],
+    },
+    identity_int8_t: {
+      returns: "int8_t",
+      expects: ["int8_t"],
+    },
+    identity_int16_t: {
+      returns: "int16_t",
+      expects: ["int16_t"],
+    },
+    identity_int32_t: {
+      returns: "int32_t",
+      expects: ["int32_t"],
+    },
+    identity_int64_t: {
+      returns: "int64_t",
+      expects: ["int64_t"],
+    },
+    identity_uint8_t: {
+      returns: "uint8_t",
+      expects: ["uint8_t"],
+    },
+    identity_uint16_t: {
+      returns: "uint16_t",
+      expects: ["uint16_t"],
+    },
+    identity_uint32_t: {
+      returns: "uint32_t",
+      expects: ["uint32_t"],
+    },
+    identity_uint64_t: {
+      returns: "uint64_t",
+      expects: ["uint64_t"],
+    },
+
+    add_char: {
+      returns: "char",
+      expects: ["char", "char"],
+    },
+    add_float: {
+      returns: "float",
+      expects: ["float", "float"],
+    },
+    add_double: {
+      returns: "double",
+      expects: ["double", "double"],
+    },
+    add_int8_t: {
+      returns: "int8_t",
+      expects: ["int8_t", "int8_t"],
+    },
+    add_int16_t: {
+      returns: "int16_t",
+      expects: ["int16_t", "int16_t"],
+    },
+    add_int32_t: {
+      returns: "int32_t",
+      expects: ["int32_t", "int32_t"],
+    },
+    add_int64_t: {
+      returns: "int64_t",
+      expects: ["int64_t", "int64_t"],
+    },
+    add_uint8_t: {
+      returns: "uint8_t",
+      expects: ["uint8_t", "uint8_t"],
+    },
+    add_uint16_t: {
+      returns: "uint16_t",
+      expects: ["uint16_t", "uint16_t"],
+    },
+    add_uint32_t: {
+      returns: "uint32_t",
+      expects: ["uint32_t", "uint32_t"],
+    },
+    add_uint64_t: {
+      returns: "uint64_t",
+      expects: ["uint64_t", "uint64_t"],
     },
   });
-  expect(add(1, 2)).toBe(3);
+  expect(add_char(1, 1)).toBe(2);
+  expect(add_float(1.1, 1.1)).toBe(2.2);
+  expect(add_double(1.1, 1.1)).toBe(2.2);
+  expect(add_int8_t(1, 1)).toBe(2);
+  expect(add_int16_t(1, 1)).toBe(2);
+  expect(add_int32_t(1, 1)).toBe(2);
+  //   expect(add_int64_t(1, 1)).toBe(2);
+  expect(add_uint8_t(1, 1)).toBe(2);
+  expect(add_uint16_t(1, 1)).toBe(2);
+  expect(add_uint32_t(1, 1)).toBe(2);
+  //   expect(add_uint64_t(1, 1)).toBe(2);
   close();
 });
 ``;