AI_Slop/DVX_GUI
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
DVX_GUI/src/test/basdev/testBasDev.c
Scott Duensing f20cec7333 Pathname and drive letter enhancements.
2026-10-13 13:49:12 -05:00

1378 lines
56 KiB
C
Raw Blame History

// The MIT License (MIT)
//
// Copyright (C) 2026 Scott Duensing
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// testBasDev.c -- the basdev library suite
//
// caseBasicIde runs the DOS fixture PARIDE (src/test/dos/fixtures/paride)
// on the host: a BASIC program that compiles, debugs and builds the
// project in its kid folder through compiler.bas and debug.bas, with its
// DECLARE LIBRARY calls made for real. The other cases drive the shared
// C pieces directly: the build pipeline's compile and source map, the run
// host, the debugger's view of a paused program and the entry points of
// compiler.bas.
#include "dvxtest.h"
#include "../../apps/kpunch/dvxbasic/basBuild.h"
#include "../../apps/kpunch/dvxbasic/basdev/basDebug.h"
#include "../../apps/kpunch/dvxbasic/basdev/basProject.h"
#include "../../apps/kpunch/dvxbasic/basdev/basValidate.h"
#include "../../apps/kpunch/dvxbasic/compiler/lexer.h"
#include "../../apps/kpunch/dvxbasic/formrt/basRunHost.h"
#include "../../apps/kpunch/dvxbasic/formrt/formrt.h"
#include "dvxPlat.h"
#include "dvxRes.h"
#include "dvxTypes.h"
#include "pmModel.h"
#include "../../libs/kpunch/audio/audioDrv.h"
#include "../../libs/kpunch/joystick/joystick.h"
#include "../../libs/kpunch/fileops/fileOps.h"
#include "taskSwch.h"
#include "dvxWm.h"
#include "thirdparty/stb_ds_wrap.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/stat.h>
#define SCREEN_W 800
#define SCREEN_H 600
#define SCREEN_BPP 32
#define BDT_TEXT_MAX 4096 // captured PRINT text / collected rows
#define BDT_TICK_MS 60 // the fake clock per Timer round
#define BDT_MAX_TICKS 200 // rounds before the fixture counts as hung
#define BDT_BP_FILE_LINE 38 // "total = total + i" in kid/kid.bas
#define BDT_PASS_TITLE "PARIDE PASS 109 built"
#define BDT_PARENT_FORM "ParIde"
#define BDT_KID_FORM "KidForm"
#define BDT_KID_TITLE "Kid"
#define BDT_PREFIX "PARIDE "
#define BDT_RENAME_REFS 70000 // references to rename ...
#define BDT_RENAME_NEWLEN 31000 // ... to a name this long: a result past INT32_MAX bytes
#define BDT_RENAME_REF "a.x\n" // one reference
#define BAS_TRUE (-1)
#define KIND_PROGRAM 0 // compiler.bas COMP_KIND_PROGRAM
#define KIND_MODULE 1 // compiler.bas COMP_KIND_MODULE
#define KIND_FORM 2 // compiler.bas COMP_KIND_FORM
#define KIND_CONTROL 4 // compiler.bas COMP_KIND_CONTROL
#define BDT_CTL_KEYS 8 // UserControl header keys (Name, Width ... DefaultEvent)
#define BDT_RUN_ENDED 4 // debug.bas RUN_ENDED
#define BDT_RUN_ERROR 5 // debug.bas RUN_ERROR
#define BDT_DIAL_ICON "BM a dial"
#define KW_CLASS_TYPE 1 // compiler.bas COMP_KW_TYPE
#define KW_CLASS_LITERAL 2 // compiler.bas COMP_KW_LITERAL
#define NO_INDEX (-1)
#define CONST_MISSING (-999999) // includeConst: no such CONST
#define DECIMAL 10
#define HEXADECIMAL 16
#define PERCENT 100 // sound.bas pitches are percent
#define BDT_KW_CONST "CONST "
// A CONST of an include file and the C value it must equal
typedef struct {
const char *file;
const char *name;
int32_t value;
} BdtConstT;
// The compiler.bas / debug.bas entry points the C cases call directly
int32_t CompBuildApp(int32_t mdl, int32_t src, const char *outPath, int32_t release);
const char *CompClassEvents(const char *classText);
int32_t CompCompile(int32_t src, int32_t optionExplicit, int32_t validate);
int32_t CompDesignControls(int32_t mdl, int32_t src, const char *appDir);
int32_t CompDesignRelease(void);
const char *CompError(void);
const char *CompErrorFile(void);
int32_t CompErrorFileLine(void);
const char *CompHelpCtrlTopic(const char *typeName);
const char *CompHelpTopic(const char *word);
int32_t CompInCode(const char *source, int32_t position);
int32_t CompIsIdent(const char *ident);
const char *CompKeyword(int32_t idx);
int32_t CompKeywordClass(int32_t idx);
int32_t CompKeywordCount(void);
int32_t CompKeywordReserved(int32_t idx);
void CompModuleFree(int32_t mdl);
const char *CompProcList(const char *source);
const char *CompProcs(int32_t mdl);
const char *CompRenameInCode(const char *source, const char *oldName, const char *newName, int32_t codeOnly);
int32_t CompSourceAdd(int32_t src, const char *path, const char *text, int32_t kind);
int32_t CompSourceCreate(void);
const char *CompSourceFiles(int32_t src);
void CompSourceFree(int32_t src);
int32_t CompSourceFromProject(int32_t src, const char *dbpPath);
const char *CompTokens(const char *source);
const char *CompWithEvents(const char *source);
const char *DbgExec(int32_t run, const char *line);
int32_t ProjAddFile(int32_t prj, const char *fileName);
void ProjClose(int32_t prj);
const char *ProjCtlHeader(const char *text, const char *key);
const char *ProjCtlKeys(void);
const char *ProjCtlNew(const char *name);
const char *ProjCtlSetHeader(const char *text, const char *key, const char *value);
const char *ProjFile(int32_t prj, int32_t idx);
int32_t ProjFileCount(int32_t prj);
int32_t ProjFileFind(int32_t prj, const char *fileName);
int32_t ProjFileKind(int32_t prj, int32_t idx);
const char *ProjFilePath(int32_t prj, int32_t idx);
const char *ProjGet(int32_t prj, const char *key);
int32_t ProjNew(const char *name, const char *folder);
int32_t ProjOpen(const char *dbpPath);
const char *ProjPath(int32_t prj);
int32_t ProjRemoveFile(int32_t prj, int32_t idx);
int32_t ProjRenameFile(int32_t prj, int32_t idx, const char *newName);
int32_t ProjSave(int32_t prj);
int32_t ProjSet(int32_t prj, const char *key, const char *value);
int32_t RunCreate(int32_t mdl, int32_t src, const char *appDir, const char *args);
void RunFree(int32_t run);
const char *RunOutput(int32_t run);
int32_t RunPoll(int32_t run, int32_t ms);
int32_t RunStart(int32_t run, const char *startupForm, int32_t breakOnStart);
// Text gathered from print callbacks and row callbacks
typedef struct {
char text[BDT_TEXT_MAX];
int32_t len;
} BdtTextT;
// The UserControl of caseDesignControls (a source set's and a project's):
// its header (a built control file's CTL0), then its code
#define BDT_DIAL_HEADER \
"VERSION DVX 1.00\n" \
"Begin UserControl Dial\n" \
" ToolboxIcon = \"dial.bmp\"\n" \
"End\n"
static const char sDialCtl[] =
BDT_DIAL_HEADER
"Private Sub UserControl_Paint()\n"
"End Sub\n";
// The child program of designProject: compiler.bas (the first %s), then
// its own design controls from the project (the second), its module freed
// while they are in use; then it ends.
#define BDT_DESIGN_CHILD_FMT \
"%s\n" \
"Dim s As Long\n" \
"Dim m As Long\n" \
"s = CompSourceCreate()\n" \
"If CompSourceFromProject(s, \"%s\") Then m = CompCompile(s, 0, 0)\n" \
"Print m\n" \
"Print CompDesignControls(m, s, \"\")\n" \
"CompSourceFree s\n" \
"CompModuleFree m\n"
// Prototypes (alphabetical; main last)
static void caseBasicIde(void);
static void caseCDebugger(void);
static void caseCompileApi(void);
static void caseDesignControls(void);
static void caseIncludeConsts(void);
static void caseProjectApi(void);
static void caseProjectControls(void);
static void caseSourceApi(void);
static bool copyKid(const char *kidDir);
static void designProject(const BasFormRtT *rt);
static BasFormT *formOf(const BasFormRtT *rt, const char *formName);
static const char *formTitle(const BasFormRtT *rt, const char *formName);
static int32_t includeConst(const char *text, const char *name);
static bool includeConstIs(const char *text, const char *name, const char *value);
static const char *includeConstValue(const char *text, const char *name);
static int32_t keywordIndex(const char *word);
static BasModuleT *loadProject(const char *dbpPath, BasProjectSourceT *ps, BasValidatorT *validator);
static bool resHas(DvxResHandleT *res, const char *name, const char *want);
static void textPrint(void *ctx, const char *text, bool newline);
static void textRow(void *ctx, const char *const *cells, int32_t cellCount);
int main(void);
// The DOS fixture on the host: the parent runs as a compiled program would
// (its forms loaded, then its Timer events), its library calls are real.
static void caseBasicIde(void) {
tCase("a BASIC program compiles, debugs and builds another (compiler.bas, debug.bas)");
tInit(SCREEN_W, SCREEN_H, SCREEN_BPP);
char kidDir[DVX_MAX_PATH];
char carrierDir[DVX_MAX_PATH];
char kidApp[DVX_MAX_PATH];
// The kid project where runDos stages it (TEST\PARIDE\KID beside the
// app), and the STUB carrier CompBuildApp reads (bascomp has one)
snprintf(kidDir, sizeof(kidDir), "%s/paride/kid", tTempDir());
snprintf(kidApp, sizeof(kidApp), "%s/kid.app", tTempDir());
platformPathDirName(BAS_BUILD_STUB_CARRIER, carrierDir, sizeof(carrierDir));
platformMkdirRecursive(carrierDir);
remove(kidApp);
TEST_TRUE(copyKid(kidDir));
TEST_TRUE(platformCopyFile(BDT_BASCOMP, BAS_BUILD_STUB_CARRIER));
BasProjectSourceT ps;
BasModuleT *mod = loadProject(BDT_FIXTURE_DIR "/paride.dbp", &ps, NULL);
TEST_TRUE(mod != NULL);
if (!mod) {
basBuildFreeProject(&ps);
tShutdown();
return;
}
const char *hostError = NULL;
BasRunSpecT spec;
memset(&spec, 0, sizeof(spec));
spec.appDir = tTempDir();
spec.title = BDT_PREFIX;
spec.suppressErrorDialog = true;
BasFormRtT *rt = basRunHostCreate(tCtx(), mod, &spec, &hostError);
TEST_TRUE(rt != NULL);
if (rt) {
for (int32_t i = 0; i < (int32_t)arrlen(ps.frmTexts); i++) {
TEST_TRUE(basRunHostRegisterFrm(rt, ps.frmTexts[i], (int32_t)strlen(ps.frmTexts[i])));
}
// ParIde_Load compiles the kid, makes the run and starts it
basNativeHostSetLive(true);
basRunHostLoadForms(rt, BDT_PARENT_FORM);
basVmSetStepLimit(rt->vm, BAS_VM_DEFAULT_STEP_SLICE);
while (basRunHostSlice(rt) == BAS_VM_STEP_LIMIT) {
}
// The Timer polls the kid through its stops to the end
for (int32_t i = 0; i < BDT_MAX_TICKS && strncmp(formTitle(rt, BDT_PARENT_FORM), BDT_PREFIX, strlen(BDT_PREFIX)) != 0; i++) {
tAdvanceClock(BDT_TICK_MS);
}
TEST_STR_EQ(formTitle(rt, BDT_PARENT_FORM), BDT_PASS_TITLE);
struct stat st;
TEST_TRUE(stat(kidApp, &st) == 0 && st.st_size > 0);
// Unloading frees the kid's run, module and source set
BasFormT *form = formOf(rt, BDT_PARENT_FORM);
if (form) {
basFormRtUnloadForm(rt, form);
}
basNativeHostSetLive(false);
basRunHostDestroy(rt);
}
basModuleFree(mod);
basBuildFreeProject(&ps);
tShutdown();
}
// The shared C pieces the IDE and the library use: a run with a
// breakpoint, the paused program's variables, evaluation, assignment,
// stepping and the [break] captions.
static void caseCDebugger(void) {
tCase("C: run host + debugger view of a paused program");
tInit(SCREEN_W, SCREEN_H, SCREEN_BPP);
BasProjectSourceT ps;
BasValidatorT validator;
BasModuleT *mod = loadProject(BDT_FIXTURE_DIR "/kid/kid.dbp", &ps, &validator);
TEST_TRUE(mod != NULL);
TEST_EQ(arrlen(validator.badTypes), 0);
TEST_TRUE(arrlen(validator.entries) > 0);
basValidateFree(&validator);
if (!mod) {
basBuildFreeProject(&ps);
tShutdown();
return;
}
// The breakpoint: kid.bas (the first file) line 38, both ways
int32_t bp = basBuildMapFileLine(ps.map, ps.map[0].path, BDT_BP_FILE_LINE);
const char *mapPath = NULL;
int32_t fileLine = 0;
TEST_TRUE(bp > 0);
TEST_TRUE(basBuildMapLine(ps.map, bp, &mapPath, &fileLine));
TEST_EQ(fileLine, BDT_BP_FILE_LINE);
BdtTextT out;
BdtTextT rows;
const char *hostError = NULL;
BasRunSpecT spec;
memset(&out, 0, sizeof(out));
memset(&spec, 0, sizeof(spec));
spec.appDir = tTempDir();
spec.printFn = textPrint;
spec.printCtx = &out;
spec.suppressErrorDialog = true;
BasFormRtT *rt = basRunHostCreate(tCtx(), mod, &spec, &hostError);
BasVmT *vm = rt ? rt->vm : NULL;
BasBreakTitleT *titles = NULL;
TEST_TRUE(rt != NULL);
if (!rt) {
basModuleFree(mod);
basBuildFreeProject(&ps);
tShutdown();
return;
}
for (int32_t i = 0; i < (int32_t)arrlen(ps.frmTexts); i++) {
basRunHostRegisterFrm(rt, ps.frmTexts[i], (int32_t)strlen(ps.frmTexts[i]));
}
basVmSetBreakpoints(vm, &bp, 1);
basRunHostLoadForms(rt, BDT_KID_FORM);
basVmSetStepLimit(vm, BAS_VM_DEFAULT_STEP_SLICE);
BasVmResultE result;
do {
result = basRunHostSlice(rt);
} while (result == BAS_VM_STEP_LIMIT);
TEST_EQ(result, BAS_VM_BREAKPOINT);
TEST_EQ(basVmGetCurrentLine(vm), bp);
TEST_STR_EQ(basDbgProcNameForPc(vm, vm->pc), "AddUp");
TEST_TRUE(basDbgCurProcIdx(vm) >= 0);
// Locals: the parameter, the local and the shared module variables
memset(&rows, 0, sizeof(rows));
TEST_TRUE(basDbgLocals(vm, textRow, &rows) >= 4);
TEST_TRUE(strstr(rows.text, "n|Long|4\n") != NULL);
TEST_TRUE(strstr(rows.text, "i|Long|1\n") != NULL);
TEST_TRUE(strstr(rows.text, "total|Long|0\n") != NULL);
TEST_TRUE(strstr(rows.text, "label|String|\"sum\"\n") != NULL);
// Call stack: AddUp at the line, then the module frame
char expect[BDT_TEXT_MAX];
memset(&rows, 0, sizeof(rows));
TEST_EQ(basDbgCallStack(vm, bp, textRow, &rows), 2);
snprintf(expect, sizeof(expect), "AddUp|%d\n" BAS_DBG_MODULE_FRAME "|\n", (int)bp);
TEST_STR_EQ(rows.text, expect);
// Watch: a variable path is read directly, an expression is evaluated
char value[BAS_DBG_VALUE_LEN];
TEST_TRUE(basDbgEval(vm, "n", value, sizeof(value)));
TEST_STR_EQ(value, "4");
TEST_TRUE(basDbgEval(vm, "total + n * 10", value, sizeof(value)));
TEST_EQ(atoi(value), 40);
TEST_TRUE(!basDbgEval(vm, "nosuch(", value, sizeof(value)));
TEST_TRUE(!basDbgEval(NULL, "n", value, sizeof(value)));
// [break] on the program's form captions while paused
basRunHostTagBreak(rt, &titles, true);
TEST_STR_EQ(formTitle(rt, BDT_KID_FORM), BDT_KID_TITLE BAS_RUN_BREAK_TAG);
basRunHostTagBreak(rt, &titles, false);
TEST_STR_EQ(formTitle(rt, BDT_KID_FORM), BDT_KID_TITLE);
arrfree(titles);
// Immediate: assignment, statement, expression, error; and SetVar
memset(&out, 0, sizeof(out));
TEST_TRUE(basDbgExec(vm, "total = 3", textPrint, &out));
TEST_STR_EQ(out.text, "total = 3\n");
memset(&out, 0, sizeof(out));
TEST_TRUE(!basDbgExec(vm, "PRINT total * 2", textPrint, &out));
TEST_EQ(atoi(out.text), 6);
memset(&out, 0, sizeof(out));
TEST_TRUE(!basDbgExec(NULL, "6 * 7", textPrint, &out));
TEST_EQ(atoi(out.text), 42);
memset(&out, 0, sizeof(out));
basDbgExec(vm, "label = ", textPrint, &out);
TEST_TRUE(strncmp(out.text, "Error: ", strlen("Error: ")) == 0);
memset(&out, 0, sizeof(out));
TEST_TRUE(basDbgSetVar(vm, "total", "total + 4", textPrint, &out));
TEST_STR_EQ(out.text, "total = 7\n");
memset(&out, 0, sizeof(out));
TEST_TRUE(!basDbgSetVar(vm, "nosuch", "1", textPrint, &out));
TEST_TRUE(!basDbgSetVar(vm, "label", "1 +", textPrint, &out));
// Step over: the breakpoint line ran once (7 + 1)
basVmStepOver(vm);
basVmResume(vm);
do {
result = basRunHostSlice(rt);
} while (result == BAS_VM_STEP_LIMIT);
TEST_EQ(result, BAS_VM_BREAKPOINT);
TEST_TRUE(basDbgEval(vm, "total", value, sizeof(value)));
TEST_STR_EQ(value, "8");
// Run free to the end: 8 + 2 + 3 + 4
basVmSetBreakpoints(vm, NULL, 0);
basVmClearStepState(vm);
basVmResume(vm);
memset(&out, 0, sizeof(out));
do {
result = basRunHostSlice(rt);
} while (result == BAS_VM_STEP_LIMIT);
TEST_EQ(result, BAS_VM_HALTED);
TEST_TRUE(strstr(out.text, "17") != NULL);
TEST_TRUE(!basRunHostAlive(rt));
basRunHostDestroy(rt);
basModuleFree(mod);
basBuildFreeProject(&ps);
tShutdown();
}
// compiler.bas from C: source sets, error mapping, procedure lists,
// identifiers, keywords, the validator's unknown types and member typos.
static void caseCompileApi(void) {
tCase("compiler.bas entry points: errors, maps, procs, validation");
tInit(SCREEN_W, SCREEN_H, SCREEN_BPP);
// A compile error maps back to its file and line
int32_t src = CompSourceCreate();
TEST_TRUE(src > 0);
TEST_EQ(CompSourceAdd(src, "first.bas", "DIM a AS LONG\na = 1\n", KIND_MODULE), BAS_TRUE);
TEST_EQ(CompSourceAdd(src, "second.bas", "DIM b AS LONG\nb = \n", KIND_MODULE), BAS_TRUE);
TEST_EQ(CompCompile(src, 0, 0), 0);
TEST_TRUE(CompError()[0] != '\0');
TEST_TRUE(strncmp(CompError(), "Line", strlen("Line")) != 0);
TEST_STR_EQ(CompErrorFile(), "second.bas");
TEST_EQ(CompErrorFileLine(), 2);
TEST_TRUE(strstr(CompSourceFiles(src), "first.bas\t1\t") != NULL);
CompSourceFree(src);
// A form whose control type no widget library registers
src = CompSourceCreate();
TEST_EQ(CompSourceAdd(src, "f.frm", "Begin Form F\n Begin Bogus b1\n End\nEnd\n", -1), BAS_TRUE);
TEST_EQ(CompCompile(src, 0, BAS_TRUE), 0);
TEST_TRUE(strstr(CompError(), "type 'Bogus' is not registered") != NULL);
CompSourceFree(src);
// A member typo on a known control fails at compile time when
// validating, and compiles without validation
const char *frm = "Begin Form F\n Begin Label lbl\n End\nEnd\n\nSUB F_Load\n lbl.Captoin = \"x\"\nEND SUB\n";
src = CompSourceCreate();
TEST_EQ(CompSourceAdd(src, "f.frm", frm, KIND_FORM), BAS_TRUE);
TEST_EQ(CompCompile(src, 0, BAS_TRUE), 0);
TEST_STR_EQ(CompErrorFile(), "f.frm");
TEST_EQ(CompErrorFileLine(), 7);
int32_t mdl = CompCompile(src, 0, 0);
TEST_TRUE(mdl > 0);
TEST_STR_EQ(CompProcs(mdl), "F_Load\tSub\tF\n");
CompModuleFree(mdl);
CompSourceFree(src);
// Procedure blocks of source text, identifiers, keywords
TEST_STR_EQ(CompProcList("x = 1\nSUB A\nEND SUB\nPrivate Function B(n)\n B = n\nEnd Function\n"), "Sub\tA\t2\t3\nFunction\tB\t4\t6\n");
TEST_EQ(CompIsIdent("abc_1"), BAS_TRUE);
TEST_EQ(CompIsIdent("1abc"), 0);
TEST_TRUE(CompKeywordCount() > 0);
TEST_TRUE(CompKeyword(0)[0] != '\0');
TEST_STR_EQ(CompKeyword(-1), "");
// The Immediate window without a program
TEST_EQ(atoi(DbgExec(0, "6 * 7")), 42);
tShutdown();
}
// compiler.bas for a form designer: a source set's UserControls made
// control types of the calling program alone (CompDesignControls), their
// module kept past CompModuleFree until they go (CompDesignRelease), a
// second call replacing the first, another program's module refused; a
// control project's (designProject); the header keys (ProjCtlKeys$).
static void caseDesignControls(void) {
tCase("compiler.bas designer: CompDesignControls, CompDesignRelease, CompBuildApp of a control project, ProjCtlKeys$");
tInit(SCREEN_W, SCREEN_H, SCREEN_BPP);
static const char host[] = "Dim x As Integer\n";
TEST_STR_EQ(ProjCtlKeys(), "Name\tName\nWidth\tInteger\nHeight\tInteger\nCanGetFocus\tBoolean\nBackColor\tColor\nToolboxIcon\tText\nDescription\tText\nDefaultEvent\tText\n");
char dir[DVX_MAX_PATH];
char want[DVX_MAX_PATH];
char path[DVX_MAX_PATH];
snprintf(dir, sizeof(dir), "%s/dsgnctl", tTempDir());
snprintf(want, sizeof(want), "%s/dial.bmp", dir);
int32_t src = CompSourceCreate();
TEST_EQ(CompSourceAdd(src, "dial.ctl", sDialCtl, KIND_CONTROL), BAS_TRUE);
int32_t mdl = CompCompile(src, 0, 0);
TEST_TRUE(mdl > 0);
// Outside a program there is no designer to register for
TEST_EQ(CompDesignControls(mdl, src, dir), 0);
TEST_TRUE(CompError()[0] != '\0');
TEST_EQ(CompDesignRelease(), BAS_TRUE);
// The calling program: a runtime made current
BasCompileErrorT err;
BasModuleT *hostMod = basBuildCompile(host, (int32_t)strlen(host), false, NULL, NULL, &err);
const char *hostError = NULL;
BasRunSpecT spec;
memset(&spec, 0, sizeof(spec));
spec.appDir = tTempDir();
spec.title = BDT_PARENT_FORM;
spec.suppressErrorDialog = true;
BasFormRtT *rt = hostMod ? basRunHostCreate(tCtx(), hostMod, &spec, &hostError) : NULL;
BasFormRtT *prev = basFormRtSetCurrent(rt);
TEST_TRUE(rt != NULL);
TEST_EQ(CompDesignControls(mdl, src, dir), 1);
TEST_STR_EQ(CompError(), "");
const WgtIfaceT *iface = basUcOwnIface(rt, "Dial");
TEST_TRUE(iface != NULL);
TEST_PTR_EQ(basUcOwnIface(NULL, "Dial"), NULL);
TEST_TRUE(basUcIconPath(iface, path, sizeof(path)));
TEST_STR_EQ(path, want);
// Freed while its controls are in use: kept, and no new use of it
CompModuleFree(mdl);
TEST_TRUE(basUcOwnIface(rt, "Dial") != NULL);
TEST_EQ(CompDesignControls(mdl, src, dir), 0);
TEST_TRUE(basUcOwnIface(rt, "Dial") != NULL);
TEST_EQ(CompDesignRelease(), BAS_TRUE);
TEST_PTR_EQ(basUcOwnIface(rt, "Dial"), NULL);
TEST_EQ(CompDesignControls(mdl, src, dir), 0);
// Another module's controls, App.Path the caller's, then replaced
int32_t next = CompCompile(src, 0, 0);
snprintf(want, sizeof(want), "%s/dial.bmp", tTempDir());
TEST_EQ(CompDesignControls(next, src, ""), 1);
TEST_TRUE(basUcIconPath(basUcOwnIface(rt, "Dial"), path, sizeof(path)));
TEST_STR_EQ(path, want);
TEST_EQ(CompDesignControls(next, src, dir), 1);
TEST_TRUE(basUcOwnIface(rt, "Dial") != NULL);
TEST_EQ(CompDesignRelease(), BAS_TRUE);
CompModuleFree(next);
// Another program's module is refused: it would go when that one ends
int32_t *ownApp = dvxMemAppIdPtr;
int32_t otherApp = (ownApp ? *ownApp : 0) + 1;
dvxMemAppIdPtr = &otherApp;
int32_t foreign = CompCompile(src, 0, 0);
dvxMemAppIdPtr = ownApp;
TEST_TRUE(foreign > 0);
TEST_EQ(CompDesignControls(foreign, src, dir), 0);
TEST_PTR_EQ(basUcOwnIface(rt, "Dial"), NULL);
CompModuleFree(foreign);
CompSourceFree(src);
if (rt) {
designProject(rt);
}
basFormRtSetCurrent(prev);
if (rt) {
basRunHostDestroy(rt);
}
basModuleFree(hostMod);
tShutdown();
}
// The CONSTs of the include files that mirror C values: one source of
// truth, checked here (a C value changed without its CONST fails).
static void caseIncludeConsts(void) {
static const BdtConstT consts[] = {
{ "resource.bas", "RES_NAME_MAX", DVX_RES_NAME_MAX },
{ "system.bas", "MOUSE_WHEEL_STEP_MIN", MOUSE_WHEEL_STEP_MIN },
{ "system.bas", "MOUSE_WHEEL_STEP_MAX", MOUSE_WHEEL_STEP_MAX },
{ "system.bas", "MOUSE_WHEEL_STEP_DEFAULT", MOUSE_WHEEL_STEP_DEFAULT },
{ "system.bas", "MOUSE_DBLCLICK_DEFAULT_MS", MOUSE_DBLCLICK_DEFAULT_MS },
{ "system.bas", "MOUSE_SPEED_DEFAULT", MOUSE_SPEED_DEFAULT },
{ "system.bas", "SYS_VIDEO_DEFAULT_WIDTH", DVX_DEFAULT_VIDEO_W },
{ "system.bas", "SYS_VIDEO_DEFAULT_HEIGHT", DVX_DEFAULT_VIDEO_H },
{ "system.bas", "SYS_VIDEO_DEFAULT_BPP", DVX_DEFAULT_VIDEO_BPP },
{ "shell.bas", "SHELL_VIEW_LARGE", PmViewLargeE },
{ "shell.bas", "SHELL_VIEW_SMALL", PmViewSmallE },
{ "shell.bas", "SHELL_VIEW_LIST", PmViewListE },
{ "shell.bas", "SHELL_PRIORITY_LOW", TS_PRIORITY_LOW },
{ "shell.bas", "SHELL_PRIORITY_NORMAL", TS_PRIORITY_NORMAL },
{ "shell.bas", "SHELL_PRIORITY_HIGH", TS_PRIORITY_HIGH },
{ "fileops.bas", "FILEOPS_ATTR_READONLY", FILEOPS_ATTR_READONLY },
{ "fileops.bas", "FILEOPS_ATTR_HIDDEN", FILEOPS_ATTR_HIDDEN },
{ "fileops.bas", "FILEOPS_ATTR_SYSTEM", FILEOPS_ATTR_SYSTEM },
{ "fileops.bas", "FILEOPS_ATTR_ARCHIVE", FILEOPS_ATTR_ARCHIVE },
{ "fileops.bas", "FILEOPS_ATTR_EDITABLE", FILEOPS_ATTR_EDITABLE },
{ "fileops.bas", "FILEOPS_DRIVE_FIXED", PlatformDriveFixedE },
{ "fileops.bas", "FILEOPS_DRIVE_REMOVABLE", PlatformDriveRemovableE },
{ "fileops.bas", "FILEOPS_DRIVE_REMOTE", PlatformDriveRemoteE },
{ "fileops.bas", "FILEOPS_SORT_NAME", FileOpsSortNameE },
{ "fileops.bas", "FILEOPS_SORT_SIZE", FileOpsSortSizeE },
{ "fileops.bas", "FILEOPS_SORT_TYPE", FileOpsSortTypeE },
{ "fileops.bas", "FILEOPS_SORT_DATE", FileOpsSortDateE },
{ "fileops.bas", "FILEOPS_COPY", FileOpsCopyE },
{ "fileops.bas", "FILEOPS_MOVE", FileOpsMoveE },
{ "fileops.bas", "FILEOPS_DELETE", FileOpsDeleteE },
{ "fileops.bas", "FILEOPS_STEP_BUSY", FileOpsStepBusyE },
{ "fileops.bas", "FILEOPS_STEP_ASK", FileOpsStepAskE },
{ "fileops.bas", "FILEOPS_STEP_ERROR", FileOpsStepErrorE },
{ "fileops.bas", "FILEOPS_STEP_DONE", FileOpsStepDoneE },
{ "fileops.bas", "FILEOPS_STEP_CANCELLED", FileOpsStepCancelledE },
{ "fileops.bas", "FILEOPS_ANSWER_YES", FileOpsAnswerYesE },
{ "fileops.bas", "FILEOPS_ANSWER_NO", FileOpsAnswerNoE },
{ "fileops.bas", "FILEOPS_ANSWER_ALL", FileOpsAnswerAllE },
{ "fileops.bas", "FILEOPS_ANSWER_CANCEL", FileOpsAnswerCancelE },
{ "fileops.bas", "FILEOPS_ANSWER_RETRY", FileOpsAnswerRetryE },
{ "fileops.bas", "FILEOPS_ANSWER_SKIP", FileOpsAnswerSkipE },
{ "compiler.bas", "COMP_KW_OTHER", BAS_KW_CLASS_OTHER },
{ "compiler.bas", "COMP_KW_TYPE", BAS_KW_CLASS_TYPE },
{ "compiler.bas", "COMP_KW_LITERAL", BAS_KW_CLASS_LITERAL },
{ "compiler.bas", "COMP_KIND_MODULE", BAS_BUILD_WRAP_MODULE },
{ "compiler.bas", "COMP_KIND_FORM", BAS_BUILD_WRAP_FORM },
{ "compiler.bas", "COMP_KIND_CLASS", BAS_BUILD_WRAP_CLASS },
{ "compiler.bas", "COMP_KIND_CONTROL", BAS_BUILD_WRAP_CONTROL },
{ "sound.bas", "SOUND_EVENT_DEFAULT", SoundDefaultE },
{ "sound.bas", "SOUND_EVENT_START", SoundStartE },
{ "sound.bas", "SOUND_EVENT_EXIT", SoundExitE },
{ "sound.bas", "SOUND_EVENT_ERROR", SoundErrorE },
{ "sound.bas", "SOUND_EVENT_WARNING", SoundWarningE },
{ "sound.bas", "SOUND_EVENT_QUESTION", SoundQuestionE },
{ "sound.bas", "SOUND_EVENT_INFO", SoundInfoE },
{ "sound.bas", "SOUND_EVENT_WINDOW_OPEN", SoundWindowOpenE },
{ "sound.bas", "SOUND_EVENT_WINDOW_CLOSE", SoundWindowCloseE },
{ "sound.bas", "SOUND_PITCH_NORMAL", AUDIO_PITCH_NORMAL * PERCENT / AUDIO_PITCH_NORMAL },
{ "sound.bas", "SOUND_PITCH_MIN", AUDIO_PITCH_MIN * PERCENT / AUDIO_PITCH_NORMAL },
{ "sound.bas", "SOUND_PITCH_MAX", AUDIO_PITCH_MAX * PERCENT / AUDIO_PITCH_NORMAL },
{ "sound.bas", "SOUND_RATE_MIN", AUDIO_RATE_MIN },
{ "sound.bas", "SOUND_RATE_MAX", AUDIO_RATE_MAX },
{ "sound.bas", "SOUND_RATE_DEFAULT", AUDIO_RATE_DEFAULT },
{ "sound.bas", "SOUND_STREAM_MS_MIN", AUDIO_STREAM_MS_MIN },
{ "sound.bas", "SOUND_STREAM_MS_DEFAULT", AUDIO_STREAM_MS_DEFAULT },
{ "sound.bas", "SOUND_STREAM_MS_MAX", AUDIO_STREAM_MS_MAX },
{ "sound.bas", "FM_VOICES_MAX", AUDIO_FM_VOICES_MAX },
{ "sound.bas", "FM_CHIP_HZ", AUDIO_FM_CHIP_HZ },
{ "sound.bas", "FM_FNUM_MAX", AUDIO_FM_FNUM_MAX },
{ "sound.bas", "FM_BLOCK_MAX", AUDIO_FM_BLOCK_MAX },
{ "sound.bas", "FM_FNUM_HI_SHIFT", AUDIO_FM_FNUM_HI_SHIFT },
{ "sound.bas", "FM_BLOCK_SHIFT", AUDIO_FM_BLOCK_SHIFT },
{ "sound.bas", "FM_MOD_CHAR", AUDIO_FM_MOD_CHAR },
{ "sound.bas", "FM_CAR_CHAR", AUDIO_FM_CAR_CHAR },
{ "sound.bas", "FM_MOD_LEVEL", AUDIO_FM_MOD_LEVEL },
{ "sound.bas", "FM_CAR_LEVEL", AUDIO_FM_CAR_LEVEL },
{ "sound.bas", "FM_MOD_ATTACK", AUDIO_FM_MOD_ATTACK },
{ "sound.bas", "FM_CAR_ATTACK", AUDIO_FM_CAR_ATTACK },
{ "sound.bas", "FM_MOD_SUSTAIN", AUDIO_FM_MOD_SUSTAIN },
{ "sound.bas", "FM_CAR_SUSTAIN", AUDIO_FM_CAR_SUSTAIN },
{ "sound.bas", "FM_FNUM_LOW", AUDIO_FM_FNUM_LOW },
{ "sound.bas", "FM_KEY_BLOCK", AUDIO_FM_KEY_BLOCK },
{ "sound.bas", "FM_FEEDBACK", AUDIO_FM_FEEDBACK },
{ "sound.bas", "FM_MOD_WAVE", AUDIO_FM_MOD_WAVE },
{ "sound.bas", "FM_CAR_WAVE", AUDIO_FM_CAR_WAVE },
{ "sound.bas", "FM_KEY_ON", AUDIO_FM_KEY_ON },
{ "sound.bas", "FM_OUT_LEFT", AUDIO_FM_OUT_LEFT },
{ "sound.bas", "FM_OUT_RIGHT", AUDIO_FM_OUT_RIGHT },
{ "sound.bas", "FM_OUT_BOTH", AUDIO_FM_OUT_BOTH },
{ "sound.bas", "FM_ADDITIVE", AUDIO_FM_ADDITIVE },
{ "sound.bas", "FM_BANK_REGS", AUDIO_FM_BANK_REGS },
{ "joystick.bas", "JOY_CAL_MIN", JOY_CAL_MIN },
{ "joystick.bas", "JOY_CAL_CENTER", JOY_CAL_CENTER },
{ "joystick.bas", "JOY_CAL_MAX", JOY_CAL_MAX },
{ "joystick.bas", "JOY_DEADZONE_DEFAULT", JOY_DEADZONE_DEFAULT },
{ "joystick.bas", "JOY_DEADZONE_MAX", JOY_DEADZONE_MAX },
{ "joystick.bas", "JOY_POLL_HZ_DEFAULT", JOY_POLL_HZ_DEFAULT },
{ "joystick.bas", "JOY_POLL_HZ_MIN", JOY_POLL_HZ_MIN },
{ "joystick.bas", "JOY_POLL_HZ_MAX", JOY_POLL_HZ_MAX },
{ "joystick.bas", "JOY_HAT_CENTERED", JOY_HAT_CENTERED },
{ "joystick.bas", "JOY_AXIS_MIN", JOY_AXIS_MIN },
{ "joystick.bas", "JOY_AXIS_MAX", JOY_AXIS_MAX },
{ "joystick.bas", "JOY_CHOICE_GAMEPORT", JoyChoiceGamePortE },
{ "joystick.bas", "JOY_CHOICE_FALLBACK", JoyChoiceFallbackE }
};
tCase("include-file CONSTs equal their C values");
for (int32_t i = 0; i < DVX_ARRAY_LEN(consts); i++) {
char path[DVX_MAX_PATH];
int32_t len = 0;
snprintf(path, sizeof(path), BDT_INCLUDE_DIR "/%s", consts[i].file);
char *text = platformReadFile(path, &len);
TEST_TRUE(text != NULL);
if (text) {
TEST_EQ(includeConst(text, consts[i].name), consts[i].value);
free(text);
}
}
// String CONSTs
int32_t resLen = 0;
char *resBas = platformReadFile(BDT_INCLUDE_DIR "/resource.bas", &resLen);
TEST_TRUE(resBas != NULL);
if (resBas) {
TEST_TRUE(includeConstIs(resBas, "RES_NAME_ICON", DVX_RES_NAME_ICON));
TEST_TRUE(includeConstIs(resBas, "RES_NAME_WIDGET_ICON", DVX_RES_NAME_WIDGET_ICON));
free(resBas);
}
}
// The .dbp model from BASIC: a new project with files and settings,
// saved, opened again, a file renamed and removed.
static void caseProjectApi(void) {
tCase("compiler.bas projects: ProjNew, ProjSave, ProjOpen, files, settings");
tInit(SCREEN_W, SCREEN_H, SCREEN_BPP);
char dir[DVX_MAX_PATH];
char dbp[DVX_MAX_PATH];
snprintf(dir, sizeof(dir), "%s/projapi", tTempDir());
snprintf(dbp, sizeof(dbp), "%s/demo.dbp", dir);
platformMkdirRecursive(dir);
remove(dbp);
int32_t prj = ProjNew("demo", dir);
TEST_TRUE(prj > 0);
TEST_EQ(ProjAddFile(prj, "main.bas"), 0);
TEST_EQ(ProjAddFile(prj, "form1.frm"), 1);
TEST_EQ(ProjAddFile(prj, "MAIN.BAS"), NO_INDEX);
TEST_EQ(ProjFileKind(prj, 1), KIND_FORM);
TEST_EQ(ProjFileKind(prj, 0), KIND_MODULE);
TEST_EQ(ProjFileKind(prj, 2), NO_INDEX);
TEST_EQ(ProjSet(prj, "Author", "Somebody"), BAS_TRUE);
TEST_EQ(ProjSet(prj, "optionexplicit", " -1"), BAS_TRUE);
TEST_EQ(ProjSet(prj, "StartupForm", "Form1"), BAS_TRUE);
TEST_EQ(ProjSet(prj, "Bogus", "x"), 0);
TEST_EQ(ProjSave(prj), BAS_TRUE);
ProjClose(prj);
TEST_EQ(ProjOpen("no-such-project.dbp"), 0);
prj = ProjOpen(dbp);
TEST_TRUE(prj > 0);
TEST_STR_EQ(ProjGet(prj, "author"), "Somebody");
TEST_STR_EQ(ProjGet(prj, "Name"), "demo");
TEST_STR_EQ(ProjGet(prj, "OptionExplicit"), "true");
TEST_STR_EQ(ProjGet(prj, "MultiInstance"), "false");
TEST_STR_EQ(ProjGet(prj, "StartupForm"), "Form1");
TEST_STR_EQ(ProjGet(prj, "Bogus"), "");
TEST_STR_EQ(ProjPath(prj), dbp);
TEST_EQ(ProjFileCount(prj), 2);
TEST_STR_EQ(ProjFile(prj, 0), "main.bas");
TEST_EQ(ProjFileFind(prj, "FORM1.FRM"), 1);
TEST_TRUE(strstr(ProjFilePath(prj, 1), "projapi") != NULL);
// A rename keeps the kind's extension and saves the project at once
TEST_EQ(ProjRenameFile(prj, 0, "x.frm"), 0);
TEST_TRUE(CompError()[0] != '\0');
TEST_EQ(ProjRenameFile(prj, 0, "app"), BAS_TRUE);
TEST_STR_EQ(ProjFile(prj, 0), "app.bas");
TEST_EQ(ProjRemoveFile(prj, 1), BAS_TRUE);
TEST_EQ(ProjRemoveFile(prj, 1), 0);
TEST_EQ(ProjFileCount(prj), 1);
ProjClose(prj);
prj = ProjOpen(dbp);
TEST_EQ(ProjFileFind(prj, "app.bas"), 0);
ProjClose(prj);
TEST_EQ(ProjFileCount(prj), 0);
tShutdown();
}
// A control project and a UserControl's header: [Project] Type = Control
// and the [Controls] section written, read and kept by renames; the
// header keys read with their defaults and set key by key, the code after
// the header untouched (compiler.bas and the C model).
static void caseProjectControls(void) {
tCase("compiler.bas projects: control projects, [Controls], UserControl headers");
tInit(SCREEN_W, SCREEN_H, SCREEN_BPP);
static const char ctl[] =
"VERSION DVX 1.00\n"
"Begin UserControl Gauge\n"
" Width = 120\n"
" CanGetFocus = False\n"
"End\n"
"Option Explicit\n"
"Private Sub UserControl_Paint()\n"
"End Sub\n";
static const char ctlCode[] = "Option Explicit\nPrivate Sub UserControl_Paint()\nEnd Sub\n";
// The header keys and their defaults
TEST_STR_EQ(ProjCtlHeader(ctl, "name"), "Gauge");
TEST_STR_EQ(ProjCtlHeader(ctl, "width"), "120");
TEST_STR_EQ(ProjCtlHeader(ctl, "Height"), "64");
TEST_STR_EQ(ProjCtlHeader(ctl, "CanGetFocus"), "False");
TEST_STR_EQ(ProjCtlHeader(ctl, "BackColor"), "");
TEST_STR_EQ(ProjCtlHeader(ctl, "Description"), "");
TEST_STR_EQ(ProjCtlHeader(ctl, "Bogus"), "");
TEST_STR_EQ(ProjCtlHeader("x = 1\n", "Width"), "");
TEST_TRUE(prjCtlKeyAt(0) != NULL);
TEST_STR_EQ(prjCtlKeyAt(0)->key, BAS_PROP_NAME);
TEST_STR_EQ(prjCtlKeyAt(1)->key, BAS_UC_KEY_WIDTH);
TEST_STR_EQ(prjCtlKeyAt(BDT_CTL_KEYS - 1)->key, BAS_UC_KEY_DEFAULTEVENT);
TEST_TRUE(prjCtlKeyAt(BDT_CTL_KEYS) == NULL);
TEST_TRUE(prjCtlKeyAt(-1) == NULL);
TEST_EQ(prjCtlKeyFind("backcolor")->kind, PrjCtlColorE);
TEST_EQ(prjCtlKeyFind("CANGETFOCUS")->kind, PrjCtlBoolE);
TEST_EQ(prjCtlKeyFind("ToolboxIcon")->kind, PrjCtlTextE);
TEST_EQ(prjCtlKeyFind("NAME")->kind, PrjCtlNameE);
TEST_TRUE(prjCtlKeyFind("Caption") == NULL);
// A key's line changed in place, added before End, removed
TEST_STR_EQ(ProjCtlSetHeader(ctl, "WIDTH", " 200 "), "VERSION DVX 1.00\nBegin UserControl Gauge\n Width = 200\n CanGetFocus = False\nEnd\nOption Explicit\nPrivate Sub UserControl_Paint()\nEnd Sub\n");
TEST_STR_EQ(CompError(), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "CanGetFocus", "-1"), "VERSION DVX 1.00\nBegin UserControl Gauge\n Width = 120\n CanGetFocus = True\nEnd\nOption Explicit\nPrivate Sub UserControl_Paint()\nEnd Sub\n");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "BackColor", "&hff0000"), "VERSION DVX 1.00\nBegin UserControl Gauge\n Width = 120\n CanGetFocus = False\n BackColor = &H00FF0000&\nEnd\nOption Explicit\nPrivate Sub UserControl_Paint()\nEnd Sub\n");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Description", "A gauge"), "VERSION DVX 1.00\nBegin UserControl Gauge\n Width = 120\n CanGetFocus = False\n Description = \"A gauge\"\nEnd\nOption Explicit\nPrivate Sub UserControl_Paint()\nEnd Sub\n");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "CanGetFocus", ""), "VERSION DVX 1.00\nBegin UserControl Gauge\n Width = 120\nEnd\nOption Explicit\nPrivate Sub UserControl_Paint()\nEnd Sub\n");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Height", ""), ctl);
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Name", "Meter"), "VERSION DVX 1.00\nBegin UserControl Meter\n Width = 120\n CanGetFocus = False\nEnd\nOption Explicit\nPrivate Sub UserControl_Paint()\nEnd Sub\n");
// Read back as set (a decimal color too), the code kept
char colored[sizeof(ctl) * 2];
snprintf(colored, sizeof(colored), "%s", ProjCtlSetHeader(ctl, "BackColor", "255"));
TEST_STR_EQ(ProjCtlHeader(colored, "BackColor"), "&H000000FF&");
TEST_TRUE(strstr(colored, ctlCode) != NULL);
TEST_STR_EQ(ProjCtlHeader(ProjCtlSetHeader(ctl, "DefaultEvent", "Changed"), "DefaultEvent"), "Changed");
// Values a key does not take
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Width", "wide"), "");
TEST_TRUE(CompError()[0] != '\0');
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Width", "-5"), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "BackColor", "&HXYZ"), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Description", "say \"hi\""), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Description", "two\nlines"), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Bogus", "1"), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Name", ""), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Name", "2Bad"), "");
TEST_STR_EQ(ProjCtlSetHeader(ctl, "Name", "Two Words"), "");
TEST_STR_EQ(ProjCtlSetHeader(ctlCode, "Width", "1"), "");
// A new control's text, and it compiles
static const char fresh[] = "VERSION DVX 1.00\nBegin UserControl Dial\n Width = 64\n Height = 64\nEnd\n\nOption Explicit\n\nPrivate Sub UserControl_Paint ()\n\nEnd Sub\n";
TEST_STR_EQ(ProjCtlNew("Dial"), fresh);
TEST_STR_EQ(CompError(), "");
TEST_STR_EQ(ProjCtlNew("9Dial"), "");
TEST_TRUE(CompError()[0] != '\0');
TEST_STR_EQ(ProjCtlNew(""), "");
int32_t src = CompSourceCreate();
TEST_EQ(CompSourceAdd(src, "dial.ctl", fresh, KIND_CONTROL), BAS_TRUE);
int32_t mdl = CompCompile(src, BAS_TRUE, 0);
TEST_TRUE(mdl > 0);
CompModuleFree(mdl);
CompSourceFree(src);
// A control project: Type and [Controls] saved and read back
char dir[DVX_MAX_PATH];
char dbp[DVX_MAX_PATH];
snprintf(dir, sizeof(dir), "%s/projctl", tTempDir());
snprintf(dbp, sizeof(dbp), "%s/gauge.dbp", dir);
platformMkdirRecursive(dir);
remove(dbp);
int32_t prj = ProjNew("gauge", dir);
TEST_STR_EQ(ProjGet(prj, "Type"), "");
TEST_EQ(ProjSet(prj, "type", BAS_PROJECT_TYPE_CONTROL), BAS_TRUE);
TEST_EQ(ProjAddFile(prj, "gauge.ctl"), 0);
TEST_EQ(ProjAddFile(prj, "util.bas"), 1);
TEST_EQ(ProjFileKind(prj, 0), KIND_CONTROL);
TEST_EQ(ProjSave(prj), BAS_TRUE);
ProjClose(prj);
int32_t len = 0;
char *text = platformReadFile(dbp, &len);
TEST_TRUE(text != NULL);
TEST_TRUE(text && strstr(text, "[" BAS_INI_SECTION_CONTROLS "]") != NULL);
TEST_TRUE(text && strstr(text, "gauge.ctl") != NULL);
TEST_TRUE(text && strstr(text, BAS_INI_KEY_TYPE) != NULL);
free(text);
PrjStateT model;
prjInit(&model);
TEST_TRUE(prjLoad(&model, dbp));
TEST_TRUE(prjIsControlProject(&model));
TEST_EQ(prjFileCount(&model), 2);
TEST_EQ(model.files[prjFileIndexByPath(&model, "gauge.ctl")].kind, PrjKindControlE);
TEST_EQ(model.files[0].kind, PrjKindModuleE);
TEST_EQ(prjKindForPath("X.CTL"), PrjKindControlE);
TEST_EQ(prjKindWrap(PrjKindControlE), BAS_BUILD_WRAP_CONTROL);
TEST_EQ(prjFieldSet(&model, BAS_INI_KEY_TYPE, ""), true);
TEST_TRUE(!prjIsControlProject(&model));
prjClose(&model);
// Modules load before controls (the compile order)
prj = ProjOpen(dbp);
TEST_STR_EQ(ProjGet(prj, "Type"), BAS_PROJECT_TYPE_CONTROL);
TEST_EQ(ProjFileFind(prj, "GAUGE.CTL"), 1);
TEST_EQ(ProjFileKind(prj, 1), KIND_CONTROL);
TEST_EQ(ProjRenameFile(prj, 1, "meter.bas"), 0);
TEST_EQ(ProjRenameFile(prj, 1, "meter"), BAS_TRUE);
TEST_STR_EQ(ProjFile(prj, 1), "meter.ctl");
ProjClose(prj);
prj = ProjOpen(dbp);
TEST_EQ(ProjFileKind(prj, ProjFileFind(prj, "meter.ctl")), KIND_CONTROL);
TEST_EQ(ProjRemoveFile(prj, 1), BAS_TRUE);
TEST_EQ(ProjSave(prj), BAS_TRUE);
ProjClose(prj);
prj = ProjOpen(dbp);
TEST_EQ(ProjFileCount(prj), 1);
TEST_EQ(ProjFileKind(prj, 0), KIND_MODULE);
ProjClose(prj);
// The validator: a project's own control type is known, its members
// are left to the run time (a registered one may be an older build)
BasValidatorT v;
memset(&v, 0, sizeof(v));
basValidateAddType(&v, "Gauge");
TEST_TRUE(basValidateIsPropValid(&v, "gauge", "Needle"));
TEST_TRUE(basValidateIsMethodValid(&v, "Gauge", "Spin"));
TEST_TRUE(!basValidateIsPropValid(&v, "CommandButton", "Needle"));
TEST_TRUE(!basValidateIsMethodValid(NULL, "CommandButton", "Spin"));
basValidateFree(&v);
tShutdown();
}
// Source text as the compiler reads it: tokens, code positions, renaming
// in code, WithEvents variables, class Events, help topics, keyword
// classes.
static void caseSourceApi(void) {
tCase("compiler.bas source text: tokens, in-code, rename, events, help topics, keyword flags");
TEST_STR_EQ(CompTokens("x = \"a\tb\" ' note\nIF y THEN\n"), "1\t1\t1\tIdentifier\tx\n1\t3\t1\tSymbol\t=\n1\t5\t5\tString\t\"a b\"\n1\t11\t6\tComment\t' note\n2\t1\t2\tKeyword\tIF\n2\t4\t1\tIdentifier\ty\n2\t6\t4\tKeyword\tTHEN\n");
TEST_STR_EQ(CompTokens("REM all of it\n"), "1\t1\t13\tComment\tREM all of it\n");
TEST_STR_EQ(CompTokens("s = \"open\n"), "1\t1\t1\tIdentifier\ts\n1\t3\t1\tSymbol\t=\n1\t5\t5\tError\t\"open\n");
const char *code = "a = \"Cmd1.x\" ' Cmd1.y\nCmd1.z = 1\ns = \"abc\n";
TEST_EQ(CompInCode(code, 1), BAS_TRUE);
TEST_EQ(CompInCode(code, 4), BAS_TRUE);
TEST_EQ(CompInCode(code, 6), 0);
TEST_EQ(CompInCode(code, 16), 0);
TEST_EQ(CompInCode(code, 23), BAS_TRUE);
TEST_EQ(CompInCode(code, 39), 0);
TEST_EQ(CompInCode(code, 0), 0);
const char *frm = "Command1.Caption = \"Command1.x\"\nSub Command1_Click\n' Command1.y\nMyCommand1.z = 1\n";
TEST_STR_EQ(CompRenameInCode(frm, "command1", "Go", BAS_TRUE), "Go.Caption = \"Command1.x\"\nSub Go_Click\n' Command1.y\nMyCommand1.z = 1\n");
TEST_STR_EQ(CompRenameInCode(frm, "Command1", "Go", 0), "Go.Caption = \"Go.x\"\nSub Go_Click\n' Go.y\nMyCommand1.z = 1\n");
TEST_STR_EQ(CompRenameInCode(frm, "Label1", "Go", BAS_TRUE), frm);
// A result too long for an int32_t length leaves the text unchanged
// (its size overflowed int32_t before)
size_t refLen = strlen(BDT_RENAME_REF);
char *many = (char *)malloc(BDT_RENAME_REFS * refLen + 1);
char *newName = (char *)malloc(BDT_RENAME_NEWLEN + 1);
if (many && newName) {
for (int32_t i = 0; i < BDT_RENAME_REFS; i++) {
memcpy(many + (size_t)i * refLen, BDT_RENAME_REF, refLen);
}
many[BDT_RENAME_REFS * refLen] = '\0';
memset(newName, 'b', BDT_RENAME_NEWLEN);
newName[BDT_RENAME_NEWLEN] = '\0';
TEST_STR_EQ(CompRenameInCode(many, "a", newName, 0), many);
}
free(many);
free(newName);
TEST_STR_EQ(CompWithEvents("Dim WithEvents a As Foo, b As Long\nPrivate WithEvents c As Bar\nx = 1 ' Dim WithEvents d As Baz\n"), "a\tFoo\nc\tBar\n");
TEST_STR_EQ(CompClassEvents("Public Event Changed(Value As Integer)\nEvent Done\nx = \"Event Nope\"\n"), "Changed\tValue As Integer\nDone\t\n");
TEST_STR_EQ(CompHelpTopic("withevents"), "lang.events");
TEST_STR_EQ(CompHelpTopic("NoSuchWord"), "");
TEST_STR_EQ(CompHelpCtrlTopic("CommandButton"), "ctrl.commandbutton");
TEST_EQ(CompKeywordClass(keywordIndex("INTEGER")), KW_CLASS_TYPE);
TEST_EQ(CompKeywordReserved(keywordIndex("INTEGER")), BAS_TRUE);
TEST_EQ(CompKeywordClass(keywordIndex("BYTE")), KW_CLASS_TYPE);
TEST_EQ(CompKeywordReserved(keywordIndex("BYTE")), 0);
TEST_EQ(CompKeywordClass(keywordIndex("TRUE")), KW_CLASS_LITERAL);
TEST_EQ(CompKeywordClass(NO_INDEX), NO_INDEX);
TEST_EQ(CompKeywordReserved(CompKeywordCount()), 0);
}
// Copy the fixture's kid project into kidDir.
static bool copyKid(const char *kidDir) {
static const char *const files[] = { "kid.dbp", "kid.bas", "kidform.frm" };
bool ok = platformMkdirRecursive(kidDir) == 0;
for (int32_t i = 0; ok && i < DVX_ARRAY_LEN(files); i++) {
char from[DVX_MAX_PATH];
char to[DVX_MAX_PATH];
snprintf(from, sizeof(from), BDT_FIXTURE_DIR "/kid/%s", files[i]);
snprintf(to, sizeof(to), "%s/%s", kidDir, files[i]);
ok = platformCopyFile(from, to);
}
return ok;
}
// caseDesignControls with program rt current: a control project's set
// (App.Path its folder; built into a control file by CompBuildApp) and a
// child program's design controls, which go when it ends along with its
// hold on their module, so that handle is free again.
static void designProject(const BasFormRtT *rt) {
char dir[DVX_MAX_PATH];
char dbp[DVX_MAX_PATH];
char ctlPath[DVX_MAX_PATH];
char iconPath[DVX_MAX_PATH];
char wgt[DVX_MAX_PATH];
char path[DVX_MAX_PATH];
char ctl0[BAS_RES_FORM_NAME_LEN];
snprintf(dir, sizeof(dir), "%s/dsgnprj", tTempDir());
snprintf(dbp, sizeof(dbp), "%s/dial.dbp", dir);
snprintf(ctlPath, sizeof(ctlPath), "%s/dial.ctl", dir);
snprintf(iconPath, sizeof(iconPath), "%s/dial.bmp", dir);
snprintf(wgt, sizeof(wgt), "%s/dial.wgt", tTempDir());
snprintf(ctl0, sizeof(ctl0), BAS_RES_CTL_FMT, (long)0);
platformMkdirRecursive(dir);
remove(dbp);
remove(wgt);
TEST_TRUE(tWriteFile(ctlPath, sDialCtl, (int32_t)strlen(sDialCtl)));
TEST_TRUE(tWriteFile(iconPath, BDT_DIAL_ICON, (int32_t)sizeof(BDT_DIAL_ICON)));
int32_t prj = ProjNew("dial", dir);
TEST_EQ(ProjSet(prj, "Type", BAS_PROJECT_TYPE_CONTROL), BAS_TRUE);
TEST_EQ(ProjAddFile(prj, "dial.ctl"), 0);
TEST_EQ(ProjSave(prj), BAS_TRUE);
ProjClose(prj);
// A project's set: App.Path (and the ToolboxIcon) its folder
int32_t src = CompSourceCreate();
TEST_EQ(CompSourceFromProject(src, dbp), BAS_TRUE);
int32_t mdl = CompCompile(src, 0, 0);
TEST_EQ(CompDesignControls(mdl, src, ""), 1);
TEST_TRUE(basUcIconPath(basUcOwnIface(rt, "Dial"), path, sizeof(path)));
TEST_STR_EQ(path, iconPath);
TEST_EQ(CompDesignRelease(), BAS_TRUE);
// A control project builds a control file: the module, the header
// text, the toolbox picture and name (no Description: the name)
TEST_EQ(CompBuildApp(mdl, src, wgt, 0), BAS_TRUE);
CompModuleFree(mdl);
CompSourceFree(src);
DvxResHandleT *res = dvxResOpen(wgt);
TEST_TRUE(res != NULL);
TEST_TRUE(resHas(res, BAS_RES_MODULE, NULL));
TEST_TRUE(resHas(res, ctl0, BDT_DIAL_HEADER));
TEST_TRUE(resHas(res, BAS_CTL_RES_ICON, BDT_DIAL_ICON));
TEST_TRUE(resHas(res, BAS_CTL_RES_NAME, "Dial"));
if (res) {
dvxResClose(res);
}
// A child program's own design controls
int32_t len = 0;
char *inc = platformReadFile(BDT_INCLUDE_DIR "/compiler.bas", &len);
size_t size = (size_t)len + sizeof(BDT_DESIGN_CHILD_FMT) + strlen(dbp);
char *text = inc ? (char *)malloc(size) : NULL;
int32_t kidSrc = CompSourceCreate();
TEST_TRUE(text != NULL);
if (text) {
snprintf(text, size, BDT_DESIGN_CHILD_FMT, inc, dbp);
TEST_EQ(CompSourceAdd(kidSrc, "child.bas", text, KIND_PROGRAM), BAS_TRUE);
}
int32_t kidMdl = CompCompile(kidSrc, 0, 0);
int32_t run = RunCreate(kidMdl, kidSrc, "", "");
int32_t state = BDT_RUN_ERROR;
basNativeHostSetLive(true);
TEST_EQ(RunStart(run, "", 0), BAS_TRUE);
for (int32_t i = 0; i < BDT_MAX_TICKS && (state = RunPoll(run, BDT_TICK_MS)) != BDT_RUN_ENDED && state != BDT_RUN_ERROR; i++) {
}
basNativeHostSetLive(false);
TEST_EQ(state, BDT_RUN_ENDED);
char *end = NULL;
int32_t freed = (int32_t)strtol(RunOutput(run), &end, DECIMAL);
int32_t designed = (int32_t)strtol(end, NULL, DECIMAL);
TEST_EQ(designed, 1);
// Its module went with it: handles are given out lowest free first,
// so at most "freed" new ones reach its number
int32_t *probes = NULL;
bool reused = false;
for (int32_t i = 0; i < freed && !reused; i++) {
int32_t h = CompSourceCreate();
arrput(probes, h);
reused = (h == freed);
}
TEST_TRUE(reused);
for (int32_t i = 0; i < (int32_t)arrlen(probes); i++) {
CompSourceFree(probes[i]);
}
arrfree(probes);
RunFree(run);
CompModuleFree(kidMdl);
CompSourceFree(kidSrc);
free(text);
free(inc);
}
static BasFormT *formOf(const BasFormRtT *rt, const char *formName) {
for (int32_t i = 0; i < (int32_t)arrlen(rt->forms); i++) {
if (strcasecmp(rt->forms[i]->name, formName) == 0) {
return rt->forms[i];
}
}
return NULL;
}
// The caption of a program's form window ("" when it has none).
static const char *formTitle(const BasFormRtT *rt, const char *formName) {
const BasFormT *form = formOf(rt, formName);
return (form && form->window) ? form->window->title : "";
}
// The value of "CONST name = value" in BASIC source text, CONST_MISSING
// when it has none.
static int32_t includeConst(const char *text, const char *name) {
const char *p = includeConstValue(text, name);
if (!p) {
return CONST_MISSING;
}
// &H20 is hexadecimal, as in BASIC
if (p[0] == '&' && (p[1] == 'H' || p[1] == 'h')) {
return (int32_t)strtol(p + 2, NULL, HEXADECIMAL);
}
return (int32_t)strtol(p, NULL, DECIMAL);
}
// Whether "CONST name = "value"" in BASIC source text is that string.
static bool includeConstIs(const char *text, const char *name, const char *value) {
const char *p = includeConstValue(text, name);
size_t len = strlen(value);
return p && p[0] == '"' && strncmp(p + 1, value, len) == 0 && p[len + 1] == '"';
}
// Where the value of "CONST name = value" starts in BASIC source text,
// NULL when it has none.
static const char *includeConstValue(const char *text, const char *name) {
size_t nameLen = strlen(name);
for (const char *line = text; *line; ) {
const char *p = dvxSkipWs(line);
const char *end = strchr(line, '\n');
if (strncasecmp(p, BDT_KW_CONST, strlen(BDT_KW_CONST)) == 0) {
p = dvxSkipWs(p + strlen(BDT_KW_CONST));
if (strncasecmp(p, name, nameLen) == 0 && !basIsIdentChar(p[nameLen])) {
p = dvxSkipWs(p + nameLen);
if (*p == '=') {
return dvxSkipWs(p + 1);
}
}
}
line = end ? end + 1 : line + strlen(line);
}
return NULL;
}
// The index of keyword word in CompKeyword$'s list, -1 when it is not one.
static int32_t keywordIndex(const char *word) {
for (int32_t i = 0; i < CompKeywordCount(); i++) {
if (strcmp(CompKeyword(i), word) == 0) {
return i;
}
}
return NO_INDEX;
}
// Read and compile a project as bascomp does (validator: also scan its
// forms and check Control.Member names). NULL when it does not compile.
static BasModuleT *loadProject(const char *dbpPath, BasProjectSourceT *ps, BasValidatorT *validator) {
PrefsHandleT *prefs = NULL;
char dir[DVX_MAX_PATH];
BasCompileErrorT err;
BasCtrlValidatorT cb;
memset(ps, 0, sizeof(*ps));
if (validator) {
memset(validator, 0, sizeof(*validator));
basValidateCallbacks(validator, &cb);
}
if (!basBuildOpenProject(dbpPath, &prefs, dir, sizeof(dir))) {
return NULL;
}
bool ok = basBuildConcatProject(prefs, dir, ps);
BasModuleT *mod = NULL;
prefsClose(prefs);
if (!ok) {
return NULL;
}
for (int32_t i = 0; validator && i < (int32_t)arrlen(ps->frmTexts); i++) {
basValidateScanFrm(validator, ps->frmTexts[i], (int32_t)strlen(ps->frmTexts[i]), NULL, NULL);
}
mod = basBuildCompile(ps->source, ps->sourceLen, ps->optionExplicit, validator ? &cb : NULL, validator ? &validator->compiler : NULL, &err);
if (!mod) {
printf(" compile: %s\n", err.message);
}
return mod;
}
// True when res has resource name and, unless want is NULL, it is the
// text want (with its NUL, as the build writes text).
static bool resHas(DvxResHandleT *res, const char *name, const char *want) {
uint32_t size = 0;
char *data = res ? (char *)dvxResRead(res, name, &size) : NULL;
bool same = data && (!want || (size == strlen(want) + 1 && memcmp(data, want, size) == 0));
free(data);
return same;
}
static void textPrint(void *ctx, const char *text, bool newline) {
BdtTextT *t = (BdtTextT *)ctx;
if (text) {
t->len = basDbgAppendDropping(t->text, BDT_TEXT_MAX, t->len, text, (int32_t)strlen(text));
}
if (newline) {
t->len = basDbgAppendDropping(t->text, BDT_TEXT_MAX, t->len, "\n", 1);
}
}
// A debugger row as "cell|cell|cell\n".
static void textRow(void *ctx, const char *const *cells, int32_t cellCount) {
BdtTextT *t = (BdtTextT *)ctx;
for (int32_t i = 0; i < cellCount; i++) {
t->len = basDbgAppendDropping(t->text, BDT_TEXT_MAX, t->len, i > 0 ? "|" : "", i > 0 ? 1 : 0);
t->len = basDbgAppendDropping(t->text, BDT_TEXT_MAX, t->len, cells[i], (int32_t)strlen(cells[i]));
}
t->len = basDbgAppendDropping(t->text, BDT_TEXT_MAX, t->len, "\n", 1);
}
int main(void) {
setvbuf(stdout, NULL, _IOLBF, 0);
tSuiteBegin("basdev");
tProcessInit(DVXTEST_WIDGET_DIR);
caseCompileApi();
caseDesignControls();
caseIncludeConsts();
caseSourceApi();
caseProjectApi();
caseProjectControls();
caseCDebugger();
caseBasicIde();
return tSuiteEnd();
}
Reference in a new issue View git blame Copy permalink