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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lltut.cpp
  3.  * @author Mark Lentczner
  4.  * @date 5/16/06
  5.  * @brief MacTester
  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.  */
  34. #include "linden_common.h"
  35. #include "lltut.h"
  36. #include "lldate.h"
  37. #include "llformat.h"
  38. #include "llsd.h"
  39. #include "lluri.h"
  40. namespace tut
  41. {
  42. void ensure_equals(const char* msg, const LLDate& actual,
  43. const LLDate& expected)
  44. {
  45. ensure_equals(msg,
  46. actual.secondsSinceEpoch(), expected.secondsSinceEpoch());
  47. }
  48. void ensure_equals(const char* msg, const LLURI& actual,
  49. const LLURI& expected)
  50. {
  51. ensure_equals(msg,
  52. actual.asString(), expected.asString());
  53. }
  54. void ensure_equals(const char* msg,
  55. const std::vector<U8>& actual, const std::vector<U8>& expected)
  56. {
  57. std::string s(msg);
  58. ensure_equals(s + " size", actual.size(), expected.size());
  59. std::vector<U8>::const_iterator i, j;
  60. int k;
  61. for (i = actual.begin(), j = expected.begin(), k = 0;
  62. i != actual.end();
  63. ++i, ++j, ++k)
  64. {
  65. ensure_equals(s + " field", *i, *j);
  66. }
  67. }
  68. void ensure_equals(const char* m, const LLSD& actual,
  69. const LLSD& expected)
  70.     {
  71.         ensure_equals(std::string(m), actual, expected);
  72.     }
  73. void ensure_equals(const std::string& msg, const LLSD& actual,
  74. const LLSD& expected)
  75. {
  76. ensure_equals(msg + " type", actual.type(), expected.type());
  77. switch (actual.type())
  78. {
  79. case LLSD::TypeUndefined:
  80. return;
  81. case LLSD::TypeBoolean:
  82. ensure_equals(msg + " boolean", actual.asBoolean(), expected.asBoolean());
  83. return;
  84. case LLSD::TypeInteger:
  85. ensure_equals(msg + " integer", actual.asInteger(), expected.asInteger());
  86. return;
  87. case LLSD::TypeReal:
  88. ensure_equals(msg + " real", actual.asReal(), expected.asReal());
  89. return;
  90. case LLSD::TypeString:
  91. ensure_equals(msg + " string", actual.asString(), expected.asString());
  92. return;
  93. case LLSD::TypeUUID:
  94. ensure_equals(msg + " uuid", actual.asUUID(), expected.asUUID());
  95. return;
  96. case LLSD::TypeDate:
  97. ensure_equals(msg + " date", actual.asDate(), expected.asDate());
  98. return;
  99. case LLSD::TypeURI:
  100. ensure_equals(msg + " uri", actual.asURI(), expected.asURI());
  101. return;
  102. case LLSD::TypeBinary:
  103. ensure_equals(msg + " binary", actual.asBinary(), expected.asBinary());
  104. return;
  105. case LLSD::TypeMap:
  106. {
  107. ensure_equals(msg + " map size", actual.size(), expected.size());
  108. LLSD::map_const_iterator actual_iter = actual.beginMap();
  109. LLSD::map_const_iterator expected_iter = expected.beginMap();
  110. while(actual_iter != actual.endMap())
  111. {
  112. ensure_equals(msg + " map keys", 
  113. actual_iter->first, expected_iter->first);
  114. ensure_equals(msg + "[" + actual_iter->first + "]",
  115. actual_iter->second, expected_iter->second);
  116. ++actual_iter;
  117. ++expected_iter;
  118. }
  119. return;
  120. }
  121. case LLSD::TypeArray:
  122. {
  123. ensure_equals(msg + " array size", actual.size(), expected.size());
  124. for(int i = 0; i < actual.size(); ++i)
  125. {
  126. ensure_equals(msg + llformat("[%d]", i),
  127. actual[i], expected[i]);
  128. }
  129. return;
  130. }
  131. }
  132. }
  133. void ensure_starts_with(const std::string& msg,
  134. const std::string& actual, const std::string& expectedStart)
  135. {
  136. if( actual.find(expectedStart, 0) != 0 )
  137. {
  138. std::stringstream ss;
  139. ss << msg << ": " << "expected to find " << expectedStart
  140. << " at start of actual " << actual;
  141. throw failure(ss.str().c_str());
  142. }
  143. }
  144. void ensure_ends_with(const std::string& msg,
  145. const std::string& actual, const std::string& expectedEnd)
  146. {
  147. if( actual.size() < expectedEnd.size()
  148. || actual.rfind(expectedEnd)
  149. != (actual.size() - expectedEnd.size()) )
  150. {
  151. std::stringstream ss;
  152. ss << msg << ": " << "expected to find " << expectedEnd
  153. << " at end of actual " << actual;
  154. throw failure(ss.str().c_str());
  155. }
  156. }
  157. void ensure_contains(const std::string& msg,
  158. const std::string& actual, const std::string& expectedSubString)
  159. {
  160. if( actual.find(expectedSubString, 0) == std::string::npos )
  161. {
  162. std::stringstream ss;
  163. ss << msg << ": " << "expected to find " << expectedSubString
  164. << " in actual " << actual;
  165. throw failure(ss.str().c_str());
  166. }
  167. }
  168. void ensure_does_not_contain(const std::string& msg,
  169. const std::string& actual, const std::string& expectedSubString)
  170. {
  171. if( actual.find(expectedSubString, 0) != std::string::npos )
  172. {
  173. std::stringstream ss;
  174. ss << msg << ": " << "expected not to find " << expectedSubString
  175. << " in actual " << actual;
  176. throw failure(ss.str().c_str());
  177. }
  178. }
  179. }