Files
breeze/tests/sync_test_host.zi
T
waozi da20d1caca Port more storage, habit and breathing tests to Ziran; fix habit record merging and the legacy path list
Habit records from a sync response are now applied together, so habits sharing a name merge with their days instead of orphaning them. LegacyPaths now matches raylib's FilePathList so the legacy scan reads the real count.
2026-09-28 19:15:10 -03:00

176 lines
5.5 KiB
Ziran

#import, file "../src/app/app_clock_host.zi";
// Host functions the storage modules call that a test does not provide. It is
// built as a separate root so that no generated header declares them twice.
// The storage code logs through raylib's variadic TraceLog; the test drops
// the message and ignores the arguments.
#program_export "TraceLog"
host_trace_log :: (level: s32, format: *u8, arguments: *void) {
unused level
unused arguments
if format == null { return }
length: usize = 0
while format[length] != cast(u8)0 { length += 1 }
unused HostWrite(2, cast(*void)format, length)
unused HostWrite(2, cast(*void)*newline[0], 1)
}
newline: [1]u8 = .[10];
c :: #system_library "c";
HostOpen :: (path: *u8, mode: *u8) -> *void #foreign c "fopen";
HostClose :: (file: *void) -> s32 #foreign c "fclose";
HostRead :: (data: *void, size: usize, count: usize, file: *void) -> usize #foreign c "fread";
HostSeek :: (file: *void, offset: s64, origin: s32) -> s32 #foreign c "fseek";
HostTell :: (file: *void) -> s64 #foreign c "ftell";
HostAllocate :: (size: usize) -> *void #foreign c "malloc";
HostRelease :: (memory: *void) #foreign c "free";
HostWrite :: (descriptor: s32, data: *void, count: usize) -> s64 #foreign c "write";
read_mode: [3]u8;
// Reads a whole file into memory the caller releases with UnloadFileData.
#program_export "LoadFileData"
host_load_file_data :: (path: *u8, size: *s32) -> *u8 {
if size != null { size.* = 0 }
if path == null { return null }
read_mode[0] = cast(u8)114
read_mode[1] = cast(u8)98
read_mode[2] = cast(u8)0
file := HostOpen(path, *read_mode[0])
if file == null { return null }
if HostSeek(file, 0, 2) != 0 {
HostClose(file)
return null
}
length := HostTell(file)
if length < 0 || length > 2147483647 || HostSeek(file, 0, 0) != 0 {
HostClose(file)
return null
}
data := cast(*u8)HostAllocate(cast(usize)length + 1)
if data == null {
HostClose(file)
return null
}
if cast(s64)HostRead(cast(*void)data, 1, cast(usize)length, file) != length {
HostRelease(cast(*void)data)
HostClose(file)
return null
}
data[length] = cast(u8)0
HostClose(file)
if size != null { size.* = cast(s32)length }
return data
}
#program_export "UnloadFileData"
host_unload_file_data :: (data: *u8) {
HostRelease(cast(*void)data)
}
// Directory listing for legacy text sessions, as raylib's FilePathList.
PathList :: struct {
capacity: u32
count: u32
paths: **u8
}
HostPipeOpen :: (command: *u8, mode: *u8) -> *void #foreign c "popen";
HostPipeClose :: (pipe: *void) -> s32 #foreign c "pclose";
HostLine :: (buffer: *u8, size: s32, pipe: *void) -> *u8 #foreign c "fgets";
HostCopy :: (destination: *u8, source: *u8, size: usize) -> *u8 #foreign c "strncpy";
command_bytes: [1200]u8;
line_bytes: [1100]u8;
pipe_mode: [2]u8;
// Lists the regular files under `root` (recursively), one path each.
#program_export "LoadDirectoryFilesEx"
host_load_directory_files :: (root: *u8, filter: *u8, recursive: bool) -> PathList {
unused filter
unused recursive
list: PathList = PathList.{0, 0, null}
if root == null { return list }
prefix: string = "find \""
index: s64 = 0
while index < prefix.count {
command_bytes[index] = prefix[index]
index += 1
}
position: s64 = 0
while root[position] != cast(u8)0 && index < 1100 {
command_bytes[index] = root[position]
index += 1
position += 1
}
tail: string = "\" -type f 2>/dev/null"
position = 0
while position < tail.count {
command_bytes[index] = tail[position]
index += 1
position += 1
}
command_bytes[index] = cast(u8)0
pipe_mode[0] = cast(u8)114
pipe_mode[1] = cast(u8)0
pipe := HostPipeOpen(*command_bytes[0], *pipe_mode[0])
if pipe == null { return list }
capacity: usize = 4096
list.paths = cast(**u8)HostAllocate(capacity * cast(usize)8)
if list.paths == null {
HostPipeClose(pipe)
return list
}
list.capacity = cast(u32)capacity
while HostLine(*line_bytes[0], 1100, pipe) != null && cast(usize)list.count < capacity {
length: s32 = 0
while line_bytes[length] != cast(u8)0 && line_bytes[length] != cast(u8)10 { length += 1 }
line_bytes[length] = cast(u8)0
copy := cast(*u8)HostAllocate(cast(usize)length + 1)
if copy == null { break }
unused HostCopy(copy, *line_bytes[0], cast(usize)length + 1)
list.paths[list.count] = copy
list.count += 1
}
HostPipeClose(pipe)
return list
}
#program_export "UnloadDirectoryFiles"
host_unload_directory_files :: (paths: PathList) {
index: u32 = 0
while index < paths.count {
HostRelease(cast(*void)paths.paths[index])
index += 1
}
if paths.paths != null { HostRelease(cast(*void)paths.paths) }
}
#program_export "IsPathFile"
host_is_path_file :: (path: *u8) -> bool {
return path != null
}
// Application-level hooks the route and modal code calls; tests that reach
// them do not need their effects.
#program_export "app_leave_practice_config"
host_leave_practice_config :: (app: *void) {
unused app
}
#program_export "profile_social_load_friends_cache"
host_load_friends_cache :: (app: *void) {
unused app
}
#program_export "profile_social_load_leaderboard_cache"
host_load_leaderboard_cache :: (app: *void) {
unused app
}
#program_export "app_request_social_refresh"
host_request_social_refresh :: (app: *void) {
unused app
}