/* * Copyright (C) 2021 Linux Studio Plugins Project * (C) 2021 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 3 мар. 2021 г. * * 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; static constexpr size_t LOG_BUFFER_SIZE = 12; static constexpr size_t FLUSH_LIMIT = 1 << 16; UTEST_BEGIN("runtime.resource", compressor) UTEST_TIMELIMIT(30) void scan_directory(wsize_t *data_size, const io::Path *base, const io::Path *path, resource::Compressor *c) { io::Dir dir; status_t res; LSPString str; io::Path child, relative; io::fattr_t fattr; size_t compressed = 0; UTEST_ASSERT(dir.open(path) == STATUS_OK); while ((res = dir.reads(&str, &fattr, false)) == STATUS_OK) { if (io::Path::is_dots(&str)) continue; UTEST_ASSERT(child.set(path, &str) == STATUS_OK); UTEST_ASSERT(relative.set(path, &str) == STATUS_OK); UTEST_ASSERT(relative.remove_base(base) == STATUS_OK); printf(" found entry: %s\n", relative.as_native()); if (fattr.type == io::fattr_t::FT_REGULAR) { io::InFileStream ifs; UTEST_ASSERT(ifs.open(&child) == STATUS_OK); wssize_t len = c->create_file(&relative, &ifs); UTEST_ASSERT(len >= 0); UTEST_ASSERT(ifs.close() == STATUS_OK); *data_size += len; compressed += len; if (compressed >= FLUSH_LIMIT) { UTEST_ASSERT(c->flush() == STATUS_OK); compressed = 0; } } else if (fattr.type == io::fattr_t::FT_DIRECTORY) { UTEST_ASSERT(c->create_dir(&relative) == STATUS_OK); scan_directory(data_size, base, &child, c); } } } void scan_resources(resource::BuiltinLoader *load, const io::Path *path, const io::Path *temp, const io::Path *rel) { resource::resource_t *rlist = NULL; io::Path file, child, out; io::OutMemoryStream oms1, oms2; io::InFileStream ifs; io::IInStream *irs; io::OutFileStream ofs; ssize_t items = load->enumerate(rel, &rlist); UTEST_ASSERT(items >= 0); UTEST_ASSERT(rlist != NULL); for (ssize_t i=0; iname) == STATUS_OK); printf(" found entry: %s\n", child.as_native()); if (item->type == resource::RES_DIR) { scan_resources(load, path, temp, &child); continue; } // Decompress the item oms1.clear(); UTEST_ASSERT((irs = load->read_stream(&child)) != NULL); wssize_t sz1 = irs->sink(&oms1); UTEST_ASSERT(sz1 >= 0); UTEST_ASSERT(irs->close() == STATUS_OK); delete irs; UTEST_ASSERT(oms1.size() == size_t(sz1)); printf(" decompressed entry size: %ld bytes\n", long(sz1)); // Save the decompressed entry UTEST_ASSERT(out.set(temp, rel) == STATUS_OK); UTEST_ASSERT(out.append_child(item->name) == STATUS_OK); printf(" saving decompressed entry as: %s\n", out.as_native()); UTEST_ASSERT(out.mkparent(true) == STATUS_OK); UTEST_ASSERT(ofs.open(&out, io::File::FM_WRITE_NEW) == STATUS_OK); wssize_t osz = ofs.write(oms1.data(), oms1.size()); UTEST_ASSERT(osz == sz1); UTEST_ASSERT(ofs.close() == STATUS_OK); // Read the original file oms2.clear(); UTEST_ASSERT(file.set(path, &child) == STATUS_OK); UTEST_ASSERT(ifs.open(&file) == STATUS_OK); wssize_t sz2 = ifs.sink(&oms2); UTEST_ASSERT(ifs.close() == STATUS_OK); UTEST_ASSERT(sz2 >= 0); UTEST_ASSERT(oms2.size() == size_t(sz2)); printf(" original entry size: %ld bytes\n", long(sz2)); // Compare the data UTEST_ASSERT(sz1 == sz2); UTEST_ASSERT(memcmp(oms1.data(), oms2.data(), sz1) == 0); oms1.drop(); oms2.drop(); } // Free items free(rlist); } void test_compress_data(const io::Path *path, resource::Compressor *c, io::OutMemoryStream *os) { wsize_t data_size = 0; io::Path tmp; io::OutFileStream ofs; // Scan and compress directory UTEST_ASSERT(c->init(LOG_BUFFER_SIZE, os) == STATUS_OK); printf("Scanning source directory...\n"); scan_directory(&data_size, path, path, c); c->flush(); // Flush compressor if ther is some data size_t buf_sz = os->size(); double ratio = double(data_size) / double(buf_sz); printf("Command size: %d, data size: %d, ratio: %.2f\n", int(os->size()), int(data_size), ratio ); UTEST_ASSERT(tmp.fmt("%s/%s.commands", tempdir(), full_name()) > 0); printf("Dumping commands to: %s\n", tmp.as_native()); UTEST_ASSERT(ofs.open(&tmp, io::File::FM_WRITE_NEW) == STATUS_OK); ofs.write(os->data(), os->size()); UTEST_ASSERT(ofs.close() == STATUS_OK); } void test_decompress_data(const io::Path *path, resource::Compressor *c, io::OutMemoryStream *os) { resource::BuiltinLoader load; io::Path rel; io::Path tmp; UTEST_ASSERT(tmp.fmt("%s/utest-%s", tempdir(), full_name()) > 0); UTEST_ASSERT(load.init(os->data(), os->size(), c->entries(), c->num_entires(), LOG_BUFFER_SIZE) == STATUS_OK); printf("Scanning resource registry...\n"); scan_resources(&load, path, &tmp, &rel); } UTEST_MAIN { io::Path path; resource::Compressor c; io::OutMemoryStream oms; UTEST_ASSERT(path.fmt("%s/compressor", resources()) > 0); printf("Resource directory: %s\n", path.as_native()); // Compress data test_compress_data(&path, &c, &oms); // Decompress data test_decompress_data(&path, &c, &oms); UTEST_ASSERT(c.close() == STATUS_OK); oms.drop(); UTEST_ASSERT(oms.close() == STATUS_OK); } UTEST_END