272 lines
9.9 KiB
C++
272 lines
9.9 KiB
C++
/**
|
|
* @file llbuffer_tut.cpp
|
|
* @author Adroit
|
|
* @date 2007-03
|
|
* @brief llbuffer test cases.
|
|
*
|
|
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, 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$
|
|
*/
|
|
|
|
#include <tut/tut.hpp>
|
|
|
|
#include "linden_common.h"
|
|
#include "lltut.h"
|
|
#include "llbuffer.h"
|
|
#include "llerror.h"
|
|
|
|
|
|
namespace tut
|
|
{
|
|
struct buffer
|
|
{
|
|
};
|
|
|
|
typedef test_group<buffer> buffer_t;
|
|
typedef buffer_t::object buffer_object_t;
|
|
tut::buffer_t tut_buffer("buffer");
|
|
|
|
template<> template<>
|
|
void buffer_object_t::test<1>()
|
|
{
|
|
LLChannelDescriptors channelDescriptors;
|
|
ensure("in() and out() functions Failed", (0 == channelDescriptors.in() && 1 == channelDescriptors.out()));
|
|
|
|
S32 val = 50;
|
|
LLChannelDescriptors channelDescriptors1(val);
|
|
ensure("LLChannelDescriptors in() and out() functions Failed", (50 == channelDescriptors1.in() && 51 == channelDescriptors1.out()));
|
|
}
|
|
|
|
template<> template<>
|
|
void buffer_object_t::test<2>()
|
|
{
|
|
LLSegment segment;
|
|
ensure("LLSegment get functions failed", (0 == segment.getChannel() && NULL == segment.data() && 0 == segment.size()));
|
|
segment.setChannel(50);
|
|
ensure_equals("LLSegment setChannel() function failed", segment.getChannel(), 50);
|
|
ensure("LLSegment isOnChannel() function failed", (true == segment.isOnChannel(50)));
|
|
}
|
|
|
|
template<> template<>
|
|
void buffer_object_t::test<3>()
|
|
{
|
|
S32 channel = 30;
|
|
const char str[] = "SecondLife";
|
|
S32 len = sizeof(str);
|
|
LLSegment segment(channel, (U8*)str, len);
|
|
ensure("LLSegment get functions failed", (30 == segment.getChannel() && len == segment.size() && (U8*)str == segment.data()));
|
|
ensure_memory_matches("LLSegment::data() failed", segment.data(), segment.size(), (U8*)str, len);
|
|
ensure("LLSegment isOnChannel() function failed", (true == segment.isOnChannel(channel)));
|
|
}
|
|
|
|
template<> template<>
|
|
void buffer_object_t::test<4>()
|
|
{
|
|
S32 channel = 50;
|
|
S32 bigSize = 16384*2;
|
|
char str[] = "SecondLife";
|
|
S32 smallSize = sizeof(str);
|
|
|
|
LLSegment segment;
|
|
LLHeapBuffer buf; // use default size of DEFAULT_HEAP_BUFFER_SIZE = 16384
|
|
|
|
S32 requestSize;
|
|
|
|
requestSize = 16384-1;
|
|
ensure("1. LLHeapBuffer createSegment failed", (true == buf.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
|
|
// second request for remainign 1 byte
|
|
|
|
requestSize = 1;
|
|
ensure("2. LLHeapBuffer createSegment failed", (true == buf.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
|
|
|
|
// it should fail now.
|
|
requestSize = 1;
|
|
ensure("3. LLHeapBuffer createSegment failed", (false == buf.createSegment(channel, requestSize, segment)));
|
|
|
|
LLHeapBuffer buf1(bigSize);
|
|
|
|
// requst for more than default size but less than total sizeit should fail now.
|
|
requestSize = 16384 + 1;
|
|
ensure("4. LLHeapBuffer createSegment failed", (true == buf1.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
|
|
|
|
LLHeapBuffer buf2((U8*) str, smallSize);
|
|
requestSize = smallSize;
|
|
ensure("5. LLHeapBuffer createSegment failed", (true == buf2.createSegment(channel, requestSize, segment)) && segment.size() == requestSize && memcmp(segment.data(), (U8*) str, requestSize) == 0);
|
|
requestSize = smallSize+1;
|
|
ensure("6. LLHeapBuffer createSegment failed", (false == buf2.createSegment(channel, requestSize, segment)));
|
|
}
|
|
|
|
//makeChannelConsumer()
|
|
template<> template<>
|
|
void buffer_object_t::test<5>()
|
|
{
|
|
LLChannelDescriptors inchannelDescriptors(20);
|
|
LLChannelDescriptors outchannelDescriptors = LLBufferArray::makeChannelConsumer(inchannelDescriptors);
|
|
ensure("LLBufferArray::makeChannelConsumer() function Failed", (21 == outchannelDescriptors.in()));
|
|
}
|
|
|
|
template<> template<>
|
|
void buffer_object_t::test<6>()
|
|
{
|
|
LLBufferArray bufferArray;
|
|
const char array[] = "SecondLife";
|
|
S32 len = strlen(array);
|
|
LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
|
|
bufferArray.append(channelDescriptors.in(), (U8*)array, len);
|
|
S32 count = bufferArray.countAfter(channelDescriptors.in(), NULL);
|
|
ensure_equals("Appended size is:", count, len);
|
|
}
|
|
|
|
//append() and prepend()
|
|
template<> template<>
|
|
void buffer_object_t::test<7>()
|
|
{
|
|
LLBufferArray bufferArray;
|
|
const char array[] = "SecondLife";
|
|
S32 len = strlen(array);
|
|
const char array1[] = "LindenLabs";
|
|
S32 len1 = strlen(array1);
|
|
|
|
std::string str(array1);
|
|
str.append(array);
|
|
|
|
LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
|
|
bufferArray.append(channelDescriptors.in(), (U8*)array, len);
|
|
bufferArray.prepend(channelDescriptors.in(), (U8*)array1, len1);
|
|
char buf[100];
|
|
S32 len2 = 20;
|
|
bufferArray.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
|
|
ensure_equals("readAfter length failed", len2, 20);
|
|
|
|
buf[len2] = '\0';
|
|
ensure_equals("readAfter/prepend/append failed", buf, str);
|
|
}
|
|
|
|
//append()
|
|
template<> template<>
|
|
void buffer_object_t::test<8>()
|
|
{
|
|
LLBufferArray bufferArray;
|
|
const char array[] = "SecondLife";
|
|
S32 len = strlen(array);
|
|
const char array1[] = "LindenLabs";
|
|
S32 len1 = strlen(array1);
|
|
|
|
std::string str(array);
|
|
str.append(array1);
|
|
|
|
LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
|
|
bufferArray.append(channelDescriptors.in(), (U8*)array, len);
|
|
bufferArray.append(channelDescriptors.in(), (U8*)array1, len1);
|
|
char buf[100];
|
|
S32 len2 = 20;
|
|
bufferArray.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
|
|
ensure_equals("readAfter length failed", len2, 20);
|
|
|
|
buf[len2] = '\0';
|
|
ensure_equals("readAfter/append/append failed", buf, str);
|
|
}
|
|
|
|
template<> template<>
|
|
void buffer_object_t::test<9>()
|
|
{
|
|
LLBufferArray bufferArray;
|
|
const char array[] = "SecondLife";
|
|
S32 len = strlen(array) + 1;
|
|
std::string str(array);
|
|
LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
|
|
bufferArray.append(channelDescriptors.in(), (U8*)array, len);
|
|
LLBufferArray bufferArray1;
|
|
ensure("Contents are not copied and the source buffer is not empty", (1 == bufferArray1.takeContents(bufferArray)));
|
|
|
|
char buf[100];
|
|
S32 len2 = len;
|
|
bufferArray1.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
|
|
ensure_equals("takeContents failed to copy", buf, str);
|
|
}
|
|
|
|
//seek()
|
|
template<> template<>
|
|
void buffer_object_t::test<10>()
|
|
{
|
|
const char array[] = "SecondLife is a Virtual World";
|
|
S32 len = strlen(array);
|
|
LLBufferArray bufferArray;
|
|
bufferArray.append(0, (U8*)array, len);
|
|
|
|
char buf[255];
|
|
S32 len1 = 16;
|
|
U8* last = bufferArray.readAfter(0, 0, (U8*)buf, len1);
|
|
buf[len1] = '\0';
|
|
last = bufferArray.seek(0, last, -2);
|
|
|
|
len1 = 15;
|
|
last = bufferArray.readAfter(0, last, (U8*)buf, len1);
|
|
buf[len1] = '\0';
|
|
std::string str(buf);
|
|
ensure_equals("Seek does'nt worked", str, std::string("a Virtual World"));
|
|
}
|
|
|
|
template<> template<>
|
|
void buffer_object_t::test<11>()
|
|
{
|
|
const char array[] = "SecondLife is a Virtual World";
|
|
S32 len = strlen(array);
|
|
LLBufferArray bufferArray;
|
|
bufferArray.append(0, (U8*)array, len);
|
|
|
|
char buf[255];
|
|
S32 len1 = 10;
|
|
U8* last = bufferArray.readAfter(0, 0, (U8*)buf, len1);
|
|
bufferArray.splitAfter(last);
|
|
LLBufferArray::segment_iterator_t iterator = bufferArray.beginSegment();
|
|
++iterator;
|
|
std::string str(((char*)(*iterator).data()), (*iterator).size());
|
|
ensure_equals("Strings are not equal;splitAfter() operation failed", str, std::string(" is a Virtual World"));
|
|
}
|
|
|
|
//makeSegment()->eraseSegment()
|
|
template<> template<>
|
|
void buffer_object_t::test<12>()
|
|
{
|
|
LLBufferArray bufferArray;
|
|
LLChannelDescriptors channelDescriptors;
|
|
LLBufferArray::segment_iterator_t it;
|
|
S32 length = 1000;
|
|
it = bufferArray.makeSegment(channelDescriptors.out(), length);
|
|
ensure("makeSegment() function failed", (it != bufferArray.endSegment()));
|
|
ensure("eraseSegment() function failed", bufferArray.eraseSegment(it));
|
|
ensure("eraseSegment() begin/end should now be same", bufferArray.beginSegment() == bufferArray.endSegment());
|
|
}
|
|
|
|
// constructSegmentAfter()
|
|
template<> template<>
|
|
void buffer_object_t::test<13>()
|
|
{
|
|
LLBufferArray bufferArray;
|
|
LLBufferArray::segment_iterator_t it;
|
|
LLSegment segment;
|
|
LLBufferArray::segment_iterator_t end = bufferArray.endSegment();
|
|
it = bufferArray.constructSegmentAfter(NULL, segment);
|
|
ensure("constructSegmentAfter() function failed", (it == end));
|
|
}
|
|
}
|