203 lines
7.9 KiB
C++
203 lines
7.9 KiB
C++
#include "files_text_document.h"
|
|
|
|
#include <objbase.h>
|
|
#include <winioctl.h>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
|
|
namespace fs = std::filesystem;
|
|
using ks::files::TextDocument;
|
|
using ks::files::TextEncoding;
|
|
using ks::files::TextLineEnding;
|
|
|
|
namespace
|
|
{
|
|
void check(bool condition, const char *message)
|
|
{
|
|
if (!condition) throw std::runtime_error(message);
|
|
}
|
|
|
|
struct Fixture
|
|
{
|
|
fs::path directory;
|
|
Fixture()
|
|
{
|
|
GUID id{};
|
|
wchar_t name[40]{};
|
|
check(SUCCEEDED(CoCreateGuid(&id)) && StringFromGUID2(id, name, 40), "Create fixture ID");
|
|
directory = fs::temp_directory_path() / (std::wstring(L"ks-files-text-") + name);
|
|
fs::create_directory(directory);
|
|
}
|
|
~Fixture()
|
|
{
|
|
std::error_code error;
|
|
fs::remove_all(directory, error);
|
|
}
|
|
};
|
|
|
|
void writeFile(const fs::path &path, const std::string &bytes)
|
|
{
|
|
std::ofstream output(path, std::ios::binary);
|
|
output.write(bytes.data(), bytes.size());
|
|
check(static_cast<bool>(output), "Write fixture");
|
|
}
|
|
|
|
std::string readFile(const fs::path &path)
|
|
{
|
|
std::ifstream input(path, std::ios::binary);
|
|
check(static_cast<bool>(input), "Read fixture");
|
|
return {std::istreambuf_iterator<char>(input), std::istreambuf_iterator<char>()};
|
|
}
|
|
|
|
void editsAcrossPages(const fs::path &file)
|
|
{
|
|
const std::string first = std::string(TextDocument::pageBytes - 2, 'a') + "\r\n";
|
|
const std::string middle = std::string(TextDocument::pageBytes - 2, 'b') + "\r\n";
|
|
const std::string last = "last\r\n";
|
|
const std::string bom = "\xef\xbb\xbf";
|
|
writeFile(file, bom + first + middle + last);
|
|
TextDocument document(file);
|
|
check(document.pages() == 3, "Expected three pages");
|
|
check(document.readPage(1) == middle, "Read middle page");
|
|
document.stage(2, "last changed\r\n");
|
|
check(!document.modifiedWith(2, last), "Restoring the only modified page leaves no changes");
|
|
check(document.modifiedWith(0, first), "An original page must not hide changes to other pages");
|
|
document.stage(0, "first changed\n");
|
|
check(document.readPage(2) == "last changed\r\n", "Read staged page");
|
|
check(document.save(), "Replace and reopen");
|
|
check(!document.modified(), "Save clears staged page edits");
|
|
check(readFile(file) == bom + "first changed\n" + middle + "last changed\r\n",
|
|
"Save must preserve untouched bytes and the BOM");
|
|
document.stage(0, "saved again\n");
|
|
check(document.save(), "Save again through the same document");
|
|
}
|
|
|
|
void unicodeBoundaries(const fs::path &file)
|
|
{
|
|
const auto chunk = TextDocument::pageBytes;
|
|
const std::string emoji = "\xf0\x9f\x98\x80";
|
|
writeFile(file, std::string(chunk - 1, 'a') + emoji + "tail");
|
|
{
|
|
TextDocument document(file, false);
|
|
check(document.boundary(1) == chunk + 3, "UTF-8 split within a code point");
|
|
check(document.readPage(0).ends_with(emoji) && document.readPage(1) == "tail", "Read split UTF-8");
|
|
}
|
|
for (const bool little : {true, false})
|
|
{
|
|
const std::string bom = little ? "\xff\xfe" : "\xfe\xff";
|
|
const std::string letter(little ? "a\0" : "\0a", 2);
|
|
const std::string pair(little ? "\x3d\xd8\x00\xde" : "\xd8\x3d\xde\x00", 4);
|
|
std::string first;
|
|
for (size_t n = 0; n < chunk / 2 - 1; ++n) first += letter;
|
|
first += pair;
|
|
writeFile(file, bom + first + letter);
|
|
TextDocument document(file);
|
|
check(document.readPage(0).ends_with(emoji) && document.readPage(1) == "a", "Read split UTF-16");
|
|
document.stage(1, emoji);
|
|
check(document.save() && readFile(file) == bom + first + pair, "Preserve UTF-16 byte order");
|
|
}
|
|
}
|
|
|
|
void rejectExternalReplacement(const fs::path &file)
|
|
{
|
|
writeFile(file, "original");
|
|
TextDocument document(file);
|
|
document.stage(0, "editor changes");
|
|
auto later = file;
|
|
later += L".later";
|
|
auto original = file;
|
|
original += L".original";
|
|
writeFile(later, "external changes");
|
|
check(MoveFileExW(file.c_str(), original.c_str(), 0) && MoveFileExW(later.c_str(), file.c_str(), 0),
|
|
"Replace file externally");
|
|
bool rejected{};
|
|
try { document.save(); }
|
|
catch (const std::exception &) { rejected = true; }
|
|
check(rejected && document.modified() && readFile(file) == "external changes",
|
|
"Preserve external file and staged changes after conflict");
|
|
}
|
|
|
|
void sparseFile(const fs::path &file)
|
|
{
|
|
constexpr uint64_t offset = 5ULL << 30;
|
|
const auto handle = CreateFileW(file.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
|
|
check(handle != INVALID_HANDLE_VALUE, "Create sparse fixture");
|
|
DWORD count{};
|
|
if (!DeviceIoControl(handle, FSCTL_SET_SPARSE, nullptr, 0, nullptr, 0, &count, nullptr))
|
|
{
|
|
CloseHandle(handle);
|
|
std::cout << "Sparse fixture skipped on this file system.\n";
|
|
return;
|
|
}
|
|
LARGE_INTEGER position{};
|
|
position.QuadPart = offset;
|
|
const bool written = SetFilePointerEx(handle, position, nullptr, FILE_BEGIN) &&
|
|
WriteFile(handle, "last", 4, &count, nullptr) && count == 4;
|
|
CloseHandle(handle);
|
|
check(written, "Write beyond the 32-bit range");
|
|
TextDocument document(file);
|
|
const auto index = document.pages() - 1;
|
|
check(document.size() == offset + 4 && document.boundary(index) == offset, "Use 64-bit offsets");
|
|
check(document.readPage(index) == "last", "Read past 4 GiB");
|
|
document.stage(index, "edited");
|
|
check(document.readPage(index) == "edited", "Stage an edit past 4 GiB");
|
|
}
|
|
|
|
void saveDraft(const fs::path &file)
|
|
{
|
|
TextDocument draft({});
|
|
check(draft.readPage(0).empty() && draft.pages()==1, "Start with an empty draft");
|
|
draft.stage(0,"one\r\ntwo\rthree\n");
|
|
writeFile(file,"existing");
|
|
bool rejected{};
|
|
try {draft.saveNew(file,{});}
|
|
catch(const std::exception &) {rejected=true;}
|
|
check(rejected && draft.modified() && readFile(file)=="existing", "Preserve a conflicting file and the draft");
|
|
fs::remove(file);
|
|
check(draft.saveNew(file,{TextEncoding::utf8,true,TextLineEnding::lf}), "Save a draft as a new file");
|
|
check(readFile(file)=="\xef\xbb\xbfone\ntwo\nthree\n" && draft.readPage(0)=="one\ntwo\nthree\n",
|
|
"Save a UTF-8 signature and normalize mixed line endings");
|
|
draft.stage(0,"after");
|
|
check(draft.save() && readFile(file)=="\xef\xbb\xbf" "after", "Edit normally after the first save");
|
|
|
|
const auto ansiFile=file.parent_path()/L"windows1252.txt";
|
|
TextDocument ansiDraft({});
|
|
ansiDraft.stage(0,"caf\xc3\xa9\n");
|
|
check(ansiDraft.saveNew(ansiFile,{TextEncoding::windows1252,false,TextLineEnding::crlf}),
|
|
"Save a draft in Windows-1252");
|
|
check(readFile(ansiFile)=="caf\xe9\r\n" && ansiDraft.readPage(0)=="caf\xc3\xa9\r\n",
|
|
"Round-trip Windows-1252 text and CRLF");
|
|
TextDocument ansiReader(ansiFile,false,TextEncoding::windows1252);
|
|
check(ansiReader.readPage(0)=="caf\xc3\xa9\r\n", "Open an existing file with an explicit code page");
|
|
|
|
const auto unicodeFile=file.parent_path()/L"utf16be.txt";
|
|
TextDocument unicodeDraft({});
|
|
unicodeDraft.stage(0,"a\n");
|
|
check(unicodeDraft.saveNew(unicodeFile,{TextEncoding::utf16be,true,TextLineEnding::cr}),
|
|
"Save a UTF-16 draft with a signature");
|
|
TextDocument unicodeReader(unicodeFile,false);
|
|
check(readFile(unicodeFile)==std::string("\xfe\xff\0a\0\r",6) && unicodeReader.readPage(0)=="a\r",
|
|
"Detect the UTF-16 signature and read CR line endings");
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
try
|
|
{
|
|
const Fixture fixture;
|
|
editsAcrossPages(fixture.directory / L"pages.txt");
|
|
unicodeBoundaries(fixture.directory / L"unicode.txt");
|
|
rejectExternalReplacement(fixture.directory / L"external.txt");
|
|
saveDraft(fixture.directory / L"created.txt");
|
|
sparseFile(fixture.directory / L"5gib.log");
|
|
std::cout << "Files text document regressions passed.\n";
|
|
}
|
|
catch (const std::exception &error)
|
|
{
|
|
std::cerr << error.what() << '\n';
|
|
return 1;
|
|
}
|
|
}
|