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

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

游戏引擎

开发平台：

C++ Builder

llmime_test.cpp：源码内容
  1. /** 
  2.  * @file llmime_test.cpp
  3.  * @author Phoenix
  4.  * @date 2006-12-24
  5.  * @brief BRIEF_DESC of llmime_test.cpp
  6.  *
  7.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2006-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"
  37. #include "llsdserialize.h"
  39. #include "../llmime.h"
  41. #include "../test/lltut.h"
  43. namespace tut
  44. {
  45. struct mime_index
  46. {
  47. };
  48. typedef test_group<mime_index> mime_index_t;
  49. typedef mime_index_t::object mime_index_object_t;
  50. tut::mime_index_t tut_mime_index("mime_index");
  52. template<> template<>
  53. void mime_index_object_t::test<1>()
  54. {
  55. LLMimeIndex mime;
  56. ensure("no headers", mime.headers().isUndefined());
  57. ensure_equals("invalid offset", mime.offset(), -1);
  58. ensure_equals("invalid content length", mime.contentLength(), -1);
  59. ensure("no content type", mime.contentType().empty());
  60. ensure("not multipart", !mime.isMultipart());
  61. ensure_equals("no attachments", mime.subPartCount(), 0);
  62. }
  64. template<> template<>
  65. void mime_index_object_t::test<2>()
  66. {
  67. const S32 CONTENT_LENGTH = 6000;
  68. const S32 CONTENT_OFFSET = 100;
  69. const std::string CONTENT_TYPE = std::string("image/j2c");
  70. LLSD headers;
  71. headers["Content-Length"] = CONTENT_LENGTH;
  72. headers["Content-Type"] = CONTENT_TYPE;
  73. LLMimeIndex mime(headers, CONTENT_OFFSET);
  74. ensure("headers are map", mime.headers().isMap());
  75. ensure_equals("offset", mime.offset(), CONTENT_OFFSET);
  76. ensure_equals("content length", mime.contentLength(), CONTENT_LENGTH);
  77. ensure_equals("type is image/j2c", mime.contentType(), CONTENT_TYPE);
  78. ensure("not multipart", !mime.isMultipart());
  79. ensure_equals("no attachments", mime.subPartCount(), 0);
  80. }
  82. template<> template<>
  83. void mime_index_object_t::test<3>()
  84. {
  85. const S32 MULTI_CONTENT_LENGTH = 8000;
  86. const S32 MULTI_CONTENT_OFFSET = 100;
  87. const std::string MULTI_CONTENT_TYPE = std::string("multipart/mixed");
  88. LLSD headers;
  89. headers["Content-Length"] = MULTI_CONTENT_LENGTH;
  90. headers["Content-Type"] = MULTI_CONTENT_TYPE;
  91. LLMimeIndex mime(headers, MULTI_CONTENT_OFFSET);
  92. llinfos << "headers: " << LLSDOStreamer<LLSDNotationFormatter>(headers)
  93. << llendl;
  96. const S32 META_CONTENT_LENGTH = 700;
  97. const S32 META_CONTENT_OFFSET = 69;
  98. const std::string META_CONTENT_TYPE = std::string(
  99. "text/llsd+xml");
  100. headers = LLSD::emptyMap();
  101. headers["Content-Length"] = META_CONTENT_LENGTH;
  102. headers["Content-Type"] = META_CONTENT_TYPE;
  103. LLMimeIndex meta(headers, META_CONTENT_OFFSET);
  104. mime.attachSubPart(meta);
  106. const S32 IMAGE_CONTENT_LENGTH = 6000;
  107. const S32 IMAGE_CONTENT_OFFSET = 200;
  108. const std::string IMAGE_CONTENT_TYPE = std::string("image/j2c");
  109. headers = LLSD::emptyMap();
  110. headers["Content-Length"] = IMAGE_CONTENT_LENGTH;
  111. headers["Content-Type"] = IMAGE_CONTENT_TYPE;
  112. LLMimeIndex image(headers, IMAGE_CONTENT_OFFSET);
  113. mime.attachSubPart(image);
  115. // make sure we have a valid multi-part
  116. ensure("is multipart", mime.isMultipart());
  117. ensure_equals("multi offset", mime.offset(), MULTI_CONTENT_OFFSET);
  118. ensure_equals(
  119. "multi content length",
  120. mime.contentLength(),
  121. MULTI_CONTENT_LENGTH);
  122. ensure_equals("two attachments", mime.subPartCount(), 2);
  124. // make sure ranged gets do the right thing with out of bounds
  125. // sub-parts.
  126. LLMimeIndex invalid_child(mime.subPart(-1));
  127. ensure("no headers", invalid_child.headers().isUndefined());
  128. ensure_equals("invalid offset", invalid_child.offset(), -1);
  129. ensure_equals(
  130. "invalid content length", invalid_child.contentLength(), -1);
  131. ensure("no content type", invalid_child.contentType().empty());
  132. ensure("not multipart", !invalid_child.isMultipart());
  133. ensure_equals("no attachments", invalid_child.subPartCount(), 0);
  135. invalid_child = mime.subPart(2);
  136. ensure("no headers", invalid_child.headers().isUndefined());
  137. ensure_equals("invalid offset", invalid_child.offset(), -1);
  138. ensure_equals(
  139. "invalid content length", invalid_child.contentLength(), -1);
  140. ensure("no content type", invalid_child.contentType().empty());
  141. ensure("not multipart", !invalid_child.isMultipart());
  142. ensure_equals("no attachments", invalid_child.subPartCount(), 0);
  143. }
  145. template<> template<>
  146. void mime_index_object_t::test<4>()
  147. {
  148. const S32 MULTI_CONTENT_LENGTH = 8000;
  149. const S32 MULTI_CONTENT_OFFSET = 100;
  150. const std::string MULTI_CONTENT_TYPE = std::string("multipart/mixed");
  151. LLSD headers;
  152. headers["Content-Length"] = MULTI_CONTENT_LENGTH;
  153. headers["Content-Type"] = MULTI_CONTENT_TYPE;
  154. LLMimeIndex mime(headers, MULTI_CONTENT_OFFSET);
  156. const S32 META_CONTENT_LENGTH = 700;
  157. const S32 META_CONTENT_OFFSET = 69;
  158. const std::string META_CONTENT_TYPE = std::string(
  159. "application/llsd+xml");
  160. headers = LLSD::emptyMap();
  161. headers["Content-Length"] = META_CONTENT_LENGTH;
  162. headers["Content-Type"] = META_CONTENT_TYPE;
  163. LLMimeIndex meta(headers, META_CONTENT_OFFSET);
  164. mime.attachSubPart(meta);
  166. const S32 IMAGE_CONTENT_LENGTH = 6000;
  167. const S32 IMAGE_CONTENT_OFFSET = 200;
  168. const std::string IMAGE_CONTENT_TYPE = std::string("image/j2c");
  169. headers = LLSD::emptyMap();
  170. headers["Content-Length"] = IMAGE_CONTENT_LENGTH;
  171. headers["Content-Type"] = IMAGE_CONTENT_TYPE;
  172. LLMimeIndex image(headers, IMAGE_CONTENT_OFFSET);
  173. mime.attachSubPart(image);
  175. // check what we have
  176. ensure("is multipart", mime.isMultipart());
  177. ensure_equals("multi offset", mime.offset(), MULTI_CONTENT_OFFSET);
  178. ensure_equals(
  179. "multi content length",
  180. mime.contentLength(),
  181. MULTI_CONTENT_LENGTH);
  182. ensure_equals("two attachments", mime.subPartCount(), 2);
  184. LLMimeIndex actual_meta = mime.subPart(0);
  185. ensure_equals(
  186. "meta type", actual_meta.contentType(), META_CONTENT_TYPE);
  187. ensure_equals(
  188. "meta offset", actual_meta.offset(), META_CONTENT_OFFSET);
  189. ensure_equals(
  190. "meta content length",
  191. actual_meta.contentLength(),
  192. META_CONTENT_LENGTH);
  194. LLMimeIndex actual_image = mime.subPart(1);
  195. ensure_equals(
  196. "image type", actual_image.contentType(), IMAGE_CONTENT_TYPE);
  197. ensure_equals(
  198. "image offset", actual_image.offset(), IMAGE_CONTENT_OFFSET);
  199. ensure_equals(
  200. "image content length",
  201. actual_image.contentLength(),
  202. IMAGE_CONTENT_LENGTH);
  203. }
  205. /*
  206. template<> template<>
  207. void mime_index_object_t::test<5>()
  208. {
  209. }
  210. template<> template<>
  211. void mime_index_object_t::test<6>()
  212. {
  213. }
  214. template<> template<>
  215. void mime_index_object_t::test<7>()
  216. {
  217. }
  218. template<> template<>
  219. void mime_index_object_t::test<8>()
  220. {
  221. }
  222. template<> template<>
  223. void mime_index_object_t::test<>()
  224. {
  225. }
  226. */
  227. }
  230. namespace tut
  231. {
  232. struct mime_parse
  233. {
  234. };
  235. typedef test_group<mime_parse> mime_parse_t;
  236. typedef mime_parse_t::object mime_parse_object_t;
  237. tut::mime_parse_t tut_mime_parse("mime_parse");
  239. template<> template<>
  240. void mime_parse_object_t::test<1>()
  241. {
  242. // parse one mime object
  243. const std::string SERIALIZED_MIME("Content-Length: 200rnContent-Type: text/plainrnrnaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccrn");
  244. std::stringstream istr;
  245. istr.str(SERIALIZED_MIME);
  246. LLMimeIndex mime;
  247. LLMimeParser parser;
  248. bool ok = parser.parseIndex(istr, mime);
  249. ensure("Parse successful.", ok);
  250. ensure_equals("content type", mime.contentType(), "text/plain");
  251. ensure_equals("content length", mime.contentLength(), 200);
  252. ensure_equals("offset", mime.offset(), 49);
  253.   }
  255. template<> template<>
  256. void mime_parse_object_t::test<2>()
  257. {
  258. // make sure we only parse one.
  259. const std::string SERIALIZED_MIME("Content-Length: 200rnContent-Type: text/plainrnrnaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccrnrnContent-Length: 200rnContent-Type: text/plainrnrnaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccrnrn");
  260. std::stringstream istr;
  261. istr.str(SERIALIZED_MIME);
  262. LLMimeIndex mime;
  263. LLMimeParser parser;
  264. bool ok = parser.parseIndex(istr, mime);
  265. ensure("Parse successful.", ok);
  266. ensure("not multipart.", !mime.isMultipart());
  267. ensure_equals("content type", mime.contentType(), "text/plain");
  268. ensure_equals("content length", mime.contentLength(), 200);
  269. ensure_equals("offset", mime.offset(), 49);
  270. }
  272. template<> template<>
  273. void mime_parse_object_t::test<3>()
  274. {
  275. // test multi-part and lack of content length for some of it.
  276. /*
  277. Content-Type: multipart/mixed; boundary="segment"rnContent-Length: 148rnrn--segmentrnContent-Type: text/plainrnrnsome datarnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn
  278.  */
  279. const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary="segment"rnContent-Length: 150rnrn--segmentrnContent-Type: text/plainrnrnsome datarnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn");
  280. std::stringstream istr;
  281. istr.str(SERIALIZED_MIME);
  282. LLMimeIndex mime;
  283. LLMimeParser parser;
  284. bool ok = parser.parseIndex(istr, mime);
  285. ensure("Parse successful.", ok);
  286. ensure("is multipart.", mime.isMultipart());
  287. ensure_equals("sub-part count", mime.subPartCount(), 2);
  288. ensure_equals("content length", mime.contentLength(), 150);
  289. ensure_equals("data offset for multipart", mime.offset(), 74);
  291. LLMimeIndex mime_plain(mime.subPart(0));
  292. ensure_equals(
  293. "first part type",
  294. mime_plain.contentType(),
  295. "text/plain");
  296. ensure_equals(
  297. "first part content length not known.",
  298. mime_plain.contentLength(),
  299. -1);
  300. ensure_equals("first part offset", mime_plain.offset(), 113);
  302. LLMimeIndex mime_xml(mime.subPart(1));
  303. ensure_equals(
  304. "second part type",
  305. mime_xml.contentType(),
  306. "text/xml; charset=UTF-8");
  307. ensure_equals(
  308. "second part content length",
  309. mime_xml.contentLength(),
  310. 22);
  311. ensure_equals("second part offset", mime_xml.offset(), 198);
  312. }
  314. template<> template<>
  315. void mime_parse_object_t::test<4>()
  316. {
  317. // test multi-part, unquoted separator, and premature eof conditions
  318. /*
  319. Content-Type: multipart/mixed; boundary=segmentrnContent-Length: 220rnrn--segmentrnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn  */
  320. const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=segmentrnContent-Length: 220rnrn--segmentrnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn");
  321. std::stringstream istr;
  322. istr.str(SERIALIZED_MIME);
  323. LLMimeIndex mime;
  324. LLMimeParser parser;
  325. bool ok = parser.parseIndex(istr, mime);
  326. ensure("Parse successful.", ok);
  327. ensure("is multipart.", mime.isMultipart());
  328. ensure_equals("sub-part count", mime.subPartCount(), 2);
  329. ensure_equals("content length", mime.contentLength(), 220);
  330. ensure_equals("data offset for multipart", mime.offset(), 72);
  332. LLMimeIndex mime_plain(mime.subPart(0));
  333. ensure_equals(
  334. "first part type",
  335. mime_plain.contentType(),
  336. "text/plain");
  337. ensure_equals(
  338. "first part content length",
  339. mime_plain.contentLength(),
  340. 55);
  341. ensure_equals("first part offset", mime_plain.offset(), 131);
  343. LLMimeIndex mime_xml(mime.subPart(1));
  344. ensure_equals(
  345. "second part type",
  346. mime_xml.contentType(),
  347. "text/xml; charset=UTF-8");
  348. ensure_equals(
  349. "second part content length",
  350. mime_xml.contentLength(),
  351. 22);
  352. ensure_equals("second part offset", mime_xml.offset(), 262);
  353. }
  355. template<> template<>
  356. void mime_parse_object_t::test<5>()
  357. {
  358. // test multi-part with multiple params
  359. const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=segment; comment="testing multiple params."rnContent-Length: 220rnrn--segmentrnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn");
  360. std::stringstream istr;
  361. istr.str(SERIALIZED_MIME);
  362. LLMimeIndex mime;
  363. LLMimeParser parser;
  364. bool ok = parser.parseIndex(istr, mime);
  365. ensure("Parse successful.", ok);
  366. ensure("is multipart.", mime.isMultipart());
  367. ensure_equals("sub-part count", mime.subPartCount(), 2);
  368. ensure_equals("content length", mime.contentLength(), 220);
  370. LLMimeIndex mime_plain(mime.subPart(0));
  371. ensure_equals(
  372. "first part type",
  373. mime_plain.contentType(),
  374. "text/plain");
  375. ensure_equals(
  376. "first part content length",
  377. mime_plain.contentLength(),
  378. 55);
  380. LLMimeIndex mime_xml(mime.subPart(1));
  381. ensure_equals(
  382. "second part type",
  383. mime_xml.contentType(),
  384. "text/xml; charset=UTF-8");
  385. ensure_equals(
  386. "second part content length",
  387. mime_xml.contentLength(),
  388. 22);
  389. }
  391. template<> template<>
  392. void mime_parse_object_t::test<6>()
  393. {
  394. // test multi-part with no specified boundary and eof
  395. /*
  396. Content-Type: multipart/relatedrnContent-Length: 220rnrn--rnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--rnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn
  397. */
  398. const std::string SERIALIZED_MIME("Content-Type: multipart/relatedrnContent-Length: 500rnrn--rnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--rnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn");
  399. std::stringstream istr;
  400. istr.str(SERIALIZED_MIME);
  401. LLMimeIndex mime;
  402. LLMimeParser parser;
  403. bool ok = parser.parseIndex(istr, mime);
  404. ensure("Parse successful.", ok);
  405. ensure("is multipart.", mime.isMultipart());
  406. ensure_equals("sub-part count", mime.subPartCount(), 2);
  407. ensure_equals("content length", mime.contentLength(), 500);
  408. ensure_equals("data offset for multipart", mime.offset(), 56);
  410. LLMimeIndex mime_plain(mime.subPart(0));
  411. ensure_equals(
  412. "first part type",
  413. mime_plain.contentType(),
  414. "text/plain");
  415. ensure_equals(
  416. "first part content length",
  417. mime_plain.contentLength(),
  418. 55);
  419. ensure_equals("first part offset", mime_plain.offset(), 108);
  421. LLMimeIndex mime_xml(mime.subPart(1));
  422. ensure_equals(
  423. "second part type",
  424. mime_xml.contentType(),
  425. "text/xml; charset=UTF-8");
  426. ensure_equals(
  427. "second part content length",
  428. mime_xml.contentLength(),
  429. 22);
  430. ensure_equals("second part offset", mime_xml.offset(), 232);
  431. }
  433. /*
  434. template<> template<>
  435. void mime_parse_object_t::test<>()
  436. {
  437. }
  438. template<> template<>
  439. void mime_parse_object_t::test<>()
  440. {
  441. }
  442. template<> template<>
  443. void mime_parse_object_t::test<>()
  444. {
  445. }
  446. template<> template<>
  447. void mime_parse_object_t::test<>()
  448. {
  449. }
  450. */
  451. }