/* * Copyright (C) 2021 Linux Studio Plugins Project * (C) 2021 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 12 февр. 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 UTEST_BEGIN("runtime.io", inmarksequence) bool check_string(const LSPString *s, size_t first, size_t len) { if (s->length() != len) return false; for (size_t i=0; ichar_at(i) != (first + i + 1)) return false; return true; } bool check_buffer(const lsp_wchar_t *b, size_t first, size_t count) { for (size_t i=0; ilength())); io::InStringSequence in(s); io::InMarkSequence ims; LSPString out; ByteBuffer buf(s->length() * sizeof(lsp_wchar_t)); lsp_wchar_t *data = buf.data(); // Test for mark() and wrap UTEST_ASSERT(ims.mark(-1) == STATUS_CLOSED); UTEST_ASSERT(ims.reset() == STATUS_CLOSED); UTEST_ASSERT(ims.wrap(&in, true) == STATUS_OK); UTEST_ASSERT(ims.mark(-1) == STATUS_OK); UTEST_ASSERT(ims.reset() == STATUS_NOT_FOUND); // Perform first read ssize_t nread = ims.read(data, s->length() * 2); UTEST_ASSERT(nread == ssize_t(s->length())); UTEST_ASSERT(!buf.corrupted()); UTEST_ASSERT(check_buffer(data, 1, s->length())); // Perform second read - EOF should be returned nread = ims.read(data, s->length() * 2); UTEST_ASSERT(nread == -STATUS_EOF); // reset() should return NOT_FOUND error UTEST_ASSERT(ims.reset() == STATUS_NOT_FOUND); // Close the stream UTEST_ASSERT(ims.close() == STATUS_OK); } void test_partial_read(const LSPString *s, size_t blk_size) { printf("Testing partial read for block size %d\n", int(blk_size)); io::InStringSequence in(s); io::InMarkSequence ims; LSPString out; ByteBuffer buf(s->length() * sizeof(lsp_wchar_t)); lsp_wchar_t *data = buf.data(); // Wrap UTEST_ASSERT(ims.wrap(&in, true) == STATUS_OK); ssize_t nread = 0, total = 0; // Perform read with specific block size while ((nread = ims.read(data, blk_size)) >= 0) { data += nread; total += nread; } UTEST_ASSERT(nread == -STATUS_EOF); UTEST_ASSERT(total == ssize_t(s->length())); // Check buffer data = buf.data(); UTEST_ASSERT(check_buffer(data, 1, s->length())); // Close the stream UTEST_ASSERT(ims.close() == STATUS_OK); } void test_character_read(const LSPString *s) { printf("Testing character read\n"); io::InStringSequence in(s); io::InMarkSequence ims; LSPString out; ByteBuffer buf(s->length() * sizeof(lsp_wchar_t)); lsp_wchar_t *data = buf.data(); // Wrap UTEST_ASSERT(ims.wrap(&in, true) == STATUS_OK); ssize_t total = 0; lsp_swchar_t ch; // Perform read with specific block size while ((ch = ims.read()) >= 0) data[total++] = ch; UTEST_ASSERT(ch == -STATUS_EOF); UTEST_ASSERT(total == ssize_t(s->length())); // Check buffer data = buf.data(); UTEST_ASSERT(check_buffer(data, 1, s->length())); // Close the stream UTEST_ASSERT(ims.close() == STATUS_OK); } void test_full_with_mark(const LSPString *s) { printf("Testing full read of %d characters with mark\n", int(s->length())); io::InStringSequence in(s); io::InMarkSequence ims; LSPString out; ByteBuffer buf(s->length() * sizeof(lsp_wchar_t) * 2); lsp_wchar_t *data = buf.data(); // Test for mark() and wrap UTEST_ASSERT(ims.wrap(&in, true) == STATUS_OK); UTEST_ASSERT(ims.mark(s->length()) == STATUS_OK); // Perform first read ssize_t nread = ims.read(data, s->length() * 2); UTEST_ASSERT(nread == ssize_t(s->length())); UTEST_ASSERT(!buf.corrupted()); UTEST_ASSERT(check_buffer(data, 1, s->length())); // Perform reset and second read UTEST_ASSERT(ims.reset() == STATUS_OK); nread = ims.read(&data[s->length()], s->length() * 2); UTEST_ASSERT(nread == ssize_t(s->length())); UTEST_ASSERT(!buf.corrupted()); UTEST_ASSERT(check_buffer(&data[s->length()], 1, s->length())); // Perform third read - EOF should be returned nread = ims.read(&data[s->length() * 2], s->length() * 2); UTEST_ASSERT(!buf.corrupted()); UTEST_ASSERT(nread == -STATUS_EOF); // Close the stream UTEST_ASSERT(ims.close() == STATUS_OK); } void test_character_with_mark(const LSPString *s) { printf("Testing full read of %d characters with mark\n", int(s->length())); io::InStringSequence in(s); io::InMarkSequence ims; LSPString out; ByteBuffer buf(s->length() * sizeof(lsp_wchar_t) * 2); lsp_wchar_t *data = buf.data(); // Test for mark() and wrap UTEST_ASSERT(ims.wrap(&in, true) == STATUS_OK); UTEST_ASSERT(ims.mark(s->length()) == STATUS_OK); // Perform first read ssize_t total = 0; lsp_swchar_t ch; while ((ch = ims.read()) >= 0) data[total++] = ch; UTEST_ASSERT(ch == -STATUS_EOF); UTEST_ASSERT(total == ssize_t(s->length())); UTEST_ASSERT(!buf.corrupted()); UTEST_ASSERT(check_buffer(data, 1, s->length())); // Perform reset and second read UTEST_ASSERT(ims.reset() == STATUS_OK); while ((ch = ims.read()) >= 0) data[total++] = ch; UTEST_ASSERT(ch == -STATUS_EOF); UTEST_ASSERT(total == ssize_t(s->length() * 2)); UTEST_ASSERT(!buf.corrupted()); UTEST_ASSERT(check_buffer(&data[s->length()], 1, s->length())); // Close the stream UTEST_ASSERT(ims.close() == STATUS_OK); } void test_partial_with_mark(const LSPString *s, ssize_t start, ssize_t mark, ssize_t blk_size) { printf("Testing partial read of %d-%d/%d characters with mark\n", int(start), int(mark), int(blk_size)); io::InStringSequence in(s); io::InMarkSequence ims; LSPString out; ByteBuffer buf(s->length() * sizeof(lsp_wchar_t) * 3); lsp_wchar_t *data = buf.data(); lsp_wchar_t *ptr = data; // Test for mark() and wrap UTEST_ASSERT(ims.wrap(&in, true) == STATUS_OK); ssize_t nread = 0, total = 0; // Perform read with specific block size while (total < start) { nread = ims.read(data, lsp_min(blk_size, start - total)); UTEST_ASSERT(nread >= 0); data += nread; total += nread; } UTEST_ASSERT(total == start); UTEST_ASSERT(check_buffer(ptr, 1, total)); // Perform mark and read next value UTEST_ASSERT(ims.mark(mark) == STATUS_OK); ptr += total; total = 0; while (total < mark) { nread = ims.read(data, lsp_min(blk_size, mark - total)); UTEST_ASSERT(nread >= 0); data += nread; total += nread; } UTEST_ASSERT(total == mark); UTEST_ASSERT(check_buffer(ptr, start + 1, total)); // Perform reset and read again UTEST_ASSERT(ims.reset() == STATUS_OK); ptr += total; total = 0; while (total < mark*2) { nread = ims.read(data, lsp_min(blk_size, mark*2 - total)); UTEST_ASSERT(nread >= 0); data += nread; total += nread; } UTEST_ASSERT(total == mark*2); UTEST_ASSERT(check_buffer(ptr, start + 1, total)); // Now reset() should fail, read the rest data UTEST_ASSERT(ims.reset() == STATUS_NOT_FOUND); ptr += total; total = 0; while ((nread = ims.read(data, blk_size)) >= 0) { data += nread; total += nread; } UTEST_ASSERT(nread == -STATUS_EOF); UTEST_ASSERT(total == ssize_t(s->length() - start - mark*2)); UTEST_ASSERT(check_buffer(ptr, start + mark*2 + 1, total)); // Close the stream UTEST_ASSERT(ims.close() == STATUS_OK); } void test_char_partial_with_mark(const LSPString *s, ssize_t start, ssize_t mark) { printf("Testing partial character read of %d-%d characters with mark\n", int(start), int(mark)); io::InStringSequence in(s); io::InMarkSequence ims; LSPString out; ByteBuffer buf(s->length() * sizeof(lsp_wchar_t) * 3); lsp_wchar_t *data = buf.data(); lsp_wchar_t *ptr = data; lsp_swchar_t ch; // Test for mark() and wrap UTEST_ASSERT(ims.wrap(&in, true) == STATUS_OK); ssize_t total = 0; // Perform initial read while (total < start) { UTEST_ASSERT((ch = ims.read()) >= 0); *data++ = ch; total++; } UTEST_ASSERT(total == start); UTEST_ASSERT(check_buffer(ptr, 1, total)); // Perform mark and read next value UTEST_ASSERT(ims.mark(mark) == STATUS_OK); ptr = data; total = 0; while (total < mark) { UTEST_ASSERT((ch = ims.read()) >= 0); *data++ = ch; total++; } UTEST_ASSERT(total == mark); UTEST_ASSERT(check_buffer(ptr, start + 1, total)); // Perform reset and read again UTEST_ASSERT(ims.reset() == STATUS_OK); ptr += total; total = 0; while (total < mark*2) { UTEST_ASSERT((ch = ims.read()) >= 0); *data++ = ch; total++; } UTEST_ASSERT(total == mark*2); UTEST_ASSERT(check_buffer(ptr, start + 1, total)); // Now reset() should fail, read the rest data UTEST_ASSERT(ims.reset() == STATUS_NOT_FOUND); ptr += total; total = 0; while ((ch = ims.read()) >= 0) { *data++ = ch; total++; } UTEST_ASSERT(ch == -STATUS_EOF); UTEST_ASSERT(total == ssize_t(s->length() - start - mark*2)); UTEST_ASSERT(check_buffer(ptr, start + mark*2 + 1, total)); // Close the stream UTEST_ASSERT(ims.close() == STATUS_OK); } UTEST_MAIN { LSPString src; for (size_t i=0; i<10000; ++i) { UTEST_ASSERT(src.append(lsp_wchar_t(i + 1))); } UTEST_ASSERT(check_string(&src, 0, 10000)); // Perform tests test_full_read(&src); test_partial_read(&src, 1); test_partial_read(&src, 31); test_partial_read(&src, 1023); test_partial_read(&src, 1024); test_character_read(&src); test_full_with_mark(&src); test_character_with_mark(&src); test_partial_with_mark(&src, 2048, 512, 512); test_partial_with_mark(&src, 2048, 1024, 512); test_partial_with_mark(&src, 2048, 2048, 512); test_partial_with_mark(&src, 2048, 512, 31); test_partial_with_mark(&src, 2048, 1024, 31); test_partial_with_mark(&src, 2048, 2048, 31); test_partial_with_mark(&src, 2048, 512, 1); test_partial_with_mark(&src, 2048, 1024, 1); test_partial_with_mark(&src, 2048, 2048, 1); test_char_partial_with_mark(&src, 2048, 512); test_char_partial_with_mark(&src, 2048, 1024); test_char_partial_with_mark(&src, 2048, 2048); test_char_partial_with_mark(&src, 2048, 512); test_char_partial_with_mark(&src, 2048, 1024); test_char_partial_with_mark(&src, 2048, 2048); test_char_partial_with_mark(&src, 2048, 512); test_char_partial_with_mark(&src, 2048, 1024); test_char_partial_with_mark(&src, 2048, 2048); } UTEST_END