Second Life viewer sources 1.18.0.6

1 files changed, 270 insertions, 0 deletions

diff --git a/linden/indra/test/llbuffer_tut.cpp b/linden/indra/test/llbuffer_tut.cpp
new file mode 100644
index 0000000..bf58abb
--- /dev/null
+++ b/linden/indra/test/llbuffer_tut.cpp
@@ -0,0 +1,270 @@
+/**
+ * @file llbuffer_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief llbuffer test cases.
+ *
+ * Copyright (c) 2007-2007, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include <tut/tut.h>
+#include "lltut.h"
+#include "llbuffer.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));
+        }
+}