рдЗрдХрд╛рдИ рдкрд░реАрдХреНрд╖рдг рд▓рд┐рдЦрддреЗ рд╕рдордп, рдЖрдорддреМрд░ рдкрд░ рдХрдХреНрд╖рд╛ рдХреЗ рдЦреБрд▓реЗ рдЗрдВрдЯрд░рдлрд╝реЗрд╕ рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рд╡рд░реНрдЧ рдХреЗ рдЖрдХреНрд░рдордгрдХрд╛рд░рд┐рдпреЛрдВ рдХреА рдЬрд╛рдВрдЪ рдХрд░рдирд╛ рдЕрдЪреНрдЫрд╛ рдорд╛рдирд╛ рдЬрд╛рддрд╛ рд╣реИред рдХреНрдпреВрдЯреА рдХреЗ рдорд╛рдорд▓реЗ рдореЗрдВ, рд╕рдм рдХреБрдЫ рдереЛрдбрд╝рд╛ рдЕрдзрд┐рдХ рдЬрдЯрд┐рд▓ рд╣реИ, рдХреНрдпреЛрдВрдХрд┐ рд╕рджрд╕реНрдп рдлрд╝рдВрдХреНрд╢рди рд╕рдВрднрд╛рд╡рд┐рдд рд░реВрдк рд╕реЗ рд╕рд┐рдЧреНрдирд▓ рднреЗрдЬ рд╕рдХрддреЗ рд╣реИрдВ рдЬреЛ рд╡рд╕реНрддреБрдУрдВ рдХреЗ "рдмрд╛рд╣рд░" рдЬрд╛рддреЗ рд╣реИрдВ рдФрд░ рдЗрд╕ рдкреНрд░рдХрд╛рд░ рдЦреБрд▓реЗ рдЗрдВрдЯрд░рдлрд╝реЗрд╕ рдХрд╛ рд╣рд┐рд╕реНрд╕рд╛ рд╣реИрдВред рдЗрди рдЙрджреНрджреЗрд╢реНрдпреЛрдВ рдХреЗ рд▓рд┐рдП, QtTestLib рдореЙрдбреНрдпреВрд▓ рдореЗрдВ рдПрдХ рдЙрдкрдпреЛрдЧреА
QSignalSpy рд╡рд░реНрдЧ рд╣реИ рдЬреЛ рдкрд░реАрдХреНрд╖рдг рдСрдмреНрдЬреЗрдХреНрдЯ рджреНрд╡рд╛рд░рд╛ рдЬрд╛рд░реА рдХрд┐рдП рдЧрдП рдПрдХ рд╡рд┐рд╢рд┐рд╖реНрдЯ рд╕рд┐рдЧреНрдирд▓ рдХреА рдирд┐рдЧрд░рд╛рдиреА рдХрд░рддрд╛ рд╣реИ рдФрд░ рд╕рд╛рд╡рдзрд╛рдиреАрдкреВрд░реНрд╡рдХ рдпрд╣ рд╕рдВрдХреЗрдд рджреЗрддрд╛ рд╣реИ рдХрд┐ рдпрд╣ рд╕рд┐рдЧреНрдирд▓ рдХрд┐рддрдиреА рдмрд╛рд░ рдФрд░ рдХрд┐рди рдореВрд▓реНрдпреЛрдВ рдХреЗ рд╕рд╛рде рд░рд┐рдХреЙрд░реНрдб рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред
рдпрд╣рд╛рдВ рдмрддрд╛рдпрд╛ рдЧрдпрд╛ рд╣реИ рдХрд┐ рдпрд╣ рдХреИрд╕реЗ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ:
рдЬреИрд╕рд╛ рдХрд┐ рдЖрдк рдЕрдВрддрд┐рдо рджреЛ рдкрдВрдХреНрддрд┐рдпреЛрдВ рд╕реЗ рджреЗрдЦ рд╕рдХрддреЗ рд╣реИрдВ, QSignalSpy рд╕реЗ рд╣реА рд╡рд┐рд░рд╛рд╕рдд рдореЗрдВ рдорд┐рд▓реА рд╣реИ
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
. QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.
QList<QList > ( ), QList , - .
:
assert(2 == firstCallArgs.size()); assert(58 == firstCallArgs.at(0).toInt()); // assert(true == firstCallArgs.at(0).toBool()); assert(2 == secondCallArgs.size()); assert(42 == secondCallArgs.at(1).toInt()); assert(false == secondCallArgs.at(2).toBool());
, :
- someSignal, , SIGNAL(someSignal(int, bool)) - ( ). , , .
assert(0 == spy.size());
, , . QVariant ...toInt(), ...toBool() , QVariant . 0. , - int QString. , : QVariant' .
, , .
, ? , :
template <... ...> class SignalSpy;
, . . - :
SignalSpy<... -...> spy(&someObject, &MyClass::someSignal);
, , , , .
, QVariant', ? - :
std::tuple<FirstArgT, SecondArgT,..., LastArgT>
:
QList<std::tuple<FirstArgT, SecondArgT,..., LastArgT> >
, SignalSpy. . :
template <... ...> class SignalSpy { public: // SignalSpy(T* signalSource, ...- ) { тАж - , , , m_calls... } QList<std::tuple<... ...> > m_calls; };
. , , :
template<typename T, typename ArgT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ArgT)); // Method . std::list<std::tuple<ArgT> > m_calls; };
:
// SomeClass void someSignal(int); SomeClass myObject; SignalSpy<SomeClass, int> spy = SignalSpy<SomeClass, int>(&myObject, &SomeClass::someSignal);
SignalSpy<SomeClass, int> , - , , :
template<typename T, typename ArgT > SignalSpy<T, ArgT> createSignalSpy(T* signalSource, void (T::*Method)(ArgT)) { return SignalSpy<T, ArgT>(signalSource, Method); };
:
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
. , . , тАФ lambda :
SignalSpy(T* signalSource, void (T::*Method)(ArgT)); { QObject::connect(signalSource, Method, [this](ArgT arg) { // . m_calls.push_back(std::make_tuple(arg)); }); }
, , . . - :
template<typename T, typename... ParamT> class SignalSpy { public : SignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { QObject::connect(signalSource, Method, [this](ParamT... args) { m_calls.push_back(std::make_tuple(args...)); }); } QList<std::tuple<ParamT...> > m_calls; }; // template<typename T,typename... ParamT> SignalSpy<T, ParamT...> createSignalSpy(T* signalSource, void (T::*Method)(ParamT...)) { return SignalSpy<T, ParamT...>(signalSource, Method); };
- :
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal); emit someObject.someSignal(58, true) emit someObject.someSignal(42,false); assert( 58, get<0>(spy.m_calls.at(0)) ); assert( true, get<1>(spy.m_calls.at(0)) ); assert( 42, get<0>(spy.m_calls.at(1)) ); assert( false, get<1>(spy.m_calls.at(1)) );
.