The codex-daochi-client-mesh-client-rename integration, committed as that task staged it: mesh_client replaces daochi_client, account storage and tests move to the Mesh names, and docs, locales and CI follow, with existing accounts, encrypted records and local storage kept compatible. The task stopped before its dependency versions were pushed; the next commit moves Breeze to the pushed pins it needs. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1214 lines
59 KiB
Ziran
1214 lines
59 KiB
Ziran
#import, file "lumi_apps_behavior.zi";
|
|
#import, file "habits_shop_apps_behavior.zi";
|
|
#import, file "habits_list_apps_behavior.zi";
|
|
#import, file "habits_stats_apps_behavior.zi";
|
|
#import, file "practice_home_apps_behavior.zi";
|
|
#import, file "practice_manual_apps_behavior.zi";
|
|
#import, file "practice_settings_apps_behavior.zi";
|
|
#import, file "practice_results_apps_behavior.zi";
|
|
#import, file "practice_sessions_apps_behavior.zi";
|
|
#import, file "apps_locale_behavior.zi";
|
|
#import, file "node_reload_apps_behavior.zi";
|
|
Packages :: #import, file "../src/apps/package_manager.zi";
|
|
#import, file "../src/apps/package_release.zi";
|
|
#import, file "../src/apps/node_apps.zi";
|
|
#import, file "../src/apps/catalog.zi";
|
|
#import, file "../src/apps/module_host.zi";
|
|
#import, file "../src/apps/asset_paths.zi";
|
|
#import, file "../src/apps/module_types.zi";
|
|
c_cache :: #system_library "c";
|
|
ModuleTestUseCache :: (enabled: bool) #foreign c_cache;
|
|
ModuleTestCachedReads :: (index: s32) -> s32 #foreign c_cache;
|
|
ModuleTestBundleOpens :: () -> s32 #foreign c_cache;
|
|
ModuleTestInstanceOpens :: () -> s32 #foreign c_cache;
|
|
ModuleTestCorruptCachedLists :: (enabled: bool) #foreign c_cache;
|
|
ModuleTestFailInstantiate :: () #foreign c_cache;
|
|
ModuleTestFailRun :: () #foreign c_cache;
|
|
ModuleTestSetRevision :: (index: s32, revision: s32) #foreign c_cache;
|
|
ModuleTestYield :: () #foreign c_cache;
|
|
ModuleTestBlockParser :: (enabled: bool) #foreign c_cache;
|
|
ModuleTestParserStarted :: () -> bool #foreign c_cache;
|
|
ModuleTestNow :: () -> float64 #foreign c_cache;
|
|
|
|
ModuleTestPrepare :: (index: s32, bytes: string) -> s32 {
|
|
result: s32 = 0
|
|
for attempt: 0..20000 {
|
|
result = AppsPreparePackage(index, bytes)
|
|
if result != 0 {
|
|
return result
|
|
}
|
|
ModuleTestYield()
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Download validation owns its parser until cancellation finishes. Polling a
|
|
// held parser must leave the visible app usable and return within a frame.
|
|
CheckNodePackagePreparation :: (bytes: string) {
|
|
slot := cast(s32)(NodeAppSlots - 1)
|
|
index := NodeAppIndex(slot)
|
|
saved_index := Packages.package_index
|
|
saved_release := Packages.package_release
|
|
saved_name := PackageText(NodeAppName(slot), "")
|
|
defer {
|
|
Packages.package_index = saved_index
|
|
Packages.package_release = saved_release
|
|
NodeAppAssign(slot, saved_name)
|
|
PackageFree(saved_name)
|
|
}
|
|
NodeAppAssign(slot, "parserprobe")
|
|
Packages.package_index = index
|
|
Packages.package_release.valid = true
|
|
unused DiaryTestHash(DiaryTestBytes(bytes), Packages.package_release.hash[:])
|
|
ModuleTestBlockParser(true)
|
|
Expect(AppsPreparePackage(index, bytes) == 0, 400)
|
|
for attempt: 0..5000 {
|
|
if ModuleTestParserStarted() { break }
|
|
ModuleTestYield()
|
|
}
|
|
Expect(ModuleTestParserStarted(), 401)
|
|
started := ModuleTestNow()
|
|
for frame: 0..99 {
|
|
Expect(AppsPreparePackage(index, bytes) == 0, 402)
|
|
}
|
|
AppsDiscardPreparation()
|
|
Expect(!AppsPreparationIdle() && ModuleTestNow() - started < 0.05, 403)
|
|
Expect(ListsRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList}).succeeded, 404)
|
|
ModuleTestBlockParser(false)
|
|
for attempt: 0..5000 {
|
|
if AppsPreparationIdle() { break }
|
|
ModuleTestYield()
|
|
}
|
|
Expect(AppsPreparationIdle(), 405)
|
|
// A Lists app is a valid ZX but cannot impersonate this node app.
|
|
Expect(ModuleTestPrepare(index, bytes) < 0 && AppsPreparationIdle(), 406)
|
|
}
|
|
|
|
#import, file "../src/apps/shared_state.zi";
|
|
#import, file "../src/apps/lists_types.zi";
|
|
#import, file "../src/apps/lists_visibility.zi";
|
|
#import, file "../src/apps/habits_types.zi";
|
|
#import, file "../src/apps/practice_types.zi";
|
|
#import, file "../src/apps/inbe_types.zi";
|
|
#import, file "../apps/diary/diary_types.zi";
|
|
Dates :: #import, file "../apps/diary/diary_date.zi";
|
|
#import, file "../src/apps/diary_store.zi";
|
|
#import, file "../src/apps/diary_records.zi";
|
|
#import, file "../src/apps/diary_blobs.zi";
|
|
#import, file "../src/apps/diary_photos.zi";
|
|
#import, file "../src/apps/media_store.zi";
|
|
#import, file "../src/apps/media_diary_photos.zi";
|
|
#import, file "../src/apps/entity_photos.zi";
|
|
#import, file "../src/storage/bundled_app_records.zi";
|
|
#import, file "../src/apps/package_files.zi";
|
|
#import, file "../src/app/app_types.zi";
|
|
#import, file "../src/core/types.zi";
|
|
#import, file "../src/core/breath_timing.zi";
|
|
#import, file "../src/practices/sun_salutation/sun_salutation_rules.zi";
|
|
#import, file "../src/storage/db.zi";
|
|
#import, file "../src/storage/data.zi";
|
|
#import, file "../src/storage/storage_core.zi";
|
|
#import, file "../src/storage/sync_state.zi";
|
|
#import, file "../src/storage/storage_settings.zi";
|
|
#import, file "../src/storage/storage_elist.zi";
|
|
#import, file "../src/storage/storage_habits.zi";
|
|
#import, file "../src/storage/storage_sessions.zi";
|
|
#import, file "../src/storage/state.zi";
|
|
#import, file "../src/storage/legacy_session_files.zi";
|
|
#import, file "../src/storage/legacy_session_time.zi";
|
|
#import, file "../src/storage/storage_thread_buffers.zi";
|
|
#import, file "../src/app/host_services.zi";
|
|
#import, file "../src/screens/elist_types.zi";
|
|
#import, file "../src/habits/habit_model.zi";
|
|
#import, file "../src/habits/habit_types.zi";
|
|
#import, file "../src/habits/habit_memory.zi";
|
|
#import, file "../src/app/text_buffers.zi";
|
|
#import, file "../src/app/app_size.zi";
|
|
#import "byte_text_linux"
|
|
#import "bundle_host"
|
|
#import "hosted_values"
|
|
#import "text_buffer"
|
|
#import "mesh_client/crypto"
|
|
#import, file "../src/app/assets.zi";
|
|
#import, file "../src/app/locale.zi";
|
|
#import, file "../src/storage/sync_node_storage.zi";
|
|
#import "file_linux"
|
|
#import, file "background_audio_stub.zi";
|
|
|
|
c :: #system_library "c";
|
|
ModuleTestText :: (name: string) -> string #foreign c;
|
|
ModuleTestCount :: (sql: string) -> s32 #foreign c;
|
|
ModuleTestSeedOld :: () -> bool #foreign c;
|
|
ModuleTestRuns :: () -> s32 #foreign c;
|
|
ModuleTestPackageBytes :: () -> bool #foreign c;
|
|
ModuleTestDiaryLockInheritance :: () -> bool #foreign c;
|
|
|
|
app: InnerBreeze;
|
|
list_id: [37]u8;
|
|
item_id: [37]u8;
|
|
long_item_title: [ELIST_TITLE_SIZE]u8;
|
|
long_item_comment: [ELIST_COMMENT_SIZE]u8;
|
|
user_id: [128]u8;
|
|
migrated_habit_id: [HABIT_ID_SIZE]u8;
|
|
edited_habit_id: [HABIT_ID_SIZE]u8;
|
|
failures: s32;
|
|
|
|
FindHabit :: (name: string) -> s32 {
|
|
index: s32 = 0
|
|
while index < app.habits.count {
|
|
if AppTextFromCString(*app.habits.items[index].name[0], HABIT_NAME_SIZE) == name {
|
|
return index
|
|
}
|
|
index += 1
|
|
}
|
|
return -1
|
|
}
|
|
|
|
Expect :: (ok: bool, code: s32) {
|
|
if !ok {
|
|
print("Module check failed: %\n", code)
|
|
if failures == 0 {
|
|
failures = code
|
|
}
|
|
}
|
|
}
|
|
|
|
CheckRootConfiguration :: () {
|
|
resources: [4]string = .["assets/lists/check.png", "assets/habits/leaf.png",
|
|
"assets/practices/breath.png", "assets/diary/calendar.png"]
|
|
kinds: [4]s32 = .[MODULE_LISTS, MODULE_HABITS, MODULE_PRACTICE, MODULE_DIARY]
|
|
for index: cast(s32)0..cast(s32)3 {
|
|
Expect(PackageResourceValid(resources[index], kinds[index]), 120 + index)
|
|
Expect(!PackageResourceValid(resources[index], kinds[(index + 1) % 4]), 124 + index)
|
|
}
|
|
unsafe: [8]string = .["assets/../apps/publishers.json", "assets//image.png",
|
|
"assets/image.png/", "/assets/image.png", "assets/./image.png",
|
|
"apps/publishers.json", "diary/2026-10-06.json", "assets/image:png"]
|
|
for index: cast(s32)0..cast(s32)7 {
|
|
Expect(!PackageResourceValid(unsafe[index], MODULE_INBE), 128 + index)
|
|
}
|
|
Expect(ModuleTestPackageBytes(), 74)
|
|
Expect(!AppsOpenPackage(""), 57)
|
|
Expect(!AppsOpenPackage(ModuleTestText("missing-assets")), 58)
|
|
Expect(!AppsOpenPackage(ModuleTestText("invalid-nested")), 59)
|
|
Expect(AppsOpenPackage(ModuleTestText("inbe")), 60)
|
|
// The apps open on their own threads; their assets read once they are open.
|
|
AppsFinishOpening()
|
|
Expect(AppsFeaturePackageSize(0) == ModuleTestText("inbe").count, 221)
|
|
names: [6]string = .["lists", "habits", "practice", "diary", "lumi", "leaderboard"]
|
|
for index: cast(s32)1..6 {
|
|
Expect(AppsFeaturePackageSize(index) == ModuleTestText(names[index - 1]).count, 222 + index)
|
|
}
|
|
Expect(AppsFeaturePackageSize(-1) == 0 && AppsFeaturePackageSize(7) == 0, 228)
|
|
size_text: [32]u8
|
|
Expect(AppBundleSizeText(66076, size_text[:]) &&
|
|
AppTextFromCString(*size_text[0], 32) == "66.1 kB", 230)
|
|
Expect(AppBundleSizeText(26131884, size_text[:]) &&
|
|
AppTextFromCString(*size_text[0], 32) == "26.1 MB", 231)
|
|
Expect(AppBundleSizeText(999950, size_text[:]) &&
|
|
AppTextFromCString(*size_text[0], 32) == "1.0 MB", 232)
|
|
Expect(!AppBundleSizeText(0, size_text[:]) && size_text[0] == cast(u8)0, 233)
|
|
// Practice pictures ship in each practice's pack; Wim Hof's pack ships
|
|
// with the app. Its card banner stays in Practices before installation.
|
|
shipped := AssetRead("assets/practices/default/whm.zx")
|
|
Expect(shipped.found && shipped.data.count > 8 && shipped.data[:2] == "ZX" &&
|
|
AssetRead("assets/practices/whm/banner-light.webp").found, 106)
|
|
language := AssetRead("locales/es.txt")
|
|
Expect(language.found && language.data.count > 1000, 107)
|
|
Expect(!AssetRead("apps/publishers.json").found, 108)
|
|
initial := InbeRun(InbeMessage.{.action = INBE_INITIAL_SCREEN,
|
|
.enabled_apps = APP_ALL, .screen = ScreenStart})
|
|
Expect(initial.succeeded && initial.screen == ScreenAudioSetup, 61)
|
|
initial.language_selected = true
|
|
initial = InbeRun(initial)
|
|
Expect(initial.succeeded && initial.screen == ScreenAppSelection, 62)
|
|
mask: s32 = 0
|
|
while mask <= APP_ALL {
|
|
Expect(AppsSetEnabled(mask) && AppsReady(), 63)
|
|
Expect(AppsInstalledMask() == APP_ALL, 219)
|
|
Expect(InbeAllows(ScreenLumi) &&
|
|
InbeAllows(ScreenEList) == ((mask & APP_LISTS) != 0) &&
|
|
InbeAllows(ScreenHabits) == ((mask & APP_HABITS) != 0) &&
|
|
InbeAllows(ScreenPatterns) == ((mask & APP_PRACTICE) != 0), 64)
|
|
Expect(InbeAllows(ScreenSettings) && InbeAllows(ScreenAppSelection), 65)
|
|
initial = InbeMessage.{.action = INBE_INITIAL_SCREEN,
|
|
.enabled_apps = mask, .screen = ScreenStart,
|
|
.language_selected = true, .apps_selected = true}
|
|
initial = InbeRun(initial)
|
|
expected: s32 = ScreenSettings
|
|
if (mask & APP_PRACTICE) != 0 {
|
|
expected = ScreenStart
|
|
} else if (mask & APP_LUMI) != 0 {
|
|
expected = ScreenLumi
|
|
} else if (mask & APP_HABITS) != 0 {
|
|
expected = ScreenHabits
|
|
} else if (mask & APP_LISTS) != 0 {
|
|
expected = ScreenEList
|
|
} else if (mask & APP_DIARY) != 0 {
|
|
expected = ScreenDiary
|
|
}
|
|
Expect(initial.succeeded && initial.screen == expected, 66)
|
|
if (mask & APP_LISTS) == 0 {
|
|
Expect(ListsRun(ListsMessage.{.action = LISTS_ROUTE,
|
|
.screen = ScreenEList}).succeeded, 67)
|
|
}
|
|
if (mask & APP_HABITS) == 0 {
|
|
Expect(HabitsRun(HabitsMessage.{.action = HABITS_ROUTE,
|
|
.screen = ScreenHabits}).succeeded, 68)
|
|
}
|
|
if (mask & APP_PRACTICE) == 0 {
|
|
Expect(PracticeRun(PracticeMessage.{.action = PRACTICE_ROUTE,
|
|
.screen = ScreenStart}).succeeded, 69)
|
|
}
|
|
mini := InbeRun(InbeMessage.{.action = INBE_MINI_CONFIGURE,
|
|
.enabled_apps = mask})
|
|
Expect(mini.succeeded && mini.enabled_apps == APP_PRACTICE &&
|
|
mini.screen == ScreenStart, 75)
|
|
Expect(AppsSetEnabled(mini.enabled_apps) &&
|
|
InbeAllows(ScreenStart) && !InbeAllows(ScreenEList), 76)
|
|
mini_session := PracticeRun(PracticeMessage.{
|
|
.action = PRACTICE_MEDITATION_STEP,
|
|
.remaining_seconds = 1, .elapsed_ms = 1000})
|
|
Expect(mini_session.succeeded && mini_session.completed, 77)
|
|
mask += 1
|
|
}
|
|
toggle := InbeRun(InbeMessage.{.action = INBE_TOGGLE_APP,
|
|
.enabled_apps = APP_ALL, .app = APP_PRACTICE, .checked = false})
|
|
Expect(toggle.succeeded && toggle.enabled_apps == (APP_ALL & ~APP_PRACTICE), 70)
|
|
toggle.app = APP_LISTS | APP_HABITS
|
|
Expect(!InbeRun(toggle).succeeded, 71)
|
|
Expect(AppsSetEnabled(APP_ALL), 72)
|
|
instances := ModuleTestInstanceOpens()
|
|
for frame: 0..199 {
|
|
unused frame
|
|
ready := ListsUiRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList})
|
|
root := InbeUiRun(InbeMessage.{.action = INBE_ROUTE, .screen = ScreenEList,
|
|
.enabled_apps = APP_ALL})
|
|
Expect(ready.succeeded && root.succeeded && root.allowed, 235)
|
|
}
|
|
Expect(ModuleTestInstanceOpens() == instances, 236)
|
|
ModuleTestFailRun()
|
|
failed := ListsUiRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList})
|
|
Expect(!failed.succeeded, 237)
|
|
ModuleTestFailInstantiate()
|
|
reset := ListsUiRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList})
|
|
Expect(!reset.succeeded && AppsReady(), 220)
|
|
recovered := ListsUiRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList})
|
|
Expect(recovered.succeeded && InbeAllows(ScreenEList), 238)
|
|
Expect(AppsFeaturePackageSize(1) == ModuleTestText("lists").count, 234)
|
|
runs := ModuleTestRuns()
|
|
Expect(InbeAllows(ScreenEList) && ModuleTestRuns() == runs + 2, 73)
|
|
}
|
|
|
|
CheckDiary :: () {
|
|
Expect(AppsValidatePackage(4, ModuleTestText("diary")), 80)
|
|
Expect(!AppsValidatePackage(4, ModuleTestText("habits")), 81)
|
|
// Diary may still be opening on its thread; frames must not reopen it.
|
|
AppsFinishOpening()
|
|
instances := ModuleTestInstanceOpens()
|
|
for frame: 0..49 {
|
|
unused frame
|
|
loaded := DiaryRun(DiaryMessage.{.action = DIARY_LOAD,
|
|
.year = 2024, .month = 2, .day = 28})
|
|
Expect(loaded.succeeded, 239)
|
|
}
|
|
Expect(ModuleTestInstanceOpens() == instances, 240)
|
|
state := DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 2, .day = 28})
|
|
Expect(state.succeeded && state.saved && !state.load_error && state.text == "", 82)
|
|
Expect(ModuleTestDiaryLockInheritance(), 491)
|
|
state.action = DIARY_EDIT
|
|
state.replacement = "A calm day 🌿\nSecond line"
|
|
state = DiaryRun(state)
|
|
Expect(state.succeeded && !state.saved && state.text == "A calm day 🌿\nSecond line", 83)
|
|
// Routing must not overwrite unsaved text held by the editor.
|
|
Expect(InbeAllows(ScreenDiary), 84)
|
|
state.action = DIARY_CONTROL
|
|
state.control = 29002
|
|
state = DiaryRun(state)
|
|
Expect(state.succeeded && state.day == 29 && state.month == 2 && state.saved, 85)
|
|
loaded := DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 2, .day = 28})
|
|
Expect(loaded.succeeded && loaded.text == "A calm day 🌿\nSecond line", 86)
|
|
loaded.action = DIARY_CONTROL
|
|
loaded.control = 29003
|
|
loaded = DiaryRun(loaded)
|
|
Expect(loaded.calendar && loaded.month_days == 29 && loaded.month_weekday == 3 && loaded.marks[28] == cast(u8)1, 87)
|
|
loaded.control = 29129
|
|
loaded = DiaryRun(loaded)
|
|
Expect(loaded.succeeded && !loaded.calendar && loaded.day == 29, 88)
|
|
Expect(!DiaryStoreSave("../outside.json", "invalid"), 89)
|
|
older := "{\"version\":1,\"date\":\"2024-03-01\",\"text\":\"Before\",\"photos\":[{\"file\":\"photo.png\",\"name\":\"Family\"}]}"
|
|
Expect(DiaryStoreSave("2024-03-01.json", older), 90)
|
|
// An older entry's photo is an embed after its text. Viewing the day
|
|
// writes nothing.
|
|
photo := DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 3, .day = 1})
|
|
Expect(photo.saved && photo.text == "Before\n\n" &&
|
|
photo.cursor == cast(s32)photo.text.count && DiaryStoreRead("2024-03-01.json").data == older, 460)
|
|
photo.action = DIARY_EDIT
|
|
photo.edit_start = 6
|
|
photo.edit_end = 6
|
|
photo.replacement = " after"
|
|
photo = DiaryRun(photo)
|
|
photo.action = DIARY_SAVE
|
|
photo = DiaryRun(photo)
|
|
// Saving keeps the photo for older versions in "photos", derived from
|
|
// the embeds.
|
|
Expect(photo.saved && photo.document == "{\"version\":1,\"date\":\"2024-03-01\",\"text\":\"Before after\\n\\n\",\"photos\":[{\"file\":\"photo.png\",\"name\":\"Family\"}]}", 91)
|
|
// A photo added to the media library is embedded by its place there, on
|
|
// its own line at the caret, and saved at once. Older versions do not
|
|
// list it: it is no Diary file.
|
|
photo.action = DIARY_ATTACH
|
|
photo.cursor = 12
|
|
photo.anchor = 12
|
|
photo.attachment_file = "photos/2024/03/01/9f2c4e1a7b3d5f60718293a4b5c6d7e8f90123456789abcdef0123456789abcd.png"
|
|
photo.attachment_name = "A second photo 🌿"
|
|
photo = DiaryRun(photo)
|
|
Expect(photo.succeeded && photo.saved &&
|
|
photo.text == "Before after\n\n\n" &&
|
|
photo.document == "{\"version\":1,\"date\":\"2024-03-01\",\"text\":\"Before after\\n\\n\\n\",\"photos\":[{\"file\":\"photo.png\",\"name\":\"Family\"}]}", 461)
|
|
// Deleting an embed's line takes the photo out of the entry everywhere.
|
|
photo.action = DIARY_EDIT
|
|
photo.edit_start = 12 + 1 + 110
|
|
photo.edit_end = cast(s32)photo.text.count
|
|
photo.replacement = ""
|
|
photo = DiaryRun(photo)
|
|
photo.action = DIARY_SAVE
|
|
photo = DiaryRun(photo)
|
|
Expect(photo.saved && photo.text == "Before after\n" &&
|
|
photo.document == "{\"version\":1,\"date\":\"2024-03-01\",\"text\":\"Before after\\n\",\"photos\":[]}", 463)
|
|
photo.action = DIARY_ATTACH
|
|
photo.attachment_file = "diary:../outside.bin"
|
|
photo.attachment_name = "Invalid"
|
|
photo = DiaryRun(photo)
|
|
Expect(!photo.succeeded && photo.text == "Before after\n", 464)
|
|
photo = DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 3, .day = 1})
|
|
Expect(photo.text == "Before after\n", 465)
|
|
// Older photo lists: brackets in names become spaces, a file listed
|
|
// twice is embedded once, and one the text embeds already is not added
|
|
// again. A photo an older version removed while its embed stayed comes
|
|
// back in "photos" on the next save.
|
|
Expect(DiaryStoreSave("2024-03-03.json", "{\"version\":1,\"date\":\"2024-03-03\",\"text\":\"x\\n\",\"photos\":[{\"file\":\"a.png\",\"name\":\"Fam[ily]\"},{\"file\":\"b.png\",\"name\":\"b\"},{\"file\":\"a.png\",\"name\":\"again\"}]}"), 466)
|
|
listed := DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 3, .day = 3})
|
|
Expect(listed.text == "x\n\n", 467)
|
|
Expect(DiaryStoreSave("2024-03-04.json", "{\"version\":1,\"date\":\"2024-03-04\",\"text\":\"\",\"photos\":[]}"), 468)
|
|
kept := DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 3, .day = 4})
|
|
kept.action = DIARY_EDIT
|
|
kept.edit_start = 0
|
|
kept.edit_end = 0
|
|
kept.replacement = "Walk\n"
|
|
kept = DiaryRun(kept)
|
|
kept.action = DIARY_SAVE
|
|
kept = DiaryRun(kept)
|
|
Expect(kept.saved && kept.document == "{\"version\":1,\"date\":\"2024-03-04\",\"text\":\"Walk\\n\",\"photos\":[{\"file\":\"p.png\",\"name\":\"p\"}]}", 469)
|
|
// Photos inside a line of text: an older list's photo embedded there is
|
|
// not added again, saving lists each one in text order, and a photo
|
|
// attached at the end of a photo's line gets a line of its own.
|
|
Expect(DiaryStoreSave("2024-03-05.json", "{\"version\":1,\"date\":\"2024-03-05\",\"text\":\"Walk  and  home\",\"photos\":[{\"file\":\"p.png\",\"name\":\"p\"}]}"), 470)
|
|
inline_day := DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 3, .day = 5})
|
|
Expect(inline_day.text == "Walk  and  home", 471)
|
|
inline_day.action = DIARY_EDIT
|
|
inline_day.edit_start = cast(s32)inline_day.text.count
|
|
inline_day.edit_end = inline_day.edit_start
|
|
inline_day.replacement = " today"
|
|
inline_day = DiaryRun(inline_day)
|
|
inline_day.action = DIARY_ATTACH
|
|
inline_day.attachment_file = "diary:r.png"
|
|
inline_day.attachment_name = "r"
|
|
inline_day = DiaryRun(inline_day)
|
|
Expect(inline_day.saved && inline_day.document == "{\"version\":1,\"date\":\"2024-03-05\",\"text\":\"Walk  and  home today\\n\\n\",\"photos\":[{\"file\":\"q.png\",\"name\":\"q\"},{\"file\":\"p.png\",\"name\":\"p\"},{\"file\":\"r.png\",\"name\":\"r\"}]}", 472)
|
|
// Text typed right after a photo keeps it in "photos".
|
|
inline_day.action = DIARY_EDIT
|
|
inline_day.edit_start = cast(s32)inline_day.text.count - 1
|
|
inline_day.edit_end = inline_day.edit_start
|
|
inline_day.replacement = " later"
|
|
inline_day = DiaryRun(inline_day)
|
|
inline_day.action = DIARY_SAVE
|
|
inline_day = DiaryRun(inline_day)
|
|
Expect(inline_day.saved && inline_day.text == "Walk  and  home today\n later\n" &&
|
|
inline_day.document == "{\"version\":1,\"date\":\"2024-03-05\",\"text\":\"Walk  and  home today\\n later\\n\",\"photos\":[{\"file\":\"q.png\",\"name\":\"q\"},{\"file\":\"p.png\",\"name\":\"p\"},{\"file\":\"r.png\",\"name\":\"r\"}]}", 473)
|
|
CheckDiaryPhotoOnFullNode()
|
|
CheckDiaryPhotoCopies()
|
|
CheckDiaryPhotosInLibrary()
|
|
Expect(DiaryStoreSave("2024-03-02.json", "damaged"), 92)
|
|
bad := DiaryRun(DiaryMessage.{.action = DIARY_LOAD, .year = 2024, .month = 3, .day = 2})
|
|
bad.action = DIARY_SAVE
|
|
Expect(bad.load_error && !DiaryRun(bad).succeeded, 93)
|
|
Expect(DiaryStoreRead("2024-03-02.json").data == "damaged", 94)
|
|
today := Dates.ParseDate(DiaryStoreClock()[:10])
|
|
tomorrow := Dates.Next(today, 1)
|
|
future := DiaryRun(DiaryMessage.{.action = DIARY_LOAD,
|
|
.year = tomorrow.year, .month = tomorrow.month, .day = tomorrow.day})
|
|
Expect(!future.succeeded, 410)
|
|
current := DiaryRun(DiaryMessage.{.action = DIARY_LOAD})
|
|
current.action = DIARY_EDIT
|
|
current.replacement = "Today's unsaved entry"
|
|
current = DiaryRun(current)
|
|
current.action = DIARY_CONTROL
|
|
current.control = 29002
|
|
current = DiaryRun(current)
|
|
Expect(!current.succeeded && current.day == today.day &&
|
|
current.month == today.month && current.year == today.year &&
|
|
current.text == "Today's unsaved entry" && !current.saved, 411)
|
|
current.control = 29003
|
|
current = DiaryRun(current)
|
|
current.control = 29012
|
|
current = DiaryRun(current)
|
|
Expect(!current.succeeded && current.calendar &&
|
|
current.month_year == today.year && current.month_number == today.month, 412)
|
|
if tomorrow.month == today.month {
|
|
current.control = 29100 + tomorrow.day
|
|
current = DiaryRun(current)
|
|
Expect(!current.succeeded && current.calendar && current.day == today.day, 413)
|
|
}
|
|
Expect(Dates.OnOrBefore(Dates.Date.{2024, 2, 29}, Dates.Date.{2024, 3, 1}) &&
|
|
!Dates.OnOrBefore(Dates.Date.{2024, 3, 1}, Dates.Date.{2024, 2, 29}) &&
|
|
!Dates.OnOrBefore(Dates.Date.{2023, 2, 29}, Dates.Date.{2024, 3, 1}) &&
|
|
Dates.OnOrBefore(Dates.Date.{2025, 12, 31}, Dates.Date.{2026, 1, 1}), 414)
|
|
current.action = DIARY_SAVE
|
|
current = DiaryRun(current)
|
|
Expect(current.saved && current.succeeded, 415)
|
|
original_owner := PackageText(AppTextFromCString(storage_user_id_buffer(), 64), "")
|
|
legacy := DiaryLegacyDirectory()
|
|
other: string = "different-diary-account"
|
|
AppCopyText(other, g_storage.user_id[:])
|
|
Expect(DiaryStoreRead("2024-02-28.json").missing, 416)
|
|
Expect(!DiaryStoreImportOwned(legacy), 417)
|
|
AppCopyText(original_owner, g_storage.user_id[:])
|
|
Expect(DiaryStoreRead("2024-02-28.json").data.count > 0, 418)
|
|
PackageFree(original_owner)
|
|
PackageFree(legacy)
|
|
|
|
}
|
|
|
|
// A photo always saves on this device: a sync node that reports no room
|
|
// only keeps the photo from syncing there.
|
|
CheckDiaryPhotoOnFullNode :: () {
|
|
node := "https://api.waozi.xyz"
|
|
sync_was_enabled := storage_sync_enabled()
|
|
storage_set_sync_enabled(1)
|
|
storage_set_setting_text("sync_server_url", node)
|
|
Expect(SyncNodeStorageRecordFull(node, "{\"code\":\"storage_full\",\"account_storage\":{\"used_bytes\":10485000,\"limit_bytes\":10485760}}") &&
|
|
SyncNodeStorageRead(node).full, 419)
|
|
png: [4096]u8
|
|
header: [8]u8 = .[cast(u8)137, cast(u8)80, cast(u8)78, cast(u8)71, cast(u8)13, cast(u8)10, cast(u8)26, cast(u8)10]
|
|
for index: cast(s32)0..cast(s32)4095 {
|
|
png[index] = ifx index < 8 then header[index] else cast(u8)(index % 251)
|
|
}
|
|
image := TextFromBytes(png[:])
|
|
source := "full-node-photo.png"
|
|
unused RemoveFile(source)
|
|
file := OpenExclusivePrivate(source)
|
|
written := file.valid && WriteTextAt(file, image, 0) == image.count
|
|
Expect(CloseFile(file) && written, 420)
|
|
name := DiaryStoreAttach(source)
|
|
Expect(name.count > 0 && DiaryStoreRead(name).data == image, 421)
|
|
PackageFree(name)
|
|
unused RemoveFile(source)
|
|
storage_set_setting_text("sync_server_url", "")
|
|
storage_set_sync_enabled(sync_was_enabled)
|
|
}
|
|
|
|
DiaryTestImage :: (bytes: []u8, seed: s32) -> string {
|
|
header: [8]u8 = .[cast(u8)137, cast(u8)80, cast(u8)78, cast(u8)71, cast(u8)13, cast(u8)10, cast(u8)26, cast(u8)10]
|
|
for index: cast(s32)0..cast(s32)bytes.count - 1 {
|
|
bytes[index] = ifx index < 8 then header[index] else cast(u8)((index * 7 + seed) % 251)
|
|
}
|
|
return TextFromBytes(bytes)
|
|
}
|
|
|
|
DiaryTestBytes :: (text: string) -> []u8 {
|
|
descriptor := cast(*TextDescriptor)(*text)
|
|
return BytesFromPointer(descriptor.data, cast(u64)text.count)
|
|
}
|
|
|
|
DiaryTestHash :: (data: []u8, output: []u8) -> string {
|
|
storage_sha256_hex(*data[0], cast(s64)data.count, *output[0])
|
|
return TextFromCString(*output[0])
|
|
}
|
|
|
|
// The pass's job for one photo's original, on any node or on the node at
|
|
// `node`, or 0; other Diary tests leave photos too.
|
|
DiaryTestNodeJob :: (pass: *DiaryBlobPass, key: string, node: string) -> s32 {
|
|
for index: cast(s32)0..pass.count - 1 {
|
|
address: [256]u8
|
|
unused DiaryBlobNode(pass, pass.jobs[index].node, address[:])
|
|
if TextUntilNul(pass.jobs[index].key[:]) == key && !pass.jobs[index].preview &&
|
|
(node.count == 0 || TextUntilNul(address[:]) == node) {
|
|
return pass.jobs[index].kind
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
DiaryTestJob :: (pass: *DiaryBlobPass, key: string) -> s32 {
|
|
return DiaryTestNodeJob(pass, key, "")
|
|
}
|
|
|
|
// The pass's request for one photo's original, skipping the others.
|
|
DiaryTestNext :: (pass: *DiaryBlobPass, request: *DiaryBlobRequest, key: string) -> bool {
|
|
while DiaryBlobNext(pass, request) {
|
|
if TextUntilNul(request.key[:]) == key && !request.preview {
|
|
return true
|
|
}
|
|
DiaryBlobAbandon(request)
|
|
DiaryBlobJobDone(pass)
|
|
}
|
|
return false
|
|
}
|
|
|
|
DiaryTestChunks :: (hash: string) -> EntityContent {
|
|
record := MediaEntityRecord(hash)
|
|
defer { PackageFree(record) }
|
|
return EntityPhotoContent(record)
|
|
}
|
|
|
|
// A photo travels as the account's entity data, sealed in chunks of its
|
|
// size plus 16 bytes, to a node and back to the account's devices.
|
|
CheckDiaryPhotoCopies :: () {
|
|
node := "https://copies.test"
|
|
sync_was_enabled := storage_sync_enabled()
|
|
storage_set_sync_enabled(1)
|
|
storage_set_setting_text("sync_server_url", node)
|
|
// The account key lets this device seal chunks.
|
|
private: [5121]u8
|
|
for index: cast(s32)0..cast(s32)5119 {
|
|
private[index] = ifx index % 2 == 0 then #char "a" else #char "7"
|
|
}
|
|
storage_set_setting_text(STORAGE_SYNC_PRIVATE_KEY_KEY, TextFromBytes(private[:5120]))
|
|
png: [3000]u8
|
|
image := DiaryTestImage(png[:], 3)
|
|
added := MediaImportBytes(image, "copied-photo.png")
|
|
Expect(added.succeeded && !added.existed, 430)
|
|
hash_text: [65]u8
|
|
hash := DiaryTestHash(png[:], hash_text[:])
|
|
key := EntityPhotoKey(hash)
|
|
Expect(TextFromBytes(added.hash[:64]) == hash, 431)
|
|
content := DiaryTestChunks(hash)
|
|
Expect(content.valid && content.chunk_count == 0 && content.size == 3000, 432)
|
|
no_copies := PackageText(PackageText("SELECT COUNT(*) FROM settings WHERE key GLOB 'cell.diary.chunk.", hash), ".*' OR key GLOB 'cell.media.*'")
|
|
Expect(ModuleTestCount(no_copies) == 0, 433)
|
|
PackageFree(no_copies)
|
|
// A pass seals and uploads it, then its record names the chunk.
|
|
pass: DiaryBlobPass
|
|
request: DiaryBlobRequest
|
|
Expect(DiaryBlobPlan(*pass, node) && DiaryTestJob(*pass, key) == DIARY_BLOB_UPLOAD, 434)
|
|
Expect(DiaryTestNext(*pass, *request, key) && request.method == "PUT" &&
|
|
request.body.count == image.count + 16 && request.body != image, 435)
|
|
sealed := PackageText(request.body, "")
|
|
blob_text: [65]u8
|
|
blob := DiaryTestHash(DiaryTestBytes(sealed), blob_text[:])
|
|
blob_path := PackageText("/api/v1/blobs/entity/", blob)
|
|
Expect(TextUntilNul(request.path[:]) == blob_path, 436)
|
|
Expect(DiaryBlobFinish(*pass, *request, 204, png[0:0]), 437)
|
|
DiaryBlobPassEnd(*pass)
|
|
content = DiaryTestChunks(hash)
|
|
Expect(content.chunk_count == 1 && TextUntilNul(content.chunks[0].address[:]) == blob &&
|
|
content.chunks[0].size == 3016, 438)
|
|
unused DiaryBlobPlan(*pass, node)
|
|
Expect(DiaryTestJob(*pass, key) == 0, 439)
|
|
DiaryBlobPassEnd(*pass)
|
|
// Another device of the account has only the record: the photo is not
|
|
// on the device until its chunks arrive, opened and checked.
|
|
path := MediaPath(hash, false)
|
|
unused RemoveFile(path)
|
|
MediaWant(hash)
|
|
Expect(!PathExists(path), 440)
|
|
Expect(DiaryBlobPlan(*pass, node) && DiaryTestJob(*pass, key) == DIARY_BLOB_DOWNLOAD, 441)
|
|
Expect(DiaryTestNext(*pass, *request, key) && request.method == "GET" &&
|
|
request.answer_bytes == sealed.count + 1, 442)
|
|
tampered := PackageText(sealed, "")
|
|
changed := DiaryTestBytes(tampered)
|
|
changed[20] = cast(u8)((cast(s32)changed[20] + 1) % 256)
|
|
generation := diary_blob_generation
|
|
Expect(DiaryBlobFinish(*pass, *request, 200, changed) &&
|
|
!PathExists(path) && diary_blob_generation == generation, 443)
|
|
DiaryBlobPassEnd(*pass)
|
|
Expect(DiaryBlobPlan(*pass, node) && DiaryTestNext(*pass, *request, key) &&
|
|
DiaryBlobFinish(*pass, *request, 404, png[0:0]) && !PathExists(path), 444)
|
|
DiaryBlobPassEnd(*pass)
|
|
Expect(DiaryBlobPlan(*pass, node) && DiaryTestNext(*pass, *request, key) &&
|
|
DiaryBlobFinish(*pass, *request, 200, DiaryTestBytes(sealed)) && diary_blob_generation > generation, 445)
|
|
DiaryBlobPassEnd(*pass)
|
|
Expect(PackageRead(path, DIARY_FILE_LIMIT) == image, 446)
|
|
// A new node gets the same chunk once.
|
|
other := "https://other-copies.test"
|
|
Expect(DiaryBlobPlan(*pass, other) && DiaryTestNodeJob(*pass, key, other) == DIARY_BLOB_UPLOAD, 447)
|
|
while DiaryTestNext(*pass, *request, key) && TextUntilNul(request.node[:]) != other {
|
|
DiaryBlobAbandon(*request)
|
|
DiaryBlobJobDone(*pass)
|
|
}
|
|
Expect(request.body == sealed, 448)
|
|
Expect(DiaryBlobFinish(*pass, *request, 204, png[0:0]), 449)
|
|
DiaryBlobPassEnd(*pass)
|
|
unused DiaryBlobPlan(*pass, other)
|
|
Expect(DiaryTestNodeJob(*pass, key, other) == 0, 459)
|
|
DiaryBlobPassEnd(*pass)
|
|
// A node without photo upload receives none; a full one stops uploads
|
|
// to it alone.
|
|
third := "https://third-copies.test"
|
|
Expect(SyncNodeSetMediaUpload(third, false), 450)
|
|
unused DiaryBlobPlan(*pass, third)
|
|
Expect(DiaryTestNodeJob(*pass, key, third) == 0, 450)
|
|
DiaryBlobPassEnd(*pass)
|
|
Expect(SyncNodeSetMediaUpload(third, true) && DiaryBlobPlan(*pass, third) &&
|
|
DiaryTestNodeJob(*pass, key, third) == DIARY_BLOB_UPLOAD, 451)
|
|
while DiaryTestNext(*pass, *request, key) && TextUntilNul(request.node[:]) != third {
|
|
DiaryBlobAbandon(*request)
|
|
DiaryBlobJobDone(*pass)
|
|
}
|
|
full := "{\"code\":\"storage_full\",\"account_storage\":{\"used_bytes\":20971000,\"limit_bytes\":20971520}}"
|
|
full_text := PackageText(full, "")
|
|
Expect(DiaryBlobFinish(*pass, *request, 413, DiaryTestBytes(full_text)) &&
|
|
pass.stopped[request.node_index] && SyncNodeStorageRead(third).full, 452)
|
|
DiaryBlobPassEnd(*pass)
|
|
PackageFree(full_text)
|
|
PackageFree(tampered)
|
|
PackageFree(blob_path)
|
|
PackageFree(sealed)
|
|
PackageFree(path)
|
|
PackageFree(key)
|
|
storage_set_setting_text(STORAGE_SYNC_PRIVATE_KEY_KEY, "")
|
|
storage_set_setting_text("sync_server_url", "")
|
|
storage_set_sync_enabled(sync_was_enabled)
|
|
}
|
|
|
|
// A Diary photo attached to a Diary file, saved, as older versions attach
|
|
// them; the caller frees its name.
|
|
DiaryLibraryAttach :: (bytes: []u8, seed: s32, source: string) -> string {
|
|
image := DiaryTestImage(bytes, seed)
|
|
unused RemoveFile(source)
|
|
file := OpenExclusivePrivate(source)
|
|
written := file.valid && WriteTextAt(file, image, 0) == image.count
|
|
Expect(CloseFile(file) && written, 480)
|
|
name := DiaryStoreAttach(source)
|
|
unused RemoveFile(source)
|
|
Expect(name.count > 0, 481)
|
|
return name
|
|
}
|
|
|
|
DiaryLibraryRun :: () {
|
|
for step: 0..63 {
|
|
unused step
|
|
unused MediaDiaryPhotosStep()
|
|
}
|
|
}
|
|
|
|
DiaryLibraryRecord :: (hash: string) -> string {
|
|
return MediaEntityRecord(hash)
|
|
}
|
|
|
|
// Photos older versions attached to Diary entries move to the account's
|
|
// entity data, which Photos shows, under the entry's day and with the
|
|
// entry's name. A Diary file no entry includes stays out, a photo in Trash
|
|
// stays there, and looking again changes nothing.
|
|
CheckDiaryPhotosInLibrary :: () {
|
|
first: [2600]u8
|
|
second: [2700]u8
|
|
orphan: [2800]u8
|
|
trashed: [2900]u8
|
|
later: [3100]u8
|
|
first_name := DiaryLibraryAttach(first[:], 11, "library-first.png")
|
|
second_name := DiaryLibraryAttach(second[:], 12, "library-second.png")
|
|
orphan_name := DiaryLibraryAttach(orphan[:], 13, "library-orphan.png")
|
|
trashed_name := DiaryLibraryAttach(trashed[:], 14, "library-trashed.png")
|
|
later_name := DiaryLibraryAttach(later[:], 15, "library-later.png")
|
|
first_hash_text: [65]u8
|
|
second_hash_text: [65]u8
|
|
orphan_hash_text: [65]u8
|
|
trashed_hash_text: [65]u8
|
|
later_hash_text: [65]u8
|
|
first_hash := DiaryTestHash(first[:], first_hash_text[:])
|
|
second_hash := DiaryTestHash(second[:], second_hash_text[:])
|
|
orphan_hash := DiaryTestHash(orphan[:], orphan_hash_text[:])
|
|
trashed_hash := DiaryTestHash(trashed[:], trashed_hash_text[:])
|
|
later_hash := DiaryTestHash(later[:], later_hash_text[:])
|
|
// One entry lists its photo, as older versions save it; another only
|
|
// embeds one in its text, as after an older version's Remove button.
|
|
first_out: Vec(u8)
|
|
BuilderPrint(*first_out, "{\"version\":1,\"date\":\"2024-04-02\",\"text\":\"Walk\",\"photos\":[{\"file\":\"%\",\"name\":\"IMG_2041.png\"}]}", first_name)
|
|
first_entry := BuilderFinish(first_out)
|
|
second_out: Vec(u8)
|
|
BuilderPrint(*second_out, "{\"version\":1,\"date\":\"2024-04-03\",\"text\":\"Tea\\n\\n\",\"photos\":[]}", second_name)
|
|
second_entry := BuilderFinish(second_out)
|
|
third_out: Vec(u8)
|
|
BuilderPrint(*third_out, "{\"version\":1,\"date\":\"2024-04-04\",\"text\":\"Rain\",\"photos\":[{\"file\":\"%\",\"name\":\"Rain\"},{\"file\":\"%\",\"name\":\"Later\"}]}", trashed_name, later_name)
|
|
third_entry := BuilderFinish(third_out)
|
|
Expect(DiaryStoreSave("2024-04-02.json", first_entry) && DiaryStoreSave("2024-04-03.json", second_entry) &&
|
|
DiaryStoreSave("2024-04-04.json", third_entry), 482)
|
|
// A photo the person moved to Trash in Photos stays there.
|
|
trashed_image := TextFromBytes(trashed[:])
|
|
Expect(MediaImportBytes(trashed_image, "Rain in Photos.png").succeeded &&
|
|
MediaSetTrashed(trashed_hash, true), 483)
|
|
trashed_record := DiaryLibraryRecord(trashed_hash)
|
|
// A photo whose file has not arrived on this device waits for it.
|
|
later_path := DiaryStorePath(later_name)
|
|
unused RemoveFile(later_path)
|
|
DiaryLibraryRun()
|
|
first_item := MediaRead(first_hash)
|
|
Expect(first_item.valid && !first_item.trashed && TextUntilNul(first_item.day[:]) == "2024-04-02" &&
|
|
TextUntilNul(first_item.taken[:]) == "2024-04-02" &&
|
|
TextUntilNul(first_item.name[:]) == "IMG_2041.png", 484)
|
|
second_item := MediaRead(second_hash)
|
|
Expect(second_item.valid && TextUntilNul(second_item.day[:]) == "2024-04-03" &&
|
|
TextUntilNul(second_item.name[:]) == "Tea cup", 485)
|
|
first_path := MediaPath(first_hash, false)
|
|
Expect(PackageRead(first_path, DIARY_FILE_LIMIT) == TextFromBytes(first[:]), 486)
|
|
Expect(!MediaRead(orphan_hash).valid && !MediaRead(later_hash).valid, 487)
|
|
trashed_now := DiaryLibraryRecord(trashed_hash)
|
|
Expect(trashed_now == trashed_record && MediaRead(trashed_hash).trashed, 488)
|
|
// Diary files of other checks belong to no entry either; the photo the
|
|
// copies check added is the fourth.
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM settings WHERE key GLOB 'entity.photos.*' AND length(key)=78") == 4, 489)
|
|
Expect(DiaryStoreRead("2024-04-02.json").data == first_entry &&
|
|
DiaryStoreRead("2024-04-03.json").data == second_entry, 490)
|
|
// The entry's Diary file draws as the library's photo, so Diary's day
|
|
// lists that picture once.
|
|
diary_asset := PackageText(DiaryPhotoAsset(PackageText("diary:", first_name)), "")
|
|
place := MediaPlace(first_item)
|
|
Expect(diary_asset.count > 0 && diary_asset[:6] == "media/" && DiaryPhotoAsset(place) == diary_asset, 491)
|
|
// Its file arrives from a node.
|
|
Expect(PackageWrite(later_path, TextFromBytes(later[:])), 492)
|
|
diary_blob_generation += 1
|
|
DiaryLibraryRun()
|
|
later_item := MediaRead(later_hash)
|
|
Expect(later_item.valid && TextUntilNul(later_item.day[:]) == "2024-04-04" &&
|
|
TextUntilNul(later_item.name[:]) == "Later", 493)
|
|
// Looking again, as after a sync or a restart, changes nothing.
|
|
first_record := DiaryLibraryRecord(first_hash)
|
|
second_record := DiaryLibraryRecord(second_hash)
|
|
later_record := DiaryLibraryRecord(later_hash)
|
|
MediaDiaryPhotosDue()
|
|
DiaryLibraryRun()
|
|
media_diary_seen_valid = false
|
|
MediaDiaryPhotosDue()
|
|
DiaryLibraryRun()
|
|
first_again := DiaryLibraryRecord(first_hash)
|
|
second_again := DiaryLibraryRecord(second_hash)
|
|
later_again := DiaryLibraryRecord(later_hash)
|
|
trashed_again := DiaryLibraryRecord(trashed_hash)
|
|
Expect(first_again == first_record && second_again == second_record && later_again == later_record &&
|
|
trashed_again == trashed_record, 494)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM settings WHERE key GLOB 'entity.photos.*' AND length(key)=78") == 5, 495)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM settings WHERE key GLOB 'cell.media.*'") == 0, 499)
|
|
// The library's file is the Diary file, linked, not a second copy: a
|
|
// byte changed in place in one shows in the other.
|
|
diary_path := DiaryStorePath(first_name)
|
|
handle := OpenUpdate(diary_path)
|
|
marked: [1]u8 = .[cast(u8)7]
|
|
Expect(handle.valid && first[100] != cast(u8)7 && WriteAt(handle, marked[:], 100) == 1, 496)
|
|
linked := PackageRead(first_path, DIARY_FILE_LIMIT)
|
|
Expect(linked.count == first.count && linked[100] == cast(u8)7, 497)
|
|
marked[0] = first[100]
|
|
Expect(WriteAt(handle, marked[:], 100) == 1 && CloseFile(handle), 498)
|
|
PackageFree(linked)
|
|
PackageFree(diary_path)
|
|
PackageFree(first_again)
|
|
PackageFree(second_again)
|
|
PackageFree(later_again)
|
|
PackageFree(trashed_again)
|
|
PackageFree(first_record)
|
|
PackageFree(second_record)
|
|
PackageFree(later_record)
|
|
PackageFree(diary_asset)
|
|
PackageFree(place)
|
|
PackageFree(first_path)
|
|
PackageFree(trashed_now)
|
|
PackageFree(trashed_record)
|
|
PackageFree(later_path)
|
|
PackageFree(first_entry)
|
|
PackageFree(second_entry)
|
|
PackageFree(third_entry)
|
|
PackageFree(first_name)
|
|
PackageFree(second_name)
|
|
PackageFree(orphan_name)
|
|
PackageFree(trashed_name)
|
|
PackageFree(later_name)
|
|
}
|
|
|
|
CheckPackagedLocales :: () {
|
|
Expect(LocaleLanguageCount() == 10, 200)
|
|
Expect(!LocaleSupports("id") && !LocaleSupports("it") && LocaleSupports("pt"), 202)
|
|
for index: cast(s32)0..LocaleLanguageCount() - 1 {
|
|
Expect(PackagedLocaleMatches(LocaleLanguageAt(index).code), 201 + index)
|
|
}
|
|
// Leave a populated Japanese cache pointing into the old root, then
|
|
// replace it with freshly allocated package assets without switching locale.
|
|
Expect(LocaleUse("ja"), 213)
|
|
previous := LocaleText("close_button")
|
|
Expect(previous == "閉じる", 214)
|
|
Expect(AppsOpenPackage(ModuleTestText("inbe")), 215)
|
|
Expect(LocaleActiveCode() == "ja" && LocaleText("close_button") == "閉じる", 216)
|
|
Expect(PackagedLocaleMatches("ja"), 217)
|
|
Expect(LocaleUse("en"), 218)
|
|
}
|
|
|
|
#program_export
|
|
CheckModules :: () -> s32 {
|
|
lists := ModuleTestText("lists")
|
|
habits := ModuleTestText("habits")
|
|
practice := ModuleTestText("practice")
|
|
Expect(!AppsOpenBytes("", habits, practice), 1)
|
|
Expect(!AppsOpenBytes(lists, "ZX", practice), 2)
|
|
Expect(!AppsOpenBytes(habits, lists, practice), 3)
|
|
// Bind the actual shared persistence effects without opening user data.
|
|
unused AppsStart(*app)
|
|
// Exercise current package-qualified widget imports before opening the
|
|
// complete root. Unsupported effects must still be rejected.
|
|
diagnostic_bytes: [2]string = .[practice, ModuleTestText("inbe")]
|
|
diagnostic_kinds: [2]s32 = .[MODULE_PRACTICE, MODULE_INBE]
|
|
for diagnostic_index: cast(s32)0..1 {
|
|
bytes := diagnostic_bytes[diagnostic_index]
|
|
diagnostic_bundle := OpenBundleBytes(HostTextData(bytes), cast(u64)bytes.count)
|
|
Expect(diagnostic_bundle != null, 234)
|
|
if diagnostic_bundle != null {
|
|
diagnostic_slot := ModuleSlot.{.kind = diagnostic_kinds[diagnostic_index]}
|
|
for capability: cast(u64)0..BundleCapabilities(diagnostic_bundle) - cast(u64)1 {
|
|
module_name := TextFromCString(BundleCapabilityModuleName(diagnostic_bundle, capability))
|
|
function_name := TextFromCString(BundleCapabilityFunctionName(diagnostic_bundle, capability))
|
|
allowed := ModuleAllows(cast(*void)(*diagnostic_slot), module_name, function_name)
|
|
if !allowed {
|
|
print("Unsupported package capability: %.%\n", module_name, function_name)
|
|
}
|
|
Expect(allowed, 235)
|
|
}
|
|
Expect(!ModuleAllows(cast(*void)(*diagnostic_slot), "untrusted", "WriteInbeHost"), 236)
|
|
CloseBundle(diagnostic_bundle)
|
|
}
|
|
}
|
|
Expect(AppsOpenBytes(lists, habits, practice), 4)
|
|
Expect(AppsFeaturePackageSize(1) == lists.count && AppsFeaturePackageSize(2) == habits.count &&
|
|
AppsFeaturePackageSize(3) == practice.count && AppsFeaturePackageSize(4) == 0, 229)
|
|
Expect(AppsRoute(ScreenEList) && AppsRoute(ScreenHabits) &&
|
|
AppsRoute(ScreenStart) && AppsRoute(ScreenMeditation) &&
|
|
!AppsRoute(ScreenSettings), 5)
|
|
CheckRootConfiguration()
|
|
CheckPackagedLocales()
|
|
Expect(ModuleTestSeedOld(), 6)
|
|
data_init()
|
|
Expect(storage_db_handle() != null, 7)
|
|
CheckNodeReloadRevisions(Expect)
|
|
AppCopyText(AppTextFromCString(storage_user_id_buffer(), 128), user_id[:])
|
|
CheckDiary()
|
|
habits_init_with_defaults(*app.habits, 0)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM sessions WHERE id='old-session'") == 1, 8)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM settings WHERE key='language' AND value='es'") == 1, 9)
|
|
// The existing upgrade rewrites non-UUID IDs together with their day rows.
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM habits h JOIN habit_days d ON d.habit_id=h.id WHERE h.name='Old habit' AND h.user_id='module-user' AND length(h.id)=36 AND h.id<>'old-habit' AND d.local_date=20260925 AND d.completed=1 AND d.count=1") == 1, 10)
|
|
old_index := FindHabit("Old habit")
|
|
Expect(old_index >= 0, 44)
|
|
if old_index >= 0 {
|
|
AppCopyText(AppTextFromCString(*app.habits.items[old_index].id[0], HABIT_ID_SIZE), migrated_habit_id[:])
|
|
}
|
|
|
|
edit := ListsMessage.{.action = LISTS_COMMIT, .editing_item = -2, .title = "Trip"}
|
|
edit = ListsRun(edit)
|
|
Expect(edit.succeeded && edit.reload && edit.sync, 11)
|
|
AppCopyText(edit.selected_id, list_id[:])
|
|
unused storage_elist_load(cast(*void)*app.elist)
|
|
Expect(app.elist.list_count == 1, 12)
|
|
rename := ListsMessage.{.action = LISTS_COMMIT, .editing_item = -3,
|
|
.selected_list = 0, .list_count = 1,
|
|
.selected_id = AppTextFromCString(*list_id[0], 37),
|
|
.id = "00000000-0000-0000-0000-000000000000",
|
|
.title = "Trip renamed"}
|
|
rename = ListsRun(rename)
|
|
Expect(!rename.succeeded && rename.editing_item == -3 &&
|
|
rename.title == "Trip renamed" && !rename.reset_input, 275)
|
|
rename.id = AppTextFromCString(*list_id[0], 37)
|
|
rename = ListsRun(rename)
|
|
Expect(rename.succeeded && rename.editing_item == -1 && rename.reset_input, 276)
|
|
edit = ListsMessage.{.action = LISTS_COMMIT, .editing_item = -1,
|
|
.selected_list = 0, .list_count = 1, .selected_id = AppTextFromCString(*list_id[0], 37),
|
|
.title = "Passport"}
|
|
Expect(ListsRun(edit).succeeded, 13)
|
|
long_title := "Long title "
|
|
for index: cast(s32)0..long_title.count - 1 {
|
|
long_item_title[index] = long_title[index]
|
|
}
|
|
for index: cast(s32)0..4999 {
|
|
long_item_title[long_title.count + index] = cast(u8)#char "x"
|
|
}
|
|
long_description := "Long description "
|
|
for index: cast(s32)0..long_description.count - 1 {
|
|
long_item_comment[index] = long_description[index]
|
|
}
|
|
for index: cast(s32)0..599 {
|
|
long_item_comment[long_description.count + index] = cast(u8)#char "y"
|
|
}
|
|
long_item := ListsMessage.{.action = LISTS_COMMIT, .editing_item = -1,
|
|
selected_list = 0, .list_count = 1, .selected_id = AppTextFromCString(*list_id[0], 37),
|
|
.title = TextUntilNul(long_item_title[:]), .comment = TextUntilNul(long_item_comment[:])}
|
|
Expect(ListsRun(long_item).succeeded, 277)
|
|
unused storage_elist_load(cast(*void)*app.elist)
|
|
Expect(app.elist.item_count == 2 &&
|
|
AppTextFromCString(*app.elist.items[1].title[0], ELIST_TITLE_SIZE) == long_item.title &&
|
|
AppTextFromCString(*app.elist.items[1].comment[0], ELIST_COMMENT_SIZE) == long_item.comment, 278)
|
|
Expect(AppTextFromCString(*app.elist.items[0].title[0], ELIST_TITLE_SIZE) == "Passport", 279)
|
|
AppCopyText(AppTextFromCString(*app.elist.items[0].id[0], 37), item_id[:])
|
|
edit.action = LISTS_SET_DONE
|
|
edit.id = AppTextFromCString(*item_id[0], 37)
|
|
edit.parent_id = AppTextFromCString(*list_id[0], 37)
|
|
edit.index = 0
|
|
edit.item_count = 1
|
|
edit.done = 1
|
|
edit.comment = "Keep relationship"
|
|
edit.now = 2.0
|
|
edit = ListsRun(edit)
|
|
Expect(edit.succeeded && edit.completing_until == 2.45, 14)
|
|
edit.action = LISTS_VISIBLE
|
|
edit = ListsRun(edit)
|
|
Expect(edit.visible, 15)
|
|
edit.now = 3.0
|
|
Expect(!ListsRun(edit).visible, 16)
|
|
unused storage_elist_load(cast(*void)*app.elist)
|
|
AppCopyText(AppTextFromCString(*item_id[0], 37), app.elist.completing_item[:])
|
|
app.elist.completing_until = 2.45
|
|
Expect(ListsRefreshVisibility(*app.elist, 2.1) && app.elist.item_visibility[0] && app.elist.visibility_deadline == 2.45, 51)
|
|
runs := ModuleTestRuns()
|
|
Expect(ListsRefreshVisibility(*app.elist, 2.2) && ModuleTestRuns() == runs, 52)
|
|
Expect(ListsRefreshVisibility(*app.elist, 2.5) && !app.elist.item_visibility[0] && ModuleTestRuns() == runs + app.elist.item_count, 53)
|
|
app.elist.show_completed = 1
|
|
Expect(ListsRefreshVisibility(*app.elist, 3.0) && app.elist.item_visibility[0] && ModuleTestRuns() == runs + 2 * app.elist.item_count, 54)
|
|
app.elist.show_completed = 0
|
|
unused storage_elist_load(cast(*void)*app.elist)
|
|
Expect(!app.elist.visibility_valid && ListsRefreshVisibility(*app.elist, 3.0) && !app.elist.item_visibility[0], 55)
|
|
// A returned text view lasts until the next call to that feature. This
|
|
// selection follows several visibility calls, so start a fresh message.
|
|
edit = ListsMessage.{.action = LISTS_SELECT, .index = 1, .list_count = 2}
|
|
edit = ListsRun(edit)
|
|
Expect(edit.selected_list == 1 && edit.reset_input && edit.reset_scroll && edit.show_completed == 0, 17)
|
|
|
|
habit := HabitsMessageFor(*app, HABITS_COMMIT)
|
|
habit.active = true
|
|
habit.is_new = true
|
|
habit.name = " \t "
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.name_error == 1 && !habit.cancel_edit, 18)
|
|
// Reuse the rejected response, including its old validation error.
|
|
habit.name = "Reading"
|
|
habit.description = "Shared habit"
|
|
habit.weekdays = 127
|
|
habit.counter_enabled = 1
|
|
habit.counter_target = 3
|
|
habit.reminder_hour = 9
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.succeeded && habit.name_error == 0 && habit.cancel_edit, 19)
|
|
habit.action = HABITS_COMMIT
|
|
habit.count = app.habits.count
|
|
habit.name = "Reading"
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.name_error == 2, 20)
|
|
habit.name = "Writing"
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.succeeded && habit.name_error == 0 && habit.cancel_edit, 21)
|
|
reading_index := FindHabit("Reading")
|
|
Expect(reading_index >= 0, 45)
|
|
if reading_index >= 0 {
|
|
AppCopyText(AppTextFromCString(*app.habits.items[reading_index].id[0], HABIT_ID_SIZE), edited_habit_id[:])
|
|
habit = HabitsMessageFor(*app, HABITS_COMMIT)
|
|
habit.active = true
|
|
habit.index = reading_index
|
|
habit.name = "Reading"
|
|
habit.description = "Edited through Habits bundle"
|
|
habit.counter_enabled = 1
|
|
habit.counter_target = 7
|
|
habit.weekdays = 31
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.succeeded && habit.cancel_edit, 46)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM habits WHERE name='Reading' AND description='Edited through Habits bundle' AND counter_enabled=1 AND counter_target=7 AND weekdays=31") == 1, 47)
|
|
}
|
|
habit.action = HABITS_DAY_ACTION
|
|
habit.index = 0
|
|
habit.count = app.habits.count
|
|
habit.scheduled = true
|
|
habit.counter_enabled = 0
|
|
habit.linked_count = 1
|
|
habit.question_count = 2
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.day_action == HABITS_DAY_LINKED && habit.block_click, 22)
|
|
habit.linked_count = 0
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.day_action == HABITS_DAY_QUESTIONS && habit.block_click, 48)
|
|
habit.span = true
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.day_action == HABITS_DAY_SPAN && habit.block_click, 50)
|
|
habit.span = false
|
|
habit.question_count = 0
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.day_action == HABITS_DAY_TOGGLE, 49)
|
|
habit.action = HABITS_HISTORY
|
|
habit.selected = 0
|
|
habit = HabitsRun(habit)
|
|
Expect(habit.screen_mode == HABITS_SCREEN_HISTORY && habit.view_mode == HABIT_VIEW_CALENDAR, 23)
|
|
|
|
step := PracticeMessage.{.action = PRACTICE_MEDITATION_STEP,
|
|
.remaining_seconds = 2, .elapsed_ms = 1500}
|
|
step = PracticeRun(step)
|
|
Expect(step.succeeded && step.remaining_seconds == 1 && step.remainder_ms == 500 && !step.completed, 24)
|
|
step.paused = true
|
|
Expect(PracticeRun(step).remaining_seconds == 1, 25)
|
|
step.paused = false
|
|
step.elapsed_ms = 500
|
|
step = PracticeRun(step)
|
|
Expect(step.completed && step.remaining_seconds == 0, 26)
|
|
step = PracticeMessage.{.action = PRACTICE_BREATH_STEP}
|
|
step.breathing = BreathSessionInit()
|
|
step.breathing.phase = BreathPhaseNext
|
|
step.breathing.round = step.breathing.max_rounds - 1
|
|
step.breathing.breath_half_ticks = 1
|
|
i: s32 = 0
|
|
while i < 120 && !step.completed {
|
|
step = PracticeRun(step)
|
|
i += 1
|
|
}
|
|
Expect(step.succeeded && step.completed, 27)
|
|
step = PracticeMessage.{.action = PRACTICE_SALUTATION_STEP}
|
|
step.salutation = SalutationStart(SalutationInit(step.salutation))
|
|
step.elapsed = 1000.0
|
|
step = PracticeRun(step)
|
|
Expect(step.succeeded && step.completed, 28)
|
|
step = PracticeMessage.{.action = PRACTICE_PATTERNS_STEP}
|
|
step.patterns.active = 1
|
|
step.patterns.duration_minutes = 1
|
|
step.patterns.elapsed_seconds = 59
|
|
step = PracticeRun(step)
|
|
Expect(step.succeeded && step.completed && step.patterns.elapsed_seconds == 60, 29)
|
|
|
|
rounds: [1]s32 = .[42]
|
|
Expect(storage_save_session(*rounds[0], 1, null, 0) != 0, 30)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM elist_items i JOIN elist_lists l ON l.id=i.list_id WHERE i.user_id=l.user_id AND i.title='Passport' AND i.comment='Keep relationship' AND i.done=1") == 1, 31)
|
|
habits_free(*app.habits)
|
|
storage_close()
|
|
AppsClose()
|
|
Expect(AppsOpenPackage(ModuleTestText("inbe")), 32)
|
|
Expect(storage_init("module-data") != 0, 33)
|
|
Expect(AppTextFromCString(storage_user_id_buffer(), 128) == AppTextFromCString(*user_id[0], 128), 34)
|
|
unused storage_elist_load(cast(*void)*app.elist)
|
|
habits_init_with_defaults(*app.habits, 0)
|
|
Expect(app.elist.item_count == 2 && app.elist.items[0].done == 1 && app.habits.count >= 3, 35)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM sessions") == 2, 36)
|
|
Expect(ModuleTestCount("SELECT COUNT(DISTINCT entity_type) FROM sync_outbox WHERE entity_type IN ('elist_list','elist_item','habit','session')") == 4, 37)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM habits h JOIN habit_days d ON d.habit_id=h.id WHERE h.name='Old habit' AND h.user_id='module-user' AND length(h.id)=36 AND d.local_date=20260925 AND d.completed=1 AND d.count=1") == 1, 43)
|
|
old_index = FindHabit("Old habit")
|
|
reading_index = FindHabit("Reading")
|
|
Expect(old_index >= 0 && reading_index >= 0, 48)
|
|
if old_index >= 0 && reading_index >= 0 {
|
|
Expect(AppTextFromCString(*app.habits.items[old_index].id[0], HABIT_ID_SIZE) == AppTextFromCString(*migrated_habit_id[0], HABIT_ID_SIZE), 49)
|
|
Expect(AppTextFromCString(*app.habits.items[reading_index].id[0], HABIT_ID_SIZE) == AppTextFromCString(*edited_habit_id[0], HABIT_ID_SIZE) && app.habits.items[reading_index].counter_target == 7, 50)
|
|
}
|
|
// A valid bundle with a mismatched host schema must fail before saving.
|
|
Expect(AppsOpenBytes(ModuleTestText("wrong-record"), habits, practice), 38)
|
|
edit = ListsMessage.{.action = LISTS_COMMIT, .editing_item = -2, .title = "Unsafe"}
|
|
Expect(!ListsRun(edit).succeeded, 39)
|
|
Expect(ModuleTestCount("SELECT COUNT(*) FROM elist_lists") == 1, 40)
|
|
Expect(AppsOpenBytes(ModuleTestText("wrong-scalar"), habits, practice), 41)
|
|
Expect(!ListsRun(edit).succeeded, 42)
|
|
app.elist.visibility_valid = false
|
|
Expect(!ListsRefreshVisibility(*app.elist, 3.0), 56)
|
|
Expect(AppsOpenBytes(lists, habits, practice), 339)
|
|
home_result := CheckPracticeHome()
|
|
Expect(home_result == 0, 340 + home_result)
|
|
Expect(AppsOpenPackage(ModuleTestText("inbe")), 100)
|
|
packaged_home_result := CheckPracticeHome()
|
|
Expect(packaged_home_result == 0, 1340 + packaged_home_result)
|
|
lumi_result := CheckLumiConversation()
|
|
Expect(lumi_result == 0, lumi_result)
|
|
shop_result := CheckHabitShop()
|
|
Expect(shop_result == 0, 240 + shop_result)
|
|
list_result := CheckHabitList()
|
|
Expect(list_result == 0, 300 + list_result)
|
|
stats_result := CheckHabitStats()
|
|
Expect(stats_result == 0, 320 + stats_result)
|
|
manual_result := CheckPracticeManual()
|
|
Expect(manual_result == 0, 360 + manual_result)
|
|
settings_result := CheckPracticeSettings()
|
|
Expect(settings_result == 0, 380 + settings_result)
|
|
results_result := CheckPracticeResults()
|
|
Expect(results_result == 0, 400 + results_result)
|
|
sessions_result := CheckPracticeSessions()
|
|
Expect(sessions_result == 0, 500 + sessions_result)
|
|
habits_free(*app.habits)
|
|
storage_close()
|
|
AppsClose()
|
|
ModuleTestUseCache(true)
|
|
cached_opens := ModuleTestBundleOpens()
|
|
Expect(AppsOpen(), 96)
|
|
// The root and its six apps, then the five cached app packages.
|
|
Expect(ModuleTestBundleOpens() - cached_opens == 12, 103)
|
|
for index: cast(s32)1..cast(s32)5 {
|
|
Expect(ModuleTestCachedReads(index) > 0, 97)
|
|
}
|
|
Expect(AppsInstalledMask() == APP_ALL, 98)
|
|
Expect(AppsFeaturePackageSize(1) == lists.count && AppsFeaturePackageSize(2) == habits.count, 235)
|
|
// Unrelated updates do not close/reopen working apps. A changed app is
|
|
// replaced transactionally, including a generic Diary with bound context.
|
|
unchanged_opens := ModuleTestBundleOpens()
|
|
unchanged_instances := ModuleTestInstanceOpens()
|
|
Expect(AppsReloadFeatures(APP_ALL), 251)
|
|
Expect(ModuleTestBundleOpens() == unchanged_opens &&
|
|
ModuleTestInstanceOpens() == unchanged_instances, 252)
|
|
habits_reads := ModuleTestCachedReads(2)
|
|
diary_reads := ModuleTestCachedReads(4)
|
|
ModuleTestSetRevision(1, 1)
|
|
ModuleTestCorruptCachedLists(true)
|
|
Expect(!AppsReloadFeatures(APP_ALL), 253)
|
|
Expect(ListsRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList}).succeeded, 254)
|
|
ModuleTestCorruptCachedLists(false)
|
|
Expect(AppsReloadFeatures(APP_ALL), 255)
|
|
Expect(ModuleTestCachedReads(2) == habits_reads && ModuleTestCachedReads(4) == diary_reads, 256)
|
|
ModuleTestSetRevision(4, 2)
|
|
Expect(AppsReloadFeatures(APP_ALL), 257)
|
|
Expect(ModuleTestCachedReads(2) == habits_reads && ModuleTestCachedReads(4) == diary_reads + 1, 258)
|
|
Expect(ModuleTestPrepare(0, ModuleTestText("inbe")) == 1, 259)
|
|
AppsDiscardPreparation()
|
|
Expect(AppsPreparationIdle(), 260)
|
|
Expect(ModuleTestPrepare(0, ModuleTestText("invalid-nested")) < 0, 261)
|
|
Expect(AppsPreparationIdle(), 262)
|
|
Expect(ModuleTestPrepare(1, lists) == 1, 263)
|
|
prepared_opens := ModuleTestBundleOpens()
|
|
prepared_reads := ModuleTestCachedReads(1)
|
|
AppsCommitPreparation(1, 3)
|
|
ModuleTestSetRevision(1, 3)
|
|
Expect(AppsReloadFeatures(APP_ALL), 264)
|
|
Expect(ModuleTestBundleOpens() == prepared_opens && ModuleTestCachedReads(1) == prepared_reads, 265)
|
|
Expect(ListsRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList}).succeeded, 266)
|
|
Expect(ModuleTestPrepare(4, ModuleTestText("diary")) == 1, 267)
|
|
AppsCommitPreparation(4, 4)
|
|
ModuleTestSetRevision(4, 4)
|
|
Expect(AppsReloadFeatures(APP_ALL) && DiaryRoute(ScreenDiary), 268)
|
|
ModuleTestBlockParser(true)
|
|
Expect(AppsPreparePackage(1, lists) == 0, 269)
|
|
for attempt: 0..5000 {
|
|
if ModuleTestParserStarted() { break }
|
|
ModuleTestYield()
|
|
}
|
|
Expect(ModuleTestParserStarted(), 270)
|
|
cancel_started := ModuleTestNow()
|
|
AppsDiscardPreparation()
|
|
Expect(!AppsPreparationIdle() && ModuleTestNow() - cancel_started < 0.05, 271)
|
|
Expect(ListsRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList}).succeeded, 272)
|
|
ModuleTestBlockParser(false)
|
|
for attempt: 0..5000 {
|
|
if AppsPreparationIdle() { break }
|
|
ModuleTestYield()
|
|
}
|
|
Expect(AppsPreparationIdle(), 273)
|
|
CheckNodePackagePreparation(lists)
|
|
ModuleTestSetRevision(1, 0)
|
|
ModuleTestSetRevision(4, 0)
|
|
AppsClose()
|
|
ModuleTestCorruptCachedLists(true)
|
|
Expect(AppsOpen() && AppsInstalledMask() == APP_ALL, 104)
|
|
Expect(AppsFeaturePackageSize(1) == lists.count, 236)
|
|
Expect(ListsRun(ListsMessage.{.action = LISTS_ROUTE, .screen = ScreenEList}).succeeded, 105)
|
|
AppsClose()
|
|
ModuleTestCorruptCachedLists(false)
|
|
ModuleTestUseCache(false)
|
|
before_opens := ModuleTestBundleOpens()
|
|
Expect(AppsOpenPackage(ModuleTestText("inbe")), 101)
|
|
AppsFinishOpening()
|
|
Expect(ModuleTestBundleOpens() - before_opens == 7, 102)
|
|
AppsClose()
|
|
Expect(AppsFeaturePackageSize(0) == 0 && AppsFeaturePackageSize(1) == 0, 237)
|
|
return failures
|
|
}
|