diff --git a/AGENTS.md b/AGENTS.md
index f98bdc64c7..283b689660 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -12,7 +12,7 @@ for it:
| Doc | When you need it |
|---|---|
| [docs/building.md](docs/building.md) | Build commands for every target (VS/MSBuild, CMake, UWP, legacy Android NDK, libretro), unit tests, pspautotests |
-| [docs/android-device-testing.md](docs/android-device-testing.md) | Running a build on a real Android device or a Quest over adb: installing the build you think you are, forcing activity recreates, measuring retained activities, VR, running the C++ unit tests on a device (`Tools/android_unittest.py`) |
+| [docs/android-device-testing.md](docs/android-device-testing.md) | Running a build on a real Android device or a Quest over adb: installing the build you think you are, forcing activity recreates, measuring retained activities, VR, running the C++ unit tests on a device (`Tools/android_unittest.py`), starting the app with options (`Tools/android_run.py`), and the storage tests that exercise content URIs in the app (`Tools/android_storage_test.py`) |
| [docs/debugging.md](docs/debugging.md) | Driving the WebSocket debugger and PPSSPPHeadless from a script, measuring a commercial game with headless, comparing binaries' speed (`Tools/headless_bench.py`), finding a game's hot JIT blocks (`--jit-profile`), breakpoint reliability per CPU backend, debugging a game that works on hardware, finding and hashing a game function (like its own `memcpy`) for `ReplaceTables` when hardware backends miss CPU writes to VRAM |
| [docs/DebuggerThreading.md](docs/DebuggerThreading.md) | `Core_RunOnCPUThread` / `g_frameMutex` / shutdown-lock rules - required reading before touching debugger code |
| [docs/HLEModules.md](docs/HLEModules.md) | Adding an HLE module or function, and the seven build files a new source file goes in |
diff --git a/Core/CMakeLists.txt b/Core/CMakeLists.txt
index cec3d2b2b2..22106d5442 100644
--- a/Core/CMakeLists.txt
+++ b/Core/CMakeLists.txt
@@ -688,7 +688,9 @@ add_library(Core STATIC
Util/AudioFormat.cpp
Util/AudioFormat.h
Util/MemStick.cpp
+ Util/StorageTest.cpp
Util/MemStick.h
+ Util/StorageTest.h
Util/GameDB.cpp
Util/GameDB.h
Util/PathUtil.cpp
diff --git a/Core/CmdLine.cpp b/Core/CmdLine.cpp
index 32ab112c25..291251da5c 100644
--- a/Core/CmdLine.cpp
+++ b/Core/CmdLine.cpp
@@ -216,7 +216,7 @@ const char *g_ExceptionActionValues[] = {
static const CommandLineParam g_autoParams[] = {
{POFF(fullscreen), CmdParamType::Bool, "fullscreen", '\0', "Force full screen mode", CmdLineMode::Application},
{POFF(fullscreen), CmdParamType::BoolInverse, "windowed", '\0', "Force windowed mode", CmdLineMode::Application},
- {POFF(startScreen), CmdParamType::String, "start-screen", '\0', "Start on a specific screen (e.g. 'gamesettings', 'touchscreentest', 'firmware')", CmdLineMode::Application},
+ {POFF(startScreen), CmdParamType::String, "start-screen", '\0', "Start on a specific screen (e.g. 'gamesettings', 'touchscreentest', 'firmware', 'storagetest')", CmdLineMode::Application},
{POFF(escapeExit), CmdParamType::Bool, "escape-exit", '\0', "Escape key exits the application", CmdLineMode::Application},
{POFF(gameWindow), CmdParamType::Bool, "game-window", '\0', "Show the game in a second window, for testing multiple outputs (Vulkan, or Metal on Mac)", CmdLineMode::Application},
{POFF(pauseMenuExit), CmdParamType::Bool, "pause-menu-exit", '\0', "Exit the application when the game ends, instead of returning to the menu", CmdLineMode::Application},
diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj
index 6ac5e84aac..4d7959926d 100644
--- a/Core/Core.vcxproj
+++ b/Core/Core.vcxproj
@@ -744,6 +744,7 @@
+
@@ -1078,6 +1079,7 @@
+
diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters
index 2ce11d6a71..79e60085de 100644
--- a/Core/Core.vcxproj.filters
+++ b/Core/Core.vcxproj.filters
@@ -1318,6 +1318,9 @@
Util
+
+ Util
+
HW
@@ -2295,6 +2298,9 @@
Util
+
+ Util
+
HW
diff --git a/Core/Util/StorageTest.cpp b/Core/Util/StorageTest.cpp
new file mode 100644
index 0000000000..c16e2e3763
--- /dev/null
+++ b/Core/Util/StorageTest.cpp
@@ -0,0 +1,230 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#include
+#include
+
+#include "Common/Data/Text/Parsers.h"
+#include "Common/File/DirListing.h"
+#include "Common/File/DiskFree.h"
+#include "Common/File/FileUtil.h"
+#include "Common/Log.h"
+#include "Common/StringUtils.h"
+#include "Common/TimeUtil.h"
+#include "Core/Util/StorageTest.h"
+
+// A test returns an empty string if it passed, and what went wrong if it didn't.
+#define CHECK(cond) do { if (!(cond)) { return StringFromFormat("line %d: %s", __LINE__, #cond); } } while (false)
+
+static std::string ReadAll(const Path &path) {
+ std::string str;
+ if (!File::ReadBinaryFileToString(path, &str)) {
+ return "";
+ }
+ return str;
+}
+
+static bool Write(const Path &path, std::string_view str) {
+ return File::WriteStringToFile(false, str, path);
+}
+
+static bool HasEntry(const std::vector &files, std::string_view name, bool isDirectory) {
+ return std::any_of(files.begin(), files.end(), [&](const File::FileInfo &f) {
+ return f.name == name && f.isDirectory == isDirectory;
+ });
+}
+
+int RunStorageTests(const Path &root, const std::function &report) {
+ const Path scratch = root / "ppsspp_storage_test";
+ // On content URIs DeleteDir takes everything in the folder along, on native paths it only removes empty
+ // ones. The memory stick move depends on knowing which.
+ const bool contentURI = root.Type() == PathType::CONTENT_URI;
+ int failures = 0;
+ std::string note;
+
+ auto run = [&](const char *name, const std::function &test) {
+ note.clear();
+ std::string error = test();
+ StorageTestResult result{ name, error.empty(), error.empty() ? note : error };
+ if (!result.passed) {
+ failures++;
+ }
+ INFO_LOG(Log::System, "StorageTest: %s %s%s%s", result.passed ? "PASS" : "FAIL", name, result.detail.empty() ? "" : ": ", result.detail.c_str());
+ report(result);
+ };
+
+ run("CreateDir", [&]() -> std::string {
+ if (File::Exists(scratch)) {
+ // Left over from a run that didn't finish.
+ CHECK(File::DeleteDirRecursively(scratch));
+ }
+ CHECK(!File::Exists(scratch));
+ CHECK(File::CreateDir(scratch));
+ CHECK(File::Exists(scratch));
+ CHECK(File::IsDirectory(scratch));
+ return "";
+ });
+ if (failures) {
+ // Nowhere to run the rest.
+ return failures;
+ }
+
+ run("WriteRead", [&]() -> std::string {
+ const Path file = scratch / "a.txt";
+ CHECK(Write(file, "hello"));
+ CHECK(File::Exists(file));
+ CHECK(!File::IsDirectory(file));
+ CHECK(ReadAll(file) == "hello");
+ File::FileInfo info;
+ CHECK(File::GetFileInfo(file, &info));
+ CHECK(info.exists && !info.isDirectory && info.size == 5);
+ return "";
+ });
+
+ run("Overwrite", [&]() -> std::string {
+ // Writing a shorter file over a longer one has to truncate it.
+ const Path file = scratch / "b.txt";
+ CHECK(Write(file, "a longer string"));
+ CHECK(Write(file, "short"));
+ CHECK(ReadAll(file) == "short");
+ return "";
+ });
+
+ run("ListDir", [&]() -> std::string {
+ CHECK(File::CreateDir(scratch / "sub"));
+ std::vector files;
+ CHECK(File::GetFilesInDir(scratch, &files));
+ CHECK(files.size() == 3);
+ CHECK(HasEntry(files, "a.txt", false));
+ CHECK(HasEntry(files, "b.txt", false));
+ CHECK(HasEntry(files, "sub", true));
+ return "";
+ });
+
+ run("CreateFullPath", [&]() -> std::string {
+ CHECK(File::CreateFullPath(scratch / "x/y/z"));
+ CHECK(File::IsDirectory(scratch / "x/y/z"));
+ // Already there is fine.
+ CHECK(File::CreateFullPath(scratch / "x/y"));
+ return "";
+ });
+
+ run("Rename", [&]() -> std::string {
+ CHECK(File::Rename(scratch / "a.txt", scratch / "renamed.txt"));
+ CHECK(!File::Exists(scratch / "a.txt"));
+ CHECK(ReadAll(scratch / "renamed.txt") == "hello");
+ return "";
+ });
+
+ run("MoveIfFast", [&]() -> std::string {
+ CHECK(File::MoveIfFast(scratch / "renamed.txt", scratch / "sub/renamed.txt"));
+ CHECK(!File::Exists(scratch / "renamed.txt"));
+ CHECK(ReadAll(scratch / "sub/renamed.txt") == "hello");
+ // Folders too, which is what the memory stick move does.
+ CHECK(File::MoveIfFast(scratch / "x", scratch / "sub/x"));
+ CHECK(File::IsDirectory(scratch / "sub/x/y/z"));
+ return "";
+ });
+
+ run("Copy", [&]() -> std::string {
+ CHECK(File::Copy(scratch / "b.txt", scratch / "sub/b.txt"));
+ CHECK(ReadAll(scratch / "sub/b.txt") == "short");
+ CHECK(ReadAll(scratch / "b.txt") == "short");
+ return "";
+ });
+
+ run("Delete", [&]() -> std::string {
+ CHECK(File::Delete(scratch / "b.txt"));
+ CHECK(!File::Exists(scratch / "b.txt"));
+ return "";
+ });
+
+ run("DeleteDir", [&]() -> std::string {
+ const Path dir = scratch / "full";
+ CHECK(File::CreateDir(dir));
+ CHECK(Write(dir / "f.txt", "f"));
+ const bool deleted = File::DeleteDir(dir);
+ if (contentURI) {
+ CHECK(deleted && !File::Exists(dir));
+ note = "takes the contents along";
+ } else {
+ CHECK(!deleted && File::Exists(dir / "f.txt"));
+ note = "only empty folders";
+ }
+ CHECK(File::DeleteDirRecursively(dir) || !File::Exists(dir));
+ CHECK(!File::Exists(dir));
+ return "";
+ });
+
+ run("Names", [&]() -> std::string {
+ // Characters that need escaping in a content URI, and outside ASCII.
+ const char *name = "100% #1 & \xC3\xA4.txt";
+ CHECK(Write(scratch / name, "odd"));
+ CHECK(ReadAll(scratch / name) == "odd");
+ std::vector files;
+ CHECK(File::GetFilesInDir(scratch, &files));
+ CHECK(HasEntry(files, name, false));
+ return "";
+ });
+
+ run("FreeSpace", [&]() -> std::string {
+ int64_t space = 0;
+ CHECK(free_disk_space(root, space));
+ CHECK(space > 0);
+ note = NiceSizeFormat(space);
+ return "";
+ });
+
+ // Not a pass/fail test: the cost of the calls the emulator makes most, for comparing implementations.
+ // On content URIs each is a call into Java and a binder transaction to the provider.
+ run("Timing", [&]() -> std::string {
+ const Path dir = scratch / "timing";
+ CHECK(File::CreateDir(dir));
+ const int count = 20;
+ std::string report;
+ auto time = [&](const char *what, int n, const std::function &op) -> bool {
+ const Instant start = Instant::Now();
+ for (int i = 0; i < n; i++) {
+ if (!op(i)) {
+ return false;
+ }
+ }
+ report += StringFromFormat("%s%s %.2f", report.empty() ? "" : ", ", what, start.ElapsedMs() / n);
+ return true;
+ };
+ auto name = [&](int i) { return dir / StringFromFormat("file%02d.bin", i); };
+ CHECK(time("create+write", count, [&](int i) { return Write(name(i), "0123456789"); }));
+ CHECK(time("overwrite", count, [&](int i) { return Write(name(i), "9876543210"); }));
+ CHECK(time("read", count, [&](int i) { return ReadAll(name(i)) == "9876543210"; }));
+ CHECK(time("exists", count, [&](int i) { return File::Exists(name(i)); }));
+ CHECK(time("missing", count, [&](int i) { return !File::Exists(dir / StringFromFormat("none%02d", i)); }));
+ CHECK(time("info", count, [&](int i) { File::FileInfo info; return File::GetFileInfo(name(i), &info) && info.size == 10; }));
+ CHECK(time("list", 5, [&](int) { std::vector files; return File::GetFilesInDir(dir, &files) && files.size() == count; }));
+ CHECK(time("delete", count, [&](int i) { return File::Delete(name(i)); }));
+ note = "ms per call: " + report;
+ return "";
+ });
+
+ run("Cleanup", [&]() -> std::string {
+ CHECK(File::DeleteDirRecursively(scratch));
+ CHECK(!File::Exists(scratch));
+ return "";
+ });
+
+ INFO_LOG(Log::System, "StorageTest: DONE, %d failed", failures);
+ return failures;
+}
diff --git a/Core/Util/StorageTest.h b/Core/Util/StorageTest.h
new file mode 100644
index 0000000000..2103cecde1
--- /dev/null
+++ b/Core/Util/StorageTest.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#pragma once
+
+#include
+#include
+
+#include "Common/File/Path.h"
+
+struct StorageTestResult {
+ std::string name;
+ bool passed;
+ // What failed, or for a pass, anything worth knowing (like which way DeleteDir went).
+ std::string detail;
+};
+
+// Exercises the file functions in a scratch folder inside root, deleted again
+// afterwards. root can be a native path, or on Android a picked folder (a content URI), which is the case
+// the unit tests can't reach: they have no Java VM. report is called after each test, on the calling thread.
+// Returns the number of failures.
+int RunStorageTests(const Path &root, const std::function &report);
diff --git a/Tools/android_run.py b/Tools/android_run.py
new file mode 100644
index 0000000000..b2f7cd8203
--- /dev/null
+++ b/Tools/android_run.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# Copyright (c) 2012- PPSSPP Project.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 2.0 or later versions.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License 2.0 for more details.
+
+# A copy of the GPL 2.0 should have been included with the program.
+# If not, see http://www.gnu.org/licenses/
+
+# Official git repository and contact information can be found at
+# https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+"""Starts PPSSPP on an Android device, with command line options, optionally building and installing it first.
+
+ python Tools/android_run.py --build --start-screen=memsticksetup # build, install, open the memory stick setup
+ python Tools/android_run.py --log --start-screen=firmware # follow the app's log until Ctrl+C
+ python Tools/android_run.py -- --some-option=x # anything after -- goes to the app as is
+
+The app only reads its options at startup, so it's force-stopped first. --start-screen names are listed in
+NativeInit() in UI/NativeApp.cpp.
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+PACKAGE = "org.ppsspp.ppsspp"
+APK = os.path.join(ROOT, "android", "build", "outputs", "apk", "normal", "debug", "android-normal-debug.apk")
+
+
+def adb(args, device, **kwargs):
+ return subprocess.run(["adb"] + (["-s", device] if device else []) + args, **kwargs)
+
+
+def build_and_install(device):
+ gradlew = os.path.join(ROOT, "gradlew.bat" if os.name == "nt" else "gradlew")
+ if subprocess.run([gradlew, ":android:assembleNormalDebug"], cwd=ROOT).returncode != 0:
+ print("Build failed")
+ return False
+ # -d: a branch can have a lower versionCode (the commit count) than what's installed. See
+ # docs/android-device-testing.md, and don't trust an install without checking what's there afterwards.
+ result = adb(["install", "-r", "-d", "-t", APK], device, capture_output=True, text=True)
+ print(result.stdout.strip(), result.stderr.strip())
+ if result.returncode != 0 or "Success" not in result.stdout:
+ print("Install failed")
+ return False
+ info = adb(["shell", "dumpsys package %s | grep versionName" % PACKAGE], device, capture_output=True, text=True).stdout
+ print("Installed: " + info.strip())
+ return True
+
+
+def start(device, app_args):
+ """Force-stops the app and starts it with app_args (a list of options)."""
+ adb(["shell", "am force-stop " + PACKAGE], device)
+ command = "am start -n %s/.PpssppActivity" % PACKAGE
+ if app_args:
+ # The shell on the device parses this once more, so quote the whole thing.
+ joined = " ".join(app_args).replace("'", "'\\''")
+ command += " --es %s.Args '%s'" % (PACKAGE, joined)
+ return adb(["shell", command], device, capture_output=True, text=True)
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+ parser.add_argument("--build", action="store_true", help="build and install the normal debug APK first")
+ parser.add_argument("-s", "--device", help="adb device serial, if there's more than one")
+ parser.add_argument("--log", action="store_true", help="follow the app's log (the PPSSPP tag) until Ctrl+C")
+ parser.add_argument("--start-screen", help="the screen to start on, like memsticksetup, firmware or storagetest")
+ parser.add_argument("app_args", nargs="*", help="more options for the app, after --")
+ args = parser.parse_args()
+
+ if args.build and not build_and_install(args.device):
+ return 1
+
+ app_args = list(args.app_args)
+ if args.start_screen:
+ app_args.insert(0, "--start-screen=" + args.start_screen)
+ if args.log:
+ adb(["logcat", "-c"], args.device)
+ result = start(args.device, app_args)
+ if result.returncode != 0 or "Error" in result.stdout:
+ print(result.stdout, result.stderr)
+ return 1
+ print("Started %s %s" % (PACKAGE, " ".join(app_args)))
+ if args.log:
+ try:
+ adb(["logcat", "-v", "brief", "PPSSPP:V", "*:S"], args.device)
+ except KeyboardInterrupt:
+ pass
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/Tools/android_storage_test.py b/Tools/android_storage_test.py
new file mode 100644
index 0000000000..dfc3bfff66
--- /dev/null
+++ b/Tools/android_storage_test.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+# Copyright (c) 2012- PPSSPP Project.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 2.0 or later versions.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License 2.0 for more details.
+
+# A copy of the GPL 2.0 should have been included with the program.
+# If not, see http://www.gnu.org/licenses/
+
+# Official git repository and contact information can be found at
+# https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+"""Runs the storage tests (UI/StorageTestScreen.cpp) in the app on an Android device.
+
+The unit tests can't reach the content URI storage code, since they have no Java VM, so these run in the
+app itself, in a folder picked with the system folder picker. The first time, create a new empty folder
+in the picker on the device and choose it. The app remembers it (in its private data), so later runs
+need no hands.
+
+ python Tools/android_storage_test.py --build # build and install the normal debug APK first
+ python Tools/android_storage_test.py # run with what's installed
+
+Exits non-zero if a test failed, or no results came within --timeout seconds.
+"""
+
+import argparse
+import re
+import subprocess
+import sys
+import threading
+import time
+
+# The build, install and start steps are shared with android_run.py, next to this.
+from android_run import PACKAGE, adb, build_and_install, start
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+ parser.add_argument("--build", action="store_true", help="build and install the normal debug APK first")
+ parser.add_argument("-s", "--device", help="adb device serial, if there's more than one")
+ parser.add_argument("--timeout", type=int, default=300, help="seconds to wait for the results, including picking a folder (default 300)")
+ args = parser.parse_args()
+
+ if args.build and not build_and_install(args.device):
+ return 1
+
+ adb(["logcat", "-c"], args.device)
+ logcat = subprocess.Popen(["adb"] + (["-s", args.device] if args.device else []) + ["logcat", "-v", "brief", "PPSSPP:V", "*:S"],
+ stdout=subprocess.PIPE, text=True, errors="replace")
+ # A fresh start, so the start screen applies (it's only read at startup).
+ if start(args.device, ["--start-screen=storagetest"]).returncode != 0:
+ print("Couldn't start " + PACKAGE)
+ logcat.kill()
+ return 1
+
+ # Read on a thread, so the timeout works even when logcat is quiet.
+ lines = []
+ done = threading.Event()
+
+ def reader():
+ for line in logcat.stdout:
+ lines.append(line.rstrip())
+ if "StorageTest: DONE" in line:
+ done.set()
+ return
+
+ threading.Thread(target=reader, daemon=True).start()
+ deadline = time.time() + args.timeout
+ shown = 0
+ asked = False
+ while not done.is_set() and time.time() < deadline:
+ time.sleep(0.2)
+ while shown < len(lines):
+ line = lines[shown]
+ shown += 1
+ if "StorageTest:" in line:
+ print(line[line.index("StorageTest:"):])
+ if not asked and time.time() > deadline - args.timeout + 5 and not any("StorageTest:" in l for l in lines):
+ print("No results yet. If this is the first run, tap Choose folder on the device, create a new empty folder in the picker, and choose it.")
+ asked = True
+ logcat.kill()
+ for line in lines[shown:]:
+ if "StorageTest:" in line:
+ print(line[line.index("StorageTest:"):])
+
+ summary = [l for l in lines if "StorageTest: DONE" in l]
+ if not summary:
+ print("Timed out after %d seconds" % args.timeout)
+ return 1
+ failed = int(re.search(r"DONE, (\d+) failed", summary[-1]).group(1))
+ return 1 if failed else 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/UI/CMakeLists.txt b/UI/CMakeLists.txt
index 2a6f150406..cf244a6751 100644
--- a/UI/CMakeLists.txt
+++ b/UI/CMakeLists.txt
@@ -133,7 +133,9 @@ list(APPEND UISource
JitCompareScreen.h
JitCompareScreen.cpp
MemStickScreen.h
+ StorageTestScreen.h
MemStickScreen.cpp
+ StorageTestScreen.cpp
ProfilerDraw.h
ProfilerDraw.cpp
CustomButtonMappingScreen.h
diff --git a/UI/NativeApp.cpp b/UI/NativeApp.cpp
index 845b7f5f74..e384a375d0 100644
--- a/UI/NativeApp.cpp
+++ b/UI/NativeApp.cpp
@@ -147,6 +147,7 @@
#include "UI/GPUDriverTestScreen.h"
#include "UI/MiscScreens.h"
#include "UI/MemStickScreen.h"
+#include "UI/StorageTestScreen.h"
#include "UI/OnScreenDisplay.h"
#include "UI/SettingsPage.h"
#include "UI/RemoteISOScreen.h"
@@ -910,6 +911,9 @@ void NativeInit(int argc, const char *argv[], const CommandLineOptions &cmdLineO
} else if (equals(cmdLineOptions.startScreen.value(), "memsticksetup")) {
g_screenManager->switchScreen(new MainScreen());
g_screenManager->push(new MemStickScreen(true));
+ } else if (equals(cmdLineOptions.startScreen.value(), "storagetest")) {
+ g_screenManager->switchScreen(new MainScreen());
+ g_screenManager->push(new StorageTestScreen());
} else if (equals(cmdLineOptions.startScreen.value(), "credits")) {
g_screenManager->switchScreen(new MainScreen());
g_screenManager->push(new CreditsScreen());
diff --git a/UI/StorageTestScreen.cpp b/UI/StorageTestScreen.cpp
new file mode 100644
index 0000000000..5f462b88ae
--- /dev/null
+++ b/UI/StorageTestScreen.cpp
@@ -0,0 +1,183 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#include "Common/File/FileUtil.h"
+#include "Common/Log.h"
+#include "Common/Log/LogManager.h"
+#include "Common/StringUtils.h"
+#include "Common/System/Request.h"
+#include "Common/Thread/ThreadUtil.h"
+#include "Common/UI/Notice.h"
+#include "Common/UI/ViewGroup.h"
+#include "Core/Config.h"
+#include "UI/StorageTestScreen.h"
+
+// A developer tool, so the strings aren't translated.
+
+static Path RememberedFolderFile() {
+ return g_Config.internalDataDirectory / "storage_test_dir.txt";
+}
+
+StorageTestScreen::StorageTestScreen()
+ : UITwoPaneBaseDialogScreen(Path(), TwoPaneFlags::SettingsToTheRight | TwoPaneFlags::ContentsCanScroll) {
+ std::string remembered;
+ if (!g_Config.internalDataDirectory.empty() && File::ReadTextFileToString(RememberedFolderFile(), &remembered)) {
+ folder_ = Path(StripSpaces(remembered));
+ // Started from a script, most likely, so get going (in update(), once the screen is up).
+ autoStart_ = File::IsDirectory(folder_);
+ if (!autoStart_) {
+ WARN_LOG(Log::System, "StorageTest: Remembered folder '%s' is gone, choose another", folder_.c_str());
+ }
+ }
+}
+
+StorageTestScreen::~StorageTestScreen() {
+ // The tests have no way to stop halfway, but they take seconds.
+ if (thread_.joinable()) {
+ thread_.join();
+ }
+ RestoreLogLevel();
+}
+
+void StorageTestScreen::RaiseLogLevel() {
+ if (logRaised_) {
+ return;
+ }
+ LogChannel *channel = g_logManager.GetLogChannel(Log::System);
+ savedLogLevel_ = channel->level;
+ savedLogEnabled_ = channel->enabled;
+ channel->enabled = true;
+ if (channel->level < LogLevel::LINFO) {
+ channel->level = LogLevel::LINFO;
+ }
+ logRaised_ = true;
+}
+
+void StorageTestScreen::RestoreLogLevel() {
+ if (!logRaised_) {
+ return;
+ }
+ LogChannel *channel = g_logManager.GetLogChannel(Log::System);
+ channel->level = savedLogLevel_;
+ channel->enabled = savedLogEnabled_;
+ logRaised_ = false;
+}
+
+void StorageTestScreen::CreateSettingsViews(UI::ViewGroup *parent) {
+ using namespace UI;
+ if (running_) {
+ parent->Add(new TextView("Running...", ALIGN_LEFT, false));
+ return;
+ }
+ parent->Add(new Choice("Choose folder", ImageID("I_FOLDER_OPEN")))->OnClick.Add([this](EventParams &) {
+ ChooseFolder();
+ });
+ if (!folder_.empty()) {
+ parent->Add(new Choice("Run tests"))->OnClick.Add([this](EventParams &) {
+ StartTests();
+ });
+ }
+}
+
+void StorageTestScreen::CreateContentViews(UI::ViewGroup *parent) {
+ using namespace UI;
+ LinearLayout *list = parent->Add(new LinearLayout(ORIENT_VERTICAL, new LinearLayoutParams(FILL_PARENT, WRAP_CONTENT)));
+ if (folder_.empty()) {
+ list->Add(new TextView("Create a new, empty folder for the tests in the folder picker, and choose it. The tests work in a folder of their own inside it and delete it again, but a folder of its own keeps them away from your data. It's remembered for later runs.", ALIGN_LEFT | FLAG_WRAP_TEXT, false));
+ return;
+ }
+ list->Add(new TextView("Folder: " + folder_.ToVisualString(), ALIGN_LEFT | FLAG_WRAP_TEXT, false));
+ const int failures = failures_;
+ if (failures >= 0) {
+ if (failures == 0) {
+ list->Add(new NoticeView(NoticeLevel::SUCCESS, "All passed", ""));
+ } else {
+ list->Add(new NoticeView(NoticeLevel::ERROR, StringFromFormat("%d failed", failures), ""));
+ }
+ }
+
+ std::lock_guard guard(resultsLock_);
+ for (const StorageTestResult &result : results_) {
+ list->Add(new NoticeView(result.passed ? NoticeLevel::SUCCESS : NoticeLevel::ERROR, result.name, result.detail));
+ }
+ shownResults_ = results_.size();
+}
+
+void StorageTestScreen::update() {
+ UITwoPaneBaseDialogScreen::update();
+ if (autoStart_) {
+ autoStart_ = false;
+ StartTests();
+ }
+
+ bool changed;
+ {
+ std::lock_guard guard(resultsLock_);
+ changed = results_.size() != shownResults_;
+ }
+ if (!running_ && thread_.joinable()) {
+ thread_.join();
+ RestoreLogLevel();
+ changed = true;
+ }
+ if (changed) {
+ RecreateViews();
+ }
+}
+
+void StorageTestScreen::ChooseFolder() {
+ System_BrowseForFolder(GetRequesterToken(), "Choose a folder to test in", folder_, [this](std::string_view value, int) {
+ const Path folder(value);
+ if (folder.empty()) {
+ return;
+ }
+ folder_ = folder;
+ if (!g_Config.internalDataDirectory.empty()) {
+ File::WriteStringToFile(true, folder_.ToString(), RememberedFolderFile());
+ }
+ StartTests();
+ });
+}
+
+void StorageTestScreen::StartTests() {
+ if (running_ || folder_.empty()) {
+ return;
+ }
+ if (thread_.joinable()) {
+ thread_.join();
+ }
+ {
+ std::lock_guard guard(resultsLock_);
+ results_.clear();
+ }
+ shownResults_ = 0;
+ failures_ = -1;
+ running_ = true;
+ RaiseLogLevel();
+ RecreateViews();
+ thread_ = std::thread([this]() {
+ SetCurrentThreadName("StorageTest");
+ // Content URIs go through Java.
+ AndroidJNIThreadContext jniContext;
+ const int failures = RunStorageTests(folder_, [this](const StorageTestResult &result) {
+ std::lock_guard guard(resultsLock_);
+ results_.push_back(result);
+ });
+ failures_ = failures;
+ running_ = false;
+ });
+}
diff --git a/UI/StorageTestScreen.h b/UI/StorageTestScreen.h
new file mode 100644
index 0000000000..9ae08ad9d0
--- /dev/null
+++ b/UI/StorageTestScreen.h
@@ -0,0 +1,67 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#pragma once
+
+#include
+#include
+#include
+#include
+
+#include "Common/File/Path.h"
+#include "Common/Log.h"
+#include "Core/Util/StorageTest.h"
+#include "UI/SimpleDialogScreen.h"
+
+// Runs RunStorageTests() in a folder the user picks, which on Android is a content URI: the storage code
+// the unit tests can't reach. Opened with --start-screen=storagetest (see Tools/android_storage_test.py).
+// The folder is remembered, so later runs start by themselves.
+class StorageTestScreen : public UITwoPaneBaseDialogScreen {
+public:
+ StorageTestScreen();
+ ~StorageTestScreen();
+
+ const char *tag() const override { return "StorageTest"; }
+
+protected:
+ void CreateSettingsViews(UI::ViewGroup *parent) override;
+ void CreateContentViews(UI::ViewGroup *parent) override;
+ std::string_view GetTitle() const override { return "Storage tests"; }
+ void update() override;
+
+private:
+ void ChooseFolder();
+ void StartTests();
+ // The results are logged at INFO for Tools/android_storage_test.py, so they have to get through
+ // whatever level the user has. Restored when the run ends, since Config::Save() stores the levels.
+ void RaiseLogLevel();
+ void RestoreLogLevel();
+
+ Path folder_;
+ bool autoStart_ = false;
+
+ std::thread thread_;
+ std::atomic running_{ false };
+ std::mutex resultsLock_;
+ std::vector results_;
+ size_t shownResults_ = 0;
+ std::atomic failures_{ -1 }; // -1 until a run has finished.
+
+ bool logRaised_ = false;
+ LogLevel savedLogLevel_ = LogLevel::LINFO;
+ bool savedLogEnabled_ = true;
+};
diff --git a/UI/UI.vcxproj b/UI/UI.vcxproj
index 5160aded30..b31d954f1c 100644
--- a/UI/UI.vcxproj
+++ b/UI/UI.vcxproj
@@ -64,6 +64,7 @@
+
@@ -141,6 +142,7 @@
+
diff --git a/UI/UI.vcxproj.filters b/UI/UI.vcxproj.filters
index fe27a86b8b..f133da1084 100644
--- a/UI/UI.vcxproj.filters
+++ b/UI/UI.vcxproj.filters
@@ -91,6 +91,9 @@
Screens
+
+ Screens
+
Views
@@ -291,6 +294,9 @@
Screens
+
+ Screens
+
Views
diff --git a/UWP/CoreUWP/CoreUWP.vcxproj b/UWP/CoreUWP/CoreUWP.vcxproj
index 51b0d350ac..f951776c92 100644
--- a/UWP/CoreUWP/CoreUWP.vcxproj
+++ b/UWP/CoreUWP/CoreUWP.vcxproj
@@ -335,6 +335,7 @@
+
@@ -662,6 +663,7 @@
+
diff --git a/UWP/CoreUWP/CoreUWP.vcxproj.filters b/UWP/CoreUWP/CoreUWP.vcxproj.filters
index 4b483af759..5dae4635b8 100644
--- a/UWP/CoreUWP/CoreUWP.vcxproj.filters
+++ b/UWP/CoreUWP/CoreUWP.vcxproj.filters
@@ -264,6 +264,7 @@
+
@@ -667,6 +668,7 @@
+
diff --git a/UWP/UI_UWP/UI_UWP.vcxproj b/UWP/UI_UWP/UI_UWP.vcxproj
index 7785a56d7e..0c3918ae12 100644
--- a/UWP/UI_UWP/UI_UWP.vcxproj
+++ b/UWP/UI_UWP/UI_UWP.vcxproj
@@ -134,6 +134,7 @@
+
@@ -210,6 +211,7 @@
+
diff --git a/UWP/UI_UWP/UI_UWP.vcxproj.filters b/UWP/UI_UWP/UI_UWP.vcxproj.filters
index ee3797984f..54c3ddafec 100644
--- a/UWP/UI_UWP/UI_UWP.vcxproj.filters
+++ b/UWP/UI_UWP/UI_UWP.vcxproj.filters
@@ -107,6 +107,9 @@
Screens
+
+ Screens
+
Screens
@@ -297,6 +300,9 @@
Screens
+
+ Screens
+
Screens
diff --git a/android/jni/Android.mk b/android/jni/Android.mk
index f4a78d738f..ffbddd4125 100644
--- a/android/jni/Android.mk
+++ b/android/jni/Android.mk
@@ -892,6 +892,7 @@ EXEC_AND_LIB_FILES := \
$(SRC)/Core/Util/AtracTrack.cpp \
$(SRC)/Core/Util/AudioFormat.cpp \
$(SRC)/Core/Util/MemStick.cpp \
+ $(SRC)/Core/Util/StorageTest.cpp \
$(SRC)/Core/Util/PathUtil.cpp \
$(SRC)/Core/Util/PortManager.cpp \
$(SRC)/Core/Util/GameDB.cpp \
@@ -1098,6 +1099,7 @@ LOCAL_SRC_FILES := \
$(SRC)/UI/AdhocServerScreen.cpp \
$(SRC)/UI/SimpleDialogScreen.cpp \
$(SRC)/UI/MemStickScreen.cpp \
+ $(SRC)/UI/StorageTestScreen.cpp \
$(SRC)/UI/IAPScreen.cpp \
$(SRC)/UI/MiscScreens.cpp \
$(SRC)/UI/MiscViews.cpp \
diff --git a/docs/android-device-testing.md b/docs/android-device-testing.md
index c67652a6b8..80ac1577ca 100644
--- a/docs/android-device-testing.md
+++ b/docs/android-device-testing.md
@@ -82,6 +82,14 @@ away within seconds, which reads as "logging stopped" rather than "logging was l
adb logcat -c && adb logcat -s PPSSPP:V PpssppActivity:V # in the background, then start the app
+## Starting the app with options
+
+ python Tools/android_run.py --build --start-screen=memsticksetup # build, install, open the memory stick setup
+ python Tools/android_run.py --log --start-screen=firmware # and follow the app's log
+
+It force-stops the app first, since options are only read at startup, and passes them in the
+`org.ppsspp.ppsspp.Args` intent extra. The `--start-screen` names are in `NativeInit()` in `UI/NativeApp.cpp`.
+
## Running the C++ unit tests on a device
CI builds the Android unit test executable but doesn't run it. To run it on a connected device:
@@ -97,10 +105,27 @@ failures. Worth doing before a release, and after changing `Common/File` or anyt
Two things to know when reading its results:
- The executable has no Java VM, so content URIs fail like missing files there. They're only exercised
- for real inside the app.
+ for real inside the app, by the storage tests below.
- From Git Bash, set `MSYS_NO_PATHCONV=1` before any `adb push`/`adb shell` of your own, or
`/data/local/tmp` gets rewritten into a Windows path and the push silently lands somewhere else.
+## Running the storage tests in the app
+
+`Core/Util/StorageTest.cpp` exercises the file functions (create, overwrite, list, rename, move, copy,
+delete, odd names, free space) in a scratch folder, and times the calls the emulator makes most. The
+`Storage` unit test runs them on a native folder; to run them on a picked folder, through the content
+URI code:
+
+ python Tools/android_storage_test.py --build # build and install the normal debug APK, then run
+ python Tools/android_storage_test.py # with what's installed
+
+That starts the app with `--start-screen=storagetest`. The first time, tap Choose folder on the device,
+create a new empty folder in the picker, and choose it. It's remembered (in `storage_test_dir.txt` in
+the app's internal data), so later runs need no hands and take seconds. Results go to logcat as
+`StorageTest: PASS/FAIL ...` lines, ending with `StorageTest: DONE, N failed`. Run them in a folder on
+an SD card too, if the device has one. Keep the screen on (Stay awake in the developer options) while
+timing: a locked phone throttles the app, and the times double.
+
## VR (Quest)
- The VR flavor is a separate package: `./gradlew :android:assembleVrDebug`, installing as
diff --git a/libretro/Makefile.common b/libretro/Makefile.common
index 38cfedceb4..cf87163f28 100644
--- a/libretro/Makefile.common
+++ b/libretro/Makefile.common
@@ -937,6 +937,7 @@ SOURCES_CXX += \
$(COREDIR)/Util/AtracTrack.cpp \
$(COREDIR)/Util/BlockAllocator.cpp \
$(COREDIR)/Util/MemStick.cpp \
+ $(COREDIR)/Util/StorageTest.cpp \
$(COREDIR)/Util/PPGeDraw.cpp \
$(COREDIR)/Util/KL4E.cpp \
$(COREDIR)/Util/PSARUnpack.cpp \
diff --git a/unittest/UnitTest.cpp b/unittest/UnitTest.cpp
index c55e5d4446..4c19d1cfc3 100644
--- a/unittest/UnitTest.cpp
+++ b/unittest/UnitTest.cpp
@@ -127,6 +127,7 @@
#include "Core/ControlMapper.h"
#include "Core/HLE/sceCtrl.h"
#include "Core/HLE/sceUsbMic.h"
+#include "Core/Util/StorageTest.h"
#include "Core/Util/PathUtil.h"
#include "Core/Util/PSARUnpack.h"
#include "Core/MIPS/MIPSVFPUUtils.h"
@@ -2938,6 +2939,21 @@ static bool TestAndroidContentURI() {
return true;
}
+// The tests the storage test screen runs on a picked folder, here on a native one.
+static bool TestStorage() {
+ const Path root = UnitTestTempPath("unittest_storage");
+ File::DeleteDirRecursively(root);
+ EXPECT_TRUE(File::CreateFullPath(root));
+ const int failures = RunStorageTests(root, [](const StorageTestResult &result) {
+ if (!result.passed) {
+ printf("%s: %s\n", result.name.c_str(), result.detail.c_str());
+ }
+ });
+ File::DeleteDirRecursively(root);
+ EXPECT_EQ_INT(failures, 0);
+ return true;
+}
+
class UnitTestWordWrapper : public WordWrapper {
public:
UnitTestWordWrapper(std::string_view str, float maxW, int flags)
@@ -4324,6 +4340,7 @@ TestItem availableTests[] = {
TEST_ITEM(Path),
TEST_ITEM(OverlayHole),
TEST_ITEM(AndroidContentURI),
+ TEST_ITEM(Storage),
TEST_ITEM(ThreadManager),
TEST_ITEM(WrapText),
TEST_ITEM(TinySet),