/*
* nghttp2 - HTTP/2 C Library
*
* Copyright (c) 2015 Tatsuhiro Tsujikawa
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "memchunk_test.h"
#include <CUnit/CUnit.h>
#include <nghttp2/nghttp2.h>
#include "memchunk.h"
#include "util.h"
namespace nghttp2 {
void test_pool_recycle(void) {
MemchunkPool pool;
CU_ASSERT(!pool.pool);
CU_ASSERT(0 == pool.poolsize);
CU_ASSERT(nullptr == pool.freelist);
auto m1 = pool.get();
CU_ASSERT(m1 == pool.pool);
CU_ASSERT(MemchunkPool::value_type::size == pool.poolsize);
CU_ASSERT(nullptr == pool.freelist);
auto m2 = pool.get();
CU_ASSERT(m2 == pool.pool);
CU_ASSERT(2 * MemchunkPool::value_type::size == pool.poolsize);
CU_ASSERT(nullptr == pool.freelist);
CU_ASSERT(m1 == m2->knext);
CU_ASSERT(nullptr == m1->knext);
auto m3 = pool.get();
CU_ASSERT(m3 == pool.pool);
CU_ASSERT(3 * MemchunkPool::value_type::size == pool.poolsize);
CU_ASSERT(nullptr == pool.freelist);
pool.recycle(m3);
CU_ASSERT(m3 == pool.pool);
CU_ASSERT(3 * MemchunkPool::value_type::size == pool.poolsize);
CU_ASSERT(m3 == pool.freelist);
auto m4 = pool.get();
CU_ASSERT(m3 == m4);
CU_ASSERT(m4 == pool.pool);
CU_ASSERT(3 * MemchunkPool::value_type::size == pool.poolsize);
CU_ASSERT(nullptr == pool.freelist);
pool.recycle(m2);
pool.recycle(m1);
CU_ASSERT(m1 == pool.freelist);
CU_ASSERT(m2 == m1->next);
CU_ASSERT(nullptr == m2->next);
}
using Memchunk16 = Memchunk<16>;
using MemchunkPool16 = Pool<Memchunk16>;
using Memchunks16 = Memchunks<Memchunk16>;
using PeekMemchunks16 = PeekMemchunks<Memchunk16>;
void test_memchunks_append(void) {
MemchunkPool16 pool;
Memchunks16 chunks(&pool);
chunks.append("012");
auto m = chunks.tail;
CU_ASSERT(3 == m->len());
CU_ASSERT(13 == m->left());
chunks.append("3456789abcdef@");
CU_ASSERT(16 == m->len());
CU_ASSERT(0 == m->left());
m = chunks.tail;
CU_ASSERT(1 == m->len());
CU_ASSERT(15 == m->left());
CU_ASSERT(17 == chunks.rleft());
char buf[16];
size_t nread;
nread = chunks.remove(buf, 8);
CU_ASSERT(8 == nread);
CU_ASSERT(0 == memcmp("01234567", buf, nread));
CU_ASSERT(9 == chunks.rleft());
nread = chunks.remove(buf, sizeof(buf));
CU_ASSERT(9 == nread);
CU_ASSERT(0 == memcmp("89abcdef@", buf, nread));
CU_ASSERT(0 == chunks.rleft());
CU_ASSERT(nullptr == chunks.head);
CU_ASSERT(nullptr == chunks.tail);
CU_ASSERT(32 == pool.poolsize);
}
void test_memchunks_drain(void) {
MemchunkPool16 pool;
Memchunks16 chunks(&pool);
chunks.append("0123456789");
size_t nread;
nread = chunks.drain(3);
CU_ASSERT(3 == nread);
char buf[16];
nread = chunks.remove(buf, sizeof(buf));
CU_ASSERT(7 == nread);
CU_ASSERT(0 == memcmp("3456789", buf, nread));
}
void test_memchunks_riovec(void) {
MemchunkPool16 pool;
Memchunks16 chunks(&pool);
char buf[3 * 16];
chunks.append(buf, sizeof(buf));
std::array<struct iovec, 2> iov;
auto iovcnt = chunks.riovec(iov.data(), iov.size());
auto m = chunks.head;
CU_ASSERT(2 == iovcnt);
CU_ASSERT(m->buf.data() == iov[0].iov_base);
CU_ASSERT(m->len() == iov[0].iov_len);
m = m->next;
CU_ASSERT(m->buf.data() == iov[1].iov_base);
CU_ASSERT(m->len() == iov[1].iov_len);
chunks.drain(2 * 16);
iovcnt = chunks.riovec(iov.data(), iov.size());
CU_ASSERT(1 == iovcnt);
m = chunks.head;
CU_ASSERT(m->buf.data() == iov[0].iov_base);
CU_ASSERT(m->len() == iov[0].iov_len);
}
void test_memchunks_recycle(void) {
MemchunkPool16 pool;
{
Memchunks16 chunks(&pool);
char buf[32];
chunks.append(buf, sizeof(buf));
}
CU_ASSERT(32 == pool.poolsize);
CU_ASSERT(nullptr != pool.freelist);
auto m = pool.freelist;
m = m->next;
CU_ASSERT(nullptr != m);
CU_ASSERT(nullptr == m->next);
}
void test_memchunks_reset(void) {
MemchunkPool16 pool;
Memchunks16 chunks(&pool);
std::array<uint8_t, 32> b{};
chunks.append(b.data(), b.size());
CU_ASSERT(32 == chunks.rleft());
chunks.reset();
CU_ASSERT(0 == chunks.rleft());
CU_ASSERT(nullptr == chunks.head);
CU_ASSERT(nullptr == chunks.tail);
auto m = pool.freelist;
CU_ASSERT(nullptr != m);
CU_ASSERT(nullptr != m->next);
CU_ASSERT(nullptr == m->next->next);
}
void test_peek_memchunks_append(void) {
MemchunkPool16 pool;
PeekMemchunks16 pchunks(&pool);
std::array<uint8_t, 32> b{{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
}},
d;
pchunks.append(b.data(), b.size());
CU_ASSERT(32 == pchunks.rleft());
CU_ASSERT(32 == pchunks.rleft_buffered());
CU_ASSERT(0 == pchunks.remove(nullptr, 0));
CU_ASSERT(32 == pchunks.rleft());
CU_ASSERT(32 == pchunks.rleft_buffered());
CU_ASSERT(12 == pchunks.remove(d.data(), 12));
CU_ASSERT(std::equal(std::begin(b), std::begin(b) + 12, std::begin(d)));
CU_ASSERT(20 == pchunks.rleft());
CU_ASSERT(32 == pchunks.rleft_buffered());
CU_ASSERT(20 == pchunks.remove(d.data(), d.size()));
CU_ASSERT(std::equal(std::begin(b) + 12, std::end(b), std::begin(d)));
CU_ASSERT(0 == pchunks.rleft());
CU_ASSERT(32 == pchunks.rleft_buffered());
}
void test_peek_memchunks_disable_peek_drain(void) {
MemchunkPool16 pool;
PeekMemchunks16 pchunks(&pool);
std::array<uint8_t, 32> b{{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
}},
d;
pchunks.append(b.data(), b.size());
CU_ASSERT(12 == pchunks.remove(d.data(), 12));
pchunks.disable_peek(true);
CU_ASSERT(!pchunks.peeking);
CU_ASSERT(20 == pchunks.rleft());
CU_ASSERT(20 == pchunks.rleft_buffered());
CU_ASSERT(20 == pchunks.remove(d.data(), d.size()));
CU_ASSERT(std::equal(std::begin(b) + 12, std::end(b), std::begin(d)));
CU_ASSERT(0 == pchunks.rleft());
CU_ASSERT(0 == pchunks.rleft_buffered());
}
void test_peek_memchunks_disable_peek_no_drain(void) {
MemchunkPool16 pool;
PeekMemchunks16 pchunks(&pool);
std::array<uint8_t, 32> b{{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
}},
d;
pchunks.append(b.data(), b.size());
CU_ASSERT(12 == pchunks.remove(d.data(), 12));
pchunks.disable_peek(false);
CU_ASSERT(!pchunks.peeking);
CU_ASSERT(32 == pchunks.rleft());
CU_ASSERT(32 == pchunks.rleft_buffered());
CU_ASSERT(32 == pchunks.remove(d.data(), d.size()));
CU_ASSERT(std::equal(std::begin(b), std::end(b), std::begin(d)));
CU_ASSERT(0 == pchunks.rleft());
CU_ASSERT(0 == pchunks.rleft_buffered());
}
void test_peek_memchunks_reset(void) {
MemchunkPool16 pool;
PeekMemchunks16 pchunks(&pool);
std::array<uint8_t, 32> b{{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
}},
d;
pchunks.append(b.data(), b.size());
CU_ASSERT(12 == pchunks.remove(d.data(), 12));
pchunks.disable_peek(true);
pchunks.reset();
CU_ASSERT(0 == pchunks.rleft());
CU_ASSERT(0 == pchunks.rleft_buffered());
CU_ASSERT(nullptr == pchunks.cur);
CU_ASSERT(nullptr == pchunks.cur_pos);
CU_ASSERT(nullptr == pchunks.cur_last);
CU_ASSERT(pchunks.peeking);
}
} // namespace nghttp2