开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
io.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：68k
源码类别：

游戏引擎

开发平台：

C++ Builder

io.cpp：源码内容
  1. /** 
  2.  * @file io.cpp
  3.  * @author Phoenix
  4.  * @date 2005-10-02
  5.  * @brief Tests for io classes and helpers
  6.  *
  7.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2005-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.  */
  35. #include "linden_common.h"
  36. #include "lltut.h"
  38. #include <iterator>
  40. #include "apr_pools.h"
  42. #include "llbuffer.h"
  43. #include "llbufferstream.h"
  44. #include "lliosocket.h"
  45. #include "llioutil.h"
  46. #include "llmemorystream.h"
  47. #include "llpipeutil.h"
  48. #include "llpumpio.h"
  49. #include "llsd.h"
  50. #include "llsdrpcclient.h"
  51. #include "llsdrpcserver.h"
  52. #include "llsdserialize.h"
  53. #include "lluuid.h"
  54. #include "llinstantmessage.h"
  56. namespace tut
  57. {
  58. struct heap_buffer_data
  59. {
  60. heap_buffer_data() : mBuffer(NULL) {}
  61. ~heap_buffer_data() { if(mBuffer) delete mBuffer; }
  62. LLHeapBuffer* mBuffer;
  63. };
  64. typedef test_group<heap_buffer_data> heap_buffer_test;
  65. typedef heap_buffer_test::object heap_buffer_object;
  66. tut::heap_buffer_test thb("heap_buffer");
  68. template<> template<>
  69. void heap_buffer_object::test<1>()
  70. {
  71. const S32 BUF_SIZE = 100;
  72. mBuffer = new LLHeapBuffer(BUF_SIZE);
  73. ensure_equals("empty buffer capacity", mBuffer->capacity(), BUF_SIZE);
  74. const S32 SEGMENT_SIZE = 50;
  75. LLSegment segment;
  76. mBuffer->createSegment(0, SEGMENT_SIZE, segment);
  77. ensure_equals("used buffer capacity", mBuffer->capacity(), BUF_SIZE);
  78. }
  80. template<> template<>
  81. void heap_buffer_object::test<2>()
  82. {
  83. const S32 BUF_SIZE = 10;
  84. mBuffer = new LLHeapBuffer(BUF_SIZE);
  85. LLSegment segment;
  86. mBuffer->createSegment(0, BUF_SIZE, segment);
  87. ensure("segment is in buffer", mBuffer->containsSegment(segment));
  88. ensure_equals("buffer consumed", mBuffer->bytesLeft(), 0);
  89. bool  created;
  90. created = mBuffer->createSegment(0, 0, segment);
  91. ensure("Create zero size segment fails", !created);
  92. created = mBuffer->createSegment(0, BUF_SIZE, segment);
  93. ensure("Create segment fails", !created);
  94. }
  96. template<> template<>
  97. void heap_buffer_object::test<3>()
  98. {
  99. const S32 BUF_SIZE = 10;
  100. mBuffer = new LLHeapBuffer(BUF_SIZE);
  101. LLSegment segment;
  102. mBuffer->createSegment(0, BUF_SIZE, segment);
  103. ensure("segment is in buffer", mBuffer->containsSegment(segment));
  104. ensure_equals("buffer consumed", mBuffer->bytesLeft(), 0);
  105. bool reclaimed = mBuffer->reclaimSegment(segment);
  106. ensure("buffer reclaimed.", reclaimed);
  107. ensure_equals("buffer available", mBuffer->bytesLeft(), BUF_SIZE);
  108. bool  created;
  109. created = mBuffer->createSegment(0, 0, segment);
  110. ensure("Create zero size segment fails", !created);
  111. created = mBuffer->createSegment(0, BUF_SIZE, segment);
  112. ensure("Create another segment succeeds", created);
  113. }
  115. template<> template<>
  116. void heap_buffer_object::test<4>()
  117. {
  118. const S32 BUF_SIZE = 10;
  119. const S32 SEGMENT_SIZE = 4;
  120. mBuffer = new LLHeapBuffer(BUF_SIZE);
  121. LLSegment seg1;
  122. mBuffer->createSegment(0, SEGMENT_SIZE, seg1);
  123. ensure("segment is in buffer", mBuffer->containsSegment(seg1));
  124. LLSegment seg2;
  125. mBuffer->createSegment(0, SEGMENT_SIZE, seg2);
  126. ensure("segment is in buffer", mBuffer->containsSegment(seg2));
  127. LLSegment seg3;
  128. mBuffer->createSegment(0, SEGMENT_SIZE, seg3);
  129. ensure("segment is in buffer", mBuffer->containsSegment(seg3));
  130. ensure_equals("segment is truncated", seg3.size(), 2);
  131. LLSegment seg4;
  132. bool created;
  133. created = mBuffer->createSegment(0, SEGMENT_SIZE, seg4);
  134. ensure("Create segment fails", !created);
  135. bool reclaimed;
  136. reclaimed = mBuffer->reclaimSegment(seg1);
  137. ensure("buffer reclaim succeed.", reclaimed);
  138. ensure_equals("no buffer available", mBuffer->bytesLeft(), 0);
  139. reclaimed = mBuffer->reclaimSegment(seg2);
  140. ensure("buffer reclaim succeed.", reclaimed);
  141. ensure_equals("buffer reclaimed", mBuffer->bytesLeft(), 0);
  142. reclaimed = mBuffer->reclaimSegment(seg3);
  143. ensure("buffer reclaim succeed.", reclaimed);
  144. ensure_equals("buffer reclaimed", mBuffer->bytesLeft(), BUF_SIZE);
  145. created = mBuffer->createSegment(0, SEGMENT_SIZE, seg1);
  146. ensure("segment is in buffer", mBuffer->containsSegment(seg1));
  147. ensure("Create segment succeds", created);
  148. }
  149. }
  151. namespace tut
  152. {
  153. struct buffer_data
  154. {
  155. LLBufferArray mBuffer;
  156. };
  157. typedef test_group<buffer_data> buffer_test;
  158. typedef buffer_test::object buffer_object;
  159. tut::buffer_test tba("buffer_array");
  161. template<> template<>
  162. void buffer_object::test<1>()
  163. {
  164. const char HELLO_WORLD[] = "hello world";
  165. const S32 str_len = strlen(HELLO_WORLD);
  166. LLChannelDescriptors ch = mBuffer.nextChannel();
  167. mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
  168. S32 count = mBuffer.countAfter(ch.in(), NULL);
  169. ensure_equals("total append size", count, str_len);
  170. LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
  171. U8* first = (*it).data();
  172. count = mBuffer.countAfter(ch.in(), first);
  173. ensure_equals("offset append size", count, str_len - 1);
  174. }
  176. template<> template<>
  177. void buffer_object::test<2>()
  178. {
  179. const char HELLO_WORLD[] = "hello world";
  180. const S32 str_len = strlen(HELLO_WORLD); /* Flawfinder: ignore */
  181. LLChannelDescriptors ch = mBuffer.nextChannel();
  182. mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
  183. mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
  184. S32 count = mBuffer.countAfter(ch.in(), NULL);
  185. ensure_equals("total append size", count, 2 * str_len);
  186. LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
  187. U8* first = (*it).data();
  188. count = mBuffer.countAfter(ch.in(), first);
  189. ensure_equals("offset append size", count, (2 * str_len) - 1);
  190. }
  192. template<> template<>
  193. void buffer_object::test<3>()
  194. {
  195. const char ONE[] = "one";
  196. const char TWO[] = "two";
  197. std::string expected(ONE);
  198. expected.append(TWO);
  199. LLChannelDescriptors ch = mBuffer.nextChannel();
  200. mBuffer.append(ch.in(), (U8*)ONE, 3);
  201. mBuffer.append(ch.in(), (U8*)TWO, 3);
  202. char buffer[255]; /* Flawfinder: ignore */
  203. S32 len = 6;
  204. mBuffer.readAfter(ch.in(), NULL, (U8*)buffer, len);
  205. ensure_equals(len, 6);
  206. buffer[len] = '';
  207. std::string actual(buffer);
  208. ensure_equals("read", actual, expected);
  209. }
  211. template<> template<>
  212. void buffer_object::test<4>()
  213. {
  214. const char ONE[] = "one";
  215. const char TWO[] = "two";
  216. std::string expected(ONE);
  217. expected.append(TWO);
  218. LLChannelDescriptors ch = mBuffer.nextChannel();
  219. mBuffer.append(ch.in(), (U8*)TWO, 3);
  220. mBuffer.prepend(ch.in(), (U8*)ONE, 3);
  221. char buffer[255]; /* Flawfinder: ignore */
  222. S32 len = 6;
  223. mBuffer.readAfter(ch.in(), NULL, (U8*)buffer, len);
  224. ensure_equals(len, 6);
  225. buffer[len] = '';
  226. std::string actual(buffer);
  227. ensure_equals("read", actual, expected);
  228. }
  230. template<> template<>
  231. void buffer_object::test<5>()
  232. {
  233. const char ONE[] = "one";
  234. const char TWO[] = "two";
  235. std::string expected("netwo");
  236. LLChannelDescriptors ch = mBuffer.nextChannel();
  237. mBuffer.append(ch.in(), (U8*)TWO, 3);
  238. mBuffer.prepend(ch.in(), (U8*)ONE, 3);
  239. char buffer[255]; /* Flawfinder: ignore */
  240. S32 len = 5;
  241. LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
  242. U8* addr = (*it).data();
  243. mBuffer.readAfter(ch.in(), addr, (U8*)buffer, len);
  244. ensure_equals(len, 5);
  245. buffer[len] = '';
  246. std::string actual(buffer);
  247. ensure_equals("read", actual, expected);
  248. }
  250. template<> template<>
  251. void buffer_object::test<6>()
  252. {
  253. std::string request("The early bird catches the worm.");
  254. std::string response("If you're a worm, sleep late.");
  255. std::ostringstream expected;
  256. expected << "ContentLength: " << response.length() << "rnrn"
  257.  << response;
  258. LLChannelDescriptors ch = mBuffer.nextChannel();
  259. mBuffer.append(ch.in(), (U8*)request.c_str(), request.length());
  260. mBuffer.append(ch.out(), (U8*)response.c_str(), response.length());
  261. S32 count = mBuffer.countAfter(ch.out(), NULL);
  262. std::ostringstream header;
  263. header << "ContentLength: " << count << "rnrn";
  264. std::string head(header.str());
  265. mBuffer.prepend(ch.out(), (U8*)head.c_str(), head.length());
  266. char buffer[1024]; /* Flawfinder: ignore */
  267. S32 len = response.size() + head.length();
  268. ensure_equals("same length", len, (S32)expected.str().length());
  269. mBuffer.readAfter(ch.out(), NULL, (U8*)buffer, len);
  270. buffer[len] = '';
  271. std::string actual(buffer);
  272. ensure_equals("threaded writes", actual, expected.str());
  273. }
  275. template<> template<>
  276. void buffer_object::test<7>()
  277. {
  278. const S32 LINE_COUNT = 3;
  279. std::string lines[LINE_COUNT] =
  280. {
  281. std::string("GET /index.htm HTTP/1.0rn"),
  282. std::string("User-Agent: Wget/1.9.1rn"),
  283. std::string("Host: localhost:8008rn")
  284. };
  285. std::string text;
  286. S32 i;
  287. for(i = 0; i < LINE_COUNT; ++i)
  288. {
  289. text.append(lines[i]);
  290. }
  291. LLChannelDescriptors ch = mBuffer.nextChannel();
  292. mBuffer.append(ch.in(), (U8*)text.c_str(), text.length());
  293. const S32 BUFFER_LEN = 1024;
  294. char buf[BUFFER_LEN];
  295. S32 len;
  296. U8* last = NULL;
  297. std::string last_line;
  298. for(i = 0; i < LINE_COUNT; ++i)
  299. {
  300. len = BUFFER_LEN;
  301. last = mBuffer.readAfter(ch.in(), last, (U8*)buf, len);
  302. char* newline = strchr((char*)buf, 'n');
  303. S32 offset = -((len - 1) - (newline - buf));
  304. ++newline;
  305. *newline = '';
  306. last_line.assign(buf);
  307. std::ostringstream message;
  308. message << "line reads in line["  << i << "]";
  309. ensure_equals(message.str().c_str(), last_line, lines[i]);
  310. last = mBuffer.seek(ch.in(), last, offset);
  311. }
  312. }
  314. template<> template<>
  315. void buffer_object::test<8>()
  316. {
  317. LLChannelDescriptors ch = mBuffer.nextChannel();
  318. mBuffer.append(ch.in(), (U8*)"1", 1);
  319. LLBufferArray buffer;
  320. buffer.append(ch.in(), (U8*)"2", 1);
  321. mBuffer.takeContents(buffer);
  322. mBuffer.append(ch.in(), (U8*)"3", 1);
  323. S32 count = mBuffer.countAfter(ch.in(), NULL);
  324. ensure_equals("buffer size", count, 3);
  325. U8* temp = new U8[count];
  326. mBuffer.readAfter(ch.in(), NULL, temp, count);
  327. ensure("buffer content", (0 == memcmp(temp, (void*)"123", 3)));
  328. delete[] temp;
  329. }
  331. template<> template<>
  332. void buffer_object::test<9>()
  333. {
  334. LLChannelDescriptors ch = mBuffer.nextChannel();
  335. mBuffer.append(ch.in(), (U8*)"1", 1);
  336. S32 capacity = mBuffer.capacity();
  337. ensure("has capacity", capacity > 0);
  338. U8* temp = new U8[capacity - 1];
  339. mBuffer.append(ch.in(), temp, capacity - 1);
  340. capacity = mBuffer.capacity();
  341. ensure("has capacity when full", capacity > 0);
  342. S32 used = mBuffer.countAfter(ch.in(), NULL);
  343. ensure_equals("used equals capacity", used, capacity);
  345. LLBufferArray::segment_iterator_t iter = mBuffer.beginSegment();
  346. while(iter != mBuffer.endSegment())
  347. {
  348. mBuffer.eraseSegment(iter++);
  349. }
  351. used = mBuffer.countAfter(ch.in(), NULL);
  352. ensure_equals("used is zero", used, 0);
  353. S32 capacity2 = mBuffer.capacity();
  354. ensure_equals("capacity the same after erase", capacity2, capacity);
  355. mBuffer.append(ch.in(), temp, capacity - 1);
  356. capacity2 = mBuffer.capacity();
  357. ensure_equals("capacity the same after append", capacity2, capacity);
  359. delete[] temp;
  360. }
  362. #if 0
  363. template<> template<>
  364. void buffer_object::test<9>()
  365. {
  366. char buffer[1024]; /* Flawfinder: ignore */
  367. S32 size = sprintf(buffer,
  368. "%d|%d|%s|%s|%s|%s|%s|%x|%x|%x|%x|%x|%s|%s|%d|%d|%x",
  369. 7,
  370. 7,
  371. "Hang Glider INFO",
  372. "18e84d1e-04a4-4c0d-8cb6-6c73477f0a9a",
  373. "0e346d8b-4433-4d66-a6b0-fd37083abc4c",
  374. "0e346d8b-4433-4d66-a6b0-fd37083abc4c",
  375. "00000000-0000-0000-0000-000000000000",
  376. 0x7fffffff,
  377. 0x7fffffff,
  378. 0,
  379. 0,
  380. 0x7fffffff,
  381. "69e0d357-2e7c-8990-a2bc-7f61c868e5a3",
  382. "2004-06-04 16:09:17 note card",
  383. 0,
  384. 10,
  385. 0) + 1;
  387. //const char* expected = "7|7|Hang Glider INFO|18e84d1e-04a4-4c0d-8cb6-6c73477f0a9a|0e346d8b-4433-4d66-a6b0-fd37083abc4c|0e346d8b-4433-4d66-a6b0-fd37083abc4c|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|7fffffff|69e0d357-2e7c-8990-a2bc-7f61c868e5a3|2004-06-04 16:09:17 note card|0|10|0";
  389. LLSD* bin_bucket = LLIMInfo::buildSDfrombuffer((U8*)buffer,size);
  391. char post_buffer[1024];
  392. U32 post_size;
  393. LLIMInfo::getBinaryBucket(bin_bucket,(U8*)post_buffer,post_size);
  394. ensure_equals("Buffer sizes",size,(S32)post_size);
  395. ensure("Buffer content",!strcmp(buffer,post_buffer));
  396. }
  397. #endif
  399. /*
  400. template<> template<>
  401. void buffer_object::test<>()
  402. {
  403. }
  404. */
  405. }
  407. namespace tut
  408. {
  409. struct buffer_and_stream_data
  410. {
  411. LLBufferArray mBuffer;
  412. };
  413. typedef test_group<buffer_and_stream_data> bas_test;
  414. typedef bas_test::object bas_object;
  415. tut::bas_test tbs("buffer_stream");
  417. template<> template<>
  418. void bas_object::test<1>()
  419. {
  420. const char HELLO_WORLD[] = "hello world";
  421. const S32 str_len = strlen(HELLO_WORLD); /* Flawfinder: ignore */
  422. LLChannelDescriptors ch = mBuffer.nextChannel();
  423. LLBufferStream str(ch, &mBuffer);
  424. mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
  425. std::string hello;
  426. std::string world;
  427. str >> hello >> world;
  428. ensure_equals("first word", hello, std::string("hello"));
  429. ensure_equals("second word", world, std::string("world"));
  430. }
  432. template<> template<>
  433. void bas_object::test<2>()
  434. {
  435. std::string part1("Eat my shor");
  436. std::string part2("ts ho");
  437. std::string part3("mer");
  438. std::string ignore("ignore me");
  439. LLChannelDescriptors ch = mBuffer.nextChannel();
  440. LLBufferStream str(ch, &mBuffer);
  441. mBuffer.append(ch.in(), (U8*)part1.c_str(), part1.length());
  442. mBuffer.append(ch.in(), (U8*)part2.c_str(), part2.length());
  443. mBuffer.append(ch.out(), (U8*)ignore.c_str(), ignore.length());
  444. mBuffer.append(ch.in(), (U8*)part3.c_str(), part3.length());
  445. std::string eat;
  446. std::string my;
  447. std::string shorts;
  448. std::string homer;
  449. str >> eat >> my >> shorts >> homer;
  450. ensure_equals("word1", eat, std::string("Eat"));
  451. ensure_equals("word2", my, std::string("my"));
  452. ensure_equals("word3", shorts, std::string("shorts"));
  453. ensure_equals("word4", homer, std::string("homer"));
  454. }
  456. template<> template<>
  457. void bas_object::test<3>()
  458. {
  459. std::string part1("junk in ");
  460. std::string part2("the trunk");
  461. const S32 CHANNEL = 0;
  462. mBuffer.append(CHANNEL, (U8*)part1.c_str(), part1.length());
  463. mBuffer.append(CHANNEL, (U8*)part2.c_str(), part2.length());
  464. U8* last = 0;
  465. const S32 BUF_LEN = 128;
  466. char buf[BUF_LEN];
  467. S32 len = 11;
  468. last = mBuffer.readAfter(CHANNEL, last, (U8*)buf, len);
  469. buf[len] = '';
  470. std::string actual(buf);
  471. ensure_equals("first read", actual, std::string("junk in the"));
  472. last = mBuffer.seek(CHANNEL, last, -6);
  473. len = 12;
  474. last = mBuffer.readAfter(CHANNEL, last, (U8*)buf, len);
  475. buf[len] = '';
  476. actual.assign(buf);
  477. ensure_equals("seek and read", actual, std::string("in the trunk"));
  478. }
  480. template<> template<>
  481. void bas_object::test<4>()
  482. {
  483. std::string phrase("zippity do da!");
  484. const S32 CHANNEL = 0;
  485. mBuffer.append(CHANNEL, (U8*)phrase.c_str(), phrase.length());
  486. const S32 BUF_LEN = 128;
  487. char buf[BUF_LEN];
  488. S32 len = 7;
  489. U8* last = mBuffer.readAfter(CHANNEL, NULL, (U8*)buf, len);
  490. mBuffer.splitAfter(last);
  491. LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
  492. LLBufferArray::segment_iterator_t end = mBuffer.endSegment();
  493. std::string first((char*)((*it).data()), (*it).size());
  494. ensure_equals("first part", first, std::string("zippity"));
  495. ++it;
  496. std::string second((char*)((*it).data()), (*it).size());
  497. ensure_equals("second part", second, std::string(" do da!"));
  498. ++it;
  499. ensure("iterators equal",  (it == end));
  500. }
  502. template<> template<>
  503. void bas_object::test<5>()
  504. {
  505. LLChannelDescriptors ch = mBuffer.nextChannel();
  506. LLBufferStream str(ch, &mBuffer);
  507. std::string h1("hello");
  508. std::string h2(", how are you doing?");
  509. std::string expected(h1);
  510. expected.append(h2);
  511. str << h1 << h2;
  512. str.flush();
  513. const S32 BUF_LEN = 128;
  514. char buf[BUF_LEN];
  515. S32 actual_len = BUF_LEN;
  516. S32 expected_len = h1.size() + h2.size();
  517. (void) mBuffer.readAfter(ch.out(), NULL, (U8*)buf, actual_len);
  518. ensure_equals("streamed size", actual_len, expected_len);
  519. buf[actual_len] = '';
  520. std::string actual(buf);
  521. ensure_equals("streamed to buf", actual, expected);
  522. }
  524. template<> template<>
  525. void bas_object::test<6>()
  526. {
  527. LLChannelDescriptors ch = mBuffer.nextChannel();
  528. LLBufferStream bstr(ch, &mBuffer);
  529. std::ostringstream ostr;
  530. std::vector<LLUUID> ids;
  531. LLUUID id;
  532. for(int i = 0; i < 5; ++i)
  533. {
  534. id.generate();
  535. ids.push_back(id);
  536. }
  537. bstr << "SELECT concat(u.username, ' ', l.name) "
  538.  << "FROM user u, user_last_name l "
  539.  << "WHERE u.last_name_id = l.last_name_id"
  540.  << " AND u.agent_id IN ('";
  541. ostr << "SELECT concat(u.username, ' ', l.name) "
  542.  << "FROM user u, user_last_name l "
  543.  << "WHERE u.last_name_id = l.last_name_id"
  544.  << " AND u.agent_id IN ('";
  545. std::copy(
  546. ids.begin(),
  547. ids.end(),
  548. std::ostream_iterator<LLUUID>(bstr, "','"));
  549. std::copy(
  550. ids.begin(),
  551. ids.end(),
  552. std::ostream_iterator<LLUUID>(ostr, "','"));
  553. bstr.seekp(-2, std::ios::cur);
  554. ostr.seekp(-2, std::ios::cur);
  555. bstr << ") ";
  556. ostr << ") ";
  557. bstr.flush();
  558. const S32 BUF_LEN = 512;
  559. char buf[BUF_LEN]; /* Flawfinder: ignore */
  560. S32 actual_len = BUF_LEN;
  561. (void) mBuffer.readAfter(ch.out(), NULL, (U8*)buf, actual_len);
  562. buf[actual_len] = '';
  563. std::string actual(buf);
  564. std::string expected(ostr.str());
  565. ensure_equals("size of string in seek",actual.size(),expected.size());
  566. ensure_equals("seek in ostream", actual, expected);
  567. }
  569. template<> template<>
  570. void bas_object::test<7>()
  571. {
  572. LLChannelDescriptors ch = mBuffer.nextChannel();
  573. LLBufferStream bstr(ch, &mBuffer);
  574. bstr << "1";
  575. bstr.flush();
  576. S32 count = mBuffer.countAfter(ch.out(), NULL);
  577. ensure_equals("buffer size 1", count, 1);
  578. LLBufferArray buffer;
  579. buffer.append(ch.out(), (U8*)"2", 1);
  580. mBuffer.takeContents(buffer);
  581. count = mBuffer.countAfter(ch.out(), NULL);
  582. ensure_equals("buffer size 2", count, 2);
  583. bstr << "3";
  584. bstr.flush();
  585. count = mBuffer.countAfter(ch.out(), NULL);
  586. ensure_equals("buffer size 3", count, 3);
  587. U8* temp = new U8[count];
  588. mBuffer.readAfter(ch.out(), NULL, temp, count);
  589. ensure("buffer content", (0 == memcmp(temp, (void*)"123", 3)));
  590. delete[] temp;
  591. }
  593. template<> template<>
  594. void bas_object::test<8>()
  595. {
  596. LLChannelDescriptors ch = mBuffer.nextChannel();
  597. LLBufferStream ostr(ch, &mBuffer);
  598. typedef std::vector<U8> buf_t;
  599. typedef std::vector<buf_t> actual_t;
  600. actual_t actual;
  601. buf_t source;
  602. bool need_comma = false;
  603. ostr << "[";
  604. S32 total_size = 1;
  605. for(S32 i = 2000; i < 2003; ++i)
  606. {
  607. if(need_comma)
  608. {
  609. ostr << ",";
  610. ++total_size;
  611. }
  612. need_comma = true;
  613. srand(69 + i); /* Flawfinder: ignore */
  614. S32 size = rand() % 1000 + 1000;
  615. std::generate_n(
  616. std::back_insert_iterator<buf_t>(source),
  617. size,
  618. rand);
  619. actual.push_back(source);
  620. ostr << "b(" << size << ")"";
  621. total_size += 8;
  622. ostr.write((const char*)(&source[0]), size);
  623. total_size += size;
  624. source.clear();
  625. ostr << """;
  626. ++total_size;
  627. }
  628. ostr << "]";
  629. ++total_size;
  630. ostr.flush();
  632. // now that we have a bunch of data on a stream, parse it all.
  633. ch = mBuffer.nextChannel();
  634. S32 count = mBuffer.countAfter(ch.in(), NULL);
  635. ensure_equals("size of buffer", count, total_size);
  636. LLBufferStream istr(ch, &mBuffer);
  637. LLSD data;
  638. count = LLSDSerialize::fromNotation(data, istr, total_size);
  639. ensure("sd parsed", data.isDefined());
  641. for(S32 j = 0; j < 3; ++j)
  642. {
  643. std::ostringstream name;
  644. LLSD child(data[j]);
  645. name << "found buffer " << j;
  646. ensure(name.str(), child.isDefined());
  647. source = child.asBinary();
  648. name.str("");
  649. name << "buffer " << j << " size";
  650. ensure_equals(name.str().c_str(), source.size(), actual[j].size());
  651. name.str("");
  652. name << "buffer " << j << " contents";
  653. ensure(
  654. name.str(),
  655. (0 == memcmp(&source[0], &actual[j][0], source.size())));
  656. }
  657. }
  659. template<> template<>
  660. void bas_object::test<9>()
  661. {
  662. LLChannelDescriptors ch = mBuffer.nextChannel();
  663. LLBufferStream ostr(ch, &mBuffer);
  664. typedef std::vector<U8> buf_t;
  665. buf_t source;
  666. bool need_comma = false;
  667. ostr << "{";
  668. S32 total_size = 1;
  669. for(S32 i = 1000; i < 3000; ++i)
  670. {
  671. if(need_comma)
  672. {
  673. ostr << ",";
  674. ++total_size;
  675. }
  676. need_comma = true;
  677. ostr << "'" << i << "':";
  678. total_size += 7;
  679. srand(69 + i); /* Flawfinder: ignore */
  680. S32 size = rand() % 1000 + 1000;
  681. std::generate_n(
  682. std::back_insert_iterator<buf_t>(source),
  683. size,
  684. rand);
  685. ostr << "b(" << size << ")"";
  686. total_size += 8;
  687. ostr.write((const char*)(&source[0]), size);
  688. total_size += size;
  689. source.clear();
  690. ostr << """;
  691. ++total_size;
  692. }
  693. ostr << "}";
  694. ++total_size;
  695. ostr.flush();
  697. // now that we have a bunch of data on a stream, parse it all.
  698. ch = mBuffer.nextChannel();
  699. S32 count = mBuffer.countAfter(ch.in(), NULL);
  700. ensure_equals("size of buffer", count, total_size);
  701. LLBufferStream istr(ch, &mBuffer);
  702. LLSD data;
  703. count = LLSDSerialize::fromNotation(data, istr, total_size);
  704. ensure("sd parsed", data.isDefined());
  705. }
  707. template<> template<>
  708. void bas_object::test<10>()
  709. {
  710. //#if LL_WINDOWS && _MSC_VER >= 1400
  711. //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
  712. //#endif
  713. const char LOGIN_STREAM[] = "{'method':'login', 'parameter': [ {"
  714. "'uri': 'sl-am:kellys.region.siva.lindenlab.com/location?start=url&px=128&py=128&pz=128&lx=0&ly=0&lz=0'}, "
  715. "{'version': i1}, {'texture_data': [ '61d724fb-ad79-f637-2186-5cf457560daa', '6e38b9be-b7cc-e77a-8aec-029a42b0b416', "
  716. "'a9073524-e89b-2924-ca6e-a81944109a1a', '658f18b5-5f1e-e593-f5d5-36c3abc7249a', '0cc799f4-8c99-6b91-bd75-b179b12429e2', "
  717. "'59fd9b64-8300-a425-aad8-2ffcbe9a49d2', '59fd9b64-8300-a425-aad8-2ffcbe9a49d2', '5748decc-f629-461c-9a36-a35a221fe21f', "
  718. "'b8fc9be2-26a6-6b47-690b-0e902e983484', 'a13ca0fe-3802-dc97-e79a-70d12171c724', 'dd9643cf-fd5d-0376-ed4a-b1cc646a97d5', "
  719. "'4ad13ae9-a112-af09-210a-cf9353a7a9e7', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', "
  720. "'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', "
  721. "'5748decc-f629-461c-9a36-a35a221fe21f', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97'],"
  722. "'session_id': '324cfa9f-fe5d-4d1c-a317-35f20a86a4d1','position': [ i128, i128, i128],'last_name': 'Linden','group_title': '-> !BLING! <-','group_name': 'test!','agent_access': 'M',"
  723. "'attachment_data': [ {'asset_id': 'aaede2b1-9955-09d4-5c93-2b557c778cf3','attachment_point': i6,'item_id': 'f3694abc-5122-db33-73d9-e0f4288dc2bf'}],"
  724. "'buddy_ids': [ '101358d5-469d-4b24-9b85-4dc3c05e635d', '1b00fec7-6265-4875-acac-80d9cfe9295c', '203ad6df-b522-491d-ba48-4e24eb57aeff', "
  725. "'22d4dcdb-aebb-47fa-b925-a871cc75ee48','27da3df5-1339-4463-80aa-40504ee3b3e5', '299d1720-b61f-4268-8c29-9614aa2d44c2', "
  726. "'2b048a24-2737-4994-9fa5-becc8e466253', '2cd5dc14-a853-49a4-be3c-a5a7178e37bc', '3de548e1-57be-cfea-2b78-83ae3ad95998', "
  727. "'3dee98e4-a6a3-4543-91c3-bbd528447ba7', '3e2d81a3-6263-6ffe-ad5c-8ce04bee07e9', '40e70b98-fed7-47f3-9700-1bce93f9350b', "
  728. "'50a9b68e-b5aa-4d35-9137-3cfebda0a15c', '54295571-9357-43ff-ae74-a83b5138160f', '6191e2d7-5f96-4856-bdab-af0f79f47ae4', "
  729. "'63e577d8-cd34-4235-a0a3-de0500133364', '79cfb666-4fd0-4af7-95df-fb7d96b4e24d', '8121c2f3-4a88-4c33-9899-8fc1273f47ee', "
  730. "'909da964-ef23-4f2a-ba13-f2a8cfd454b6','a2e76fcd-9360-4f6d-a924-000000000001', 'aaa6d664-527e-4d83-9cbb-7ef79ccc7cc8', "
  731. "'b79bfb6c-23be-49eb-b35b-30ff2f501b37', 'ba0d9c79-148c-4a79-8e3c-0665eebe2427', 'bc9bda98-57cd-498f-b993-4ff1ac9dec93', "
  732. "'c62d16f6-81cb-419d-9cac-e46dc394084d', 'd48f8fa7-2512-4fe5-80c8-c0a923412e07', 'd77e3e24-7e6c-4c3f-96d0-a1746337f8fb', "
  733. "'da615c63-a84b-4592-a3d6-a90dd3e92e6e', 'df47190a-7eb7-4aff-985f-2d1d3ad6c6e9', 'e3380196-72cd-499c-a2ba-caa180bd5fe4', "
  734. "'e937863f-f134-4207-803b-d6e686651d6c', 'efcdf98b-5269-45ef-ac7a-0671f09ea9d9'],"
  735. "'circuit_code': i124,'group_id': '8615c885-9cf0-bf0a-6e40-0c11462aa652','limited_to_estate': i1,'look_at': [ i0, i0, i0],"
  736. "'agent_id': '0e346d8b-4433-4d66-a6b0-fd37083abc4c','first_name': 'Kelly','start': 'url'}]}";
  737. LLChannelDescriptors ch = mBuffer.nextChannel();
  738. mBuffer.append(ch.out(), (U8*)LOGIN_STREAM, strlen(LOGIN_STREAM)); /* Flawfinder: ignore */
  739. ch = mBuffer.nextChannel();
  740. LLBufferStream istr(ch, &mBuffer);
  741. LLSD data;
  742. S32 count = LLSDSerialize::fromNotation(
  743. data,
  744. istr,
  745. mBuffer.count(ch.in()));
  746. ensure("parsed something", (count > 0));
  747. ensure("sd parsed", data.isDefined());
  748. ensure_equals("sd type", data.type(), LLSD::TypeMap);
  749. ensure("has method", data.has("method"));
  750. ensure("has parameter", data.has("parameter"));
  751. LLSD parameter = data["parameter"];
  752. ensure_equals("parameter is array", parameter.type(), LLSD::TypeArray);
  753. LLSD agent_params = parameter[2];
  754. std::string s_value;
  755. s_value = agent_params["last_name"].asString();
  756. ensure_equals("last name", s_value, std::string("Linden"));
  757. s_value = agent_params["first_name"].asString();
  758. ensure_equals("first name", s_value, std::string("Kelly"));
  759. s_value = agent_params["agent_access"].asString();
  760. ensure_equals("agent access", s_value, std::string("M"));
  761. s_value = agent_params["group_name"].asString();
  762. ensure_equals("group name", s_value, std::string("test!"));
  763. s_value = agent_params["group_title"].asString();
  764. ensure_equals("group title", s_value, std::string("-> !BLING! <-"));
  766. LLUUID agent_id("0e346d8b-4433-4d66-a6b0-fd37083abc4c");
  767. LLUUID id = agent_params["agent_id"];
  768. ensure_equals("agent id", id, agent_id);
  769. LLUUID session_id("324cfa9f-fe5d-4d1c-a317-35f20a86a4d1");
  770. id = agent_params["session_id"];
  771. ensure_equals("session id", id, session_id);
  772. LLUUID group_id ("8615c885-9cf0-bf0a-6e40-0c11462aa652");
  773. id = agent_params["group_id"];
  774. ensure_equals("group id", id, group_id);
  776. S32 i_val = agent_params["limited_to_estate"];
  777. ensure_equals("limited to estate", i_val, 1);
  778. i_val = agent_params["circuit_code"];
  779. ensure_equals("circuit code", i_val, 124);
  780. }
  783. template<> template<>
  784. void bas_object::test<11>()
  785. {
  786. std::string val = "{!'foo'@:#'bar'}";
  787. std::istringstream istr;
  788. istr.str(val);
  789. LLSD sd;
  790. S32 count = LLSDSerialize::fromNotation(sd, istr, val.size());
  791. ensure_equals("parser error return value", count, -1);
  792. ensure("data undefined", sd.isUndefined());
  793. }
  795. template<> template<>
  796. void bas_object::test<12>()
  797. {
  798. //#if LL_WINDOWS && _MSC_VER >= 1400
  799. //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
  800. //#endif
  801. std::string val = "{!'foo':[i1,'hi',{@'bar'#:[$i2%,^'baz'&]*}+]=}";
  802. std::istringstream istr;
  803. istr.str(val);
  804. LLSD sd;
  805. S32 count = LLSDSerialize::fromNotation(sd, istr, val.size());
  806. ensure_equals("parser error return value", count, -1);
  807. ensure("data undefined", sd.isUndefined());
  808. }
  810. /*
  811. template<> template<>
  812. void bas_object::test<13>()
  813. {
  814. }
  815. template<> template<>
  816. void bas_object::test<14>()
  817. {
  818. }
  819. template<> template<>
  820. void bas_object::test<15>()
  821. {
  822. }
  823. */
  824. }
  827. namespace tut
  828. {
  829. class PumpAndChainTestData
  830. {
  831. protected:
  832. apr_pool_t* mPool;
  833. LLPumpIO* mPump;
  834. LLPumpIO::chain_t mChain;
  836. public:
  837. PumpAndChainTestData()
  838. {
  839. apr_pool_create(&mPool, NULL);
  840. mPump = new LLPumpIO(mPool);
  841. }
  843. ~PumpAndChainTestData()
  844. {
  845. mChain.clear();
  846. delete mPump;
  847. apr_pool_destroy(mPool);
  848. }
  849. };
  850. typedef test_group<PumpAndChainTestData> PumpAndChainTestGroup;
  851. typedef PumpAndChainTestGroup::object PumpAndChainTestObject;
  852. PumpAndChainTestGroup pumpAndChainTestGroup("pump_and_chain");
  854. template<> template<>
  855. void PumpAndChainTestObject::test<1>()
  856. {
  857. LLPipeStringExtractor* extractor = new LLPipeStringExtractor();
  859. mChain.push_back(LLIOPipe::ptr_t(new LLIOFlush));
  860. mChain.push_back(LLIOPipe::ptr_t(extractor));
  862. LLTimer timer;
  863. timer.setTimerExpirySec(100.0f);
  865. mPump->addChain(mChain, DEFAULT_CHAIN_EXPIRY_SECS);
  866. while(!extractor->done() && !timer.hasExpired())
  867. {
  868. mPump->pump();
  869. mPump->callback();
  870. }
  872. ensure("reading string finished", extractor->done());
  873. ensure_equals("string was empty", extractor->string(), "");
  874. }
  875. }
  877. /*
  878. namespace tut
  879. {
  880. struct double_construct
  881. {
  882. public:
  883. double_construct()
  884. {
  885. llinfos << "constructed" << llendl;
  886. }
  887. ~double_construct()
  888. {
  889. llinfos << "destroyed" << llendl;
  890. }
  891. };
  892. typedef test_group<double_construct> double_construct_test_group;
  893. typedef double_construct_test_group::object dc_test_object;
  894. double_construct_test_group dctest("double construct");
  895. template<> template<>
  896. void dc_test_object::test<1>()
  897. {
  898. ensure("test 1", true);
  899. }
  900. }
  901. */
  903. namespace tut
  904. {
  905. /**
  906.  * @brief we want to test the pipes & pumps under bad conditions.
  907.  */
  908. struct pipe_and_pump_fitness
  909. {
  910. public:
  911. enum
  912. {
  913. SERVER_LISTEN_PORT = 13050
  914. };
  916. pipe_and_pump_fitness()
  917. {
  918. LLFrameTimer::updateFrameTime();
  919. apr_pool_create(&mPool, NULL);
  920. mPump = new LLPumpIO(mPool);
  921. mSocket = LLSocket::create(
  922. mPool,
  923. LLSocket::STREAM_TCP,
  924. SERVER_LISTEN_PORT);
  925. }
  927. ~pipe_and_pump_fitness()
  928. {
  929. mSocket.reset();
  930. delete mPump;
  931. apr_pool_destroy(mPool);
  932. }
  934. protected:
  935. apr_pool_t* mPool;
  936. LLPumpIO* mPump;
  937. LLSocket::ptr_t mSocket;
  938. };
  939. typedef test_group<pipe_and_pump_fitness> fitness_test_group;
  940. typedef fitness_test_group::object fitness_test_object;
  941. fitness_test_group fitness("pipe and pump fitness");
  943. template<> template<>
  944. void fitness_test_object::test<1>()
  945. {
  946. lldebugs << "fitness_test_object::test<1>()" << llendl;
  948. // Set up the server
  949. //lldebugs << "fitness_test_object::test<1> - setting up server."
  950. //  << llendl;
  951. LLPumpIO::chain_t chain;
  952. typedef LLCloneIOFactory<LLPipeStringInjector> emitter_t;
  953. emitter_t* emitter = new emitter_t(
  954. new LLPipeStringInjector("suckers never play me"));
  955. boost::shared_ptr<LLChainIOFactory> factory(emitter);
  956. LLIOServerSocket* server = new LLIOServerSocket(
  957. mPool,
  958. mSocket,
  959. factory);
  960. server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
  961. chain.push_back(LLIOPipe::ptr_t(server));
  962. mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
  964. // We need to tickle the pump a little to set up the listen()
  965. //lldebugs << "fitness_test_object::test<1> - initializing server."
  966. //  << llendl;
  967. pump_loop(mPump, 0.1f);
  969. // Set up the client
  970. //lldebugs << "fitness_test_object::test<1> - connecting client."
  971. //  << llendl;
  972. LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
  973. LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
  974. bool connected = client->blockingConnect(server_host);
  975. ensure("Connected to server", connected);
  976. lldebugs << "connected" << llendl;
  978. // We have connected, since the socket reader does not block,
  979. // the first call to read data will return EAGAIN, so we need
  980. // to write something.
  981. chain.clear();
  982. chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
  983. chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
  984. chain.push_back(LLIOPipe::ptr_t(new LLIONull));
  985. mPump->addChain(chain, 1.0f);
  987. // Now, the server should immediately send the data, but we'll
  988. // never read it. pump for a bit
  989. F32 elapsed = pump_loop(mPump, 2.0f);
  990. ensure("Did not take too long", (elapsed < 3.0f));
  991. }
  993. template<> template<>
  994. void fitness_test_object::test<2>()
  995. {
  996. lldebugs << "fitness_test_object::test<2>()" << llendl;
  998. // Set up the server
  999. LLPumpIO::chain_t chain;
  1000. typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
  1001. emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
  1002. boost::shared_ptr<LLChainIOFactory> factory(emitter);
  1003. LLIOServerSocket* server = new LLIOServerSocket(
  1004. mPool,
  1005. mSocket,
  1006. factory);
  1007. server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
  1008. chain.push_back(LLIOPipe::ptr_t(server));
  1009. mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
  1011. // We need to tickle the pump a little to set up the listen()
  1012. pump_loop(mPump, 0.1f);
  1014. // Set up the client
  1015. LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
  1016. LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
  1017. bool connected = client->blockingConnect(server_host);
  1018. ensure("Connected to server", connected);
  1019. lldebugs << "connected" << llendl;
  1021. // We have connected, since the socket reader does not block,
  1022. // the first call to read data will return EAGAIN, so we need
  1023. // to write something.
  1024. chain.clear();
  1025. chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
  1026. chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
  1027. chain.push_back(LLIOPipe::ptr_t(new LLIONull));
  1028. mPump->addChain(chain, SHORT_CHAIN_EXPIRY_SECS / 2.0f);
  1030. // Now, the server should immediately send the data, but we'll
  1031. // never read it. pump for a bit
  1032. F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS * 2.0f);
  1033. ensure("Did not take too long", (elapsed < 3.0f));
  1034. }
  1036. template<> template<>
  1037. void fitness_test_object::test<3>()
  1038. {
  1039. lldebugs << "fitness_test_object::test<3>()" << llendl;
  1041. // Set up the server
  1042. LLPumpIO::chain_t chain;
  1043. typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
  1044. emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
  1045. boost::shared_ptr<LLChainIOFactory> factory(emitter);
  1046. LLIOServerSocket* server = new LLIOServerSocket(
  1047. mPool,
  1048. mSocket,
  1049. factory);
  1050. server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
  1051. chain.push_back(LLIOPipe::ptr_t(server));
  1052. mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
  1054. // We need to tickle the pump a little to set up the listen()
  1055. pump_loop(mPump, 0.1f);
  1057. // Set up the client
  1058. LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
  1059. LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
  1060. bool connected = client->blockingConnect(server_host);
  1061. ensure("Connected to server", connected);
  1062. lldebugs << "connected" << llendl;
  1064. // We have connected, since the socket reader does not block,
  1065. // the first call to read data will return EAGAIN, so we need
  1066. // to write something.
  1067. chain.clear();
  1068. chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
  1069. chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
  1070. chain.push_back(LLIOPipe::ptr_t(new LLIONull));
  1071. mPump->addChain(chain, SHORT_CHAIN_EXPIRY_SECS * 2.0f);
  1073. // Now, the server should immediately send the data, but we'll
  1074. // never read it. pump for a bit
  1075. F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS * 2.0f + 1.0f);
  1076. ensure("Did not take too long", (elapsed < 4.0f));
  1077. }
  1079. template<> template<>
  1080. void fitness_test_object::test<4>()
  1081. {
  1082. lldebugs << "fitness_test_object::test<4>()" << llendl;
  1084. // Set up the server
  1085. LLPumpIO::chain_t chain;
  1086. typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
  1087. emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
  1088. boost::shared_ptr<LLChainIOFactory> factory(emitter);
  1089. LLIOServerSocket* server = new LLIOServerSocket(
  1090. mPool,
  1091. mSocket,
  1092. factory);
  1093. server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS + 1.80f);
  1094. chain.push_back(LLIOPipe::ptr_t(server));
  1095. mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
  1097. // We need to tickle the pump a little to set up the listen()
  1098. pump_loop(mPump, 0.1f);
  1100. // Set up the client
  1101. LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
  1102. LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
  1103. bool connected = client->blockingConnect(server_host);
  1104. ensure("Connected to server", connected);
  1105. lldebugs << "connected" << llendl;
  1107. // We have connected, since the socket reader does not block,
  1108. // the first call to read data will return EAGAIN, so we need
  1109. // to write something.
  1110. chain.clear();
  1111. chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
  1112. chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
  1113. chain.push_back(LLIOPipe::ptr_t(new LLIONull));
  1114. mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
  1116. // Now, the server should immediately send the data, but we'll
  1117. // never read it. pump for a bit
  1118. F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS + 3.0f);
  1119. ensure("Did not take too long", (elapsed < DEFAULT_CHAIN_EXPIRY_SECS));
  1120. }
  1122. template<> template<>
  1123. void fitness_test_object::test<5>()
  1124. {
  1125. // Set up the server
  1126. LLPumpIO::chain_t chain;
  1127. typedef LLCloneIOFactory<LLIOSleeper> sleeper_t;
  1128. sleeper_t* sleeper = new sleeper_t(new LLIOSleeper);
  1129. boost::shared_ptr<LLChainIOFactory> factory(sleeper);
  1130. LLIOServerSocket* server = new LLIOServerSocket(
  1131. mPool,
  1132. mSocket,
  1133. factory);
  1134. server->setResponseTimeout(1.0);
  1135. chain.push_back(LLIOPipe::ptr_t(server));
  1136. mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
  1137. // We need to tickle the pump a little to set up the listen()
  1138. pump_loop(mPump, 0.1f);
  1139. U32 count = mPump->runningChains();
  1140. ensure_equals("server chain onboard", count, 1);
  1141. lldebugs << "** Server is up." << llendl;
  1143. // Set up the client
  1144. LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
  1145. LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
  1146. bool connected = client->blockingConnect(server_host);
  1147. ensure("Connected to server", connected);
  1148. lldebugs << "connected" << llendl;
  1149. F32 elapsed = pump_loop(mPump,0.1f);
  1150. count = mPump->runningChains();
  1151. ensure_equals("server chain onboard", count, 2);
  1152. lldebugs << "** Client is connected." << llendl;
  1154. // We have connected, since the socket reader does not block,
  1155. // the first call to read data will return EAGAIN, so we need
  1156. // to write something.
  1157. chain.clear();
  1158. chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
  1159. chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
  1160. chain.push_back(LLIOPipe::ptr_t(new LLIONull));
  1161. mPump->addChain(chain, 0.2f);
  1162. chain.clear();
  1164. // pump for a bit and make sure all 3 chains are running
  1165. elapsed = pump_loop(mPump,0.1f);
  1166. count = mPump->runningChains();
  1167. ensure_equals("client chain onboard", count, 3);
  1168. lldebugs << "** request should have been sent." << llendl;
  1170. // pump for long enough the the client socket closes, and the
  1171. // server socket should not be closed yet.
  1172. elapsed = pump_loop(mPump,0.2f);
  1173. count = mPump->runningChains();
  1174. ensure_equals("client chain timed out ", count, 2);
  1175. lldebugs << "** client chain should be closed." << llendl;
  1177. // At this point, the socket should be closed by the timeout
  1178. elapsed = pump_loop(mPump,1.0f);
  1179. count = mPump->runningChains();
  1180. ensure_equals("accepted socked close", count, 1);
  1181. lldebugs << "** Sleeper should have timed out.." << llendl;
  1182. }
  1183. }
  1185. namespace tut
  1186. {
  1187. struct rpc_server_data
  1188. {
  1189. class LLSimpleRPCResponse : public LLSDRPCResponse
  1190. {
  1191. public:
  1192. LLSimpleRPCResponse(LLSD* response) :
  1193. mResponsePtr(response)
  1194. {
  1195. }
  1196. ~LLSimpleRPCResponse() {}
  1197. virtual bool response(LLPumpIO* pump)
  1198. {
  1199. *mResponsePtr = mReturnValue;
  1200. return true;
  1201. }
  1202. virtual bool fault(LLPumpIO* pump)
  1203. {
  1204. *mResponsePtr = mReturnValue;
  1205. return false;
  1206. }
  1207. virtual bool error(LLPumpIO* pump)
  1208. {
  1209. ensure("LLSimpleRPCResponse::error()", false);
  1210. return false;
  1211. }
  1212. public:
  1213. LLSD* mResponsePtr;
  1214. };
  1216. class LLSimpleRPCClient : public LLSDRPCClient
  1217. {
  1218. public:
  1219. LLSimpleRPCClient(LLSD* response) :
  1220. mResponsePtr(response)
  1221. {
  1222. }
  1223. ~LLSimpleRPCClient() {}
  1224. void echo(const LLSD& parameter)
  1225. {
  1226. LLSimpleRPCResponse* resp;
  1227. resp = new LLSimpleRPCResponse(mResponsePtr);
  1228. static const std::string URI_NONE;
  1229. static const std::string METHOD_ECHO("echo");
  1230. call(URI_NONE, METHOD_ECHO, parameter, resp, EPBQ_CALLBACK);
  1231. }
  1232. public:
  1233. LLSD* mResponsePtr;
  1234. };
  1236. class LLSimpleRPCServer : public LLSDRPCServer
  1237. {
  1238. public:
  1239. LLSimpleRPCServer()
  1240. {
  1241. mMethods["echo"] = new mem_fn_t(
  1242. this,
  1243. &LLSimpleRPCServer::rpc_Echo);
  1244. }
  1245. ~LLSimpleRPCServer() {}
  1246. protected:
  1247. typedef LLSDRPCMethodCall<LLSimpleRPCServer> mem_fn_t;
  1248. ESDRPCSStatus rpc_Echo(
  1249. const LLSD& parameter,
  1250. const LLChannelDescriptors& channels,
  1251. LLBufferArray* data)
  1252. {
  1253. buildResponse(channels, data, parameter);
  1254. return ESDRPCS_DONE;
  1255. }
  1256. };
  1258. apr_pool_t* mPool;
  1259. LLPumpIO* mPump;
  1260. LLPumpIO::chain_t mChain;
  1261. LLSimpleRPCClient* mClient;
  1262. LLSD mResponse;
  1264. rpc_server_data() :
  1265. mPool(NULL),
  1266. mPump(NULL),
  1267. mClient(NULL)
  1268. {
  1269. apr_pool_create(&mPool, NULL);
  1270. mPump = new LLPumpIO(mPool);
  1271. mClient = new LLSimpleRPCClient(&mResponse);
  1272. mChain.push_back(LLIOPipe::ptr_t(mClient));
  1273. mChain.push_back(LLIOPipe::ptr_t(new LLFilterSD2XMLRPCRequest));
  1274. mChain.push_back(LLIOPipe::ptr_t(new LLFilterXMLRPCRequest2LLSD));
  1275. mChain.push_back(LLIOPipe::ptr_t(new LLSimpleRPCServer));
  1276. mChain.push_back(LLIOPipe::ptr_t(new LLFilterSD2XMLRPCResponse));
  1277. mChain.push_back(LLIOPipe::ptr_t(new LLFilterXMLRPCResponse2LLSD));
  1278. mChain.push_back(LLIOPipe::ptr_t(mClient));
  1279. }
  1280. ~rpc_server_data()
  1281. {
  1282. mChain.clear();
  1283. delete mPump;
  1284. mPump = NULL;
  1285. apr_pool_destroy(mPool);
  1286. mPool = NULL;
  1287. }
  1288. void pump_loop(const LLSD& request)
  1289. {
  1290. LLTimer timer;
  1291. timer.setTimerExpirySec(1.0f);
  1292. mClient->echo(request);
  1293. mPump->addChain(mChain, DEFAULT_CHAIN_EXPIRY_SECS);
  1294. while(mResponse.isUndefined() && !timer.hasExpired())
  1295. {
  1296. mPump->pump();
  1297. mPump->callback();
  1298. }
  1299. }
  1300. };
  1301. typedef test_group<rpc_server_data> rpc_server_test;
  1302. typedef rpc_server_test::object rpc_server_object;
  1303. tut::rpc_server_test rpc("rpc_server");
  1305. template<> template<>
  1306. void rpc_server_object::test<1>()
  1307. {
  1308. LLSD request;
  1309. request = 1;
  1310. pump_loop(request);
  1311. //llinfos << "request: " << *request << llendl;
  1312. //llinfos << "response: " << *mResponse << llendl;
  1313. ensure_equals("integer request response", mResponse.asInteger(), 1);
  1314. }
  1316. template<> template<>
  1317. void rpc_server_object::test<2>()
  1318. {
  1319. //#if LL_WINDOWS && _MSC_VER >= 1400
  1320. //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
  1321. //#endif
  1322. std::string uri("sl-am:66.150.244.180:12035/location?start=region&px=70.9247&py=254.378&pz=38.7304&lx=-0.043753&ly=-0.999042&lz=0");
  1323. std::stringstream stream;
  1324. stream << "{'task_id':ucc706f2d-0b68-68f8-11a4-f1043ff35ca0}n{ntnametObject|ntpermissions 0n}";
  1325. std::vector<U8> expected_binary;
  1326. expected_binary.resize(stream.str().size());
  1327. memcpy(&expected_binary[0], stream.str().c_str(), stream.str().size()); /* Flawfinder: ignore */
  1328. stream.str("");
  1329. stream << "[{'uri':'" << uri << "'}, {'version':i1}, "
  1330.   << "{'agent_id':'3c115e51-04f4-523c-9fa6-98aff1034730', 'session_id':'2c585cec-038c-40b0-b42e-a25ebab4d132', 'circuit_code':i1075, 'start':'region', 'limited_to_estate':i1 'first_name':'Phoenix', 'last_name':'Linden', 'group_title':'', 'group_id':u00000000-0000-0000-0000-000000000000, 'position':[r70.9247,r254.378,r38.7304], 'look_at':[r-0.043753,r-0.999042,r0], 'granters':[ua2e76fcd-9360-4f6d-a924-000000000003], 'texture_data':['5e481e8a-58a6-fc34-6e61-c7a36095c07f', 'c39675f5-ca90-a304-bb31-42cdb803a132', '5c989edf-88d1-b2ac-b00b-5ed4bab8e368', '6522e74d-1660-4e7f-b601-6f48c1659a77', '7ca39b4c-bd19-4699-aff7-f93fd03d3e7b', '41c58177-5eb6-5aeb-029d-bc4093f3c130', '97b75473-8b93-9b25-2a11-035b9ae93195', '1c2d8d9b-90eb-89d4-dea8-c1ed83990614', '69ec543f-e27b-c07c-9094-a8be6300f274', 'c9f8b80f-c629-4633-04ee-c566ce9fea4b', '989cddba-7ab6-01ed-67aa-74accd2a2a65', '45e319b2-6a8c-fa5c-895b-1a7149b88aef', '5748decc-f629-461c-9a36-a35a221fe21f', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', '685fbe10-ab40-f065-0aec-726cc6dfd7a1', '406f98fd-9c89-1d52-5f39-e67d508c5ee5', '685fbe10-ab40-f065-0aec-726cc6dfd7a1', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97'], "
  1331.   << "'attachment_data':["
  1332.   << "{'attachment_point':i2, 'item_id':'d6852c11-a74e-309a-0462-50533f1ef9b3', 'asset_id':'c69b29b1-8944-58ae-a7c5-2ca7b23e22fb'},"
  1333.   << "{'attachment_point':i10, 'item_id':'ff852c22-a74e-309a-0462-50533f1ef900', 'asset_data':b(" << expected_binary.size() << ")"";
  1334. stream.write((const char*)&expected_binary[0], expected_binary.size());
  1335. stream << ""}"
  1336.   << "]"
  1337.   << "}]";
  1339. LLSD request;
  1340. S32 count = LLSDSerialize::fromNotation(
  1341. request,
  1342. stream,
  1343. stream.str().size());
  1344. ensure("parsed something", (count > 0));
  1346. pump_loop(request);
  1347. ensure_equals("return type", mResponse.type(), LLSD::TypeArray);
  1348. ensure_equals("return size", mResponse.size(), 3);
  1350. ensure_equals(
  1351. "uri parameter type",
  1352. mResponse[0].type(),
  1353. LLSD::TypeMap);
  1354. ensure_equals(
  1355. "uri type",
  1356. mResponse[0]["uri"].type(),
  1357. LLSD::TypeString);
  1358. ensure_equals("uri value", mResponse[0]["uri"].asString(), uri);
  1360. ensure_equals(
  1361. "version parameter type",
  1362. mResponse[1].type(),
  1363. LLSD::TypeMap);
  1364. ensure_equals(
  1365. "version type",
  1366. mResponse[1]["version"].type(),
  1367. LLSD::TypeInteger);
  1368. ensure_equals(
  1369. "version value",
  1370. mResponse[1]["version"].asInteger(),
  1371. 1);
  1373. ensure_equals("agent params type", mResponse[2].type(), LLSD::TypeMap);
  1374. LLSD attachment_data = mResponse[2]["attachment_data"];
  1375. ensure("attachment data exists", attachment_data.isDefined());
  1376. ensure_equals(
  1377. "attachment type",
  1378. attachment_data.type(),
  1379. LLSD::TypeArray);
  1380. ensure_equals(
  1381. "attachment type 0",
  1382. attachment_data[0].type(),
  1383. LLSD::TypeMap);
  1384. ensure_equals(
  1385. "attachment type 1",
  1386. attachment_data[1].type(),
  1387. LLSD::TypeMap);
  1388. ensure_equals("attachment size 1", attachment_data[1].size(), 3);
  1389. ensure_equals(
  1390. "asset data type",
  1391. attachment_data[1]["asset_data"].type(),
  1392. LLSD::TypeBinary);
  1393. std::vector<U8> actual_binary;
  1394. actual_binary = attachment_data[1]["asset_data"].asBinary();
  1395. ensure_equals(
  1396. "binary data size",
  1397. actual_binary.size(),
  1398. expected_binary.size());
  1399. ensure(
  1400. "binary data",
  1401. (0 == memcmp(
  1402. &actual_binary[0],
  1403. &expected_binary[0],
  1404. expected_binary.size())));
  1405. }
  1407. template<> template<>
  1408. void rpc_server_object::test<3>()
  1409. {
  1410. //#if LL_WINDOWS && _MSC_VER >= 1400
  1411. //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
  1412. //#endif
  1413. std::string uri("sl-am:66.150.244.180:12035/location?start=region&px=70.9247&py=254.378&pz=38.7304&lx=-0.043753&ly=-0.999042&lz=0");
  1415. LLBufferArray buffer;
  1416. LLChannelDescriptors buffer_channels = buffer.nextChannel();
  1417. LLBufferStream stream(buffer_channels, &buffer);
  1418. stream << "[{'uri':'" << uri << "'}, {'version':i1}, "
  1419.   << "{'agent_id':'3c115e51-04f4-523c-9fa6-98aff1034730', 'session_id':'2c585cec-038c-40b0-b42e-a25ebab4d132', 'circuit_code':i1075, 'start':'region', 'limited_to_estate':i1 'first_name':'Phoenix', 'last_name':'Linden', 'group_title':'', 'group_id':u00000000-0000-0000-0000-000000000000, 'position':[r70.9247,r254.378,r38.7304], 'look_at':[r-0.043753,r-0.999042,r0], 'granters':[ua2e76fcd-9360-4f6d-a924-000000000003], 'texture_data':['5e481e8a-58a6-fc34-6e61-c7a36095c07f', 'c39675f5-ca90-a304-bb31-42cdb803a132', '5c989edf-88d1-b2ac-b00b-5ed4bab8e368', '6522e74d-1660-4e7f-b601-6f48c1659a77', '7ca39b4c-bd19-4699-aff7-f93fd03d3e7b', '41c58177-5eb6-5aeb-029d-bc4093f3c130', '97b75473-8b93-9b25-2a11-035b9ae93195', '1c2d8d9b-90eb-89d4-dea8-c1ed83990614', '69ec543f-e27b-c07c-9094-a8be6300f274', 'c9f8b80f-c629-4633-04ee-c566ce9fea4b', '989cddba-7ab6-01ed-67aa-74accd2a2a65', '45e319b2-6a8c-fa5c-895b-1a7149b88aef', '5748decc-f629-461c-9a36-a35a221fe21f', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', '685fbe10-ab40-f065-0aec-726cc6dfd7a1', '406f98fd-9c89-1d52-5f39-e67d508c5ee5', '685fbe10-ab40-f065-0aec-726cc6dfd7a1', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97'], "
  1420.   << "'attachment_data':["
  1421.   << "{'attachment_point':i2, 'item_id':'d6852c11-a74e-309a-0462-50533f1ef9b3', 'asset_id':'c69b29b1-8944-58ae-a7c5-2ca7b23e22fb'},";
  1423. std::stringstream tmp_str;
  1424. tmp_str << "{'task_id':ucc706f2d-0b68-68f8-11a4-f1043ff35ca0}n{ntnametObject|ntpermissions 0n}";
  1425. std::vector<U8> expected_binary;
  1426. expected_binary.resize(tmp_str.str().size());
  1427. memcpy( /* Flawfinder: ignore */
  1428. &expected_binary[0],
  1429. tmp_str.str().c_str(),
  1430. tmp_str.str().size());
  1432. LLBufferArray attachment_buffer;
  1433. LLChannelDescriptors attach_channels = attachment_buffer.nextChannel();
  1434. LLBufferStream attach_stream(attach_channels, &attachment_buffer);
  1435. attach_stream.write((const char*)&expected_binary[0], expected_binary.size());
  1436. attach_stream.flush();
  1437. S32 len = attachment_buffer.countAfter(attach_channels.out(), NULL);
  1438. stream << "{'attachment_point':i10, 'item_id':'ff852c22-a74e-309a-0462-50533f1ef900', 'asset_data':b(" << len << ")"";
  1439. stream.flush();
  1440. buffer.takeContents(attachment_buffer);
  1441. stream << ""}]}]";
  1442. stream.flush();
  1444. LLChannelDescriptors read_channel = buffer.nextChannel();
  1445. LLBufferStream read_stream(read_channel, &buffer);
  1446. LLSD request;
  1447. S32 count = LLSDSerialize::fromNotation(
  1448. request,
  1449. read_stream,
  1450. buffer.count(read_channel.in()));
  1451. ensure("parsed something", (count > 0));
  1452. ensure("deserialized", request.isDefined());
  1454. // do the rpc round trip
  1455. pump_loop(request);
  1457. ensure_equals("return type", mResponse.type(), LLSD::TypeArray);
  1458. ensure_equals("return size", mResponse.size(), 3);
  1460. LLSD child = mResponse[0];
  1461. ensure("uri map exists", child.isDefined());
  1462. ensure_equals("uri parameter type", child.type(), LLSD::TypeMap);
  1463. ensure("uri string exists", child.has("uri"));
  1464. ensure_equals("uri type", child["uri"].type(), LLSD::TypeString);
  1465. ensure_equals("uri value", child["uri"].asString(), uri);
  1467. child = mResponse[1];
  1468. ensure("version map exists", child.isDefined());
  1469. ensure_equals("version param type", child.type(), LLSD::TypeMap);
  1470. ensure_equals(
  1471. "version type",
  1472. child["version"].type(),
  1473. LLSD::TypeInteger);
  1474. ensure_equals("version value", child["version"].asInteger(), 1);
  1476. child = mResponse[2];
  1477. ensure("agent params map exists", child.isDefined());
  1478. ensure_equals("agent params type", child.type(), LLSD::TypeMap);
  1479. child = child["attachment_data"];
  1480. ensure("attachment data exists", child.isDefined());
  1481. ensure_equals("attachment type", child.type(), LLSD::TypeArray);
  1482. LLSD attachment = child[0];
  1483. ensure_equals("attachment type 0", attachment.type(), LLSD::TypeMap);
  1484. attachment = child[1];
  1485. ensure_equals("attachment type 1", attachment.type(), LLSD::TypeMap);
  1486. ensure_equals("attachment size 1", attachment.size(), 3);
  1487. ensure_equals(
  1488. "asset data type",
  1489. attachment["asset_data"].type(),
  1490. LLSD::TypeBinary);
  1491. std::vector<U8> actual_binary = attachment["asset_data"].asBinary();
  1492. ensure_equals(
  1493. "binary data size",
  1494. actual_binary.size(),
  1495. expected_binary.size());
  1496. ensure(
  1497. "binary data",
  1498. (0 == memcmp(
  1499. &actual_binary[0],
  1500. &expected_binary[0],
  1501. expected_binary.size())));
  1502. }
  1504. template<> template<>
  1505. void rpc_server_object::test<4>()
  1506. {
  1507. std::string message("parcel '' is naughty.");
  1508. std::stringstream str;
  1509. str << "{'message':'" << LLSDNotationFormatter::escapeString(message)
  1510. << "'}";
  1511. LLSD request;
  1512. S32 count = LLSDSerialize::fromNotation(
  1513. request,
  1514. str,
  1515. str.str().size());
  1516. ensure_equals("parse count", count, 2);
  1517. ensure_equals("request type", request.type(), LLSD::TypeMap);
  1518. pump_loop(request);
  1519. ensure("valid response", mResponse.isDefined());
  1520. ensure_equals("response type", mResponse.type(), LLSD::TypeMap);
  1521. std::string actual = mResponse["message"].asString();
  1522. ensure_equals("message contents", actual, message);
  1523. }
  1525. template<> template<>
  1526. void rpc_server_object::test<5>()
  1527. {
  1528. // test some of the problem cases with llsdrpc over xmlrpc -
  1529. // for example:
  1530. // * arrays are auto-converted to parameter lists, thus, this
  1531. // becomes one parameter.
  1532. // * undef goes over the wire as false (this might not be a good idea)
  1533. // * uuids are converted to string.
  1534. std::string val = "[{'failures':!,'successfuls':[u3c115e51-04f4-523c-9fa6-98aff1034730]}]";
  1535. std::istringstream istr;
  1536. istr.str(val);
  1537. LLSD sd;
  1538. LLSDSerialize::fromNotation(sd, istr, val.size());
  1539. pump_loop(sd);
  1540. ensure("valid response", mResponse.isDefined());
  1541. ensure_equals("parsed type", mResponse.type(), LLSD::TypeMap);
  1542. ensure_equals("parsed size", mResponse.size(), 2);
  1543. LLSD failures = mResponse["failures"];
  1544. ensure_equals("no failures.", failures.asBoolean(), false);
  1545. LLSD success = mResponse["successfuls"];
  1546. ensure_equals("success type", success.type(), LLSD::TypeArray);
  1547. ensure_equals("success size", success.size(), 1);
  1548. ensure_equals(
  1549. "success instance type",
  1550. success[0].type(),
  1551. LLSD::TypeString);
  1552. }
  1554. /*
  1555. template<> template<>
  1556. void rpc_server_object::test<5>()
  1557. {
  1558. std::string expected("xf3");//xffsomething");
  1559. LLSD* request = LLSD::createString(expected);
  1560. pump_loop(request);
  1561. std::string actual;
  1562. mResponse->getString(actual);
  1563. if(actual != expected)
  1564. {
  1565. //llwarns << "iteration " << i << llendl;
  1566. std::ostringstream e_str;
  1567. std::string::iterator iter = expected.begin();
  1568. std::string::iterator end = expected.end();
  1569. for(; iter != end; ++iter)
  1570. {
  1571. e_str << (S32)((U8)(*iter)) << " ";
  1572. }
  1573. e_str << std::endl;
  1574. llsd_serialize_string(e_str, expected);
  1575. llwarns << "expected size: " << expected.size() << llendl;
  1576. llwarns << "expected:   " << e_str.str() << llendl;
  1578. std::ostringstream a_str;
  1579. iter = actual.begin();
  1580. end = actual.end();
  1581. for(; iter != end; ++iter)
  1582. {
  1583. a_str << (S32)((U8)(*iter)) << " ";
  1584. }
  1585. a_str << std::endl;
  1586. llsd_serialize_string(a_str, actual);
  1587. llwarns << "actual size:   " << actual.size() << llendl;
  1588. llwarns << "actual: " << a_str.str() << llendl;
  1589. }
  1590. ensure_equals("binary string request response", actual, expected);
  1591. delete request;
  1592. }
  1594. template<> template<>
  1595. void rpc_server_object::test<5>()
  1596. {
  1597. }
  1598. */
  1599. }
  1602. /*
  1603. 'asset_data':b(12100)"{'task_id':ucc706f2d-0b68-68f8-11a4-f1043ff35ca0}n{ntnametObject|ntpermissions 0nt{nttbase_maskt7fffffffnttowner_maskt7fffffffnttgroup_maskt00000000ntteveryone_maskt00000000nttnext_owner_maskt7fffffffnttcreator_idt13fd9595-a47b-4d64-a5fb-6da645f038e0nttowner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttlast_owner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttgroup_idt00000000-0000-0000-0000-000000000000nt}ntlocal_idt217444921nttotal_crct323nttypet2nttask_validt2nttravel_accesst13ntdisplayoptst2ntdisplaytypetvntpost-0.368634403t0.00781063363t-0.569040775ntoldpost150.117996t25.8658009t8.19664001ntrotationt-0.06293071806430816650390625t-0.6995697021484375t-0.7002241611480712890625t0.1277817934751510620117188ntchildpost-0.00499999989t-0.0359999985t0.307999998ntchildrott-0.515492737293243408203125t-0.46601200103759765625t0.529055416584014892578125t0.4870323240756988525390625ntscalet0.074629t0.289956t0.01ntsit_offsett0t0t0ntcamera_eye_offsett0t0t0ntcamera_at_offsett0t0t0ntsit_quatt0t0t0t1ntsit_hintt0ntstatet160ntmaterialt3ntsoundidt00000000-0000-0000-0000-000000000000ntsoundgaint0ntsoundradiust0ntsoundflagst0nttextcolort0 0 0 1ntselectedt0ntselectort00000000-0000-0000-0000-000000000000ntusephysicst0ntrotate_xt1ntrotate_yt1ntrotate_zt1ntphantomt0ntremote_script_access_pint0ntvolume_detectt0ntblock_grabst0ntdie_at_edget0ntreturn_at_edget0nttemporaryt0ntsandboxt0ntsandboxhomet0t0t0ntshape 0nt{nttpath 0ntt{ntttcurvet16ntttbegint0ntttendt1ntttscale_xt1ntttscale_yt1ntttshear_xt0ntttshear_yt0nttttwistt0nttttwist_begint0ntttradius_offsett0nttttaper_xt0nttttaper_yt0ntttrevolutionst1ntttskewt0ntt}nttprofile 0ntt{ntttcurvet1ntttbegint0ntttendt1nttthollowt0ntt}nt}ntfacest6nt{nttimageidtddde1ffc-678b-3cda-1748-513086bdf01bnttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtddde1ffc-678b-3cda-1748-513086bdf01bnttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett-1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}ntps_next_crct1ntgpw_biast1ntipt0ntcompletetTRUEntdelayt50000ntnextstartt0ntbirthtimet1061088050622956ntreztimet1094866329019785ntparceltimet1133568981980596nttax_ratet1.00084ntscratchpadt0nt{ntnt}ntsale_infot0nt{nttsale_typetnotnttsale_pricet10nt}ntcorrect_family_idt00000000-0000-0000-0000-000000000000nthas_rezzedt0ntpre_link_base_maskt7fffffffntlinked tchildntdefault_pay_pricet-2t1t5t10t20n}n{'task_id':u61fa7364-e151-0597-774c-523312dae31b}n{ntnametObject|ntpermissions 0nt{nttbase_maskt7fffffffnttowner_maskt7fffffffnttgroup_maskt00000000ntteveryone_maskt00000000nttnext_owner_maskt7fffffffnttcreator_idt13fd9595-a47b-4d64-a5fb-6da645f038e0nttowner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttlast_owner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttgroup_idt00000000-0000-0000-0000-000000000000nt}ntlocal_idt217444922nttotal_crct324nttypet2nttask_validt2nttravel_accesst13ntdisplayoptst2ntdisplaytypetvntpost-0.367110789t0.00780026987t-0.566269755ntoldpost150.115005t25.8479004t8.18669987ntrotationt0.47332942485809326171875t-0.380102097988128662109375t-0.5734078884124755859375t0.550168216228485107421875ntchildpost-0.00499999989t-0.0370000005t0.305000007ntchildrott-0.736649334430694580078125t-0.03042060509324073791503906t-0.02784589119255542755126953t0.67501628398895263671875ntscalet0.074629t0.289956t0.01ntsit_offsett0t0t0ntcamera_eye_offsett0t0t0ntcamera_at_offsett0t0t0ntsit_quatt0t0t0t1ntsit_hintt0ntstatet160ntmaterialt3ntsoundidt00000000-0000-0000-0000-000000000000ntsoundgaint0ntsoundradiust0ntsoundflagst0nttextcolort0 0 0 1ntselectedt0ntselectort00000000-0000-0000-0000-000000000000ntusephysicst0ntrotate_xt1ntrotate_yt1ntrotate_zt1ntphantomt0ntremote_script_access_pint0ntvolume_detectt0ntblock_grabst0ntdie_at_edget0ntreturn_at_edget0nttemporaryt0ntsandboxt0ntsandboxhomet0t0t0ntshape 0nt{nttpath 0ntt{ntttcurvet16ntttbegint0ntttendt1ntttscale_xt1ntttscale_yt1ntttshear_xt0ntttshear_yt0nttttwistt0nttttwist_begint0ntttradius_offsett0nttttaper_xt0nttttaper_yt0ntttrevolutionst1ntttskewt0ntt}nttprofile 0ntt{ntttcurvet1ntttbegint0ntttendt1nttthollowt0ntt}nt}ntfacest6nt{nttimageidtddde1ffc-678b-3cda-1748-513086bdf01bnttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtf54a0c32-3cd1-d49a-5b4f-7b792bebc204nttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidtddde1ffc-678b-3cda-1748-513086bdf01bnttcolorst0.937255 0.796078 0.494118 1nttscalest1nttscalett-1nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}ntps_next_crct1ntgpw_biast1ntipt0ntcompletetTRUEntdelayt50000ntnextstartt0ntbirthtimet1061087839248891ntreztimet1094866329020800ntparceltimet1133568981981983nttax_ratet1.00084ntscratchpadt0nt{ntnt}ntsale_infot0nt{nttsale_typetnotnttsale_pricet10nt}ntcorrect_family_idt00000000-0000-0000-0000-000000000000nthas_rezzedt0ntpre_link_base_maskt7fffffffntlinked tchildntdefault_pay_pricet-2t1t5t10t20n}n{'task_id':ub8d68643-7dd8-57af-0d24-8790032aed0c}n{ntnametObject|ntpermissions 0nt{nttbase_maskt7fffffffnttowner_maskt7fffffffnttgroup_maskt00000000ntteveryone_maskt00000000nttnext_owner_maskt7fffffffnttcreator_idt13fd9595-a47b-4d64-a5fb-6da645f038e0nttowner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttlast_owner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttgroup_idt00000000-0000-0000-0000-000000000000nt}ntlocal_idt217444923nttotal_crct235nttypet2nttask_validt2nttravel_accesst13ntdisplayoptst2ntdisplaytypetvntpost-0.120029509t-0.00284469454t-0.0302077383ntoldpost150.710999t25.8584995t8.19172001ntrotationt0.145459949970245361328125t-0.1646589934825897216796875t0.659558117389678955078125t-0.718826770782470703125ntchildpost0t-0.182999998t-0.26699999ntchildrott0.991444766521453857421875t3.271923924330621957778931e-05t-0.0002416197530692443251609802t0.1305266767740249633789062ntscalet0.0382982t0.205957t0.368276ntsit_offsett0t0t0ntcamera_eye_offsett0t0t0ntcamera_at_offsett0t0t0ntsit_quatt0t0t0t1ntsit_hintt0ntstatet160ntmaterialt3ntsoundidt00000000-0000-0000-0000-000000000000ntsoundgaint0ntsoundradiust0ntsoundflagst0nttextcolort0 0 0 1ntselectedt0ntselectort00000000-0000-0000-0000-000000000000ntusephysicst0ntrotate_xt1ntrotate_yt1ntrotate_zt1ntphantomt0ntremote_script_access_pint0ntvolume_detectt0ntblock_grabst0ntdie_at_edget0ntreturn_at_edget0nttemporaryt0ntsandboxt0ntsandboxhomet0t0t0ntshape 0nt{nttpath 0ntt{ntttcurvet32ntttbegint0.3ntttendt0.65ntttscale_xt1ntttscale_yt0.05ntttshear_xt0ntttshear_yt0nttttwistt0nttttwist_begint0ntttradius_offsett0nttttaper_xt0nttttaper_yt0ntttrevolutionst1ntttskewt0ntt}nttprofile 0ntt{ntttcurvet0ntttbegint0ntttendt1nttthollowt0ntt}nt}ntfacest3nt{nttimageidte7150bed-3e3e-c698-eb15-d17b178148afnttcolorst0.843137 0.156863 0.156863 1nttscalest15nttscalett1nttoffsetst0nttoffsettt0nttimagerott-1.57084nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidte7150bed-3e3e-c698-eb15-d17b178148afnttcolorst0.843137 0.156863 0.156863 1nttscalest15nttscalett1nttoffsetst0nttoffsettt0nttimagerott-1.57084nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidte7150bed-3e3e-c698-eb15-d17b178148afnttcolorst0.843137 0.156863 0.156863 1nttscalest15nttscalett1nttoffsetst0nttoffsettt0nttimagerott-1.57084nttbumpt0nttfullbrightt0nttmedia_flagst0nt}ntps_next_crct1ntgpw_biast1ntipt0ntcompletetTRUEntdelayt50000ntnextstartt0ntbirthtimet1061087534454174ntreztimet1094866329021741ntparceltimet1133568981982889nttax_ratet1.00326ntscratchpadt0nt{ntnt}ntsale_infot0nt{nttsale_typetnotnttsale_pricet10nt}ntcorrect_family_idt00000000-0000-0000-0000-000000000000nthas_rezzedt0ntpre_link_base_maskt7fffffffntlinked tchildntdefault_pay_pricet-2t1t5t10t20n}n{'task_id':ue4b19200-9d33-962f-c8c5-6f25be3a3fd0}n{ntnametApotheosis_Immolaine_tail|ntpermissions 0nt{nttbase_maskt7fffffffnttowner_maskt7fffffffnttgroup_maskt00000000ntteveryone_maskt00000000nttnext_owner_maskt7fffffffnttcreator_idt13fd9595-a47b-4d64-a5fb-6da645f038e0nttowner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttlast_owner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttgroup_idt00000000-0000-0000-0000-000000000000nt}ntlocal_idt217444924nttotal_crct675nttypet1nttask_validt2nttravel_accesst13ntdisplayoptst2ntdisplaytypetvntpost-0.34780401t-0.00968400016t-0.260098994ntoldpost0t0t0ntrotationt0.73164522647857666015625t-0.67541944980621337890625t-0.07733880728483200073242188t0.05022468417882919311523438ntvelocityt0t0t0ntangvelt0t0t0ntscalet0.0382982t0.32228t0.383834ntsit_offsett0t0t0ntcamera_eye_offsett0t0t0ntcamera_at_offsett0t0t0ntsit_quatt0t0t0t1ntsit_hintt0ntstatet160ntmaterialt3ntsoundidt00000000-0000-0000-0000-000000000000ntsoundgaint0ntsoundradiust0ntsoundflagst0nttextcolort0 0 0 1ntselectedt0ntselectort00000000-0000-0000-0000-000000000000ntusephysicst0ntrotate_xt1ntrotate_yt1ntrotate_zt1ntphantomt0ntremote_script_access_pint0ntvolume_detectt0ntblock_grabst0ntdie_at_edget0ntreturn_at_edget0nttemporaryt0ntsandboxt0ntsandboxhomet0t0t0ntshape 0nt{nttpath 0ntt{ntttcurvet32ntttbegint0.3ntttendt0.65ntttscale_xt1ntttscale_yt0.05ntttshear_xt0ntttshear_yt0nttttwistt0nttttwist_begint0ntttradius_offsett0nttttaper_xt0nttttaper_yt0ntttrevolutionst1ntttskewt0ntt}nttprofile 0ntt{ntttcurvet0ntttbegint0ntttendt1nttthollowt0ntt}nt}ntfacest3nt{nttimageidte7150bed-3e3e-c698-eb15-d17b178148afnttcolorst0.843137 0.156863 0.156863 1nttscalest15nttscalett1nttoffsetst0nttoffsettt0nttimagerott-1.57084nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidte7150bed-3e3e-c698-eb15-d17b178148afnttcolorst0.843137 0.156863 0.156863 1nttscalest15nttscalett1nttoffsetst0nttoffsettt0nttimagerott-1.57084nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidte7150bed-3e3e-c698-eb15-d17b178148afnttcolorst0.843137 0.156863 0.156863 1nttscalest15nttscalett1nttoffsetst0nttoffsettt0nttimagerott-1.57084nttbumpt0nttfullbrightt0nttmedia_flagst0nt}ntps_next_crct1ntgpw_biast1ntipt0ntcompletetTRUEntdelayt50000ntnextstartt0ntbirthtimet1061087463950186ntreztimet1094866329022555ntparceltimet1133568981984359ntdescriptiont(No Description)|nttax_ratet1.01736ntnamevaluetAttachPt U32 RW S 10ntnamevaluetAttachmentOrientation VEC3 RW DS -3.110088, -0.182018, 1.493795ntnamevaluetAttachmentOffset VEC3 RW DS -0.347804, -0.009684, -0.260099ntnamevaluetAttachItemID STRING RW SV 20f36c3a-b44b-9bc7-87f3-018bfdfc8cdantscratchpadt0nt{ntnt}ntsale_infot0nt{nttsale_typetnotnttsale_pricet10nt}ntorig_asset_idt8747acbc-d391-1e59-69f1-41d06830e6c0ntorig_item_idt20f36c3a-b44b-9bc7-87f3-018bfdfc8cdantfrom_task_idt3c115e51-04f4-523c-9fa6-98aff1034730ntcorrect_family_idt00000000-0000-0000-0000-000000000000nthas_rezzedt0ntpre_link_base_maskt7fffffffntlinked tlinkedntdefault_pay_pricet-2t1t5t10t20n}n"
  1604. */