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

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file   lllazy_test.cpp
  3.  * @author Nat Goodspeed
  4.  * @date   2009-01-28
  5.  * @brief  Tests of lllazy.h.
  6.  * 
  7.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2009-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. // Precompiled header
  35. #include "linden_common.h"
  36. // associated header
  37. #include "lllazy.h"
  38. // STL headers
  39. #include <iostream>
  40. // std headers
  41. // external library headers
  42. #include <boost/lambda/construct.hpp>
  43. #include <boost/lambda/bind.hpp>
  44. // other Linden headers
  45. #include "../test/lltut.h"
  46. namespace bll = boost::lambda;
  47. /*****************************************************************************
  48. *   Test classes
  49. *****************************************************************************/
  50. // Let's say that because of its many external dependencies, YuckyFoo is very
  51. // hard to instantiate in a test harness.
  52. class YuckyFoo
  53. {
  54. public:
  55.     virtual ~YuckyFoo() {}
  56.     virtual std::string whoami() const { return "YuckyFoo"; }
  57. };
  58. // Let's further suppose that YuckyBar is another hard-to-instantiate class.
  59. class YuckyBar
  60. {
  61. public:
  62.     YuckyBar(const std::string& which):
  63.         mWhich(which)
  64.     {}
  65.     virtual ~YuckyBar() {}
  66.     virtual std::string identity() const { return std::string("YuckyBar(") + mWhich + ")"; }
  67. private:
  68.     const std::string mWhich;
  69. };
  70. // Pretend that this class would be tough to test because, up until we started
  71. // trying to test it, it contained instances of both YuckyFoo and YuckyBar.
  72. // Now we've refactored so it contains LLLazy<YuckyFoo> and LLLazy<YuckyBar>.
  73. // More than that, it contains them by virtue of deriving from
  74. // LLLazyBase<YuckyFoo> and LLLazyBase<YuckyBar>.
  75. // We postulate two different LLLazyBases because, with only one, you need not
  76. // specify *which* get()/set() method you're talking about. That's a simpler
  77. // case.
  78. class NeedsTesting: public LLLazyBase<YuckyFoo>, public LLLazyBase<YuckyBar>
  79. {
  80. public:
  81.     NeedsTesting():
  82.         // mYuckyBar("RealYuckyBar")
  83.         LLLazyBase<YuckyBar>(bll::bind(bll::new_ptr<YuckyBar>(), "RealYuckyBar"))
  84.     {}
  85.     virtual ~NeedsTesting() {}
  86.     virtual std::string describe() const
  87.     {
  88.         return std::string("NeedsTesting(") + getLazy<YuckyFoo>(this).whoami() + ", " +
  89.             getLazy<YuckyBar>(this).identity() + ")";
  90.     }
  91. private:
  92.     // These instance members were moved to LLLazyBases:
  93.     // YuckyFoo mYuckyFoo;
  94.     // YuckyBar mYuckyBar;
  95. };
  96. // Fake up a test YuckyFoo class
  97. class TestFoo: public YuckyFoo
  98. {
  99. public:
  100.     virtual std::string whoami() const { return "TestFoo"; }
  101. };
  102. // and a test YuckyBar
  103. class TestBar: public YuckyBar
  104. {
  105. public:
  106.     TestBar(const std::string& which): YuckyBar(which) {}
  107.     virtual std::string identity() const
  108.     {
  109.         return std::string("TestBar(") + YuckyBar::identity() + ")";
  110.     }
  111. };
  112. // So here's a test subclass of NeedsTesting that uses TestFoo and TestBar
  113. // instead of YuckyFoo and YuckyBar.
  114. class TestNeedsTesting: public NeedsTesting
  115. {
  116. public:
  117.     TestNeedsTesting()
  118.     {
  119.         // Exercise setLazy(T*)
  120.         setLazy<YuckyFoo>(this, new TestFoo());
  121.         // Exercise setLazy(Factory)
  122.         setLazy<YuckyBar>(this, bll::bind(bll::new_ptr<TestBar>(), "TestYuckyBar"));
  123.     }
  124.     virtual std::string describe() const
  125.     {
  126.         return std::string("TestNeedsTesting(") + NeedsTesting::describe() + ")";
  127.     }
  128.     void toolate()
  129.     {
  130.         setLazy<YuckyFoo>(this, new TestFoo());
  131.     }
  132. };
  133. // This class tests having an explicit LLLazy<T> instance as a named member,
  134. // rather than deriving from LLLazyBase<T>.
  135. class LazyMember
  136. {
  137. public:
  138.     YuckyFoo& getYuckyFoo() { return *mYuckyFoo; }
  139.     std::string whoisit() const { return mYuckyFoo->whoami(); }
  140. protected:
  141.     LLLazy<YuckyFoo> mYuckyFoo;
  142. };
  143. // This is a test subclass of the above, dynamically replacing the
  144. // LLLazy<YuckyFoo> member.
  145. class TestLazyMember: public LazyMember
  146. {
  147. public:
  148.     // use factory setter
  149.     TestLazyMember()
  150.     {
  151.         mYuckyFoo.set(bll::new_ptr<TestFoo>());
  152.     }
  153.     // use instance setter
  154.     TestLazyMember(YuckyFoo* instance)
  155.     {
  156.         mYuckyFoo.set(instance);
  157.     }
  158. };
  159. /*****************************************************************************
  160. *   TUT
  161. *****************************************************************************/
  162. namespace tut
  163. {
  164.     struct lllazy_data
  165.     {
  166.     };
  167.     typedef test_group<lllazy_data> lllazy_group;
  168.     typedef lllazy_group::object lllazy_object;
  169.     lllazy_group lllazygrp("lllazy");
  170.     template<> template<>
  171.     void lllazy_object::test<1>()
  172.     {
  173.         // Instantiate an official one, just because we can
  174.         NeedsTesting nt;
  175.         // and a test one
  176.         TestNeedsTesting tnt;
  177. //      std::cout << nt.describe() << 'n';
  178.         ensure_equals(nt.describe(), "NeedsTesting(YuckyFoo, YuckyBar(RealYuckyBar))");
  179. //      std::cout << tnt.describe() << 'n';
  180.         ensure_equals(tnt.describe(),
  181.                       "TestNeedsTesting(NeedsTesting(TestFoo, TestBar(YuckyBar(TestYuckyBar))))");
  182.     }
  183.     template<> template<>
  184.     void lllazy_object::test<2>()
  185.     {
  186.         TestNeedsTesting tnt;
  187.         std::string threw;
  188.         try
  189.         {
  190.             tnt.toolate();
  191.         }
  192.         catch (const LLLazyCommon::InstanceChange& e)
  193.         {
  194.             threw = e.what();
  195.         }
  196.         ensure_contains("InstanceChange exception", threw, "replace LLLazy instance");
  197.     }
  198.     template<> template<>
  199.     void lllazy_object::test<3>()
  200.     {
  201.         {
  202.             LazyMember lm;
  203.             // operator*() on-demand instantiation
  204.             ensure_equals(lm.getYuckyFoo().whoami(), "YuckyFoo");
  205.         }
  206.         {
  207.             LazyMember lm;
  208.             // operator->() on-demand instantiation
  209.             ensure_equals(lm.whoisit(), "YuckyFoo");
  210.         }
  211.     }
  212.     template<> template<>
  213.     void lllazy_object::test<4>()
  214.     {
  215.         {
  216.             // factory setter
  217.             TestLazyMember tlm;
  218.             ensure_equals(tlm.whoisit(), "TestFoo");
  219.         }
  220.         {
  221.             // instance setter
  222.             TestLazyMember tlm(new TestFoo());
  223.             ensure_equals(tlm.whoisit(), "TestFoo");
  224.         }
  225.     }
  226. } // namespace tut