2010-04-11 01:11:39 +02:00
|
|
|
/*
|
|
|
|
|
AdviceSituations(Test) - catalogue of standard Advice usage scenarios
|
2010-12-17 23:28:49 +01:00
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
Copyright (C) Lumiera.org
|
|
|
|
|
2010, Hermann Vosseler <Ichthyostega@web.de>
|
2010-12-17 23:28:49 +01:00
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
This program is free software; you can redistribute it and/or
|
|
|
|
|
modify it under the terms of the GNU General Public License as
|
2010-12-17 23:28:49 +01:00
|
|
|
published by the Free Software Foundation; either version 2 of
|
|
|
|
|
the License, or (at your option) any later version.
|
|
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
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.
|
2010-12-17 23:28:49 +01:00
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
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.
|
2010-12-17 23:28:49 +01:00
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
* *****************************************************/
|
|
|
|
|
|
2017-02-22 01:54:20 +01:00
|
|
|
/** @file advice-situations-test.cpp
|
2017-02-22 03:17:18 +01:00
|
|
|
** unit test \ref AdviceSituations_test
|
2016-11-03 18:20:10 +01:00
|
|
|
*/
|
|
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
|
|
|
|
|
#include "lib/test/run.hpp"
|
|
|
|
|
//#include "lib/test/test-helper.hpp"
|
|
|
|
|
|
2012-12-01 08:44:07 +01:00
|
|
|
#include "common/advice.hpp"
|
|
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
|
|
|
|
|
|
2012-12-01 08:44:07 +01:00
|
|
|
namespace lumiera {
|
2010-04-11 01:11:39 +02:00
|
|
|
namespace advice {
|
|
|
|
|
namespace test {
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-10-24 23:06:36 +02:00
|
|
|
/**************************************************************************************//**
|
2010-04-11 01:11:39 +02:00
|
|
|
* @test documentation of the fundamental usage scenarios envisioned in the Advice concept.
|
|
|
|
|
* This test will be augmented and completed as the Lumiera application matures.
|
|
|
|
|
*
|
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
|
|
|
* @todo yet more use cases to come.... ////////////////////////////////////////////////////////TICKET #335
|
2010-04-11 01:11:39 +02:00
|
|
|
*
|
|
|
|
|
* @see advice.hpp
|
|
|
|
|
* @see AdviceBasics_test
|
|
|
|
|
* @see AdviceConfiguration_test
|
|
|
|
|
*/
|
|
|
|
|
class AdviceSituations_test : public Test
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
virtual void
|
|
|
|
|
run (Arg)
|
|
|
|
|
{
|
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
|
|
|
pattern01_justPickAndBeHappy();
|
|
|
|
|
pattern02_pickIfPresent();
|
|
|
|
|
pattern03_installOnlyOnce();
|
2010-04-11 01:11:39 +02:00
|
|
|
TODO ("more advice usage scenarios.....?");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
/** @test usage pattern 01: simply consume Advice -- irrespective if set explicitly. */
|
2010-04-11 01:11:39 +02:00
|
|
|
void
|
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
|
|
|
pattern01_justPickAndBeHappy()
|
2010-04-11 01:11:39 +02:00
|
|
|
{
|
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
|
|
|
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());
|
2010-04-11 01:11:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
/** @test usage pattern 01: . */
|
2010-04-11 01:11:39 +02:00
|
|
|
void
|
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
|
|
|
pattern03_installOnlyOnce()
|
2010-04-11 01:11:39 +02:00
|
|
|
{
|
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
|
|
|
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());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-11 01:11:39 +02:00
|
|
|
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #335
|
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
|
|
|
/** @test usage pattern ∞ : somewhat literally fantastic */
|
|
|
|
|
void
|
|
|
|
|
check_SevenMoreWondersOfTheWorld()
|
|
|
|
|
{
|
|
|
|
|
UNIMPLEMENTED ("suitable advice to save the world");
|
2010-04-11 01:11:39 +02:00
|
|
|
}
|
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
|
|
|
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #335
|
2010-04-11 01:11:39 +02:00
|
|
|
|
|
|
|
|
// more to come.....
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** Register this test class... */
|
|
|
|
|
LAUNCHER (AdviceSituations_test, "function common");
|
|
|
|
|
|
|
|
|
|
|
2012-12-01 08:44:07 +01:00
|
|
|
}}} // namespace lumiera::advice::test
|