From aa4053c2b0493d3020af5ed2bbdd7c6e46207864 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Fri, 6 Nov 2026 12:01:28 +0100 Subject: [PATCH] Add a storage test screen, to test content URIs on a device The unit tests have no Java VM on Android, so the content URI storage code could only be tested by hand. RunStorageTests() exercises file creation, overwrite, listing, rename, moves, copies, deletes, odd names and free space in a scratch folder, and times the calls the emulator makes most. The new StorageTestScreen (--start-screen=storagetest) runs them in a picked folder and remembers it. Tools/android_storage_test.py starts it over adb and collects the results from logcat, and Tools/android_run.py builds, installs and starts the app with any options. The screen raises the System log channel to INFO during a run, so the results get through. The Storage unit test runs the same tests on a native folder. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 2 +- Core/CMakeLists.txt | 2 + Core/CmdLine.cpp | 2 +- Core/Core.vcxproj | 2 + Core/Core.vcxproj.filters | 6 + Core/Util/StorageTest.cpp | 230 ++++++++++++++++++++++++++++ Core/Util/StorageTest.h | 36 +++++ Tools/android_run.py | 102 ++++++++++++ Tools/android_storage_test.py | 101 ++++++++++++ UI/CMakeLists.txt | 2 + UI/NativeApp.cpp | 4 + UI/StorageTestScreen.cpp | 183 ++++++++++++++++++++++ UI/StorageTestScreen.h | 67 ++++++++ UI/UI.vcxproj | 2 + UI/UI.vcxproj.filters | 6 + UWP/CoreUWP/CoreUWP.vcxproj | 2 + UWP/CoreUWP/CoreUWP.vcxproj.filters | 2 + UWP/UI_UWP/UI_UWP.vcxproj | 2 + UWP/UI_UWP/UI_UWP.vcxproj.filters | 6 + android/jni/Android.mk | 2 + docs/android-device-testing.md | 27 +++- libretro/Makefile.common | 1 + unittest/UnitTest.cpp | 17 ++ 23 files changed, 803 insertions(+), 3 deletions(-) create mode 100644 Core/Util/StorageTest.cpp create mode 100644 Core/Util/StorageTest.h create mode 100644 Tools/android_run.py create mode 100644 Tools/android_storage_test.py create mode 100644 UI/StorageTestScreen.cpp create mode 100644 UI/StorageTestScreen.h 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),