Script stuff
This commit is contained in:
@@ -14,5 +14,6 @@ add_subdirectory(entity)
|
||||
add_subdirectory(physics)
|
||||
add_subdirectory(scene)
|
||||
# add_subdirectory(item)
|
||||
add_subdirectory(script)
|
||||
add_subdirectory(time)
|
||||
add_subdirectory(util)
|
||||
@@ -0,0 +1,13 @@
|
||||
# Copyright (c) 2026 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
include(dusktest)
|
||||
|
||||
dusktest(test_modulerequire.c)
|
||||
|
||||
dusktest(test_overworldscene.c)
|
||||
target_compile_definitions(test_overworldscene PRIVATE
|
||||
DUSK_ASSETS_DIR="${DUSK_ASSETS_DIR}"
|
||||
)
|
||||
@@ -0,0 +1,228 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "dusktest.h"
|
||||
#include "asset/asset.h"
|
||||
#include "script/scriptmanager.h"
|
||||
#include "script/module/modulebase.h"
|
||||
#include "util/memory.h"
|
||||
#include <zip.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
// ============================================================
|
||||
// In-memory ZIP fixture + script manager lifecycle
|
||||
// ============================================================
|
||||
|
||||
static zip_t *g_zip = NULL;
|
||||
|
||||
static int require_setup(void **state) {
|
||||
zip_error_t err;
|
||||
zip_error_init(&err);
|
||||
|
||||
zip_source_t *write_src = zip_source_buffer_create(NULL, 0, 1, &err);
|
||||
if(!write_src) return -1;
|
||||
|
||||
zip_t *za = zip_open_from_source(write_src, ZIP_TRUNCATE, &err);
|
||||
if(!za) { zip_source_free(write_src); return -1; }
|
||||
|
||||
#define ADD_FILE(name, content) do { \
|
||||
zip_source_t *s = zip_source_buffer(za, content, strlen(content), 0); \
|
||||
if(zip_file_add(za, name, s, ZIP_FL_OVERWRITE) < 0) { \
|
||||
zip_close(za); return -1; \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
ADD_FILE(
|
||||
"lib.js",
|
||||
"module.exports = { test: function() { return 'hello world'; } };"
|
||||
);
|
||||
ADD_FILE(
|
||||
"counted.js",
|
||||
"GLOBAL_COUNTER = "
|
||||
"(typeof GLOBAL_COUNTER === 'undefined' ? 0 : GLOBAL_COUNTER) + 1;\n"
|
||||
"module.exports = { count: GLOBAL_COUNTER };"
|
||||
);
|
||||
ADD_FILE(
|
||||
"dir/parent.js",
|
||||
"var child = require('./child.js');\n"
|
||||
"module.exports = { childValue: child.value };"
|
||||
);
|
||||
ADD_FILE("dir/child.js", "module.exports = { value: 42 };");
|
||||
ADD_FILE(
|
||||
"circular-a.js",
|
||||
"var b = require('./circular-b.js');\n"
|
||||
"module.exports = "
|
||||
"{ name: 'a', bName: b.name, bSawUndefinedA: b.aWasUndefined };"
|
||||
);
|
||||
ADD_FILE(
|
||||
"circular-b.js",
|
||||
"var a = require('./circular-a.js');\n"
|
||||
"module.exports = "
|
||||
"{ name: 'b', aWasUndefined: (typeof a === 'undefined') };"
|
||||
);
|
||||
|
||||
#undef ADD_FILE
|
||||
|
||||
zip_source_keep(write_src);
|
||||
if(zip_close(za) != 0) { zip_source_free(write_src); return -1; }
|
||||
|
||||
zip_stat_t zs;
|
||||
memset(&zs, 0, sizeof(zs));
|
||||
if(zip_source_stat(write_src, &zs) != 0 || !(zs.valid & ZIP_STAT_SIZE)) {
|
||||
zip_source_free(write_src); return -1;
|
||||
}
|
||||
|
||||
void *zipbuf = malloc((size_t)zs.size);
|
||||
if(!zipbuf) { zip_source_free(write_src); return -1; }
|
||||
|
||||
if(zip_source_open(write_src) != 0) {
|
||||
free(zipbuf); zip_source_free(write_src); return -1;
|
||||
}
|
||||
zip_source_read(write_src, zipbuf, (zip_uint64_t)zs.size);
|
||||
zip_source_close(write_src);
|
||||
zip_source_free(write_src);
|
||||
|
||||
zip_error_init(&err);
|
||||
zip_source_t *read_src = zip_source_buffer_create(
|
||||
zipbuf, (zip_uint64_t)zs.size, 1, &err
|
||||
);
|
||||
if(!read_src) { free(zipbuf); return -1; }
|
||||
|
||||
g_zip = zip_open_from_source(read_src, 0, &err);
|
||||
if(!g_zip) { zip_source_free(read_src); return -1; }
|
||||
|
||||
ASSET.zip = g_zip;
|
||||
|
||||
errorret_t ret = scriptManagerInit();
|
||||
if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int require_teardown(void **state) {
|
||||
errorret_t ret = scriptManagerDispose();
|
||||
if(errorIsNotOk(ret)) errorCatch(ret);
|
||||
|
||||
if(g_zip) { zip_close(g_zip); g_zip = NULL; }
|
||||
ASSET.zip = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Tests
|
||||
// ============================================================
|
||||
|
||||
static void test_require_basic(void **state) {
|
||||
jerry_value_t result;
|
||||
errorret_t ret = scriptManagerExec(
|
||||
"var something = require('./lib.js'); something.test();", &result
|
||||
);
|
||||
assert_true(errorIsOk(ret));
|
||||
assert_true(jerry_value_is_string(result));
|
||||
|
||||
char_t buf[64];
|
||||
moduleBaseToString(result, buf, sizeof(buf));
|
||||
assert_string_equal(buf, "hello world");
|
||||
|
||||
jerry_value_free(result);
|
||||
assert_int_equal(memoryGetAllocatedCount(), 0);
|
||||
}
|
||||
|
||||
static void test_require_caches_and_executes_once(void **state) {
|
||||
jerry_value_t result;
|
||||
errorret_t ret = scriptManagerExec(
|
||||
"require('./counted.js'); require('./counted.js');"
|
||||
"require('./counted.js').count;",
|
||||
&result
|
||||
);
|
||||
assert_true(errorIsOk(ret));
|
||||
assert_true(jerry_value_is_number(result));
|
||||
assert_int_equal(moduleBaseValueInt(result), 1);
|
||||
|
||||
jerry_value_free(result);
|
||||
assert_int_equal(memoryGetAllocatedCount(), 0);
|
||||
}
|
||||
|
||||
static void test_require_relative_path_resolves_to_requiring_files_dir(
|
||||
void **state
|
||||
) {
|
||||
jerry_value_t result;
|
||||
errorret_t ret = scriptManagerExec(
|
||||
"require('dir/parent.js').childValue;", &result
|
||||
);
|
||||
assert_true(errorIsOk(ret));
|
||||
assert_true(jerry_value_is_number(result));
|
||||
assert_int_equal(moduleBaseValueInt(result), 42);
|
||||
|
||||
jerry_value_free(result);
|
||||
assert_int_equal(memoryGetAllocatedCount(), 0);
|
||||
}
|
||||
|
||||
static void test_require_circular_does_not_hang(void **state) {
|
||||
jerry_value_t result;
|
||||
errorret_t ret = scriptManagerExec("require('./circular-a.js');", &result);
|
||||
assert_true(errorIsOk(ret));
|
||||
assert_true(jerry_value_is_object(result));
|
||||
|
||||
jerry_value_t nameVal = moduleBaseGetProp(result, "name");
|
||||
char_t nameBuf[16];
|
||||
moduleBaseToString(nameVal, nameBuf, sizeof(nameBuf));
|
||||
assert_string_equal(nameBuf, "a");
|
||||
jerry_value_free(nameVal);
|
||||
|
||||
jerry_value_t bNameVal = moduleBaseGetProp(result, "bName");
|
||||
char_t bNameBuf[16];
|
||||
moduleBaseToString(bNameVal, bNameBuf, sizeof(bNameBuf));
|
||||
assert_string_equal(bNameBuf, "b");
|
||||
jerry_value_free(bNameVal);
|
||||
|
||||
// circular-b.js's require('./circular-a.js') ran while circular-a.js was
|
||||
// still mid-execution (before it set module.exports), so it must have
|
||||
// seen the in-progress module's exports as still undefined.
|
||||
jerry_value_t sawVal = moduleBaseGetProp(result, "bSawUndefinedA");
|
||||
assert_true(jerry_value_is_true(sawVal));
|
||||
jerry_value_free(sawVal);
|
||||
|
||||
jerry_value_free(result);
|
||||
assert_int_equal(memoryGetAllocatedCount(), 0);
|
||||
}
|
||||
|
||||
static void test_require_missing_file_throws(void **state) {
|
||||
errorret_t ret = scriptManagerExec("require('./does-not-exist.js');", NULL);
|
||||
assert_true(errorIsNotOk(ret));
|
||||
errorCatch(ret);
|
||||
|
||||
assert_int_equal(memoryGetAllocatedCount(), 0);
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// main
|
||||
// ============================================================
|
||||
|
||||
int main(void) {
|
||||
assertInit();
|
||||
const struct CMUnitTest tests[] = {
|
||||
cmocka_unit_test_setup_teardown(
|
||||
test_require_basic, require_setup, require_teardown
|
||||
),
|
||||
cmocka_unit_test_setup_teardown(
|
||||
test_require_caches_and_executes_once, require_setup, require_teardown
|
||||
),
|
||||
cmocka_unit_test_setup_teardown(
|
||||
test_require_relative_path_resolves_to_requiring_files_dir,
|
||||
require_setup, require_teardown
|
||||
),
|
||||
cmocka_unit_test_setup_teardown(
|
||||
test_require_circular_does_not_hang, require_setup, require_teardown
|
||||
),
|
||||
cmocka_unit_test_setup_teardown(
|
||||
test_require_missing_file_throws, require_setup, require_teardown
|
||||
),
|
||||
};
|
||||
return cmocka_run_group_tests(tests, NULL, NULL);
|
||||
}
|
||||
@@ -0,0 +1,243 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "dusktest.h"
|
||||
#include "util/memory.h"
|
||||
#include "time/time.h"
|
||||
#include "scene/scene.h"
|
||||
#include "entity/entitymanager.h"
|
||||
#include "entity/component.h"
|
||||
#include "entity/component/display/entityposition.h"
|
||||
#include "entity/component/physics/entityphysics.h"
|
||||
#include "entity/component/display/entityrenderable.h"
|
||||
#include "display/mesh/plane.h"
|
||||
#include "display/mesh/capsule.h"
|
||||
#include "script/scriptmanager.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifndef DUSK_ASSETS_DIR
|
||||
#error "DUSK_ASSETS_DIR must be defined"
|
||||
#endif
|
||||
|
||||
// Reads the real, shipped overworldscene.js from disk (not a copy embedded
|
||||
// in this test) so this test actually verifies what ships.
|
||||
static char_t *readScriptSource(void) {
|
||||
char_t path[512];
|
||||
snprintf(
|
||||
path, sizeof(path), "%s/scripts/overworldscene.js", DUSK_ASSETS_DIR
|
||||
);
|
||||
|
||||
FILE *f = fopen(path, "rb");
|
||||
assert_non_null(f);
|
||||
|
||||
fseek(f, 0, SEEK_END);
|
||||
long size = ftell(f);
|
||||
fseek(f, 0, SEEK_SET);
|
||||
|
||||
char_t *buf = (char_t *)memoryAllocate((size_t)size + 1);
|
||||
size_t read = fread(buf, 1, (size_t)size, f);
|
||||
fclose(f);
|
||||
buf[read] = '\0';
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
static int overworld_setup(void **state) {
|
||||
sceneInit();
|
||||
|
||||
errorret_t ret = scriptManagerInit();
|
||||
if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int overworld_teardown(void **state) {
|
||||
errorret_t ret = scriptManagerDispose();
|
||||
if(errorIsNotOk(ret)) errorCatch(ret);
|
||||
|
||||
sceneDispose();
|
||||
|
||||
// JerryScript defers freeing native-wrapped handles (Entity/Scene/
|
||||
// Position/Physics/Renderable instances) until GC/jerry_cleanup() runs,
|
||||
// so the leak check can only be meaningful after scriptManagerDispose()
|
||||
// has actually run above -- not inside the test body.
|
||||
assert_int_equal(memoryGetAllocatedCount(), 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_overworldscene_builds_expected_entities(void **state) {
|
||||
char_t *src = readScriptSource();
|
||||
errorret_t ret = scriptManagerExec(src, NULL);
|
||||
memoryFree(src);
|
||||
assert_true(errorIsOk(ret));
|
||||
|
||||
sceneid_t sceneId = sceneGetActive();
|
||||
assert_true(sceneId != SCENE_ID_INVALID);
|
||||
entitymanager_t *mgr = sceneGetEntities(sceneId);
|
||||
|
||||
// Entity 0: camera. Position + Camera components, initial orbit
|
||||
// position placed with angle=0 (Time.delta defaults to 0 with no
|
||||
// timeInit()/timeUpdate() in this test), i.e. eye=(radius, height, 0).
|
||||
entityid_t camEntity = 0;
|
||||
componentid_t camPos = entityGetComponent(
|
||||
mgr, camEntity, COMPONENT_TYPE_POSITION
|
||||
);
|
||||
assert_true(camPos != COMPONENT_ID_INVALID);
|
||||
assert_true(
|
||||
entityGetComponent(mgr, camEntity, COMPONENT_TYPE_CAMERA) !=
|
||||
COMPONENT_ID_INVALID
|
||||
);
|
||||
|
||||
vec3 camPosition;
|
||||
entityPositionGetLocalPosition(mgr, camEntity, camPos, camPosition);
|
||||
assert_float_equal(camPosition[0], 18.0f, 0.0001f);
|
||||
assert_float_equal(camPosition[1], 10.0f, 0.0001f);
|
||||
assert_float_equal(camPosition[2], 0.0f, 0.0001f);
|
||||
|
||||
// Entity 1: static ground plane.
|
||||
entityid_t planeEntity = 1;
|
||||
componentid_t planePos = entityGetComponent(
|
||||
mgr, planeEntity, COMPONENT_TYPE_POSITION
|
||||
);
|
||||
assert_true(planePos != COMPONENT_ID_INVALID);
|
||||
|
||||
vec3 planePosition, planeScale;
|
||||
entityPositionGetLocalPosition(mgr, planeEntity, planePos, planePosition);
|
||||
entityPositionGetLocalScale(mgr, planeEntity, planePos, planeScale);
|
||||
assert_float_equal(planePosition[0], -10.0f, 0.0001f);
|
||||
assert_float_equal(planePosition[1], 0.0f, 0.0001f);
|
||||
assert_float_equal(planePosition[2], -10.0f, 0.0001f);
|
||||
assert_float_equal(planeScale[0], 20.0f, 0.0001f);
|
||||
assert_float_equal(planeScale[1], 1.0f, 0.0001f);
|
||||
assert_float_equal(planeScale[2], 20.0f, 0.0001f);
|
||||
|
||||
componentid_t planePhysics = entityGetComponent(
|
||||
mgr, planeEntity, COMPONENT_TYPE_PHYSICS
|
||||
);
|
||||
assert_true(planePhysics != COMPONENT_ID_INVALID);
|
||||
assert_int_equal(
|
||||
entityPhysicsGetBodyType(mgr, planeEntity, planePhysics),
|
||||
PHYSICS_BODY_STATIC
|
||||
);
|
||||
physicsshape_t planeShape = entityPhysicsGetShape(
|
||||
mgr, planeEntity, planePhysics
|
||||
);
|
||||
assert_int_equal(planeShape.type, PHYSICS_SHAPE_PLANE);
|
||||
assert_float_equal(planeShape.data.plane.normal[0], 0.0f, 0.0001f);
|
||||
assert_float_equal(planeShape.data.plane.normal[1], 1.0f, 0.0001f);
|
||||
assert_float_equal(planeShape.data.plane.normal[2], 0.0f, 0.0001f);
|
||||
assert_float_equal(planeShape.data.plane.distance, 0.0f, 0.0001f);
|
||||
|
||||
componentid_t planeRenderable = entityGetComponent(
|
||||
mgr, planeEntity, COMPONENT_TYPE_RENDERABLE
|
||||
);
|
||||
assert_true(planeRenderable != COMPONENT_ID_INVALID);
|
||||
entityrenderable_t *planeR = componentGetData(
|
||||
mgr, planeEntity, planeRenderable, COMPONENT_TYPE_RENDERABLE
|
||||
);
|
||||
assert_ptr_equal(planeR->data.material.meshes[0], &PLANE_MESH_SIMPLE);
|
||||
assert_int_equal(planeR->data.material.material.unlit.color.r, 128);
|
||||
assert_int_equal(planeR->data.material.material.unlit.color.g, 128);
|
||||
assert_int_equal(planeR->data.material.material.unlit.color.b, 128);
|
||||
assert_int_equal(planeR->data.material.material.unlit.color.a, 255);
|
||||
|
||||
// Entity 2: player. Dynamic capsule body (default body type), PLAYER
|
||||
// component present.
|
||||
entityid_t playerEntity = 2;
|
||||
componentid_t playerPos = entityGetComponent(
|
||||
mgr, playerEntity, COMPONENT_TYPE_POSITION
|
||||
);
|
||||
assert_true(playerPos != COMPONENT_ID_INVALID);
|
||||
|
||||
vec3 playerPosition;
|
||||
entityPositionGetLocalPosition(mgr, playerEntity, playerPos, playerPosition);
|
||||
assert_float_equal(playerPosition[0], 0.0f, 0.0001f);
|
||||
assert_float_equal(playerPosition[1], 2.0f, 0.0001f);
|
||||
assert_float_equal(playerPosition[2], 0.0f, 0.0001f);
|
||||
|
||||
componentid_t playerPhysics = entityGetComponent(
|
||||
mgr, playerEntity, COMPONENT_TYPE_PHYSICS
|
||||
);
|
||||
assert_true(playerPhysics != COMPONENT_ID_INVALID);
|
||||
assert_int_equal(
|
||||
entityPhysicsGetBodyType(mgr, playerEntity, playerPhysics),
|
||||
PHYSICS_BODY_DYNAMIC
|
||||
);
|
||||
physicsshape_t playerShape = entityPhysicsGetShape(
|
||||
mgr, playerEntity, playerPhysics
|
||||
);
|
||||
assert_int_equal(playerShape.type, PHYSICS_SHAPE_CAPSULE);
|
||||
assert_float_equal(playerShape.data.capsule.radius, 0.5f, 0.0001f);
|
||||
assert_float_equal(playerShape.data.capsule.halfHeight, 0.5f, 0.0001f);
|
||||
|
||||
componentid_t playerRenderable = entityGetComponent(
|
||||
mgr, playerEntity, COMPONENT_TYPE_RENDERABLE
|
||||
);
|
||||
assert_true(playerRenderable != COMPONENT_ID_INVALID);
|
||||
entityrenderable_t *playerR = componentGetData(
|
||||
mgr, playerEntity, playerRenderable, COMPONENT_TYPE_RENDERABLE
|
||||
);
|
||||
assert_ptr_equal(playerR->data.material.meshes[0], &CAPSULE_MESH_SIMPLE);
|
||||
assert_int_equal(playerR->data.material.material.unlit.color.r, 0);
|
||||
assert_int_equal(playerR->data.material.material.unlit.color.g, 0);
|
||||
assert_int_equal(playerR->data.material.material.unlit.color.b, 255);
|
||||
assert_int_equal(playerR->data.material.material.unlit.color.a, 255);
|
||||
|
||||
assert_true(
|
||||
entityGetComponent(mgr, playerEntity, COMPONENT_TYPE_PLAYER) !=
|
||||
COMPONENT_ID_INVALID
|
||||
);
|
||||
}
|
||||
|
||||
static void test_overworldscene_update_orbits_camera(void **state) {
|
||||
char_t *src = readScriptSource();
|
||||
errorret_t ret = scriptManagerExec(src, NULL);
|
||||
memoryFree(src);
|
||||
assert_true(errorIsOk(ret));
|
||||
|
||||
sceneid_t sceneId = sceneGetActive();
|
||||
entitymanager_t *mgr = sceneGetEntities(sceneId);
|
||||
entityid_t camEntity = 0;
|
||||
componentid_t camPos = entityGetComponent(
|
||||
mgr, camEntity, COMPONENT_TYPE_POSITION
|
||||
);
|
||||
|
||||
// Drive one frame with a known delta and confirm the camera orbited by
|
||||
// exactly angle = delta * speed (0.1 * 0.5 = 0.05 rad).
|
||||
TIME.delta = 0.1f;
|
||||
ret = scriptManagerCallGlobal("update");
|
||||
assert_true(errorIsOk(ret));
|
||||
|
||||
vec3 camPosition;
|
||||
entityPositionGetLocalPosition(mgr, camEntity, camPos, camPosition);
|
||||
const float_t expectedAngle = 0.1f * 0.5f;
|
||||
assert_float_equal(
|
||||
camPosition[0], cosf(expectedAngle) * 18.0f, 0.0001f
|
||||
);
|
||||
assert_float_equal(camPosition[1], 10.0f, 0.0001f);
|
||||
assert_float_equal(
|
||||
camPosition[2], sinf(expectedAngle) * 18.0f, 0.0001f
|
||||
);
|
||||
|
||||
TIME.delta = 0.0f;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
assertInit();
|
||||
const struct CMUnitTest tests[] = {
|
||||
cmocka_unit_test_setup_teardown(
|
||||
test_overworldscene_builds_expected_entities,
|
||||
overworld_setup, overworld_teardown
|
||||
),
|
||||
cmocka_unit_test_setup_teardown(
|
||||
test_overworldscene_update_orbits_camera,
|
||||
overworld_setup, overworld_teardown
|
||||
),
|
||||
};
|
||||
return cmocka_run_group_tests(tests, NULL, NULL);
|
||||
}
|
||||
Reference in New Issue
Block a user