Merge remote-tracking branch 'secondlife/release/26.4' into 26.4

1 files changed, 0 insertions, 506 deletions

diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp
deleted file mode 100644
index c5d5dcb9d4..0000000000
--- a/indra/test/llevents_tut.cpp
+++ /dev/null
@@ -1,506 +0,0 @@
-/**
- * @file   llevents_tut.cpp
- * @author Nat Goodspeed
- * @date   2008-09-12
- * @brief  Test of llevents.h
- *
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if LL_WINDOWS
-#pragma warning (disable : 4675) // "resolved by ADL" -- just as I want!
-#endif
-
-// Precompiled header
-#include "linden_common.h"
-// associated header
-// UGLY HACK! We want to verify state internal to the classes without
-// providing public accessors.
-#define testable public
-#include "llevents.h"
-#undef testable
-// STL headers
-// std headers
-#include <iostream>
-#include <typeinfo>
-// external library headers
-#include <boost/bind.hpp>
-// other Linden headers
-#include "tests/listener.h"             // must PRECEDE lltut.h
-#include "lltut.h"
-#include "catch_and_store_what_in.h"
-#include "stringize.h"
-
-template<typename T>
-T make(const T& value)
-{
-    return value;
-}
-
-/*****************************************************************************
- *   tut test group
- *****************************************************************************/
-namespace tut
-{
-struct events_data
-{
-    events_data() :
-        pumps(LLEventPumps::instance()),
-        listener0("first"),
-        listener1("second")
-    {
-    }
-    LLEventPumps& pumps;
-    Listener listener0;
-    Listener listener1;
-
-    void check_listener(const std::string& desc, const Listener& listener, LLSD::Integer got)
-    {
-        ensure_equals(STRINGIZE(listener << ' ' << desc),
-                      listener.getLastEvent().asInteger(), got);
-    }
-};
-typedef test_group<events_data> events_group;
-typedef events_group::object events_object;
-tut::events_group evgr("events");
-
-template<> template<>
-void events_object::test<1>()
-{
-    set_test_name("basic operations");
-    // Having to modify this to track the statically-
-    // constructed pumps in other TUT modules in this giant monolithic test
-    // executable isn't such a hot idea.
-    // ensure_equals("initial pump", pumps.mPumpMap.size(), 1);
-    size_t initial_pumps(pumps.mPumpMap.size());
-    LLEventPump& per_frame(pumps.obtain("per-frame"));
-    ensure_equals("first explicit pump", pumps.mPumpMap.size(), initial_pumps + 1);
-    // Verify that per_frame was instantiated as an LLEventStream.
-    ensure("LLEventStream leaf class", dynamic_cast<LLEventStream*> (&per_frame));
-    ensure("enabled", per_frame.enabled());
-    // Trivial test, but posting an event to an EventPump with no
-    // listeners should not blow up. The test is relevant because defining
-    // a boost::signal with a non-void return signature, using the default
-    // combiner, blows up if there are no listeners. This is because the
-    // default combiner is defined to return the value returned by the
-    // last listener, which is meaningless if there were no listeners.
-    per_frame.post(0);
-    LLBoundListener connection = listener0.listenTo(per_frame);
-    ensure("connected", connection.connected());
-    ensure("not blocked", !connection.blocked());
-    per_frame.post(1);
-    check_listener("received", listener0, 1);
-    { // block the connection
-        LLEventPump::Blocker block(connection);
-        ensure("blocked", connection.blocked());
-        per_frame.post(2);
-        check_listener("not updated", listener0, 1);
-    } // unblock
-    ensure("unblocked", !connection.blocked());
-    per_frame.post(3);
-    check_listener("unblocked", listener0, 3);
-    LLBoundListener sameConnection = per_frame.getListener(listener0.getName());
-    ensure("still connected", sameConnection.connected());
-    ensure("still not blocked", !sameConnection.blocked());
-    { // block it again
-        LLEventPump::Blocker block(sameConnection);
-        ensure("re-blocked", sameConnection.blocked());
-        per_frame.post(4);
-        check_listener("re-blocked", listener0, 3);
-    } // unblock
-    std::string threw = catch_what<LLEventPump::DupListenerName>(
-        [&per_frame, this](){
-            // NOTE: boost::bind() saves its arguments by VALUE! If you pass
-            // an object instance rather than a pointer, you'll end up binding
-            // to an internal copy of that instance! Use boost::ref() to
-            // capture a reference instead.
-            per_frame.listen(listener0.getName(), // note bug, dup name
-                             boost::bind(&Listener::call, boost::ref(listener1), _1));
-        });
-    ensure_equals(threw,
-                  std::string("DupListenerName: "
-                              "Attempt to register duplicate listener name '") +
-                              listener0.getName() + "' on " + typeid(per_frame).name() +
-                              " '" + per_frame.getName() + "'");
-    // do it right this time
-    listener1.listenTo(per_frame);
-    per_frame.post(5);
-    check_listener("got", listener0, 5);
-    check_listener("got", listener1, 5);
-    per_frame.enable(false);
-    per_frame.post(6);
-    check_listener("didn't get", listener0, 5);
-    check_listener("didn't get", listener1, 5);
-    per_frame.enable();
-    per_frame.post(7);
-    check_listener("got", listener0, 7);
-    check_listener("got", listener1, 7);
-    per_frame.stopListening(listener0.getName());
-    ensure("disconnected 0", ! connection.connected());
-    ensure("disconnected 1", ! sameConnection.connected());
-    per_frame.post(8);
-    check_listener("disconnected", listener0, 7);
-    check_listener("still connected", listener1, 8);
-    per_frame.stopListening(listener1.getName());
-    per_frame.post(9);
-    check_listener("disconnected", listener1, 8);
-}
-
-template<> template<>
-void events_object::test<2>()
-{
-    set_test_name("callstop() returning true");
-    LLEventPump& per_frame(pumps.obtain("per-frame"));
-    listener0.reset(0);
-    listener1.reset(0);
-    LLBoundListener bound0 = listener0.listenTo(per_frame, &Listener::callstop);
-    LLBoundListener bound1 = listener1.listenTo(per_frame, &Listener::call,
-                                                // after listener0
-                                                make<LLEventPump::NameList>(LLEventPump::NameList{ listener0.getName() }));
-    ensure("enabled", per_frame.enabled());
-    ensure("connected 0", bound0.connected());
-    ensure("unblocked 0", !bound0.blocked());
-    ensure("connected 1", bound1.connected());
-    ensure("unblocked 1", !bound1.blocked());
-    per_frame.post(1);
-    check_listener("got", listener0, 1);
-    // Because listener0.callstop() returns true, control never reaches listener1.call().
-    check_listener("got", listener1, 0);
-}
-
-bool chainEvents(Listener& someListener, const LLSD& event)
-{
-    // Make this call so we can watch for side effects for test purposes.
-    someListener.call(event);
-    // This function represents a recursive event chain -- or some other
-    // scenario in which an event handler raises additional events.
-    int value = event.asInteger();
-    if (value)
-    {
-        LLEventPumps::instance().obtain("login").post(value - 1);
-    }
-    return false;
-}
-
-template<> template<>
-void events_object::test<3>()
-{
-    set_test_name("explicitly-instantiated LLEventStream");
-    // Explicitly instantiate an LLEventStream, and verify that it
-    // self-registers with LLEventPumps
-    size_t registered = pumps.mPumpMap.size();
-    size_t owned = pumps.mOurPumps.size();
-    LLEventPump* localInstance;
-    {
-        LLEventStream myEventStream("stream");
-        localInstance = &myEventStream;
-        LLEventPump& stream(pumps.obtain("stream"));
-        ensure("found named LLEventStream instance", &stream == localInstance);
-        ensure_equals("registered new instance", pumps.mPumpMap.size(), registered + 1);
-        ensure_equals("explicit instance not owned", pumps.mOurPumps.size(), owned);
-    } // destroy myEventStream -- should unregister
-    ensure_equals("destroyed instance unregistered", pumps.mPumpMap.size(), registered);
-    ensure_equals("destroyed instance not owned", pumps.mOurPumps.size(), owned);
-    LLEventPump& stream(pumps.obtain("stream"));
-    ensure("new LLEventStream instance", &stream != localInstance);
-    ensure_equals("obtain()ed instance registered", pumps.mPumpMap.size(), registered + 1);
-    ensure_equals("obtain()ed instance owned", pumps.mOurPumps.size(), owned + 1);
-}
-
-template<> template<>
-void events_object::test<4>()
-{
-    set_test_name("stopListening()");
-    LLEventPump& login(pumps.obtain("login"));
-    listener0.listenTo(login);
-    login.stopListening(listener0.getName());
-    // should not throw because stopListening() should have removed name
-    listener0.listenTo(login, &Listener::callstop);
-    LLBoundListener wrong = login.getListener("bogus");
-    ensure("bogus connection disconnected", !wrong.connected());
-    ensure("bogus connection blocked", wrong.blocked());
-}
-
-template<> template<>
-void events_object::test<5>()
-{
-    set_test_name("chaining LLEventPump instances");
-    LLEventPump& upstream(pumps.obtain("upstream"));
-    // One potentially-useful construct is to chain LLEventPumps together.
-    // Among other things, this allows you to turn subsets of listeners on
-    // and off in groups.
-    LLEventPump& filter0(pumps.obtain("filter0"));
-    LLEventPump& filter1(pumps.obtain("filter1"));
-    upstream.listen(filter0.getName(), boost::bind(&LLEventPump::post, boost::ref(filter0), _1));
-    upstream.listen(filter1.getName(), boost::bind(&LLEventPump::post, boost::ref(filter1), _1));
-    listener0.listenTo(filter0);
-    listener1.listenTo(filter1);
-    listener0.reset(0);
-    listener1.reset(0);
-    upstream.post(1);
-    check_listener("got unfiltered", listener0, 1);
-    check_listener("got unfiltered", listener1, 1);
-    filter0.enable(false);
-    upstream.post(2);
-    check_listener("didn't get filtered", listener0, 1);
-    check_listener("got filtered", listener1, 2);
-}
-
-template<> template<>
-void events_object::test<6>()
-{
-    set_test_name("listener dependency order");
-    typedef LLEventPump::NameList NameList;
-    LLEventPump& button(pumps.obtain("button"));
-    Collect collector;
-    button.listen("Mary",
-                  boost::bind(&Collect::add, boost::ref(collector), "Mary", _1),
-                  // state that "Mary" must come after "checked"
-                  make<NameList>(NameList{ "checked" }));
-    button.listen("checked",
-                  boost::bind(&Collect::add, boost::ref(collector), "checked", _1),
-                  // "checked" must come after "spot"
-                  make<NameList>(NameList{ "spot" }));
-    button.listen("spot",
-                  boost::bind(&Collect::add, boost::ref(collector), "spot", _1));
-    button.post(1);
-    ensure_equals(collector.result, make<StringVec>(StringVec{ "spot", "checked", "Mary" }));
-    collector.clear();
-    button.stopListening("Mary");
-    button.listen("Mary",
-            boost::bind(&Collect::add, boost::ref(collector), "Mary", _1),
-            LLEventPump::empty, // no after dependencies
-            // now "Mary" must come before "spot"
-                  make<NameList>(NameList{ "spot" }));
-    button.post(2);
-    ensure_equals(collector.result, make<StringVec>(StringVec{ "Mary", "spot", "checked" }));
-    collector.clear();
-    button.stopListening("spot");
-    std::string threw = catch_what<LLEventPump::Cycle>(
-        [&button, &collector](){
-            button.listen("spot",
-                          boost::bind(&Collect::add, boost::ref(collector), "spot", _1),
-                          // after "Mary" and "checked" -- whoops!
-                          make<NameList>(NameList{ "Mary", "checked" }));
-        });
-    // Obviously the specific wording of the exception text can
-    // change; go ahead and change the test to match.
-    // Establish that it contains:
-    // - the name and runtime type of the LLEventPump
-    ensure_contains("LLEventPump type", threw, typeid(button).name());
-    ensure_contains("LLEventPump name", threw, "'button'");
-    // - the name of the new listener that caused the problem
-    ensure_contains("new listener name", threw, "'spot'");
-    // - a synopsis of the problematic dependencies.
-    ensure_contains("cyclic dependencies", threw,
-                    "\"Mary\" -> before (\"spot\")");
-    ensure_contains("cyclic dependencies", threw,
-                    "after (\"spot\") -> \"checked\"");
-    ensure_contains("cyclic dependencies", threw,
-                    "after (\"Mary\", \"checked\") -> \"spot\"");
-    button.listen("yellow",
-                  boost::bind(&Collect::add, boost::ref(collector), "yellow", _1), make<NameList>(NameList{ "checked" }));
-    button.listen("shoelaces",
-                  boost::bind(&Collect::add, boost::ref(collector), "shoelaces", _1), make<NameList>(NameList{ "checked" }));
-    button.post(3);
-    ensure_equals(collector.result, make<StringVec>(StringVec{ "Mary", "checked", "yellow", "shoelaces" }));
-    collector.clear();
-    threw = catch_what<LLEventPump::OrderChange>(
-        [&button, &collector](){
-            button.listen("of",
-                          boost::bind(&Collect::add, boost::ref(collector), "of", _1),
-                          make<NameList>(NameList{ "shoelaces" }),
-                          make<NameList>(NameList{ "yellow" }));
-        });
-    // Same remarks about the specific wording of the exception. Just
-    // ensure that it contains enough information to clarify the
-    // problem and what must be done to resolve it.
-    ensure_contains("LLEventPump type", threw, typeid(button).name());
-    ensure_contains("LLEventPump name", threw, "'button'");
-    ensure_contains("new listener name", threw, "'of'");
-    ensure_contains("prev listener name", threw, "'yellow'");
-    // std::cout << "Thrown Exception: " << threw << std::endl;
-    ensure_contains("old order", threw, "was: Mary, checked, yellow, shoelaces");
-    ensure_contains("new order", threw, "now: Mary, checked, shoelaces, of, yellow");
-    button.post(4);
-    ensure_equals(collector.result, make<StringVec>(StringVec{ "Mary", "checked", "yellow", "shoelaces" }));
-}
-
-template<> template<>
-void events_object::test<7>()
-{
-    set_test_name("tweaked and untweaked LLEventPump instance names");
-    {   // nested scope
-        // Hand-instantiate an LLEventStream...
-        LLEventStream bob("bob");
-        std::string threw = catch_what<LLEventPump::DupPumpName>(
-            [](){
-                // then another with a duplicate name.
-                LLEventStream bob2("bob");
-            });
-        ensure("Caught DupPumpName", !threw.empty());
-    }   // delete first 'bob'
-    LLEventStream bob("bob");       // should work, previous one unregistered
-    LLEventStream bob1("bob", true);// allowed to tweak name
-    ensure_equals("tweaked LLEventStream name", bob1.getName(), "bob1");
-    std::vector<std::shared_ptr<LLEventStream> > streams;
-    for (int i = 2; i <= 10; ++i)
-    {
-        streams.push_back(std::shared_ptr<LLEventStream>(new LLEventStream("bob", true)));
-    }
-    ensure_equals("last tweaked LLEventStream name", streams.back()->getName(), "bob10");
-}
-
-// Define a function that accepts an LLListenerOrPumpName
-void eventSource(const LLListenerOrPumpName& listener)
-{
-    // Pretend that some time has elapsed. Call listener immediately.
-    listener(17);
-}
-
-template<> template<>
-void events_object::test<8>()
-{
-    set_test_name("LLListenerOrPumpName");
-    // Passing a boost::bind() expression to LLListenerOrPumpName
-    listener0.reset(0);
-    eventSource(boost::bind(&Listener::call, boost::ref(listener0), _1));
-    check_listener("got by listener", listener0, 17);
-    // Passing a string LLEventPump name to LLListenerOrPumpName
-    listener0.reset(0);
-    LLEventStream random("random");
-    listener0.listenTo(random);
-    eventSource("random");
-    check_listener("got by pump name", listener0, 17);
-    std::string threw = catch_what<LLListenerOrPumpName::Empty>(
-        [](){
-            LLListenerOrPumpName empty;
-            empty(17);
-        });
-
-    ensure("threw Empty", !threw.empty());
-}
-
-class TempListener: public Listener
-{
-public:
-    TempListener(const std::string& name, bool& liveFlag) :
-        Listener(name), mLiveFlag(liveFlag)
-    {
-        mLiveFlag = true;
-    }
-
-    virtual ~TempListener()
-    {
-        mLiveFlag = false;
-    }
-
-private:
-    bool& mLiveFlag;
-};
-
-template<> template<>
-void events_object::test<9>()
-{
-    set_test_name("listen(boost::bind(...TempListener...))");
-    // listen() can't do anything about a plain TempListener instance:
-    // it's not managed with shared_ptr, nor is it an LLEventTrackable subclass
-    bool live = false;
-    LLEventPump& heaptest(pumps.obtain("heaptest"));
-    LLBoundListener connection;
-    {
-        TempListener tempListener("temp", live);
-        ensure("TempListener constructed", live);
-        connection = heaptest.listen(tempListener.getName(),
-                                     boost::bind(&Listener::call,
-                                                 boost::ref(tempListener),
-                                                 _1));
-        heaptest.post(1);
-        check_listener("received", tempListener, 1);
-    } // presumably this will make newListener go away?
-    // verify that
-    ensure("TempListener destroyed", !live);
-    // This is the case against which we can't defend. Don't even try to
-    // post to heaptest -- that would engage Undefined Behavior.
-    // Cautiously inspect connection...
-    ensure("misleadingly connected", connection.connected());
-    // then disconnect by hand.
-    heaptest.stopListening("temp");
-}
-
-class TempTrackableListener: public TempListener, public LLEventTrackable
-{
-public:
-    TempTrackableListener(const std::string& name, bool& liveFlag):
-        TempListener(name, liveFlag)
-    {}
-};
-
-template<> template<>
-void events_object::test<10>()
-{
-    set_test_name("listen(boost::bind(...TempTrackableListener ref...))");
-    bool live = false;
-    LLEventPump& heaptest(pumps.obtain("heaptest"));
-    LLBoundListener connection;
-    {
-        TempTrackableListener tempListener("temp", live);
-        ensure("TempTrackableListener constructed", live);
-        connection = heaptest.listen(tempListener.getName(),
-                                     boost::bind(&TempTrackableListener::call,
-                                                 boost::ref(tempListener), _1));
-        heaptest.post(1);
-        check_listener("received", tempListener, 1);
-    } // presumably this will make tempListener go away?
-    // verify that
-    ensure("TempTrackableListener destroyed", ! live);
-    ensure("implicit disconnect", ! connection.connected());
-    // now just make sure we don't blow up trying to access a freed object!
-    heaptest.post(2);
-}
-
-template<> template<>
-void events_object::test<11>()
-{
-    set_test_name("listen(boost::bind(...TempTrackableListener pointer...))");
-    bool live = false;
-    LLEventPump& heaptest(pumps.obtain("heaptest"));
-    LLBoundListener connection;
-    {
-        TempTrackableListener* newListener(new TempTrackableListener("temp", live));
-        ensure("TempTrackableListener constructed", live);
-        connection = heaptest.listen(newListener->getName(),
-                                     boost::bind(&TempTrackableListener::call,
-                                                 newListener, _1));
-        heaptest.post(1);
-        check_listener("received", *newListener, 1);
-        // explicitly destroy newListener
-        delete newListener;
-    }
-    // verify that
-    ensure("TempTrackableListener destroyed", ! live);
-    ensure("implicit disconnect", ! connection.connected());
-    // now just make sure we don't blow up trying to access a freed object!
-    heaptest.post(2);
-}
-
-} // namespace tut