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

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file llsdutil_tut.cpp
  3.  * @author Adroit
  4.  * @date 2007-02
  5.  * @brief LLSD conversion routines test cases.
  6.  *
  7.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2007-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  34. #include "linden_common.h"
  35. #include "lltut.h"
  36. #include "m4math.h"
  37. #include "v2math.h"
  38. #include "v2math.h"
  39. #include "v3color.h"
  40. #include "v3math.h"
  41. #include "v3dmath.h"
  42. #include "v4coloru.h"
  43. #include "v4math.h"
  44. #include "llquaternion.h"
  45. #include "llsdutil.h"
  46. #include "llsdutil_math.h"
  47. #include "stringize.h"
  48. #include <set>
  49. #include <boost/range.hpp>
  50. namespace tut
  51. {
  52. struct llsdutil_data
  53. {
  54.         void test_matches(const std::string& proto_key, const LLSD& possibles,
  55.                           const char** begin, const char** end)
  56.         {
  57.             std::set<std::string> succeed(begin, end);
  58.             LLSD prototype(possibles[proto_key]);
  59.             for (LLSD::map_const_iterator pi(possibles.beginMap()), pend(possibles.endMap());
  60.                  pi != pend; ++pi)
  61.             {
  62.                 std::string match(llsd_matches(prototype, pi->second));
  63.                 std::set<std::string>::const_iterator found = succeed.find(pi->first);
  64.                 if (found != succeed.end())
  65.                 {
  66.                     // This test is supposed to succeed. Comparing to the
  67.                     // empty string ensures that if the test fails, it will
  68.                     // display the string received so we can tell what failed.
  69.                     ensure_equals("match", match, "");
  70.                 }
  71.                 else
  72.                 {
  73.                     // This test is supposed to fail. If we get a false match,
  74.                     // the string 'match' will be empty, which doesn't tell us
  75.                     // much about which case went awry. So construct a more
  76.                     // detailed description string.
  77.                     ensure(proto_key + " shouldn't match " + pi->first, ! match.empty());
  78.                 }
  79.             }
  80.         }
  81. };
  82. typedef test_group<llsdutil_data> llsdutil_test;;
  83. typedef llsdutil_test::object llsdutil_object;
  84. tut::llsdutil_test tutil("llsdutil");
  85. template<> template<>
  86. void llsdutil_object::test<1>()
  87. {
  88. LLSD sd;
  89. U64 valueIn , valueOut;
  90. valueIn = U64L(0xFEDCBA9876543210);
  91. sd = ll_sd_from_U64(valueIn);
  92. valueOut = ll_U64_from_sd(sd);
  93. ensure_equals("U64 valueIn->sd->valueOut", valueIn, valueOut);
  94. }
  95. template<> template<>
  96. void llsdutil_object::test<2>()
  97. {
  98. LLSD sd;
  99. U32 valueIn, valueOut;
  100. valueIn = 0x87654321;
  101. sd = ll_sd_from_U32(valueIn);
  102. valueOut = ll_U32_from_sd(sd);
  103. ensure_equals("U32 valueIn->sd->valueOut", valueIn, valueOut);
  104. }
  105. template<> template<>
  106. void llsdutil_object::test<3>()
  107. {
  108. U32 valueIn, valueOut;
  109. valueIn = 0x87654321;
  110. LLSD sd;
  111. sd = ll_sd_from_ipaddr(valueIn);
  112. valueOut = ll_ipaddr_from_sd(sd);
  113. ensure_equals("valueIn->sd->valueOut", valueIn, valueOut);
  114. }
  115. template<> template<>
  116. void llsdutil_object::test<4>()
  117. {
  118. LLSD sd;
  119. LLVector3 vec1(-1.0, 2.0, -3.0);
  120. sd = ll_sd_from_vector3(vec1); 
  121. LLVector3 vec2 = ll_vector3_from_sd(sd);
  122. ensure_equals("vector3 -> sd -> vector3: 1", vec1, vec2);
  123. LLVector3 vec3(sd);
  124. ensure_equals("vector3 -> sd -> vector3: 2", vec1, vec3);
  125. sd.clear();
  126. vec1.setVec(0., 0., 0.);
  127. sd = ll_sd_from_vector3(vec1); 
  128. vec2 = ll_vector3_from_sd(sd);
  129. ensure_equals("vector3 -> sd -> vector3: 3", vec1, vec2);
  130. sd.clear();
  131. }
  132. template<> template<>
  133. void llsdutil_object::test<5>()
  134. {
  135. LLSD sd;
  136. LLVector3d vec1((F64)(U64L(0xFEDCBA9876543210) << 2), -1., 0);
  137. sd = ll_sd_from_vector3d(vec1); 
  138. LLVector3d vec2 = ll_vector3d_from_sd(sd);
  139. ensure_equals("vector3d -> sd -> vector3d: 1", vec1, vec2);
  140. LLVector3d vec3(sd); 
  141. ensure_equals("vector3d -> sd -> vector3d : 2", vec1, vec3);
  142. }
  143. template<> template<>
  144. void llsdutil_object::test<6>()
  145. {
  146. LLSD sd;
  147. LLVector2 vec((F32) -3., (F32) 4.2);
  148. sd = ll_sd_from_vector2(vec); 
  149. LLVector2 vec1 = ll_vector2_from_sd(sd);
  150. ensure_equals("vector2 -> sd -> vector2", vec, vec1);
  151. LLSD sd2 = ll_sd_from_vector2(vec1); 
  152. ensure_equals("sd -> vector2 -> sd: 2", sd, sd2);
  153. }
  154. template<> template<>
  155. void llsdutil_object::test<7>()
  156. {
  157. LLSD sd;
  158. LLQuaternion quat((F32) 1., (F32) -0.98, (F32) 2.3, (F32) 0xffff);
  159. sd = ll_sd_from_quaternion(quat); 
  160. LLQuaternion quat1 = ll_quaternion_from_sd(sd);
  161. ensure_equals("LLQuaternion -> sd -> LLQuaternion", quat, quat1);
  162. LLSD sd2 = ll_sd_from_quaternion(quat1); 
  163. ensure_equals("sd -> LLQuaternion -> sd ", sd, sd2);
  164. }
  165. template<> template<>
  166. void llsdutil_object::test<8>()
  167. {
  168. LLSD sd;
  169. LLColor4 c(1.0f, 2.2f, 4.0f, 7.f);
  170. sd = ll_sd_from_color4(c); 
  171. LLColor4 c1 =ll_color4_from_sd(sd);
  172. ensure_equals("LLColor4 -> sd -> LLColor4", c, c1);
  173. LLSD sd1 = ll_sd_from_color4(c1);
  174. ensure_equals("sd -> LLColor4 -> sd", sd, sd1);
  175. }
  176.     template<> template<>
  177.     void llsdutil_object::test<9>()
  178.     {
  179.         set_test_name("llsd_matches");
  180.         // for this test, construct a map of all possible LLSD types
  181.         LLSD map;
  182.         map.insert("empty",     LLSD());
  183.         map.insert("Boolean",   LLSD::Boolean());
  184.         map.insert("Integer",   LLSD::Integer(0));
  185.         map.insert("Real",      LLSD::Real(0.0));
  186.         map.insert("String",    LLSD::String("bah"));
  187.         map.insert("NumString", LLSD::String("1"));
  188.         map.insert("UUID",      LLSD::UUID());
  189.         map.insert("Date",      LLSD::Date());
  190.         map.insert("URI",       LLSD::URI());
  191.         map.insert("Binary",    LLSD::Binary());
  192.         map.insert("Map",       LLSD().with("foo", LLSD()));
  193.         // Only an empty array can be constructed on the fly
  194.         LLSD array;
  195.         array.append(LLSD());
  196.         map.insert("Array",     array);
  197.         // These iterators are declared outside our various for loops to avoid
  198.         // fatal MSVC warning: "I used to be broken, but I'm all better now!"
  199.         LLSD::map_const_iterator mi, mend(map.endMap());
  200.         /*-------------------------- llsd_matches --------------------------*/
  201.         // empty prototype matches anything
  202.         for (mi = map.beginMap(); mi != mend; ++mi)
  203.         {
  204.             ensure_equals(std::string("empty matches ") + mi->first, llsd_matches(LLSD(), mi->second), "");
  205.         }
  206.         LLSD proto_array, data_array;
  207.         for (int i = 0; i < 3; ++i)
  208.         {
  209.             proto_array.append(LLSD());
  210.             data_array.append(LLSD());
  211.         }
  212.         // prototype array matches only array
  213.         for (mi = map.beginMap(); mi != mend; ++mi)
  214.         {
  215.             ensure(std::string("array doesn't match ") + mi->first,
  216.                    ! llsd_matches(proto_array, mi->second).empty());
  217.         }
  218.         // data array must be at least as long as prototype array
  219.         proto_array.append(LLSD());
  220.         ensure_equals("data array too short", llsd_matches(proto_array, data_array),
  221.                       "Array size 4 required instead of Array size 3");
  222.         data_array.append(LLSD());
  223.         ensure_equals("data array just right", llsd_matches(proto_array, data_array), "");
  224.         data_array.append(LLSD());
  225.         ensure_equals("data array longer", llsd_matches(proto_array, data_array), "");
  226.         // array element matching
  227.         data_array[0] = LLSD::String();
  228.         ensure_equals("undefined prototype array entry", llsd_matches(proto_array, data_array), "");
  229.         proto_array[0] = LLSD::Binary();
  230.         ensure_equals("scalar prototype array entry", llsd_matches(proto_array, data_array),
  231.                       "[0]: Binary required instead of String");
  232.         data_array[0] = LLSD::Binary();
  233.         ensure_equals("matching prototype array entry", llsd_matches(proto_array, data_array), "");
  234.         // build a coupla maps
  235.         LLSD proto_map, data_map;
  236.         data_map["got"] = LLSD();
  237.         data_map["found"] = LLSD();
  238.         for (LLSD::map_const_iterator dmi(data_map.beginMap()), dmend(data_map.endMap());
  239.              dmi != dmend; ++dmi)
  240.         {
  241.             proto_map[dmi->first] = dmi->second;
  242.         }
  243.         proto_map["foo"] = LLSD();
  244.         proto_map["bar"] = LLSD();
  245.         // prototype map matches only map
  246.         for (mi = map.beginMap(); mi != mend; ++mi)
  247.         {
  248.             ensure(std::string("map doesn't match ") + mi->first,
  249.                    ! llsd_matches(proto_map, mi->second).empty());
  250.         }
  251.         // data map must contain all keys in prototype map
  252.         std::string error(llsd_matches(proto_map, data_map));
  253.         ensure_contains("missing keys", error, "missing keys");
  254.         ensure_contains("missing foo", error, "foo");
  255.         ensure_contains("missing bar", error, "bar");
  256.         ensure_does_not_contain("found found", error, "found");
  257.         ensure_does_not_contain("got got", error, "got");
  258.         data_map["bar"] = LLSD();
  259.         error = llsd_matches(proto_map, data_map);
  260.         ensure_contains("missing foo", error, "foo");
  261.         ensure_does_not_contain("got bar", error, "bar");
  262.         data_map["foo"] = LLSD();
  263.         ensure_equals("data map just right", llsd_matches(proto_map, data_map), "");
  264.         data_map["extra"] = LLSD();
  265.         ensure_equals("data map with extra", llsd_matches(proto_map, data_map), "");
  266.         // map element matching
  267.         data_map["foo"] = LLSD::String();
  268.         ensure_equals("undefined prototype map entry", llsd_matches(proto_map, data_map), "");
  269.         proto_map["foo"] = LLSD::Binary();
  270.         ensure_equals("scalar prototype map entry", llsd_matches(proto_map, data_map),
  271.                       "['foo']: Binary required instead of String");
  272.         data_map["foo"] = LLSD::Binary();
  273.         ensure_equals("matching prototype map entry", llsd_matches(proto_map, data_map), "");
  274.         // String
  275.         {
  276.             static const char* matches[] = { "String", "NumString", "Boolean", "Integer",
  277.                                              "Real", "UUID", "Date", "URI" };
  278.             test_matches("String", map, boost::begin(matches), boost::end(matches));
  279.         }
  280.         // Boolean, Integer, Real
  281.         static const char* numerics[] = { "Boolean", "Integer", "Real" };
  282.         for (const char **ni = boost::begin(numerics), **nend = boost::end(numerics);
  283.              ni != nend; ++ni)
  284.         {
  285.             static const char* matches[] = { "Boolean", "Integer", "Real", "String", "NumString" };
  286.             test_matches(*ni, map, boost::begin(matches), boost::end(matches));
  287.         }
  288.         // UUID
  289.         {
  290.             static const char* matches[] = { "UUID", "String", "NumString" };
  291.             test_matches("UUID", map, boost::begin(matches), boost::end(matches));
  292.         }
  293.         // Date
  294.         {
  295.             static const char* matches[] = { "Date", "String", "NumString" };
  296.             test_matches("Date", map, boost::begin(matches), boost::end(matches));
  297.         }
  298.         // URI
  299.         {
  300.             static const char* matches[] = { "URI", "String", "NumString" };
  301.             test_matches("URI", map, boost::begin(matches), boost::end(matches));
  302.         }
  303.         // Binary
  304.         {
  305.             static const char* matches[] = { "Binary" };
  306.             test_matches("Binary", map, boost::begin(matches), boost::end(matches));
  307.         }
  308.         /*-------------------------- llsd_equals ---------------------------*/
  309.         // Cross-product of each LLSD type with every other
  310.         for (LLSD::map_const_iterator lmi(map.beginMap()), lmend(map.endMap());
  311.              lmi != lmend; ++lmi)
  312.         {
  313.             for (LLSD::map_const_iterator rmi(map.beginMap()), rmend(map.endMap());
  314.                  rmi != rmend; ++rmi)
  315.             {
  316.                 // Name this test based on the map keys naming the types of
  317.                 // interest, e.g "String::Integer".
  318.                 // We expect the values (xmi->second) to be equal if and only
  319.                 // if the type names (xmi->first) are equal.
  320.                 ensure(STRINGIZE(lmi->first << "::" << rmi->first),
  321.                        bool(lmi->first == rmi->first) ==
  322.                        bool(llsd_equals(lmi->second, rmi->second)));
  323.             }
  324.         }
  325.         // Array cases
  326.         LLSD rarray;
  327.         rarray.append(1.0);
  328.         rarray.append(2);
  329.         rarray.append("3");
  330.         LLSD larray(rarray);
  331.         ensure("llsd_equals(equal arrays)", llsd_equals(larray, rarray));
  332.         rarray[2] = "4";
  333.         ensure("llsd_equals(different [2])", ! llsd_equals(larray, rarray));
  334.         rarray = larray;
  335.         rarray.append(LLSD::Date());
  336.         ensure("llsd_equals(longer right array)", ! llsd_equals(larray, rarray));
  337.         rarray = larray;
  338.         rarray.erase(2);
  339.         ensure("llsd_equals(shorter right array)", ! llsd_equals(larray, rarray));
  340.         // Map cases
  341.         LLSD rmap;
  342.         rmap["San Francisco"] = 65;
  343.         rmap["Phoenix"] = 92;
  344.         rmap["Boston"] = 77;
  345.         LLSD lmap(rmap);
  346.         ensure("llsd_equals(equal maps)", llsd_equals(lmap, rmap));
  347.         rmap["Boston"] = 80;
  348.         ensure("llsd_equals(different ["Boston"])", ! llsd_equals(lmap, rmap));
  349.         rmap = lmap;
  350.         rmap["Atlanta"] = 95;
  351.         ensure("llsd_equals(superset right map)", ! llsd_equals(lmap, rmap));
  352.         rmap = lmap;
  353.         lmap["Seattle"] = 72;
  354.         ensure("llsd_equals(superset left map)", ! llsd_equals(lmap, rmap));
  355.     }
  356. }