static void
test_homo_move_assign ()
{
rw_info (0, __FILE__, __LINE__,
"move assignment operator (homogenous tuples)");
std::tuple<> et1, et2;
et2 = std::move (et1);
_RWSTD_UNUSED (et2);
int i = std::rand ();
std::tuple<int> it1 (i);
std::tuple<int> it2;
it2 = std::move (it1);
test (__LINE__, it2, i);
// move assignment ill-formed for constant element types
std::tuple<std::tuple<int> > nt1 (it2);
std::tuple<std::tuple<int> > nt2;
nt2 = std::move (nt1);
test (__LINE__, nt2, it2);
std::tuple<long, const char*> pt1 (1234567890L, "string");
std::tuple<long, const char*> pt2;
pt2 = std::move (pt1);
test (__LINE__, pt2, 1234567890L, (const char*) "string");
const UserDefined ud (i);
std::tuple<UserDefined> ut1 (ud);
std::tuple<UserDefined> ut2;
UserDefined::reset ();
ut2 = std::move (ut1); ++UserDefined::expect.move_asgn;
test (__LINE__, ut2, ud);
std::tuple<bool, char, int, double, void*, UserDefined>
bt1 (true, 'a', i, 3.14159, (void* const) &i, ud);
std::tuple<bool, char, int, double, void*, UserDefined> bt2;
UserDefined::reset ();
bt2 = std::move (bt1); ++UserDefined::expect.move_asgn;
test (__LINE__, bt2, true, 'a', i, 3.14159, (void* const) &i, ud);
}
static void
test_homo_move_ctor ()
{
rw_info (0, __FILE__, __LINE__,
"move constructor (homogenous tuples)");
std::tuple<> et (std::tuple<> ()); _RWSTD_UNUSED (et);
const int ci = std::rand ();
std::tuple<int> it1 (ci);
std::tuple<int> it2 (std::move (it1));
test (__LINE__, it2, ci);
std::tuple<const int> ct1 (ci);
std::tuple<const int> ct2 = std::move (ct1);
test (__LINE__, ct2, ci);
std::tuple<std::tuple<int> > nt1 (it1);
std::tuple<std::tuple<int> > nt2 = std::move (nt1);
test (__LINE__, nt2, it1);
std::tuple<long, const char*> pt1 (1234567890L, "string");
std::tuple<long, const char*> pt2 (std::move (pt1));
test (__LINE__, pt2, 1234567890L, (const char*) "string");
const UserDefined ud (ci);
std::tuple<UserDefined> ut1 (ud);
UserDefined::reset ();
std::tuple<UserDefined> ut2 (std::move (ut1));
++UserDefined::expect.move_ctor;
test (__LINE__, ut2, ud);
std::tuple<bool, char, int, double, void*, UserDefined>
bt1 (true, 'a', ci, 3.14159, (void*) &ci, ud);
++UserDefined::expect.copy_ctor;
std::tuple<bool, char, int, double, void*, UserDefined>
bt2 (std::move (bt1));
++UserDefined::expect.move_ctor;
test (__LINE__, bt2, true, 'a', ci, 3.14159, (void*) &ci, ud);
}
static void
test_lt ()
{
rw_info (0, __FILE__, __LINE__, "operator<");
std::tuple<> nt1, nt2;
TEST (!(nt1 < nt1));
TEST (!(nt1 < nt2));
std::tuple<int> it1 (1), it2 (2);
TEST (!(it1 < it1));
TEST (it1 < it2);
UserDefined ud1 (1), ud2 (2);
std::tuple<UserDefined> ut1 (ud1), ut2 (ud2);
TEST (!(ut1 < ut1));
TEST (ut1 < ut2);
std::tuple<long, const char*> pt1 (1234L, "string");
TEST (!(pt1 < pt1));
std::tuple<long, const char*> pt2 (1235L, "string");
TEST (pt1 < pt2);
std::tuple<long, const char*> pt3 (1234L, "strings");
TEST (pt1 < pt3);
std::tuple<bool, char, int, double, void*, UserDefined>
bt1 (true, 'a', 255, 3.14159, &nt1, ud1),
bt2 (true, 'a', 256, 3.14159, &nt1, ud1),
bt3 (true, 'a', 255, 3.14159, &nt1, ud2);
rw_assert (!(bt1 < bt1), __FILE__, __LINE__,
"bt1 < bt1, got true, expected false");
rw_assert (bt1 < bt2, __FILE__, __LINE__,
"bt1 < bt2, got false, expected true");
rw_assert (bt1 < bt3, __FILE__, __LINE__,
"bt1 < bt3, got false, expected true");
}
static void
test_eq ()
{
rw_info (0, __FILE__, __LINE__, "operator==");
std::tuple<> nt1, nt2;
// special case
rw_assert (nt1 == nt1, __FILE__, __LINE__,
"nt1 == nt1, got false, expected true");
#undef TEST
#define TEST(expr) \
rw_assert (expr, __FILE__, __LINE__, #expr \
"; got %b, expected %b", !(expr), expr)
TEST (nt1 == nt2);
std::tuple<int> it1 (1), it2 (1), it3 (2);
TEST (it1 == it1);
TEST (it1 == it2);
TEST (!(it1 == it3));
UserDefined ud1 (1), ud2 (2);
std::tuple<UserDefined> ut1 (ud1), ut2 (ud1), ut3 (ud2);
TEST (ut1 == ut1);
TEST (ut1 == ut2);
TEST (!(ut1 == ut3));
std::tuple<bool, char, int, double, void*, UserDefined>
bt1 (true, 'a', 255, 3.14159, &nt1, ud1),
bt2 (true, 'a', 255, 3.14159, &nt1, ud1),
bt3 (true, 'a', 256, 3.14159, &nt1, ud1);
TEST (bt1 == bt1);
TEST (bt1 == bt2);
TEST (!(bt1 == bt3));
}
QT_END_NAMESPACE
void tst_QButtonGroup::arrowKeyNavigation()
{
if (!qt_tab_all_widgets())
QSKIP("This test requires full keyboard control to be enabled.");
QDialog dlg(0);
QHBoxLayout layout(&dlg);
QGroupBox g1("1", &dlg);
QHBoxLayout g1layout(&g1);
QRadioButton bt1("Radio1", &g1);
QPushButton pb("PB", &g1);
QLineEdit le(&g1);
QRadioButton bt2("Radio2", &g1);
g1layout.addWidget(&bt1);
g1layout.addWidget(&pb);
g1layout.addWidget(&le);
g1layout.addWidget(&bt2);
// create a mixed button group with radion buttons and push
// buttons. Not very useful, but it tests borderline cases wrt
// focus handling.
QButtonGroup bgrp1(&g1);
bgrp1.addButton(&bt1);
bgrp1.addButton(&pb);
bgrp1.addButton(&bt2);
QGroupBox g2("2", &dlg);
QVBoxLayout g2layout(&g2);
// we don't need a button group here, because radio buttons are
// auto exclusive, i.e. they group themselves in he same parent
// widget.
QRadioButton bt3("Radio3", &g2);
QRadioButton bt4("Radio4", &g2);
g2layout.addWidget(&bt3);
g2layout.addWidget(&bt4);
layout.addWidget(&g1);
layout.addWidget(&g2);
dlg.show();
qApp->setActiveWindow(&dlg);
QVERIFY(QTest::qWaitForWindowActive(&dlg));
bt1.setFocus();
QTRY_VERIFY(bt1.hasFocus());
QTest::keyClick(&bt1, Qt::Key_Right);
QVERIFY(pb.hasFocus());
QTest::keyClick(&pb, Qt::Key_Right);
QVERIFY(bt2.hasFocus());
QTest::keyClick(&bt2, Qt::Key_Right);
QVERIFY(bt2.hasFocus());
QTest::keyClick(&bt2, Qt::Key_Left);
QVERIFY(pb.hasFocus());
QTest::keyClick(&pb, Qt::Key_Left);
QVERIFY(bt1.hasFocus());
QTest::keyClick(&bt1, Qt::Key_Tab);
QVERIFY(pb.hasFocus());
QTest::keyClick(&pb, Qt::Key_Tab);
QVERIFY(le.hasFocus());
QCOMPARE(le.selectedText(), le.text());
QTest::keyClick(&le, Qt::Key_Tab);
QVERIFY(bt2.hasFocus());
QTest::keyClick(&bt2, Qt::Key_Tab);
QVERIFY(bt3.hasFocus());
QTest::keyClick(&bt3, Qt::Key_Down);
QVERIFY(bt4.hasFocus());
QTest::keyClick(&bt4, Qt::Key_Down);
QVERIFY(bt4.hasFocus());
QTest::keyClick(&bt4, Qt::Key_Up);
QVERIFY(bt3.hasFocus());
QTest::keyClick(&bt3, Qt::Key_Up);
QVERIFY(bt3.hasFocus());
}