llbuffer_tut.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:9k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file llbuffer_tut.cpp
  3.  * @author Adroit
  4.  * @date 2007-03
  5.  * @brief llbuffer test cases.
  6.  *
  7.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2007-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  34. #include <tut/tut.hpp>
  35. #include "linden_common.h"
  36. #include "lltut.h"
  37. #include "llbuffer.h"
  38. #include "llerror.h"
  39. #include "llmemtype.h"
  40. namespace tut
  41. {
  42. struct buffer
  43. {
  44. };
  45. typedef test_group<buffer> buffer_t;
  46. typedef buffer_t::object buffer_object_t;
  47. tut::buffer_t tut_buffer("buffer");
  48. template<> template<>
  49. void buffer_object_t::test<1>()
  50. {
  51. LLChannelDescriptors channelDescriptors;
  52. ensure("in() and out() functions Failed", (0 == channelDescriptors.in() && 1 == channelDescriptors.out()));
  53. S32 val = 50;
  54. LLChannelDescriptors channelDescriptors1(val);
  55. ensure("LLChannelDescriptors in() and out() functions Failed", (50 == channelDescriptors1.in() && 51 == channelDescriptors1.out()));
  56. }
  57. template<> template<>
  58. void buffer_object_t::test<2>()
  59. {
  60. LLSegment segment;
  61. ensure("LLSegment get functions failed", (0 == segment.getChannel() && NULL == segment.data() && 0 == segment.size()));
  62. segment.setChannel(50);
  63. ensure_equals("LLSegment setChannel() function failed", segment.getChannel(), 50);
  64. ensure("LLSegment isOnChannel() function failed", (TRUE == segment.isOnChannel(50)));
  65. }
  66. template<> template<>
  67. void buffer_object_t::test<3>()
  68. {
  69. S32 channel = 30;
  70. const char str[] = "SecondLife";
  71. S32 len = sizeof(str);
  72. LLSegment segment(channel, (U8*)str, len);
  73. ensure("LLSegment get functions failed", (30 == segment.getChannel() && len == segment.size() && (U8*)str == segment.data()));
  74. ensure_memory_matches("LLSegment::data() failed",  segment.data(), segment.size(), (U8*)str, len);
  75. ensure("LLSegment isOnChannel() function failed", (TRUE == segment.isOnChannel(channel)));
  76. }  
  77. template<> template<>
  78. void buffer_object_t::test<4>()
  79. {
  80. S32 channel = 50;
  81. S32 bigSize = 16384*2;
  82. char str[] = "SecondLife";
  83. S32 smallSize = sizeof(str);
  84. LLSegment segment;
  85. LLHeapBuffer buf; // use default size of DEFAULT_HEAP_BUFFER_SIZE = 16384
  86. S32 requestSize;
  87. requestSize = 16384-1;
  88. ensure("1. LLHeapBuffer createSegment failed", (TRUE == buf.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
  89. // second request for remainign 1 byte
  90. requestSize = 1;
  91. ensure("2. LLHeapBuffer createSegment failed", (TRUE == buf.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
  92. // it should fail now.
  93. requestSize = 1;
  94. ensure("3. LLHeapBuffer createSegment failed", (FALSE == buf.createSegment(channel, requestSize, segment)));
  95. LLHeapBuffer buf1(bigSize);
  96. // requst for more than default size but less than total sizeit should fail now.
  97. requestSize = 16384 + 1;
  98. ensure("4. LLHeapBuffer createSegment failed", (TRUE == buf1.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
  99. LLHeapBuffer buf2((U8*) str, smallSize);
  100. requestSize = smallSize;
  101. ensure("5. LLHeapBuffer createSegment failed", (TRUE == buf2.createSegment(channel, requestSize, segment)) && segment.size() == requestSize && memcmp(segment.data(), (U8*) str, requestSize) == 0);
  102. requestSize = smallSize+1;
  103. ensure("6. LLHeapBuffer createSegment failed", (FALSE == buf2.createSegment(channel, requestSize, segment)));
  104. }
  105. //makeChannelConsumer()
  106. template<> template<>
  107. void buffer_object_t::test<5>()
  108. {
  109. LLChannelDescriptors inchannelDescriptors(20);
  110. LLChannelDescriptors outchannelDescriptors = LLBufferArray::makeChannelConsumer(inchannelDescriptors);
  111. ensure("LLBufferArray::makeChannelConsumer() function Failed", (21 == outchannelDescriptors.in()));
  112. }
  113. template<> template<>
  114. void buffer_object_t::test<6>()
  115. {
  116. LLBufferArray bufferArray;
  117. const char array[] = "SecondLife";
  118. S32 len = strlen(array);
  119. LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
  120. bufferArray.append(channelDescriptors.in(), (U8*)array, len);
  121. S32 count = bufferArray.countAfter(channelDescriptors.in(), NULL);
  122. ensure_equals("Appended size is:", count, len);
  123. }
  124. //append() and prepend()
  125. template<> template<>
  126. void buffer_object_t::test<7>()
  127. {
  128. LLBufferArray bufferArray;
  129. const char array[] = "SecondLife";
  130. S32 len = strlen(array);
  131. const char array1[] = "LindenLabs";
  132. S32 len1 = strlen(array1);
  133. std::string str(array1);
  134. str.append(array);
  135. LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
  136. bufferArray.append(channelDescriptors.in(), (U8*)array, len);
  137. bufferArray.prepend(channelDescriptors.in(), (U8*)array1, len1);
  138. char buf[100];
  139. S32 len2 = 20;
  140. bufferArray.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
  141. ensure_equals("readAfter length failed", len2, 20);
  142. buf[len2] = '';
  143. ensure_equals("readAfter/prepend/append failed", buf, str);
  144. }
  145. //append()
  146. template<> template<>
  147. void buffer_object_t::test<8>()
  148. {
  149. LLBufferArray bufferArray;
  150. const char array[] = "SecondLife";
  151. S32 len = strlen(array);
  152. const char array1[] = "LindenLabs";
  153. S32 len1 = strlen(array1);
  154. std::string str(array);
  155. str.append(array1);
  156. LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
  157. bufferArray.append(channelDescriptors.in(), (U8*)array, len);
  158. bufferArray.append(channelDescriptors.in(), (U8*)array1, len1);
  159. char buf[100];
  160. S32 len2 = 20;
  161. bufferArray.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
  162. ensure_equals("readAfter length failed", len2, 20);
  163. buf[len2] = '';
  164. ensure_equals("readAfter/append/append failed", buf, str);
  165. }
  166. template<> template<>
  167. void buffer_object_t::test<9>()
  168. {
  169. LLBufferArray bufferArray;
  170. const char array[] = "SecondLife";
  171. S32 len = strlen(array) + 1;
  172. std::string str(array);
  173. LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
  174. bufferArray.append(channelDescriptors.in(), (U8*)array, len);
  175. LLBufferArray bufferArray1;
  176. ensure("Contents are not copied and the source buffer is not empty", (1 == bufferArray1.takeContents(bufferArray)));
  177. char buf[100];
  178. S32 len2 = len;
  179. bufferArray1.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
  180. ensure_equals("takeContents failed to copy", buf, str);
  181. }
  182. //seek()
  183. template<> template<>
  184. void buffer_object_t::test<10>()
  185. {
  186. const char array[] = "SecondLife is a Virtual World";
  187. S32 len = strlen(array);
  188. LLBufferArray bufferArray;
  189. bufferArray.append(0, (U8*)array, len);
  190. char buf[255];
  191. S32 len1 = 16;
  192. U8* last = bufferArray.readAfter(0, 0, (U8*)buf, len1);
  193. buf[len1] = '';
  194. last = bufferArray.seek(0, last, -2);
  195. len1 = 15;
  196. last = bufferArray.readAfter(0, last, (U8*)buf, len1);
  197. buf[len1] = '';
  198. std::string str(buf);
  199. ensure_equals("Seek does'nt worked", str, std::string("a Virtual World"));
  200. }
  201. template<> template<>
  202. void buffer_object_t::test<11>()
  203. {
  204. const char array[] = "SecondLife is a Virtual World";
  205. S32 len = strlen(array);
  206. LLBufferArray bufferArray;
  207. bufferArray.append(0, (U8*)array, len);
  208. char buf[255];
  209. S32 len1 = 10;
  210. U8* last = bufferArray.readAfter(0, 0, (U8*)buf, len1);
  211. bufferArray.splitAfter(last);
  212. LLBufferArray::segment_iterator_t iterator = bufferArray.beginSegment();
  213. ++iterator;
  214. std::string str(((char*)(*iterator).data()), (*iterator).size());
  215. ensure_equals("Strings are not equal;splitAfter() operation failed", str, std::string(" is a Virtual World"));
  216. }
  217. //makeSegment()->eraseSegment()
  218. template<> template<>
  219. void buffer_object_t::test<12>()
  220. {
  221. LLBufferArray bufferArray;
  222. LLChannelDescriptors channelDescriptors;
  223. LLBufferArray::segment_iterator_t it;
  224. S32 length = 1000;
  225. it = bufferArray.makeSegment(channelDescriptors.out(), length);
  226. ensure("makeSegment() function failed", (it != bufferArray.endSegment()));
  227. ensure("eraseSegment() function failed", bufferArray.eraseSegment(it));
  228. ensure("eraseSegment() begin/end should now be same", bufferArray.beginSegment() == bufferArray.endSegment());
  229. }
  230. // constructSegmentAfter()
  231. template<> template<>
  232. void buffer_object_t::test<13>()
  233. {
  234. LLBufferArray bufferArray;
  235. LLBufferArray::segment_iterator_t it;
  236. LLSegment segment;
  237. LLBufferArray::segment_iterator_t end = bufferArray.endSegment();
  238. it = bufferArray.constructSegmentAfter(NULL, segment);
  239. ensure("constructSegmentAfter() function failed", (it == end));
  240. }
  241. }