diff --git a/lib/c-api/src/wasm_c_api/module.rs b/lib/c-api/src/wasm_c_api/module.rs
index dca2d6e3f..4f060f1dd 100644
--- a/lib/c-api/src/wasm_c_api/module.rs
+++ b/lib/c-api/src/wasm_c_api/module.rs
@@ -115,3 +115,164 @@ pub unsafe extern "C" fn wasm_module_serialize(
     };
     *out_ptr = byte_vec.into();
 }
+
+#[cfg(test)]
+mod tests {
+    use inline_c::assert_c;
+
+    #[test]
+    fn test_module_validate() {
+        (assert_c! {
+            #include <assert.h>
+            #include "wasmer_wasm.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasm_byte_vec_new_from_string(&wat, "(module)");
+                wasm_byte_vec_t* wasm = wat2wasm(&wat);
+
+                assert(wasm_module_validate(store, wasm));
+
+                wasm_byte_vec_delete(wasm);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[test]
+    fn test_module_new() {
+        (assert_c! {
+            #include <assert.h>
+            #include "wasmer_wasm.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasm_byte_vec_new_from_string(&wat, "(module)");
+                wasm_byte_vec_t* wasm = wat2wasm(&wat);
+
+                wasm_module_t* module = wasm_module_new(store, wasm);
+
+                assert(module);
+
+                wasm_byte_vec_delete(wasm);
+                wasm_module_delete(module);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+            }
+        })
+        .success();
+    }
+
+    #[test]
+    fn test_module_exports() {
+        (assert_c! {
+            #include <string.h>
+            #include <assert.h>
+            #include "wasmer_wasm.h"
+
+            void assert_exporttype_name(const wasm_exporttype_t* exporttype, const char* expected) {
+                assert(strncmp(wasm_exporttype_name(exporttype)->data, expected, strlen(expected)) == 0);
+            }
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasm_byte_vec_new_from_string(
+                    &wat,
+                    "(module\n"
+                    "  (func (export \"function\") (param i32 i64))\n"
+                    "  (global (export \"global\") i32 (i32.const 7))\n"
+                    "  (table (export \"table\") 0 funcref)\n"
+                    "  (memory (export \"memory\") 1))"
+                );
+                wasm_byte_vec_t* wasm = wat2wasm(&wat);
+
+                wasm_module_t* module = wasm_module_new(store, wasm);
+
+                assert(module);
+
+                wasm_exporttype_vec_t export_types;
+                wasm_module_exports(module, &export_types);
+
+                assert(export_types.size == 4);
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[0];
+                    assert_exporttype_name(export_type, "function");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_FUNC);
+
+                    wasm_functype_t* func_type = wasm_externtype_as_functype(extern_type);
+
+                    const wasm_valtype_vec_t* func_params = wasm_functype_params(func_type);
+                    assert(func_params->size == 2);
+                    assert(wasm_valtype_kind(func_params->data[0]) == WASM_I32);
+                    assert(wasm_valtype_kind(func_params->data[1]) == WASM_I64);
+
+                    const wasm_valtype_vec_t* func_results = wasm_functype_results(func_type);
+                    assert(func_results->size == 0);
+                }
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[1];
+                    assert_exporttype_name(export_type, "global");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_GLOBAL);
+
+                    wasm_globaltype_t* global_type = wasm_externtype_as_globaltype(extern_type);
+                    assert(wasm_valtype_kind(wasm_globaltype_content(global_type)) == WASM_I32);
+                    assert(wasm_globaltype_mutability(global_type) == WASM_CONST);
+                }
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[2];
+                    assert_exporttype_name(export_type, "table");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_TABLE);
+
+                    wasm_tabletype_t* table_type = wasm_externtype_as_tabletype(extern_type);
+                    assert(wasm_valtype_kind(wasm_tabletype_element(table_type)) == WASM_FUNCREF);
+
+                    const wasm_limits_t* table_limits = wasm_tabletype_limits(table_type);
+                    assert(table_limits->min == 0);
+                    assert(table_limits->max == wasm_limits_max_default);
+                }
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[3];
+                    assert_exporttype_name(export_type, "memory");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_MEMORY);
+
+                    wasm_memorytype_t* memory_type = wasm_externtype_as_memorytype(extern_type);
+                    const wasm_limits_t* memory_limits = wasm_memorytype_limits(memory_type);
+                    assert(memory_limits->min == 1);
+                    assert(memory_limits->max == wasm_limits_max_default);
+                }
+
+                wasm_exporttype_vec_delete(&export_types);
+                wasm_byte_vec_delete(wasm);
+                wasm_module_delete(module);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+            }
+        })
+        .success();
+    }
+}