Differential D20970 Diff 57461 autotests/server/handlertest.cpp

Changeset View

Standalone View

View Options

autotests/server/handlertest.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Line(s)59private:
94 { 94​ {
95 MAKE_CMD_ROW(Protocol::Command::Logout, LogoutHandler) 95​ MAKE_CMD_ROW(Protocol::Command::Logout, LogoutHandler)
96 } 96​ }
97 97​
98 void addInvalidCommands() 98​ void addInvalidCommands()
99 { 99​ {
100 //MAKE_CMD_ROW(Protocol::Command::Invalid, UnknownCommandHandler) 100​ //MAKE_CMD_ROW(Protocol::Command::Invalid, UnknownCommandHandler)
101 } 101​ }
102​
103​ template<typename T>
104​ QByteArray typeName(const T &t)
105​ {
106​ const auto &v = *t.get();
107​ return typeid(v).name();
108​ }
109​
110​
102private Q_SLOTS: 111​private Q_SLOTS:
103 void testFindAuthenticatedCommand_data() 112​ void testFindAuthenticatedCommand_data()
104 { 113​ {
105 setupTestData(); 114​ setupTestData();
106 addAuthCommands(); 115​ addAuthCommands();
107 } 116​ }
108 117​
109 void testFindAuthenticatedCommand() 118​ void testFindAuthenticatedCommand()
110 { 119​ {
111 QFETCH(Protocol::Command::Type, command); 120​ QFETCH(Protocol::Command::Type, command);
112 QFETCH(QByteArray, className); 121​ QFETCH(QByteArray, className);
113 QScopedPointer<Handler> handler(Handler::findHandlerForCommandAuthenticated(command)); 122​ const auto handler = Handler::findHandlerForCommandAuthenticated(command);
114 QVERIFY(!handler.isNull()); 123​ QVERIFY(handler);
115 QCOMPARE(QByteArray(typeid(*handler.data()).name()), className); 124​ QCOMPARE(typeName(handler), className);
116 } 125​ }
117 126​
118 void testFindAuthenticatedCommandNegative_data() 127​ void testFindAuthenticatedCommandNegative_data()
119 { 128​ {
120 setupTestData(); 129​ setupTestData();
121 addNonAuthCommands(); 130​ addNonAuthCommands();
122 addAlwaysCommands(); 131​ addAlwaysCommands();
123 addInvalidCommands(); 132​ addInvalidCommands();
124 } 133​ }
125 134​
126 void testFindAuthenticatedCommandNegative() 135​ void testFindAuthenticatedCommandNegative()
127 { 136​ {
128 QFETCH(Protocol::Command::Type, command); 137​ QFETCH(Protocol::Command::Type, command);
129 QFETCH(QByteArray, className); 138​ QFETCH(QByteArray, className);
130 139​
131 QScopedPointer<Handler> handler(Handler::findHandlerForCommandAuthenticated(command)); 140​ const auto handler = Handler::findHandlerForCommandAuthenticated(command);
132 QVERIFY(handler.isNull()); 141​ QVERIFY(!handler);
133 } 142​ }
134 143​
135 void testFindNonAutenticatedCommand_data() 144​ void testFindNonAutenticatedCommand_data()
136 { 145​ {
137 setupTestData(); 146​ setupTestData();
138 addNonAuthCommands(); 147​ addNonAuthCommands();
139 } 148​ }
140 149​
141 void testFindNonAutenticatedCommand() 150​ void testFindNonAutenticatedCommand()
142 { 151​ {
143 QFETCH(Protocol::Command::Type, command); 152​ QFETCH(Protocol::Command::Type, command);
144 QFETCH(QByteArray, className); 153​ QFETCH(QByteArray, className);
145 154​
146 QScopedPointer<Handler> handler(Handler::findHandlerForCommandNonAuthenticated(command)); ​
147 QVERIFY(!handler.isNull()); ​
148 QCOMPARE(QByteArray(typeid(*handler.data()).name()), className); ​
149 } ​
150 ​
151 void testFindNonAutenticatedCommandNegative_data() ​
152 { ​
153 setupTestData(); ​
154 addAuthCommands(); ​
155 addAlwaysCommands(); ​
156 addInvalidCommands(); ​
157 } ​
158 ​
159 void testFindNonAutenticatedCommandNegative() ​
160 { ​
161 QFETCH(Protocol::Command::Type, command); ​
162 QFETCH(QByteArray, className); ​
163 155​
164 QScopedPointer<Handler> handler(Handler::findHandlerForCommandNonAuthenticated(command)); 156​ auto handler = Handler::findHandlerForCommandNonAuthenticated(command);
165 QVERIFY(handler.isNull()); 157​ QVERIFY(handler);
158​ QCOMPARE(typeName(handler), className);
166 } 159​ }
167 160​
168 void testFindAlwaysCommand_data() 161​ void testFindAlwaysCommand_data()
169 { 162​ {
170 setupTestData(); 163​ setupTestData();
171 addAlwaysCommands(); 164​ addAlwaysCommands();
172 } 165​ }
173 166​
174 void testFindAlwaysCommand() 167​ void testFindAlwaysCommand()
175 { 168​ {
176 QFETCH(Protocol::Command::Type, command); 169​ QFETCH(Protocol::Command::Type, command);
177 QFETCH(QByteArray, className); 170​ QFETCH(QByteArray, className);
178 171​
179 QScopedPointer<Handler> handler(Handler::findHandlerForCommandAlwaysAllowed(command)); 172​ const auto handler = Handler::findHandlerForCommandAlwaysAllowed(command);
180 QVERIFY(!handler.isNull()); 173​ QVERIFY(handler);
181 QCOMPARE(QByteArray(typeid(*handler.data()).name()), className); 174​ QCOMPARE(typeName(handler), className);
182 } 175​ }
183 176​
184 void testFindAlwaysCommandNegative_data() 177​ void testFindAlwaysCommandNegative_data()
185 { 178​ {
186 setupTestData(); 179​ setupTestData();
187 addAuthCommands(); 180​ addAuthCommands();
188 addNonAuthCommands(); 181​ addNonAuthCommands();
189 addInvalidCommands(); 182​ addInvalidCommands();
190 } 183​ }
191 184​
192 void testFindAlwaysCommandNegative() 185​ void testFindAlwaysCommandNegative()
193 { 186​ {
194 QFETCH(Protocol::Command::Type, command); 187​ QFETCH(Protocol::Command::Type, command);
195 QFETCH(QByteArray, className); 188​ QFETCH(QByteArray, className);
196 189​
197 QScopedPointer<Handler> handler(Handler::findHandlerForCommandAlwaysAllowed(command)); 190​ const auto handler = Handler::findHandlerForCommandAlwaysAllowed(command);
198 QVERIFY(handler.isNull()); 191​ QVERIFY(!handler);
199 } 192​ }
200}; 193​};
201 194​
202AKTEST_MAIN(HandlerTest) 195​AKTEST_MAIN(HandlerTest)
203 196​
204#include "handlertest.moc" 197​#include "handlertest.moc"