llbuffer_tut.cpp

Go to the documentation of this file.

#include <tut/tut.h>
#include "linden_common.h"
#include "lltut.h"
#include "llbuffer.h"
#include "llerror.h"
#include "llmemtype.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));
        }
}

---