LUMIERA.clone/tests/library/advice/advice-situations-test.cpp
Ichthyostega 6b4bf0a6ea Library: allow to check if Advice was explicitly given
For context: The »Advice System« was coined a long time ago, in 2010,
based on the vague impression that it might be useful for that kind of application
we are about to build here. And, as can be expected, none of the usage situations
envisioned at that time was brought to bear. Non the less, the facility came in
handy at times, precisely because it is cross-cutting and allows to pass
information without imposing any systematic relationship between the
communication partners.

And now we've got again such a situation.
The global style manager in the UI has to build a virtual CSS path,
which is needed by drawing code somewhere deep down, and we absolutely
do not want to pass a reference to the style manager over 20 recursive calls.

The alternatives would be
 (1) to turn the style manager into a public service
 (2) to have a static access function somewhere
 (3) to use a global variable.
For rationale, (1) would be overblown, because we do not actually request
a service to do work for us, rather we need some global piece of information.
(2) would be equivalent to (1), just more confusing. And (3) is basically
what the Advice system does, with the added benefit of a clear-cut service
access point and a well defined lifecycle.

This changeset adds the ability to check if actual Advice has been published,
which allows us to invoke the (possibly expensive) GTK path building and
style context building code only once.
2019-07-13 17:00:23 +02:00

149 lines
4.6 KiB
C++

/*
AdviceSituations(Test) - catalogue of standard Advice usage scenarios
Copyright (C) Lumiera.org
2010, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
/** @file advice-situations-test.cpp
** unit test \ref AdviceSituations_test
*/
#include "lib/test/run.hpp"
//#include "lib/test/test-helper.hpp"
#include "common/advice.hpp"
namespace lumiera {
namespace advice {
namespace test {
namespace {
}
/**************************************************************************************//**
* @test documentation of the fundamental usage scenarios envisioned in the Advice concept.
* This test will be augmented and completed as the Lumiera application matures.
*
* @todo yet more use cases to come.... ////////////////////////////////////////////////////////TICKET #335
*
* @see advice.hpp
* @see AdviceBasics_test
* @see AdviceConfiguration_test
*/
class AdviceSituations_test : public Test
{
virtual void
run (Arg)
{
pattern01_justPickAndBeHappy();
pattern02_pickIfPresent();
pattern03_installOnlyOnce();
TODO ("more advice usage scenarios.....?");
}
/** @test usage pattern 01: simply consume Advice -- irrespective if set explicitly. */
void
pattern01_justPickAndBeHappy()
{
Request<int> generic{"solution(life_and_universe_and_everything)"};
CHECK (0 == generic.getAdvice()); // the early bird gets the worm...
Provision<int> universal{"solution(life_and_universe_and_everything)"};
universal.setAdvice(5);
CHECK (5 == generic.getAdvice()); // ...while the bad girls go everywhere
universal.retractAdvice();
CHECK (0 == generic.getAdvice()); // nothing to see here, just move on
}
/** @test usage pattern 01: detect if specific advice was given. */
void
pattern02_pickIfPresent()
{
Request<int> request{"something(special)"};
CHECK (not request.isMatched());
Provision<int> info{"something(special)"};
info.setAdvice(55);
CHECK (request.isMatched());
CHECK (55 == request.getAdvice());
info.retractAdvice();
CHECK (not request.isMatched());
}
/** @test usage pattern 01: . */
void
pattern03_installOnlyOnce()
{
Provision<int> info{"something(special)"};
CHECK (not info.isGiven());
Request<int> question{"something(special)"};
CHECK (0 == question.getAdvice());
CHECK (not question.isMatched());
auto publish = [&](int i)
{
if (not info.isGiven())
info.setAdvice (i);
};
for (uint i=0; i<5; ++i)
if (i % 2)
publish (i);
CHECK (1 == question.getAdvice());
CHECK (question.isMatched());
info.retractAdvice();
CHECK (not info.isGiven());
CHECK (not question.isMatched());
}
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #335
/** @test usage pattern ∞ : somewhat literally fantastic */
void
check_SevenMoreWondersOfTheWorld()
{
UNIMPLEMENTED ("suitable advice to save the world");
}
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #335
// more to come.....
};
/** Register this test class... */
LAUNCHER (AdviceSituations_test, "function common");
}}} // namespace lumiera::advice::test