PuzzleSDK
Public 成员函数 | 所有成员列表
ParseUriTest类 参考

#include <UnitTest.h>

+ 类 ParseUriTest 继承关系图:
+ ParseUriTest 的协作图:

Public 成员函数

 CREATE_FUNC (ParseUriTest)
 
virtual void onEnter () override
 
virtual std::string subtitle () const override
 
- Public 成员函数 继承自 UnitTestDemo
virtual std::string title () const override
 
- Public 成员函数 继承自 TestCase
 TestCase ()
 
 ~TestCase ()
 
virtual Type getTestType () const
 
virtual float getDuration () const
 
virtual std::string getExpectedOutput () const
 
virtual std::string getActualOutput () const
 
virtual void restartTestCallback (cocos2d::Ref *sender)
 
virtual void nextTestCallback (cocos2d::Ref *sender)
 
virtual void priorTestCallback (cocos2d::Ref *sender)
 
virtual void onBackCallback (cocos2d::Ref *sender)
 
void setTestSuite (TestSuite *testSuite)
 
TestSuite * getTestSuite () const
 
float getRunTime () const
 
void setTestCaseName (const std::string &name)
 
std::string getTestCaseName () const
 
const cocos2d::Label * getSubtitleLable () const
 
const cocos2d::MenuItemImage * getRestartTestItem () const
 

额外继承的成员函数

- Public 类型 继承自 TestCase
enum class  Type { ROBUSTNESS , UNIT , GRAPHICAL_STATIC , MANUAL }
 
- Public 属性 继承自 TestCase
CC_CONSTRUCTOR_ACCESS __pad0__: virtual bool init() override
 
- Protected 属性 继承自 TestCase
cocos2d::MenuItemImage * _priorTestItem
 
cocos2d::MenuItemImage * _restartTestItem
 
cocos2d::MenuItemImage * _nextTestItem
 
cocos2d::Label * _titleLabel
 
cocos2d::Label * _subtitleLabel
 

详细描述

在文件 UnitTest.h 第 91 行定义.

成员函数说明

◆ CREATE_FUNC()

ParseUriTest::CREATE_FUNC ( ParseUriTest  )

◆ onEnter()

void ParseUriTest::onEnter ( )
overridevirtual

重载 TestCase .

在文件 UnitTest.cpp 第 955 行定义.

956{
957 UnitTestDemo::onEnter();
958
959 {
960 std::string s("http://www.facebook.com/hello/world?query#fragment");
961 Uri u = Uri::parse(s);
962 EXPECT_EQ("http", u.getScheme());
963 EXPECT_EQ("", u.getUserName());
964 EXPECT_EQ("", u.getPassword());
965 EXPECT_EQ("www.facebook.com", u.getHost());
966 EXPECT_EQ(0, u.getPort());
967 EXPECT_EQ("www.facebook.com", u.getAuthority());
968 EXPECT_EQ("/hello/world", u.getPath());
969 EXPECT_EQ("query", u.getQuery());
970 EXPECT_EQ("fragment", u.getFragment());
971 EXPECT_EQ(s, u.toString()); // canonical
972 }
973
974 {
975 std::string s("http://www.facebook.com:8080/hello/world?query#fragment");
976 Uri u = Uri::parse(s);
977 EXPECT_EQ("http", u.getScheme());
978 EXPECT_EQ("", u.getUserName());
979 EXPECT_EQ("", u.getPassword());
980 EXPECT_EQ("www.facebook.com", u.getHost());
981 EXPECT_EQ(8080, u.getPort());
982 EXPECT_EQ("www.facebook.com:8080", u.getAuthority());
983 EXPECT_EQ("/hello/world", u.getPath());
984 EXPECT_EQ("query", u.getQuery());
985 EXPECT_EQ("fragment", u.getFragment());
986 EXPECT_EQ(s, u.toString()); // canonical
987 }
988
989 {
990 std::string s("http://127.0.0.1:8080/hello/world?query#fragment");
991 Uri u = Uri::parse(s);
992 EXPECT_EQ("http", u.getScheme());
993 EXPECT_EQ("", u.getUserName());
994 EXPECT_EQ("", u.getPassword());
995 EXPECT_EQ("127.0.0.1", u.getHost());
996 EXPECT_EQ(8080, u.getPort());
997 EXPECT_EQ("127.0.0.1:8080", u.getAuthority());
998 EXPECT_EQ("/hello/world", u.getPath());
999 EXPECT_EQ("query", u.getQuery());
1000 EXPECT_EQ("fragment", u.getFragment());
1001 EXPECT_EQ(s, u.toString()); // canonical
1002 }
1003
1004 {
1005 std::string s("http://[::1]:8080/hello/world?query#fragment");
1006 Uri u = Uri::parse(s);
1007 EXPECT_EQ("http", u.getScheme());
1008 EXPECT_EQ("", u.getUserName());
1009 EXPECT_EQ("", u.getPassword());
1010 EXPECT_EQ("[::1]", u.getHost());
1011 EXPECT_EQ("::1", u.getHostName());
1012 EXPECT_EQ(8080, u.getPort());
1013 EXPECT_EQ("[::1]:8080", u.getAuthority());
1014 EXPECT_EQ("/hello/world", u.getPath());
1015 EXPECT_EQ("query", u.getQuery());
1016 EXPECT_EQ("fragment", u.getFragment());
1017 EXPECT_EQ(s, u.toString()); // canonical
1018 }
1019
1020 {
1021 std::string s("http://[2401:db00:20:7004:face:0:29:0]:8080/hello/world?query");
1022 Uri u = Uri::parse(s);
1023 EXPECT_EQ("http", u.getScheme());
1024 EXPECT_EQ("", u.getUserName());
1025 EXPECT_EQ("", u.getPassword());
1026 EXPECT_EQ("[2401:db00:20:7004:face:0:29:0]", u.getHost());
1027 EXPECT_EQ("2401:db00:20:7004:face:0:29:0", u.getHostName());
1028 EXPECT_EQ(8080, u.getPort());
1029 EXPECT_EQ("[2401:db00:20:7004:face:0:29:0]:8080", u.getAuthority());
1030 EXPECT_EQ("/hello/world", u.getPath());
1031 EXPECT_EQ("query", u.getQuery());
1032 EXPECT_EQ("", u.getFragment());
1033 EXPECT_EQ(s, u.toString()); // canonical
1034 }
1035
1036 {
1037 std::string s("http://[2401:db00:20:7004:face:0:29:0]/hello/world?query");
1038 Uri u = Uri::parse(s);
1039 EXPECT_EQ("http", u.getScheme());
1040 EXPECT_EQ("", u.getUserName());
1041 EXPECT_EQ("", u.getPassword());
1042 EXPECT_EQ("[2401:db00:20:7004:face:0:29:0]", u.getHost());
1043 EXPECT_EQ("2401:db00:20:7004:face:0:29:0", u.getHostName());
1044 EXPECT_EQ(0, u.getPort());
1045 EXPECT_EQ("[2401:db00:20:7004:face:0:29:0]", u.getAuthority());
1046 EXPECT_EQ("/hello/world", u.getPath());
1047 EXPECT_EQ("query", u.getQuery());
1048 EXPECT_EQ("", u.getFragment());
1049 EXPECT_EQ(s, u.toString()); // canonical
1050 }
1051
1052 {
1053 std::string s("http://user:pass@host.com/");
1054 Uri u = Uri::parse(s);
1055 EXPECT_EQ("http", u.getScheme());
1056 EXPECT_EQ("user", u.getUserName());
1057 EXPECT_EQ("pass", u.getPassword());
1058 EXPECT_EQ("host.com", u.getHost());
1059 EXPECT_EQ(0, u.getPort());
1060 EXPECT_EQ("user:pass@host.com", u.getAuthority());
1061 EXPECT_EQ("/", u.getPath());
1062 EXPECT_EQ("", u.getQuery());
1063 EXPECT_EQ("", u.getFragment());
1064 EXPECT_EQ(s, u.toString());
1065 }
1066
1067 {
1068 std::string s("http://user@host.com/");
1069 Uri u = Uri::parse(s);
1070 EXPECT_EQ("http", u.getScheme());
1071 EXPECT_EQ("user", u.getUserName());
1072 EXPECT_EQ("", u.getPassword());
1073 EXPECT_EQ("host.com", u.getHost());
1074 EXPECT_EQ(0, u.getPort());
1075 EXPECT_EQ("user@host.com", u.getAuthority());
1076 EXPECT_EQ("/", u.getPath());
1077 EXPECT_EQ("", u.getQuery());
1078 EXPECT_EQ("", u.getFragment());
1079 EXPECT_EQ(s, u.toString());
1080 }
1081
1082 {
1083 std::string s("http://user:@host.com/");
1084 Uri u = Uri::parse(s);
1085 EXPECT_EQ("http", u.getScheme());
1086 EXPECT_EQ("user", u.getUserName());
1087 EXPECT_EQ("", u.getPassword());
1088 EXPECT_EQ("host.com", u.getHost());
1089 EXPECT_EQ(0, u.getPort());
1090 EXPECT_EQ("user@host.com", u.getAuthority());
1091 EXPECT_EQ("/", u.getPath());
1092 EXPECT_EQ("", u.getQuery());
1093 EXPECT_EQ("", u.getFragment());
1094 EXPECT_EQ("http://user@host.com/", u.toString());
1095 }
1096
1097 {
1098 std::string s("http://:pass@host.com/");
1099 Uri u = Uri::parse(s);
1100 EXPECT_EQ("http", u.getScheme());
1101 EXPECT_EQ("", u.getUserName());
1102 EXPECT_EQ("pass", u.getPassword());
1103 EXPECT_EQ("host.com", u.getHost());
1104 EXPECT_EQ(0, u.getPort());
1105 EXPECT_EQ(":pass@host.com", u.getAuthority());
1106 EXPECT_EQ("/", u.getPath());
1107 EXPECT_EQ("", u.getQuery());
1108 EXPECT_EQ("", u.getFragment());
1109 EXPECT_EQ(s, u.toString());
1110 }
1111
1112 {
1113 std::string s("http://@host.com/");
1114 Uri u = Uri::parse(s);
1115 EXPECT_EQ("http", u.getScheme());
1116 EXPECT_EQ("", u.getUserName());
1117 EXPECT_EQ("", u.getPassword());
1118 EXPECT_EQ("host.com", u.getHost());
1119 EXPECT_EQ(0, u.getPort());
1120 EXPECT_EQ("host.com", u.getAuthority());
1121 EXPECT_EQ("/", u.getPath());
1122 EXPECT_EQ("", u.getQuery());
1123 EXPECT_EQ("", u.getFragment());
1124 EXPECT_EQ("http://host.com/", u.toString());
1125 }
1126
1127 {
1128 std::string s("http://:@host.com/");
1129 Uri u = Uri::parse(s);
1130 EXPECT_EQ("http", u.getScheme());
1131 EXPECT_EQ("", u.getUserName());
1132 EXPECT_EQ("", u.getPassword());
1133 EXPECT_EQ("host.com", u.getHost());
1134 EXPECT_EQ(0, u.getPort());
1135 EXPECT_EQ("host.com", u.getAuthority());
1136 EXPECT_EQ("/", u.getPath());
1137 EXPECT_EQ("", u.getQuery());
1138 EXPECT_EQ("", u.getFragment());
1139 EXPECT_EQ("http://host.com/", u.toString());
1140 }
1141
1142 {
1143 std::string s("file:///etc/motd");
1144 Uri u = Uri::parse(s);
1145 EXPECT_EQ("file", u.getScheme());
1146 EXPECT_EQ("", u.getUserName());
1147 EXPECT_EQ("", u.getPassword());
1148 EXPECT_EQ("", u.getHost());
1149 EXPECT_EQ(0, u.getPort());
1150 EXPECT_EQ("", u.getAuthority());
1151 EXPECT_EQ("/etc/motd", u.getPath());
1152 EXPECT_EQ("", u.getQuery());
1153 EXPECT_EQ("", u.getFragment());
1154 EXPECT_EQ(s, u.toString());
1155 }
1156
1157 {
1158 std::string s("file://etc/motd");
1159 Uri u = Uri::parse(s);
1160 EXPECT_EQ("file", u.getScheme());
1161 EXPECT_EQ("", u.getUserName());
1162 EXPECT_EQ("", u.getPassword());
1163 EXPECT_EQ("etc", u.getHost());
1164 EXPECT_EQ(0, u.getPort());
1165 EXPECT_EQ("etc", u.getAuthority());
1166 EXPECT_EQ("/motd", u.getPath());
1167 EXPECT_EQ("", u.getQuery());
1168 EXPECT_EQ("", u.getFragment());
1169 EXPECT_EQ(s, u.toString());
1170 }
1171
1172 {
1173 // test query parameters
1174 std::string s("http://localhost?&key1=foo&key2=&key3&=bar&=bar=&");
1175 Uri u = Uri::parse(s);
1176 auto paramsList = u.getQueryParams();
1177 std::map<std::string, std::string> params;
1178 for (auto& param : paramsList) {
1179 params[param.first] = param.second;
1180 }
1181 EXPECT_EQ(3, params.size());
1182 EXPECT_EQ("foo", params["key1"]);
1183 EXPECT_NE(params.end(), params.find("key2"));
1184 EXPECT_EQ("", params["key2"]);
1185 EXPECT_NE(params.end(), params.find("key3"));
1186 EXPECT_EQ("", params["key3"]);
1187 }
1188
1189 {
1190 // test query parameters
1191 std::string s("http://localhost?&&&&&&&&&&&&&&&");
1192 Uri u = Uri::parse(s);
1193 auto params = u.getQueryParams();
1194 EXPECT_TRUE(params.empty());
1195 }
1196
1197 {
1198 // test query parameters
1199 std::string s("http://localhost?&=invalid_key&key2&key3=foo");
1200 Uri u = Uri::parse(s);
1201 auto paramsList = u.getQueryParams();
1202 std::map<std::string, std::string> params;
1203 for (auto& param : paramsList) {
1204 params[param.first] = param.second;
1205 }
1206 EXPECT_EQ(2, params.size());
1207 EXPECT_NE(params.end(), params.find("key2"));
1208 EXPECT_EQ("", params["key2"]);
1209 EXPECT_EQ("foo", params["key3"]);
1210 }
1211
1212 {
1213 // test query parameters
1214 std::string s("http://localhost?&key1=====&&=key2&key3=");
1215 Uri u = Uri::parse(s);
1216 auto paramsList = u.getQueryParams();
1217 std::map<std::string, std::string> params;
1218 for (auto& param : paramsList) {
1219 params[param.first] = param.second;
1220 }
1221 EXPECT_EQ(1, params.size());
1222 EXPECT_NE(params.end(), params.find("key3"));
1223 EXPECT_EQ("", params["key3"]);
1224 }
1225
1226 {
1227 // test query parameters
1228 std::string s("ws://localhost:90?key1=foo=bar&key2=foobar&");
1229 Uri u = Uri::parse(s);
1230 auto paramsList = u.getQueryParams();
1231 std::map<std::string, std::string> params;
1232 for (auto& param : paramsList) {
1233 params[param.first] = param.second;
1234 }
1235 EXPECT_EQ(1, params.size());
1236 EXPECT_EQ("foobar", params["key2"]);
1237
1238 // copy constructor
1239 {
1240 Uri v(u);
1241 u = v = u;
1242 EXPECT_TRUE(v.isValid());
1243 EXPECT_EQ("ws", v.getScheme());
1244 EXPECT_EQ("localhost", v.getHost());
1245 EXPECT_EQ("localhost", v.getHostName());
1246 EXPECT_EQ("", v.getPath());
1247 EXPECT_EQ(90, v.getPort());
1248 EXPECT_EQ("", v.getFragment());
1249 EXPECT_EQ("key1=foo=bar&key2=foobar&", v.getQuery());
1250 EXPECT_EQ(u, v);
1251 }
1252
1253 // copy assign operator
1254 {
1255 Uri v;
1256 v = u;
1257 EXPECT_TRUE(v.isValid());
1258 EXPECT_EQ("ws", v.getScheme());
1259 EXPECT_EQ("localhost", v.getHost());
1260 EXPECT_EQ("localhost", v.getHostName());
1261 EXPECT_EQ("", v.getPath());
1262 EXPECT_EQ(90, v.getPort());
1263 EXPECT_EQ("", v.getFragment());
1264 EXPECT_EQ("key1=foo=bar&key2=foobar&", v.getQuery());
1265 EXPECT_EQ(u, v);
1266 }
1267
1268 // Self move assignment
1269 {
1270 u = u;
1271 EXPECT_TRUE(u.isValid());
1272 }
1273
1274 // Self move assignment
1275 {
1276 u = std::move(u);
1277 EXPECT_TRUE(u.isValid());
1278 }
1279
1280 // move constructor
1281 {
1282 Uri v = std::move(u);
1283 EXPECT_FALSE(u.isValid());
1284 EXPECT_TRUE(v.isValid());
1285 EXPECT_EQ("ws", v.getScheme());
1286 EXPECT_EQ("localhost", v.getHost());
1287 EXPECT_EQ("localhost", v.getHostName());
1288 EXPECT_EQ("", v.getPath());
1289 EXPECT_EQ(90, v.getPort());
1290 EXPECT_EQ("", v.getFragment());
1291 EXPECT_EQ("key1=foo=bar&key2=foobar&", v.getQuery());
1292 u = std::move(v);
1293 }
1294
1295 // copy assign operator
1296 {
1297 Uri v;
1298 v = std::move(u);
1299 EXPECT_FALSE(u.isValid());
1300 EXPECT_TRUE(v.isValid());
1301 EXPECT_EQ("ws", v.getScheme());
1302 EXPECT_EQ("localhost", v.getHost());
1303 EXPECT_EQ("localhost", v.getHostName());
1304 EXPECT_EQ("", v.getPath());
1305 EXPECT_EQ(90, v.getPort());
1306 EXPECT_EQ("", v.getFragment());
1307 EXPECT_EQ("key1=foo=bar&key2=foobar&", v.getQuery());
1308 u = v;
1309 }
1310 }
1311
1312 {
1313 std::string s("2http://www.facebook.com");
1314
1315 Uri u = Uri::parse(s);
1316 EXPECT_FALSE(u.isValid());
1317 }
1318
1319 {
1320 std::string s("www[facebook]com");
1321
1322 Uri u = Uri::parse("http://" + s);
1323 EXPECT_FALSE(u.isValid());
1324 }
1325
1326 {
1327 std::string s("http://[::1:8080/hello/world?query#fragment");
1328 Uri u = Uri::parse(s);
1329 EXPECT_FALSE(u.isValid());
1330 }
1331
1332 {
1333 std::string s("http://::1]:8080/hello/world?query#fragment");
1334
1335 Uri u = Uri::parse(s);
1336 EXPECT_FALSE(u.isValid());
1337 }
1338
1339 {
1340 std::string s("http://::1:8080/hello/world?query#fragment");
1341 Uri u = Uri::parse(s);
1342 EXPECT_FALSE(u.isValid());
1343 }
1344
1345 {
1346 std::string s("http://2401:db00:20:7004:face:0:29:0/hello/world?query");
1347 Uri u = Uri::parse(s);
1348 EXPECT_FALSE(u.isValid());
1349 }
1350
1351 {
1352 Uri http = Uri::parse("http://google.com");
1353 Uri https = Uri::parse("https://www.google.com:90");
1354 Uri query = Uri::parse("http://google.com:8080/foo/bar?foo=bar");
1355 Uri localhost = Uri::parse("http://localhost:8080");
1356 Uri ipv6 = Uri::parse("https://[2001:0db8:85a3:0042:1000:8a2e:0370:7334]");
1357 Uri ipv6short = Uri::parse("http://[2001:db8:85a3:42:1000:8a2e:370:7334]");
1358 Uri ipv6port = Uri::parse("http://[2001:db8:85a3:42:1000:8a2e:370:7334]:90");
1359 Uri ipv6abbrev = Uri::parse("http://[2001::7334:a:90]");
1360 Uri ipv6http = Uri::parse("http://[2001::7334:a]:90");
1361 Uri ipv6query = Uri::parse("http://[2001::7334:a]:90/foo/bar?foo=bar");
1362
1363 EXPECT_EQ(http.getScheme(), "http");
1364 EXPECT_EQ(http.getPort(), 0);
1365 EXPECT_EQ(http.getHost(), "google.com");
1366 EXPECT_EQ(https.getScheme(), "https");
1367 EXPECT_EQ(https.getPort(), 90);
1368 EXPECT_EQ(https.getHost(), "www.google.com");
1369 EXPECT_EQ(query.getPort(), 8080);
1370 EXPECT_EQ(query.getPathEtc(), "/foo/bar?foo=bar");
1371 EXPECT_EQ(localhost.getScheme(), "http");
1372 EXPECT_EQ(localhost.getHost(), "localhost");
1373 EXPECT_EQ(localhost.getPort(), 8080);
1374 EXPECT_EQ(ipv6.getScheme(), "https");
1375 EXPECT_EQ(ipv6.getHostName(), "2001:0db8:85a3:0042:1000:8a2e:0370:7334");
1376 EXPECT_EQ(ipv6.getPort(), 0);
1377 EXPECT_EQ(ipv6short.getScheme(), "http");
1378 EXPECT_EQ(ipv6short.getHostName(), "2001:db8:85a3:42:1000:8a2e:370:7334");
1379 EXPECT_EQ(ipv6short.getPort(), 0);
1380 EXPECT_EQ(ipv6port.getScheme(), "http");
1381 EXPECT_EQ(ipv6port.getHostName(), "2001:db8:85a3:42:1000:8a2e:370:7334");
1382 EXPECT_EQ(ipv6port.getPort(), 90);
1383 EXPECT_EQ(ipv6abbrev.getScheme(), "http");
1384 EXPECT_EQ(ipv6abbrev.getHostName(), "2001::7334:a:90");
1385 EXPECT_EQ(ipv6abbrev.getPort(), 0);
1386 EXPECT_EQ(ipv6http.getScheme(), "http");
1387 EXPECT_EQ(ipv6http.getPort(), 90);
1388 EXPECT_EQ(ipv6http.getHostName(), "2001::7334:a");
1389 EXPECT_EQ(ipv6query.getScheme(), "http");
1390 EXPECT_EQ(ipv6query.getPort(), 90);
1391 EXPECT_EQ(ipv6query.getHostName(), "2001::7334:a");
1392 EXPECT_EQ(ipv6query.getPathEtc(), "/foo/bar?foo=bar");
1393 }
1394
1395 {
1396 Uri u0 = Uri::parse("http://localhost:84/foo.html?&q=123");
1397 Uri u1 = Uri::parse("https://localhost:82/foo.html?&q=1");
1398 Uri u2 = Uri::parse("ws://localhost/foo");
1399 Uri u3 = Uri::parse("localhost/foo");
1400 Uri u4 = Uri::parse("localhost:8080");
1401 Uri u5 = Uri::parse("bb://localhost?&foo=12:4&ccc=13");
1402 Uri u6 = Uri::parse("cc://localhost:91?&foo=321&bbb=1");
1403
1404 EXPECT_EQ(u0.getScheme(), "http");
1405 EXPECT_EQ(u0.getHost(), "localhost");
1406 EXPECT_EQ(u0.getPort(), 84);
1407 EXPECT_EQ(u0.getPath(), "/foo.html");
1408 EXPECT_EQ(u0.getPathEtc(), "/foo.html?&q=123");
1409
1410 EXPECT_EQ(u1.getScheme(), "https");
1411 EXPECT_EQ(u1.getHost(), "localhost");
1412 EXPECT_EQ(u1.getPort(), 82);
1413 EXPECT_EQ(u1.getPathEtc(), "/foo.html?&q=1");
1414
1415 EXPECT_EQ(u2.getScheme(), "ws");
1416 EXPECT_EQ(u2.getHost(), "localhost");
1417 EXPECT_EQ(u2.getPort(), 0);
1418 EXPECT_EQ(u2.getPath(), "/foo");
1419
1420 EXPECT_EQ(u3.getScheme(), "");
1421 EXPECT_EQ(u3.getHost(), "localhost");
1422 EXPECT_EQ(u3.getPort(), 0);
1423 EXPECT_EQ(u3.getPath(), "/foo");
1424
1425 EXPECT_EQ(u4.getScheme(), "");
1426 EXPECT_EQ(u4.getHost(), "localhost");
1427 EXPECT_EQ(u4.getPort(), 8080);
1428 EXPECT_EQ(u4.getPath(), "");
1429 EXPECT_EQ(u4.getPathEtc(), "");
1430
1431 EXPECT_EQ(u5.getScheme(), "bb");
1432 EXPECT_EQ(u5.getHost(), "localhost");
1433 EXPECT_EQ(u5.getPort(), 0);
1434 EXPECT_EQ(u5.getPath(), "");
1435 EXPECT_EQ(u5.getPathEtc(), "?&foo=12:4&ccc=13");
1436 EXPECT_EQ(u5.getQuery(), "&foo=12:4&ccc=13");
1437
1438 EXPECT_EQ(u6.getScheme(), "cc");
1439 EXPECT_EQ(u6.getHost(), "localhost");
1440 EXPECT_EQ(u6.getPort(), 91);
1441 EXPECT_EQ(u6.getPath(), "");
1442 EXPECT_EQ(u6.getPathEtc(), "?&foo=321&bbb=1");
1443 EXPECT_EQ(u6.getQuery(), "&foo=321&bbb=1");
1444 }
1445
1446}
EXPECT_NE
#define EXPECT_NE(a, b)
Definition: UnitTest.cpp:64
EXPECT_TRUE
#define EXPECT_TRUE(a)
Definition: UnitTest.cpp:65
EXPECT_FALSE
#define EXPECT_FALSE(a)
Definition: UnitTest.cpp:66
EXPECT_EQ
#define EXPECT_EQ(a, b)
Definition: UnitTest.cpp:63
TestCase::onEnter
virtual void onEnter() override
Definition: BaseTest.cpp:430

引用了 EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, EXPECT_TRUE , 以及 TestCase::onEnter().

+ 函数调用图:

◆ subtitle()

std::string ParseUriTest::subtitle ( ) const
overridevirtual

重载 TestCase .

在文件 UnitTest.cpp 第 1448 行定义.

1449{
1450 return "Uri::parse Test";
1451}
该类的文档由以下文件生成: