/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 6 мар. 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include #include #include #include #include #include #include using namespace lsp; using namespace lsp::io; UTEST_BEGIN("runtime.io", file) void testClosedFile(const char *label, File &fd) { uint8_t tmpbuf[0x100]; printf("Testing %s...\n", label); // Test for read failues UTEST_ASSERT(fd.read(tmpbuf, sizeof(tmpbuf)) < 0); UTEST_ASSERT(fd.pread(0, tmpbuf, sizeof(tmpbuf)) < 0); // Test for write failures UTEST_ASSERT(fd.write(tmpbuf, sizeof(tmpbuf) < 0)); UTEST_ASSERT(fd.pwrite(0, tmpbuf, sizeof(tmpbuf) < 0)); UTEST_ASSERT(fd.position() < 0); // Test for supplementary failures UTEST_ASSERT(fd.seek(0, File::FSK_SET) != STATUS_OK); UTEST_ASSERT(fd.position() < 0); UTEST_ASSERT(fd.flush() != STATUS_OK); UTEST_ASSERT(fd.sync() != STATUS_OK); // Test for close success UTEST_ASSERT(fd.close() == STATUS_OK); } void testWriteonlyFile(File &fd) { uint32_t tmpbuf[0x100]; UTEST_ASSERT(fd.seek(0, SEEK_END) == STATUS_OK); UTEST_ASSERT(fd.position() == 0); // Write data to file wssize_t written = 0; for (size_t i=0; i<0x100; ++i) { for (size_t j=0; j<0x100; ++j) tmpbuf[j] = uint32_t((i << 8) | j); UTEST_ASSERT(fd.write(tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); written += sizeof(tmpbuf); } UTEST_ASSERT(fd.flush() == STATUS_OK); // Get status io::fattr_t attr; UTEST_ASSERT(fd.stat(&attr) == STATUS_OK); UTEST_ASSERT(attr.type == io::fattr_t::FT_REGULAR); UTEST_ASSERT(attr.size == wsize_t(written)); // Obtain position and change it UTEST_ASSERT(fd.position() == written); wssize_t position = 0x1000; UTEST_ASSERT(fd.seek(position, SEEK_SET) == STATUS_OK); UTEST_ASSERT(fd.position() == position); // Ensure that read gives failures UTEST_ASSERT(fd.read(tmpbuf, sizeof(tmpbuf)) < 0); UTEST_ASSERT(fd.read(tmpbuf, 0) < 0); UTEST_ASSERT(fd.pread(0x10000, tmpbuf, sizeof(tmpbuf)) < 0); UTEST_ASSERT(fd.pread(0x10000, tmpbuf, 0) < 0); UTEST_ASSERT(fd.position() == position); // Ensure that positional write gives no failures ::memset(tmpbuf, 0x55, sizeof(tmpbuf)); UTEST_ASSERT(fd.write(tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); UTEST_ASSERT(fd.write(tmpbuf, 0) == 0); position += sizeof(tmpbuf); UTEST_ASSERT(fd.position() == position); ::memset(tmpbuf, 0xaa, sizeof(tmpbuf)); UTEST_ASSERT(fd.pwrite(written, tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); UTEST_ASSERT(fd.pwrite(written, tmpbuf, 0) == 0); UTEST_ASSERT(fd.position() == position); // Ensure that sync() and flush() work properly UTEST_ASSERT(fd.flush() == STATUS_OK); UTEST_ASSERT(fd.sync() == STATUS_OK); // Try to truncate file UTEST_ASSERT(fd.truncate(written) == STATUS_OK); UTEST_ASSERT(fd.seek(0, SEEK_END) == STATUS_OK); UTEST_ASSERT(fd.position() == written); UTEST_ASSERT(fd.pwrite(written, tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); // Test for close success UTEST_ASSERT(fd.close() == STATUS_OK); } void testReadonlyFile(File &fd) { uint32_t tmpbuf[0x100], ckbuf[0x100]; UTEST_ASSERT(fd.position() == 0); // Read data from file wssize_t read = 0; for (size_t i=0; i<0x100; ++i) { if (read != 0x1000) { for (size_t j=0; j<0x100; ++j) ckbuf[j] = uint32_t((i << 8) | j); } else ::memset(ckbuf, 0x55, sizeof(ckbuf)); UTEST_ASSERT(fd.read(tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); UTEST_ASSERT(::memcmp(tmpbuf, ckbuf, sizeof(tmpbuf)) == 0); read += sizeof(tmpbuf); } // Read the last chunk and check EOF detection ::memset(ckbuf, 0xaa, sizeof(ckbuf)); UTEST_ASSERT(fd.read(tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); UTEST_ASSERT(::memcmp(tmpbuf, ckbuf, sizeof(tmpbuf)) == 0); read += sizeof(tmpbuf); UTEST_ASSERT(fd.read(tmpbuf, sizeof(tmpbuf)) == (-STATUS_EOF)); // Get status io::fattr_t attr; UTEST_ASSERT(fd.stat(&attr) == STATUS_OK); UTEST_ASSERT(attr.type == io::fattr_t::FT_REGULAR); UTEST_ASSERT(attr.size == wsize_t(read)); // Obtain position and change it UTEST_ASSERT(fd.position() == read); wssize_t position = 0x1000; UTEST_ASSERT(fd.seek(position, SEEK_SET) == STATUS_OK); UTEST_ASSERT(fd.position() == position); // Ensure that write gives failures UTEST_ASSERT(fd.write(tmpbuf, sizeof(tmpbuf)) < 0); UTEST_ASSERT(fd.write(tmpbuf, 0) < 0); UTEST_ASSERT(fd.pwrite(0x10000, tmpbuf, sizeof(tmpbuf)) < 0); UTEST_ASSERT(fd.pwrite(0x10000, tmpbuf, 0) < 0); UTEST_ASSERT(fd.position() == position); // Ensure that positional read gives no failures ::memset(ckbuf, 0x55, sizeof(ckbuf)); UTEST_ASSERT(fd.read(tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); UTEST_ASSERT(fd.read(tmpbuf, 0) == 0); UTEST_ASSERT(::memcmp(tmpbuf, ckbuf, sizeof(tmpbuf)) == 0); position += sizeof(tmpbuf); UTEST_ASSERT(fd.position() == position); ::memset(ckbuf, 0xaa, sizeof(ckbuf)); UTEST_ASSERT(fd.pread(read - sizeof(tmpbuf), tmpbuf, sizeof(tmpbuf)) == sizeof(tmpbuf)); UTEST_ASSERT(fd.pread(read - sizeof(tmpbuf), tmpbuf, 0) == 0); UTEST_ASSERT(fd.position() == position); // Ensure that sync() and flush() do not work UTEST_ASSERT(fd.flush() != STATUS_OK); UTEST_ASSERT(fd.sync() != STATUS_OK); // Try to truncate file UTEST_ASSERT(fd.truncate(0x1000) != STATUS_OK); UTEST_ASSERT(fd.seek(0, SEEK_END) == STATUS_OK); UTEST_ASSERT(fd.position() == read); // Test for close success UTEST_ASSERT(fd.close() == STATUS_OK); } template void testWriteonlyFileName(const char *label, const LSPString *path, TemplateFile &fd) { printf("Testing %s...\n", label); // Open file with creation and truncation UTEST_ASSERT(fd.open(path, File::FM_WRITE | File::FM_CREATE | File::FM_TRUNC) == STATUS_OK); testWriteonlyFile(fd); } template void testReadonlyFileName(const char *label, const LSPString *path, TemplateFile &fd) { printf("Testing %s...\n", label); // Open file UTEST_ASSERT(fd.open(path, File::FM_READ) == STATUS_OK); testReadonlyFile(fd); } void testWriteonlyDescriptor(const char *label, FILE *f, StdioFile &fd) { printf("Testing %s...\n", label); UTEST_ASSERT(fd.wrap(f, File::FM_WRITE, false) == STATUS_OK); testWriteonlyFile(fd); } void testReadonlyDescriptor(const char *label, FILE *f, StdioFile &fd) { printf("Testing %s...\n", label); UTEST_ASSERT(fd.wrap(f, File::FM_READ, false) == STATUS_OK); testReadonlyFile(fd); } template void testUnexistingFile(const char *label, TemplateFile &fd) { printf("Testing %s...\n", label); LSPString path; UTEST_ASSERT(path.fmt_utf8("%s" FILE_SEPARATOR_S "utest-nonexisting-%s.tmp", tempdir(), full_name())); UTEST_ASSERT(fd.open(&path, File::FM_WRITE) != STATUS_OK); UTEST_ASSERT(fd.close() == STATUS_OK); } void createFile(const io::Path *prefix, int num) { io::Path path; const char *buf; io::OutFileStream ofs; LSPString postfix; printf(" creating file: %d\n", num); // Form file name UTEST_ASSERT(postfix.fmt_ascii("rendel-%02d.tmp", num) > 0); UTEST_ASSERT(path.set(prefix) == STATUS_OK); UTEST_ASSERT(path.append(&postfix) == STATUS_OK); // Write data to file and close UTEST_ASSERT(ofs.open(&path, io::File::FM_WRITE_NEW) == STATUS_OK); UTEST_ASSERT((buf = path.as_utf8()) != NULL); UTEST_ASSERT(ofs.write(buf, strlen(buf)) > 0); UTEST_ASSERT(ofs.close() == STATUS_OK); } void renameFile(const io::Path *prefix, int from, int to, int mode) { io::Path f, t; LSPString postfix; printf(" renaming file: %d -> %d\n", from, to); // Form source file name UTEST_ASSERT(postfix.fmt_ascii("rendel-%02d.tmp", from) > 0); UTEST_ASSERT(f.set(prefix) == STATUS_OK); UTEST_ASSERT(f.append(&postfix) == STATUS_OK); // Form destination file name UTEST_ASSERT(postfix.fmt_ascii("rendel-%02d.tmp", to) > 0); UTEST_ASSERT(t.set(prefix) == STATUS_OK); UTEST_ASSERT(t.append(&postfix) == STATUS_OK); // Rename the file status_t res = STATUS_NOT_IMPLEMENTED; switch (mode) { case 0: res = io::File::rename(f.as_utf8(), t.as_utf8()); break; case 1: res = io::File::rename(f.as_utf8(), t.as_string()); break; case 2: res = io::File::rename(f.as_utf8(), &t); break; case 3: res = io::File::rename(f.as_string(), t.as_utf8()); break; case 4: res = io::File::rename(f.as_string(), t.as_string()); break; case 5: res = io::File::rename(f.as_string(), &t); break; case 6: res = io::File::rename(&f, t.as_utf8()); break; case 7: res = io::File::rename(&f, t.as_string()); break; case 8: res = io::File::rename(&f, &t); break; default: break; } UTEST_ASSERT(res == STATUS_OK); } void checkFile(const io::Path *prefix, int from, int to) { io::Path f, t; io::InFileStream ifs; io::InSequence is; LSPString postfix, payload; printf(" checking file: unexists %d, exists %d\n", from, to); // Form source file name UTEST_ASSERT(postfix.fmt_ascii("rendel-%02d.tmp", from) > 0); UTEST_ASSERT(f.set(prefix) == STATUS_OK); UTEST_ASSERT(f.append(&postfix) == STATUS_OK); UTEST_ASSERT(!f.exists()); // Form destination file name UTEST_ASSERT(postfix.fmt_ascii("rendel-%02d.tmp", to) > 0); UTEST_ASSERT(t.set(prefix) == STATUS_OK); UTEST_ASSERT(t.append(&postfix) == STATUS_OK); // Open file UTEST_ASSERT(ifs.open(&t) == STATUS_OK); UTEST_ASSERT(is.wrap(&ifs, WRAP_NONE, "UTF-8") == STATUS_OK); UTEST_ASSERT(is.read_line(&payload, true) == STATUS_OK); UTEST_ASSERT(is.close() == STATUS_OK); UTEST_ASSERT(ifs.close() == STATUS_OK); // Test the output UTEST_ASSERT_MSG(payload.equals(f.as_string()), "Payload: %s, expected: %s", payload.get_native(), f.as_native() ); } void testRenameDelete() { printf("Testing rename and delete...\n"); io::Path prefix; UTEST_ASSERT(prefix.fmt("%s/utest-%s-rendel", tempdir(), full_name())); // Create files for (int i=0; i<18; ++i) createFile(&prefix, i); // Rename/move files for (int i=0; i<18; i += 2) renameFile(&prefix, i, i+1, i >> 1); // Check file for (int i=0; i<18; i += 2) checkFile(&prefix, i, i+1); } void testCopy() { printf("Testing file copy...\n"); ssize_t res, nread; io::Path dst, src; io::NativeFile in, out; UTEST_ASSERT(src.fmt("%s/utest-%s-copy-src.bin", tempdir(), full_name()) > 0); UTEST_ASSERT(dst.fmt("%s/utest-%s-copy-dst.bin", tempdir(), full_name()) > 0); // Generate source file printf(" generating source file...\n"); ByteBuffer buf1(0x1000), buf2(0x1000); UTEST_ASSERT(in.open(&src, io::File::FM_READWRITE_NEW) == STATUS_OK); wssize_t written = 0; for (size_t i=0; i<0x100; ++i) { buf1.randomize(); UTEST_ASSERT(in.write(buf1.data(), buf1.size()) == ssize_t(buf1.size())); written += buf1.size(); } UTEST_ASSERT(in.flush() == STATUS_OK); // Copy the file printf(" copying file %s to %s...\n", src.as_native(), dst.as_native()); wssize_t copied = io::File::copy(&src, &dst, 0x1234); UTEST_ASSERT_MSG(copied == written, "Expected to be written %ld bytes but written %ld bytes", long(written), long(copied)); // Validate the file printf(" verifying file contents...\n"); UTEST_ASSERT(in.seek(0, io::File::FSK_SET) == STATUS_OK); UTEST_ASSERT(out.open(&dst, io::File::FM_READ) == STATUS_OK); copied = 0; while ((res = in.read(buf1.data(), buf1.size())) >= 0) { nread = out.read(buf2.data(), res); UTEST_ASSERT(nread == res); UTEST_ASSERT(buf1.equals(buf2.data(), res)); copied += nread; } UTEST_ASSERT(res == -STATUS_EOF); UTEST_ASSERT(in.close() == STATUS_OK); UTEST_ASSERT(out.close() == STATUS_OK); UTEST_ASSERT(copied == written); printf(" all is ok, %d bytes copied\n", written); } UTEST_MAIN { LSPString path; File none_fd; StdioFile std_fd; NativeFile native_fd; UTEST_ASSERT(path.fmt_utf8("%s" FILE_SEPARATOR_S "utest-%s.tmp", tempdir(), full_name())); // Test closed files, all should fail the same way testClosedFile("test_closed_file (abstract)", none_fd); testClosedFile("test_closed_file (stdio)", std_fd); testClosedFile("test_closed_file (native)", native_fd); // Test stdio file testWriteonlyFileName("test_writeonly_filename (stdio)", &path, std_fd); testReadonlyFileName("test_readonly_filename (stdio)", &path, std_fd); testUnexistingFile("test_unexsiting_file (stdio)", std_fd); // Test stdio file as a wrapper FILE *fd = fopen(path.get_native(), "wb+"); UTEST_ASSERT(fd != NULL); testWriteonlyDescriptor("test_writeonly_descriptor (stdio)", fd, std_fd); UTEST_ASSERT(fseek(fd, 0, SEEK_SET) == 0); testReadonlyDescriptor("test_readonly_descriptor (stdio)", fd, std_fd); UTEST_ASSERT(fclose(fd) == 0); // Test native file testWriteonlyFileName("test_writeonly_filename (native)", &path, native_fd); testReadonlyFileName("test_readonly_filename (native)", &path, native_fd); testUnexistingFile("test_unexsiting_file (native)", native_fd); // Test rename and delete testRenameDelete(); // Test file copy testCopy(); } UTEST_END