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

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

游戏引擎

开发平台：

C++ Builder

llerror_test.cpp：源码内容
  1. /** 
  2.  * @file llerror_test.cpp
  3.  * @date   December 2006
  4.  * @brief error unit tests
  5.  *
  6.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2006-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #include <vector>
  36. #include "linden_common.h"
  38. #include "../llerror.h"
  40. #include "../llerrorcontrol.h"
  41. #include "../llsd.h"
  43. #include "../test/lltut.h"
  45. namespace
  46. {
  47. void test_that_error_h_includes_enough_things_to_compile_a_message()
  48. {
  49. llinfos << "!" << llendl;
  50. }
  51. }
  53. namespace
  54. {
  55. static bool fatalWasCalled;
  56. void fatalCall(const std::string&) { fatalWasCalled = true; }
  58. class TestRecorder : public LLError::Recorder
  59. {
  60. public:
  61. TestRecorder() : mWantsTime(false) { }
  62. ~TestRecorder() { LLError::removeRecorder(this); }
  64. void recordMessage(LLError::ELevel level,
  65. const std::string& message)
  66. {
  67. mMessages.push_back(message);
  68. }
  70. int countMessages() { return (int) mMessages.size(); }
  71. void clearMessages() { mMessages.clear(); }
  73. void setWantsTime(bool t) { mWantsTime = t; }
  74. bool wantsTime() { return mWantsTime; }
  76. std::string message(int n)
  77. {
  78. std::ostringstream test_name;
  79. test_name << "testing message " << n << ", not enough messages";
  81. tut::ensure(test_name.str(), n < countMessages());
  82. return mMessages[n];
  83. }
  85. private:
  86. typedef std::vector<std::string> MessageVector;
  87. MessageVector mMessages;
  89. bool mWantsTime;
  90. };
  91. }
  93. namespace tut
  94. {
  95. struct ErrorTestData
  96. {
  97. TestRecorder mRecorder;
  98. LLError::Settings* mPriorErrorSettings;
  100. ErrorTestData()
  101. {
  102. fatalWasCalled = false;
  104. mPriorErrorSettings = LLError::saveAndResetSettings();
  105. LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
  106. LLError::setFatalFunction(fatalCall);
  107. LLError::addRecorder(&mRecorder);
  108. }
  110. ~ErrorTestData()
  111. {
  112. LLError::removeRecorder(&mRecorder);
  113. LLError::restoreSettings(mPriorErrorSettings);
  114. }
  116. void ensure_message_count(int expectedCount)
  117. {
  118. ensure_equals("message count", mRecorder.countMessages(), expectedCount);
  119. }
  121. void ensure_message_contains(int n, const std::string& expectedText)
  122. {
  123. std::ostringstream test_name;
  124. test_name << "testing message " << n;
  126. ensure_contains(test_name.str(), mRecorder.message(n), expectedText);
  127. }
  129. void ensure_message_does_not_contain(int n, const std::string& expectedText)
  130. {
  131. std::ostringstream test_name;
  132. test_name << "testing message " << n;
  134. ensure_does_not_contain(test_name.str(), mRecorder.message(n), expectedText);
  135. }
  136. };
  138. typedef test_group<ErrorTestData> ErrorTestGroup;
  139. typedef ErrorTestGroup::object ErrorTestObject;
  141. ErrorTestGroup errorTestGroup("error");
  143. template<> template<>
  144. void ErrorTestObject::test<1>()
  145. // basic test of output
  146. {
  147. llinfos << "test" << llendl;
  148. llinfos << "bob" << llendl;
  150. ensure_message_contains(0, "test");
  151. ensure_message_contains(1, "bob");
  152. }
  153. }
  155. namespace
  156. {
  157. void writeSome()
  158. {
  159. lldebugs << "one" << llendl;
  160. llinfos << "two" << llendl;
  161. llwarns << "three" << llendl;
  162. llerrs << "four" << llendl;
  163. // fatal messages write out and addtional "error" message
  164. }
  165. };
  167. namespace tut
  168. {
  169. template<> template<>
  170. void ErrorTestObject::test<2>()
  171. // messages are filtered based on default level
  172. {
  173. LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
  174. writeSome();
  175. ensure_message_contains(0, "one");
  176. ensure_message_contains(1, "two");
  177. ensure_message_contains(2, "three");
  178. ensure_message_contains(3, "error");
  179. ensure_message_contains(4, "four");
  180. ensure_message_count(5);
  182. LLError::setDefaultLevel(LLError::LEVEL_INFO);
  183. writeSome();
  184. ensure_message_contains(5, "two");
  185. ensure_message_contains(6, "three");
  186. ensure_message_contains(7, "error");
  187. ensure_message_contains(8, "four");
  188. ensure_message_count(9);
  190. LLError::setDefaultLevel(LLError::LEVEL_WARN);
  191. writeSome();
  192. ensure_message_contains(9, "three");
  193. ensure_message_contains(10, "error");
  194. ensure_message_contains(11, "four");
  195. ensure_message_count(12);
  197. LLError::setDefaultLevel(LLError::LEVEL_ERROR);
  198. writeSome();
  199. ensure_message_contains(12, "error");
  200. ensure_message_contains(13, "four");
  201. ensure_message_count(14);
  203. LLError::setDefaultLevel(LLError::LEVEL_NONE);
  204. writeSome();
  205. ensure_message_count(14);
  206. }
  208. template<> template<>
  209. void ErrorTestObject::test<3>()
  210. // error type string in output
  211. {
  212. writeSome();
  213. ensure_message_contains(0, "DEBUG: ");
  214. ensure_message_contains(1, "INFO: ");
  215. ensure_message_contains(2, "WARNING: ");
  216. ensure_message_does_not_contain(3, "ERROR");
  217. ensure_message_contains(4, "ERROR: ");
  218. ensure_message_count(5);
  219. }
  221. template<> template<>
  222. void ErrorTestObject::test<4>()
  223. // file abbreviation
  224. {
  225. std::string thisFile = __FILE__;
  226. std::string abbreviateFile = LLError::abbreviateFile(thisFile);
  228. ensure_ends_with("file name abbreviation",
  229. abbreviateFile,
  230. "llcommon/tests/llerror_test.cpp"
  231. );
  232. ensure_does_not_contain("file name abbreviation",
  233. abbreviateFile, "indra");
  235. std::string someFile =
  236. #if LL_WINDOWS
  237. "C:/amy/bob/cam.cpp"
  238. #else
  239. "/amy/bob/cam.cpp"
  240. #endif
  241. ;
  242. std::string someAbbreviation = LLError::abbreviateFile(someFile);
  244. ensure_equals("non-indra file abbreviation",
  245. someAbbreviation, someFile);
  246. }
  247. }
  249. namespace
  250. {
  251. std::string locationString(int line)
  252. {
  253. std::ostringstream location;
  254. location << LLError::abbreviateFile(__FILE__)
  255.  << "(" << line << ") : ";
  256.  
  257. return location.str();
  258. }
  260. std::string writeReturningLocation()
  261. {
  262. llinfos << "apple" << llendl; int this_line = __LINE__;
  263. return locationString(this_line);
  264. }
  266. std::string writeReturningLocationAndFunction()
  267. {
  268. llinfos << "apple" << llendl; int this_line = __LINE__;
  269. return locationString(this_line) + __FUNCTION__;
  270. }
  272. std::string errorReturningLocation()
  273. {
  274. llerrs << "die" << llendl; int this_line = __LINE__;
  275. return locationString(this_line);
  276. }
  277. }
  279. namespace tut
  280. {
  281. template<> template<>
  282. void ErrorTestObject::test<5>()
  283. // file and line information in log messages
  284. {
  285. std::string location = writeReturningLocation();
  286. // expecting default to not print location information
  288. LLError::setPrintLocation(true);
  289. writeReturningLocation();
  291. LLError::setPrintLocation(false);
  292. writeReturningLocation();
  294. ensure_message_does_not_contain(0, location);
  295. ensure_message_contains(1, location);
  296. ensure_message_does_not_contain(2, location);
  297. }
  298. }
  300. /* The following helper functions and class members all log a simple message
  301. from some particular function scope.  Each function takes a bool argument
  302. that indicates if it should log its own name or not (in the manner that
  303. existing log messages often do.)  The functions all return their C++
  304. name so that test can be substantial mechanized.
  305.  */
  306.  
  307. std::string logFromGlobal(bool id)
  308. {
  309. llinfos << (id ? "logFromGlobal: " : "") << "hi" << llendl;
  310. return "logFromGlobal";
  311. }
  313. static std::string logFromStatic(bool id)
  314. {
  315. llinfos << (id ? "logFromStatic: " : "") << "hi" << llendl;
  316. return "logFromStatic";
  317. }
  319. namespace
  320. {
  321. std::string logFromAnon(bool id)
  322. {
  323. llinfos << (id ? "logFromAnon: " : "") << "hi" << llendl;
  324. return "logFromAnon";
  325. }
  326. }
  328. namespace Foo {
  329. std::string logFromNamespace(bool id)
  330. {
  331. llinfos << (id ? "Foo::logFromNamespace: " : "") << "hi" << llendl;
  332. //return "Foo::logFromNamespace";
  333. // there is no standard way to get the namespace name, hence
  334. // we won't be testing for it
  335. return "logFromNamespace";
  336. }
  337. }
  339. namespace
  340. {
  341. class ClassWithNoLogType {
  342. public:
  343. std::string logFromMember(bool id)
  344. {
  345. llinfos << (id ? "ClassWithNoLogType::logFromMember: " : "") << "hi" << llendl;
  346. return "ClassWithNoLogType::logFromMember";
  347. }
  348. static std::string logFromStatic(bool id)
  349. {
  350. llinfos << (id ? "ClassWithNoLogType::logFromStatic: " : "") << "hi" << llendl;
  351. return "ClassWithNoLogType::logFromStatic";
  352. }
  353. };
  355. class ClassWithLogType {
  356. LOG_CLASS(ClassWithLogType);
  357. public:
  358. std::string logFromMember(bool id)
  359. {
  360. llinfos << (id ? "ClassWithLogType::logFromMember: " : "") << "hi" << llendl;
  361. return "ClassWithLogType::logFromMember";
  362. }
  363. static std::string logFromStatic(bool id)
  364. {
  365. llinfos << (id ? "ClassWithLogType::logFromStatic: " : "") << "hi" << llendl;
  366. return "ClassWithLogType::logFromStatic";
  367. }
  368. };
  370. std::string logFromNamespace(bool id) { return Foo::logFromNamespace(id); }
  371. std::string logFromClassWithNoLogTypeMember(bool id) { ClassWithNoLogType c; return c.logFromMember(id); }
  372. std::string logFromClassWithNoLogTypeStatic(bool id) { return ClassWithNoLogType::logFromStatic(id); }
  373. std::string logFromClassWithLogTypeMember(bool id) { ClassWithLogType c; return c.logFromMember(id); }
  374. std::string logFromClassWithLogTypeStatic(bool id) { return ClassWithLogType::logFromStatic(id); }
  376. void ensure_has(const std::string& message,
  377. const std::string& actual, const std::string& expected)
  378. {
  379. std::string::size_type n1 = actual.find(expected);
  380. if (n1 == std::string::npos)
  381. {
  382. std::stringstream ss;
  383. ss << message << ": " << "expected to find a copy of " << expected
  384. << " in actual " << actual;
  385. throw tut::failure(ss.str().c_str());
  386. }
  387. }
  389. typedef std::string (*LogFromFunction)(bool);
  390. void testLogName(TestRecorder& recorder, LogFromFunction f,
  391. const std::string& class_name = "")
  392. {
  393. recorder.clearMessages();
  394. std::string name = f(false);
  395. f(true);
  397. std::string messageWithoutName = recorder.message(0);
  398. std::string messageWithName = recorder.message(1);
  400. ensure_has(name + " logged without name",
  401. messageWithoutName, name);
  402. ensure_has(name + " logged with name",
  403. messageWithName, name);
  405. if (!class_name.empty())
  406. {
  407. ensure_has(name + "logged without name",
  408. messageWithoutName, class_name);
  409. ensure_has(name + "logged with name",
  410. messageWithName, class_name);
  411. }
  412. }
  413. }
  415. namespace tut
  416. {
  417. template<> template<>
  418. //  class/function information in output
  419. void ErrorTestObject::test<6>()
  420. {
  421. testLogName(mRecorder, logFromGlobal);
  422. testLogName(mRecorder, logFromStatic);
  423. testLogName(mRecorder, logFromAnon);
  424. testLogName(mRecorder, logFromNamespace);
  425. //testLogName(mRecorder, logFromClassWithNoLogTypeMember, "ClassWithNoLogType");
  426. //testLogName(mRecorder, logFromClassWithNoLogTypeStatic, "ClassWithNoLogType");
  427. // XXX: figure out what the exepcted response is for these
  428. testLogName(mRecorder, logFromClassWithLogTypeMember, "ClassWithLogType");
  429. testLogName(mRecorder, logFromClassWithLogTypeStatic, "ClassWithLogType");
  430. }
  431. }
  433. namespace
  434. {
  435. std::string innerLogger()
  436. {
  437. llinfos << "inside" << llendl;
  438. return "moo";
  439. }
  441. std::string outerLogger()
  442. {
  443. llinfos << "outside(" << innerLogger() << ")" << llendl;
  444. return "bar";
  445. }
  447. void uberLogger()
  448. {
  449. llinfos << "uber(" << outerLogger() << "," << innerLogger() << ")" << llendl;
  450. }
  452. class LogWhileLogging
  453. {
  454. public:
  455. void print(std::ostream& out) const
  456. {
  457. llinfos << "logging" << llendl;
  458. out << "baz";
  459. }
  460. };
  462. std::ostream& operator<<(std::ostream& out, const LogWhileLogging& l)
  463. { l.print(out); return out; }
  465. void metaLogger()
  466. {
  467. LogWhileLogging l;
  468. llinfos << "meta(" << l << ")" << llendl;
  469. }
  471. }
  473. namespace tut
  474. {
  475. template<> template<>
  476. // handle nested logging
  477. void ErrorTestObject::test<7>()
  478. {
  479. outerLogger();
  480. ensure_message_contains(0, "inside");
  481. ensure_message_contains(1, "outside(moo)");
  482. ensure_message_count(2);
  484. uberLogger();
  485. ensure_message_contains(2, "inside");
  486. ensure_message_contains(3, "inside");
  487. ensure_message_contains(4, "outside(moo)");
  488. ensure_message_contains(5, "uber(bar,moo)");
  489. ensure_message_count(6);
  491. metaLogger();
  492. ensure_message_contains(6, "logging");
  493. ensure_message_contains(7, "meta(baz)");
  494. ensure_message_count(8);
  495. }
  497. template<> template<>
  498. // special handling of llerrs calls
  499. void ErrorTestObject::test<8>()
  500. {
  501. LLError::setPrintLocation(false);
  502. std::string location = errorReturningLocation();
  504. ensure_message_contains(0, location + "error");
  505. ensure_message_contains(1, "die");
  506. ensure_message_count(2);
  508. ensure("fatal callback called", fatalWasCalled);
  509. }
  510. }
  512. namespace
  513. {
  514. std::string roswell()
  515. {
  516. return "1947-07-08T03:04:05Z";
  517. }
  519. void ufoSighting()
  520. {
  521. llinfos << "ufo" << llendl;
  522. }
  523. }
  525. namespace tut
  526. {
  527. template<> template<>
  528. // time in output (for recorders that need it)
  529. void ErrorTestObject::test<9>()
  530. {
  531. LLError::setTimeFunction(roswell);
  533. mRecorder.setWantsTime(false);
  534. ufoSighting();
  535. ensure_message_contains(0, "ufo");
  536. ensure_message_does_not_contain(0, roswell());
  538. mRecorder.setWantsTime(true);
  539. ufoSighting();
  540. ensure_message_contains(1, "ufo");
  541. ensure_message_contains(1, roswell());
  542. }
  544. template<> template<>
  545. // output order
  546. void ErrorTestObject::test<10>()
  547. {
  548. #if LL_LINUX
  549.         skip("Fails on Linux, see comments");
  550. // on Linux:
  551. // [error, 10] fail: 'order is time type location function message: expected
  552. // '1947-07-08T03:04:05Z INFO: llcommon/tests/llerror_test.cpp(268) :
  553. // writeReturningLocationAndFunction: apple' actual
  554. // '1947-07-08T03:04:05Z INFO: llcommon/tests/llerror_test.cpp(268) :
  555. // LLError::NoClassInfo::writeReturningLocationAndFunction: apple''
  556. #endif
  557. LLError::setPrintLocation(true);
  558. LLError::setTimeFunction(roswell);
  559. mRecorder.setWantsTime(true);
  560. std::string locationAndFunction = writeReturningLocationAndFunction();
  562. ensure_equals("order is time type location function message",
  563. mRecorder.message(0),
  564. roswell() + " INFO: " + locationAndFunction + ": apple");
  565. }
  567. template<> template<>
  568. // multiple recorders
  569. void ErrorTestObject::test<11>()
  570. {
  571. TestRecorder altRecorder;
  572. LLError::addRecorder(&altRecorder);
  574. llinfos << "boo" << llendl;
  576. ensure_message_contains(0, "boo");
  577. ensure_equals("alt recorder count", altRecorder.countMessages(), 1);
  578. ensure_contains("alt recorder message 0", altRecorder.message(0), "boo");
  580. LLError::setTimeFunction(roswell);
  582. TestRecorder anotherRecorder;
  583. anotherRecorder.setWantsTime(true);
  584. LLError::addRecorder(&anotherRecorder);
  586. llinfos << "baz" << llendl;
  588. std::string when = roswell();
  590. ensure_message_does_not_contain(1, when);
  591. ensure_equals("alt recorder count", altRecorder.countMessages(), 2);
  592. ensure_does_not_contain("alt recorder message 1", altRecorder.message(1), when);
  593. ensure_equals("another recorder count", anotherRecorder.countMessages(), 1);
  594. ensure_contains("another recorder message 0", anotherRecorder.message(0), when);
  595. }
  596. }
  598. class TestAlpha
  599. {
  600. LOG_CLASS(TestAlpha);
  601. public:
  602. static void doDebug() { lldebugs << "add dice" << llendl; }
  603. static void doInfo() { llinfos  << "any idea" << llendl; }
  604. static void doWarn() { llwarns  << "aim west" << llendl; }
  605. static void doError() { llerrs   << "ate eels" << llendl; }
  606. static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
  607. };
  609. class TestBeta
  610. {
  611. LOG_CLASS(TestBeta);
  612. public:
  613. static void doDebug() { lldebugs << "bed down" << llendl; }
  614. static void doInfo() { llinfos  << "buy iron" << llendl; }
  615. static void doWarn() { llwarns  << "bad word" << llendl; }
  616. static void doError() { llerrs   << "big easy" << llendl; }
  617. static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
  618. };
  620. namespace tut
  621. {
  622. template<> template<>
  623. // filtering by class
  624. void ErrorTestObject::test<12>()
  625. {
  626. LLError::setDefaultLevel(LLError::LEVEL_WARN);
  627. LLError::setClassLevel("TestBeta", LLError::LEVEL_INFO);
  629. TestAlpha::doAll();
  630. TestBeta::doAll();
  632. ensure_message_contains(0, "aim west");
  633. ensure_message_contains(1, "error");
  634. ensure_message_contains(2, "ate eels");
  635. ensure_message_contains(3, "buy iron");
  636. ensure_message_contains(4, "bad word");
  637. ensure_message_contains(5, "error");
  638. ensure_message_contains(6, "big easy");
  639. ensure_message_count(7);
  640. }
  642. template<> template<>
  643. // filtering by function, and that it will override class filtering
  644. void ErrorTestObject::test<13>()
  645. {
  646. LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
  647. LLError::setClassLevel("TestBeta", LLError::LEVEL_WARN);
  648. LLError::setFunctionLevel("TestBeta::doInfo", LLError::LEVEL_DEBUG);
  649. LLError::setFunctionLevel("TestBeta::doError", LLError::LEVEL_NONE);
  651. TestBeta::doAll();
  652. ensure_message_contains(0, "buy iron");
  653. ensure_message_contains(1, "bad word");
  654. ensure_message_count(2);
  655. }
  657. template<> template<>
  658. // filtering by file
  659. // and that it is overridden by both class and function filtering
  660. void ErrorTestObject::test<14>()
  661. {
  662. LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
  663. LLError::setFileLevel(LLError::abbreviateFile(__FILE__),
  664. LLError::LEVEL_WARN);
  665. LLError::setClassLevel("TestAlpha", LLError::LEVEL_INFO);
  666. LLError::setFunctionLevel("TestAlpha::doError",
  667. LLError::LEVEL_NONE);
  668. LLError::setFunctionLevel("TestBeta::doError",
  669. LLError::LEVEL_NONE);
  671. TestAlpha::doAll();
  672. TestBeta::doAll();
  673. ensure_message_contains(0, "any idea");
  674. ensure_message_contains(1, "aim west");
  675. ensure_message_contains(2, "bad word");
  676. ensure_message_count(3);
  677. }
  679. template<> template<>
  680. // proper cached, efficient lookup of filtering
  681. void ErrorTestObject::test<15>()
  682. {
  683. LLError::setDefaultLevel(LLError::LEVEL_NONE);
  685. TestAlpha::doInfo();
  686. ensure_message_count(0);
  687. ensure_equals("first check", LLError::shouldLogCallCount(), 1);
  688. TestAlpha::doInfo();
  689. ensure_message_count(0);
  690. ensure_equals("second check", LLError::shouldLogCallCount(), 1);
  692. LLError::setClassLevel("TestAlpha", LLError::LEVEL_DEBUG);
  693. TestAlpha::doInfo();
  694. ensure_message_count(1);
  695. ensure_equals("third check", LLError::shouldLogCallCount(), 2);
  696. TestAlpha::doInfo();
  697. ensure_message_count(2);
  698. ensure_equals("fourth check", LLError::shouldLogCallCount(), 2);
  700. LLError::setClassLevel("TestAlpha", LLError::LEVEL_WARN);
  701. TestAlpha::doInfo();
  702. ensure_message_count(2);
  703. ensure_equals("fifth check", LLError::shouldLogCallCount(), 3);
  704. TestAlpha::doInfo();
  705. ensure_message_count(2);
  706. ensure_equals("sixth check", LLError::shouldLogCallCount(), 3);
  707. }
  709. template<> template<>
  710. // configuration from LLSD
  711. void ErrorTestObject::test<16>()
  712. {
  713. std::string this_file = LLError::abbreviateFile(__FILE__);
  714. LLSD config;
  715. config["print-location"] = true;
  716. config["default-level"] = "DEBUG";
  718. LLSD set1;
  719. set1["level"] = "WARN";
  720. set1["files"][0] = this_file;
  722. LLSD set2;
  723. set2["level"] = "INFO";
  724. set2["classes"][0] = "TestAlpha";
  726. LLSD set3;
  727. set3["level"] = "NONE";
  728. set3["functions"][0] = "TestAlpha::doError";
  729. set3["functions"][1] = "TestBeta::doError";
  731. config["settings"][0] = set1;
  732. config["settings"][1] = set2;
  733. config["settings"][2] = set3;
  735. LLError::configure(config);
  737. TestAlpha::doAll();
  738. TestBeta::doAll();
  739. ensure_message_contains(0, "any idea");
  740. ensure_message_contains(0, this_file);
  741. ensure_message_contains(1, "aim west");
  742. ensure_message_contains(2, "bad word");
  743. ensure_message_count(3);
  745. // make sure reconfiguring works
  746. LLSD config2;
  747. config2["default-level"] = "WARN";
  749. LLError::configure(config2);
  751. TestAlpha::doAll();
  752. TestBeta::doAll();
  753. ensure_message_contains(3, "aim west");
  754. ensure_message_does_not_contain(3, this_file);
  755. ensure_message_contains(4, "error");
  756. ensure_message_contains(5, "ate eels");
  757. ensure_message_contains(6, "bad word");
  758. ensure_message_contains(7, "error");
  759. ensure_message_contains(8, "big easy");
  760. ensure_message_count(9);
  761. }
  762. }
  764. /* Tests left:
  765. handling of classes without LOG_CLASS
  767. live update of filtering from file
  769. syslog recorder
  770. file recorder
  771. cerr/stderr recorder
  772. fixed buffer recorder
  773. windows recorder
  775. mutex use when logging (?)
  776. strange careful about to crash handling (?)
  777. */