path: root/indra/llcorehttp/tests/test_bufferarray.hpp

/**
 * @file test_bufferarray.hpp
 * @brief unit tests for the LLCore::BufferArray class
 *
 * $LicenseInfo:firstyear=2012&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2012, Linden Research, Inc.
 *
 * This library 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;
 * version 2.1 of the License only.
 *
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */
#ifndef TEST_LLCORE_BUFFER_ARRAY_H_
#define TEST_LLCORE_BUFFER_ARRAY_H_

#include "bufferarray.h"

#include <iostream>


using namespace LLCore;



namespace tut
{

struct BufferArrayTestData
{
    // the test objects inherit from this so the member functions and variables
    // can be referenced directly inside of the test functions.
};

typedef test_group<BufferArrayTestData> BufferArrayTestGroupType;
typedef BufferArrayTestGroupType::object BufferArrayTestObjectType;
BufferArrayTestGroupType BufferArrayTestGroup("BufferArray Tests");

template <> template <>
void BufferArrayTestObjectType::test<1>()
{
    set_test_name("BufferArray construction");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();
    ensure("One ref on construction of BufferArray", ba->getRefCount() == 1);
    ensure("Nothing in BA", 0 == ba->size());

    // Try to read
    char buffer[20];
    size_t read_len(ba->read(0, buffer, sizeof(buffer)));
    ensure("Read returns empty", 0 == read_len);

    // release the implicit reference, causing the object to be released
    ba->release();
}

template <> template <>
void BufferArrayTestObjectType::test<2>()
{
    set_test_name("BufferArray single write");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();

    // write some data to the buffer
    char str1[] = "abcdefghij";
    char buffer[256];

    size_t len = ba->write(0, str1, strlen(str1));
    ensure("Wrote length correct", strlen(str1) == len);
    ensure("Recorded size correct", strlen(str1) == ba->size());

    // read some data back
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(2, buffer, 2);
    ensure("Read length correct", 2 == len);
    ensure("Read content correct", 'c' == buffer[0] && 'd' == buffer[1]);
    ensure("Read didn't overwrite", 'X' == buffer[2]);

    // release the implicit reference, causing the object to be released
    ba->release();
}


template <> template <>
void BufferArrayTestObjectType::test<3>()
{
    set_test_name("BufferArray multiple writes");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();

    // write some data to the buffer
    char str1[] = "abcdefghij";
    size_t str1_len(strlen(str1));
    char buffer[256];

    size_t len = ba->write(0, str1, str1_len);
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", str1_len == ba->size());

    // again...
    len = ba->write(str1_len, str1, strlen(str1));
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", (2 * str1_len) == ba->size());

    // read some data back
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(8, buffer, 4);
    ensure("Read length correct", 4 == len);
    ensure("Read content correct", 'i' == buffer[0] && 'j' == buffer[1]);
    ensure("Read content correct", 'a' == buffer[2] && 'b' == buffer[3]);
    ensure("Read didn't overwrite", 'X' == buffer[4]);

    // Read whole thing
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(0, buffer, sizeof(buffer));
    ensure("Read length correct", (2 * str1_len) == len);
    ensure("Read content correct (3)", 0 == strncmp(buffer, str1, str1_len));
    ensure("Read content correct (4)", 0 == strncmp(&buffer[str1_len], str1, str1_len));
    ensure("Read didn't overwrite (5)", 'X' == buffer[2 * str1_len]);

    // release the implicit reference, causing the object to be released
    ba->release();
}

template <> template <>
void BufferArrayTestObjectType::test<4>()
{
    set_test_name("BufferArray overwriting");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();

    // write some data to the buffer
    char str1[] = "abcdefghij";
    size_t str1_len(strlen(str1));
    char str2[] = "ABCDEFGHIJ";
    char buffer[256];

    size_t len = ba->write(0, str1, str1_len);
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", str1_len == ba->size());

    // again...
    len = ba->write(str1_len, str1, strlen(str1));
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", (2 * str1_len) == ba->size());

    // reposition and overwrite
    len = ba->write(8, str2, 4);
    ensure("Overwrite length correct", 4 == len);

    // Leave position and read verifying content (stale really from seek() days)
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(12, buffer, 4);
    ensure("Read length correct", 4 == len);
    ensure("Read content correct", 'c' == buffer[0] && 'd' == buffer[1]);
    ensure("Read content correct.2", 'e' == buffer[2] && 'f' == buffer[3]);
    ensure("Read didn't overwrite", 'X' == buffer[4]);

    // reposition and check
    len = ba->read(6, buffer, 8);
    ensure("Read length correct.2", 8 == len);
    ensure("Read content correct.3", 'g' == buffer[0] && 'h' == buffer[1]);
    ensure("Read content correct.4", 'A' == buffer[2] && 'B' == buffer[3]);
    ensure("Read content correct.5", 'C' == buffer[4] && 'D' == buffer[5]);
    ensure("Read content correct.6", 'c' == buffer[6] && 'd' == buffer[7]);
    ensure("Read didn't overwrite.7", 'X' == buffer[8]);

    // release the implicit reference, causing the object to be released
    ba->release();
}

template <> template <>
void BufferArrayTestObjectType::test<5>()
{
    set_test_name("BufferArray multiple writes - sequential reads");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();

    // write some data to the buffer
    char str1[] = "abcdefghij";
    size_t str1_len(strlen(str1));
    char buffer[256];

    size_t len = ba->write(0, str1, str1_len);
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", str1_len == ba->size());

    // again...
    len = ba->write(str1_len, str1, str1_len);
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", (2 * str1_len) == ba->size());

    // read some data back
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(8, buffer, 4);
    ensure("Read length correct", 4 == len);
    ensure("Read content correct", 'i' == buffer[0] && 'j' == buffer[1]);
    ensure("Read content correct.2", 'a' == buffer[2] && 'b' == buffer[3]);
    ensure("Read didn't overwrite", 'X' == buffer[4]);

    // Read some more without repositioning
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(12, buffer, sizeof(buffer));
    ensure("Read length correct", (str1_len - 2) == len);
    ensure("Read content correct.3", 0 == strncmp(buffer, str1+2, str1_len-2));
    ensure("Read didn't overwrite.2", 'X' == buffer[str1_len-1]);

    // release the implicit reference, causing the object to be released
    ba->release();
}

template <> template <>
void BufferArrayTestObjectType::test<6>()
{
    set_test_name("BufferArray overwrite spanning blocks and appending");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();

    // write some data to the buffer
    char str1[] = "abcdefghij";
    size_t str1_len(strlen(str1));
    char str2[] = "ABCDEFGHIJKLMNOPQRST";
    size_t str2_len(strlen(str2));
    char buffer[256];

    size_t len = ba->write(0, str1, str1_len);
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", str1_len == ba->size());

    // again...
    len = ba->write(str1_len, str1, strlen(str1));
    ensure("Wrote length correct", str1_len == len);
    ensure("Recorded size correct", (2 * str1_len) == ba->size());

    // reposition and overwrite
    len = ba->write(8, str2, str2_len);
    ensure("Overwrite length correct", str2_len == len);

    // Leave position and read verifying content
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(8 + str2_len, buffer, 0);
    ensure("Read length correct", 0 == len);
    ensure("Read didn't overwrite", 'X' == buffer[0]);

    // reposition and check
    len = ba->read(0, buffer, sizeof(buffer));
    ensure("Read length correct.2", (str1_len + str2_len - 2) == len);
    ensure("Read content correct", 0 == strncmp(buffer, str1, str1_len-2));
    ensure("Read content correct.2", 0 == strncmp(buffer+str1_len-2, str2, str2_len));
    ensure("Read didn't overwrite.2", 'X' == buffer[str1_len + str2_len - 2]);

    // release the implicit reference, causing the object to be released
    ba->release();
}

template <> template <>
void BufferArrayTestObjectType::test<7>()
{
    set_test_name("BufferArray overwrite spanning blocks and sequential writes");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();

    // write some data to the buffer
    char str1[] = "abcdefghij";
    size_t str1_len(strlen(str1));
    char str2[] = "ABCDEFGHIJKLMNOPQRST";
    size_t str2_len(strlen(str2));
    char buffer[256];

    // 2x str1
    size_t len = ba->write(0, str1, str1_len);
    len = ba->write(str1_len, str1, str1_len);

    // reposition and overwrite
    len = ba->write(6, str2, 2);
    ensure("Overwrite length correct", 2 == len);

    len = ba->write(8, str2, 2);
    ensure("Overwrite length correct.2", 2 == len);

    len = ba->write(10, str2, 2);
    ensure("Overwrite length correct.3", 2 == len);

    // append some data
    len = ba->append(str2, str2_len);
    ensure("Append length correct", str2_len == len);

    // append some more
    void * out_buf(ba->appendBufferAlloc(str1_len));
    memcpy(out_buf, str1, str1_len);

    // And some final writes
    len = ba->write(3 * str1_len + str2_len, str2, 2);
    ensure("Write length correct.2", 2 == len);

    // Check contents
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(0, buffer, sizeof(buffer));
    ensure("Final buffer length correct", (3 * str1_len + str2_len + 2) == len);
    ensure("Read content correct", 0 == strncmp(buffer, str1, 6));
    ensure("Read content correct.2", 0 == strncmp(buffer + 6, str2, 2));
    ensure("Read content correct.3", 0 == strncmp(buffer + 8, str2, 2));
    ensure("Read content correct.4", 0 == strncmp(buffer + 10, str2, 2));
    ensure("Read content correct.5", 0 == strncmp(buffer + str1_len + 2, str1 + 2, str1_len - 2));
    ensure("Read content correct.6", 0 == strncmp(buffer + str1_len + str1_len, str2, str2_len));
    ensure("Read content correct.7", 0 == strncmp(buffer + str1_len + str1_len + str2_len, str1, str1_len));
    ensure("Read content correct.8", 0 == strncmp(buffer + str1_len + str1_len + str2_len + str1_len, str2, 2));
    ensure("Read didn't overwrite", 'X' == buffer[str1_len + str1_len + str2_len + str1_len + 2]);

    // release the implicit reference, causing the object to be released
    ba->release();
}

template <> template <>
void BufferArrayTestObjectType::test<8>()
{
    set_test_name("BufferArray zero-length appendBufferAlloc");

    // create a new ref counted object with an implicit reference
    BufferArray * ba = new BufferArray();

    // write some data to the buffer
    char str1[] = "abcdefghij";
    size_t str1_len(strlen(str1));
    char str2[] = "ABCDEFGHIJKLMNOPQRST";
    size_t str2_len(strlen(str2));
    char buffer[256];

    // 2x str1
    size_t len = ba->write(0, str1, str1_len);
    len = ba->write(str1_len, str1, str1_len);

    // zero-length allocate (we allow this with a valid pointer returned)
    void * out_buf(ba->appendBufferAlloc(0));
    ensure("Buffer from zero-length appendBufferAlloc non-NULL", NULL != out_buf);

    // Do it again
    void * out_buf2(ba->appendBufferAlloc(0));
    ensure("Buffer from zero-length appendBufferAlloc non-NULL.2", NULL != out_buf2);
    ensure("Two zero-length appendBufferAlloc buffers distinct", out_buf != out_buf2);

    // And some final writes
    len = ba->write(2 * str1_len, str2, str2_len);

    // Check contents
    memset(buffer, 'X', sizeof(buffer));
    len = ba->read(0, buffer, sizeof(buffer));
    ensure("Final buffer length correct", (2 * str1_len + str2_len) == len);
    ensure("Read content correct.1", 0 == strncmp(buffer, str1, str1_len));
    ensure("Read content correct.2", 0 == strncmp(buffer + str1_len, str1, str1_len));
    ensure("Read content correct.3", 0 == strncmp(buffer + str1_len + str1_len, str2, str2_len));
    ensure("Read didn't overwrite", 'X' == buffer[str1_len + str1_len + str2_len]);

    // release the implicit reference, causing the object to be released
    ba->release();
}

}  // end namespace tut


#endif  // TEST_LLCORE_BUFFER_ARRAY_H_