开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
http-reader-test.cpp.svn-base
资源名称：openkore-2.0.7.zip　[点击查看]
上传用户：market2
上传日期：2018-11-18
资源大小：18786k
文件大小：11k
源码类别：

外挂编程

开发平台：

Windows_Unix

http-reader-test.cpp.svn-base：源码内容
  1. /*  HttpReader unit test program
  2.  *  Copyright (C) 2006   Written by VCL
  3.  *
  4.  *  This program is free software; you can redistribute it and/or modify
  5.  *  it under the terms of the GNU General Public License as published by
  6.  *  the Free Software Foundation; either version 2 of the License, or
  7.  *  (at your option) any later version.
  8.  *
  9.  *  This program is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *  GNU General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU General Public License
  15.  *  along with this program; if not, write to the Free Software
  16.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17.  */
  18. #undef NDEBUG
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <assert.h>
  23. #include <time.h>
  24. #include <list>
  26. #ifdef WIN32
  27. #define WIN32_LEAN_AND_MEAN
  28. #include <windows.h>
  29. #else
  30. #include <unistd.h>
  31. #define Sleep(miliseconds) usleep(miliseconds * 1000)
  32. #endif
  34. #include "std-http-reader.h"
  35. #include "mirror-http-reader.h"
  37. using namespace std;
  38. using namespace OpenKore;
  41. typedef HttpReader * (*HttpReaderCreator) (const char *url);
  42. typedef HttpReader * (*HttpReaderPostCreator) (const char *url, const char *postData, int postDataSize);
  44. #define SMALL_TEST_URL "http://www.openkore.com/test/HttpReader.txt"
  45. #define SMALL_TEST_CONTENT "Hello world!n"
  46. #define SMALL_TEST_SIZE 13
  47. #define SMALL_TEST_CHECKSUM 2773980202U
  49. #define LARGE_TEST_URL "http://www.openkore.com:80/test/HttpReaderLarge.txt"
  50. #define LARGE_TEST_SIZE 74048
  51. #define LARGE_TEST_CHECKSUM 1690026430U
  53. #define SLOW_TEST_URL "http://kambing.vlsm.org/gnu/gcc/gcc-4.1.0/gcc-core-4.1.0.tar.bz2"
  55. #define ERROR_URL "http://www.openkore.com/test/FileNotFound.txt"
  56. #define INVALID_URL "http://111.111.111.111:82/"
  57. #define INVALID_URL2 "http://www.fooooooo.com"
  58. #define SECURE_URL "https://sourceforge.net"
  60. #define POST_TEST_URL "http://www.openkore.com/test/TestPost.php"
  61. #define POST_TEST_DATA "mydata=hello+world"
  64. static HttpReader *
  65. createStdHttpReader(const char *url) {
  66. return StdHttpReader::create(url);
  67. }
  69. static HttpReader *
  70. createStdHttpReaderPost(const char *url, const char *postData, int postDataSize) {
  71. return StdHttpReader::createAndPost(url, postData, postDataSize);
  72. }
  74. static HttpReader *
  75. createMirrorHttpReader(const char *url) {
  76. list<const char *> urls;
  77. urls.push_back(url);
  78. return new MirrorHttpReader(urls, 3000);
  79. }
  82. /**
  83.  * A class for testing a HttpReader implementation.
  84.  */
  85. class Tester {
  86. public:
  87. /**
  88.  * Create a new Tester object.
  89.  *
  90.  * @param creatorFunc  A function which creates a HttpReader instance.
  91.  * @require creatorFunc != NULL
  92.  */
  93. Tester(HttpReaderCreator creatorFunc, HttpReaderPostCreator creatorPostFunc) {
  94. this->createHttpReader = creatorFunc;
  95. this->createHttpReaderPost = creatorPostFunc;
  96. }
  98. virtual ~Tester() {}
  100. /** Run the unit tests. */
  101. void
  102. virtual run() {
  103. printf("Testing status transitions (1)...n");
  104. assert( testStatusTransitions(SMALL_TEST_URL) );
  105. printf("Testing status transitions (2)...n");
  106. assert( testStatusTransitions(LARGE_TEST_URL) );
  107. printf("Testing status transitions (3)...n");
  108. assert( !testStatusTransitions(ERROR_URL) );
  109. printf("Testing status transitions (4)...n");
  110. assert( testStatusTransitions(SECURE_URL) );
  111. printf("Testing status transitions (5)...n");
  113. printf("Testing getData (1)...n");
  114. assert( testGetData(SMALL_TEST_URL, SMALL_TEST_CONTENT, SMALL_TEST_SIZE) );
  115. printf("Testing getData (2)...n");
  116. assert( testGetData(LARGE_TEST_URL, NULL, LARGE_TEST_SIZE) );
  117. printf("Testing getData (3)...n");
  118. assert( !testGetData(ERROR_URL, NULL, 0) );
  119. printf("Testing getData (4)...n");
  120. assert( !testGetData(INVALID_URL2, NULL, 0) );
  122. printf("Testing pullData (1)...n");
  123. assert( testPullData(SMALL_TEST_URL, SMALL_TEST_SIZE, SMALL_TEST_CHECKSUM) );
  124. printf("Testing pullData (2)...n");
  125. assert( testPullData(LARGE_TEST_URL, LARGE_TEST_SIZE, LARGE_TEST_CHECKSUM) );
  126. printf("Testing pullData (3)...n");
  127. assert( !testPullData(ERROR_URL, 0, 0) );
  128. printf("Testing pullData (4)...n");
  129. assert( !testPullData(INVALID_URL2, 0, 0) );
  131. if (createHttpReaderPost != NULL) {
  132. printf("Testing POST...n");
  133. testPOST(POST_TEST_URL, POST_TEST_DATA);
  134. }
  136. printf("Testing cancellation while connecting (1)...n");
  137. testConnectCancellation(INVALID_URL);
  138. printf("Testing cancellation while connecting (2)...n");
  139. testConnectCancellation(INVALID_URL2);
  140. printf("Testing cancellation while downloading...n");
  141. testDownloadCancellation(SLOW_TEST_URL);
  142. }
  144. protected:
  145. /**
  146.  * Calculate a simple checksum of the specified data.
  147.  */
  148. unsigned int
  149. calcChecksum(const char *data, unsigned int len, unsigned int seed = 0) {
  150. for (unsigned int i = 0; i < len; i++) {
  151. seed = seed * 32 + data[i];
  152. }
  153. return seed;
  154. }
  156. private:
  157. HttpReaderCreator createHttpReader;
  158. HttpReaderPostCreator createHttpReaderPost;
  160. protected:
  161. // Test whether status transitions behave as documented.
  162. bool
  163. testStatusTransitions(const char *url) {
  164. HttpReader *http = createHttpReader(url);
  165. HttpReaderStatus status = HTTP_READER_CONNECTING;
  166. HttpReaderStatus oldStatus;
  168. do {
  169. oldStatus = status;
  170. status = http->getStatus();
  172. switch (oldStatus) {
  173. case HTTP_READER_CONNECTING:
  174. assert(status == HTTP_READER_CONNECTING
  175. || status == HTTP_READER_DOWNLOADING
  176. || status == HTTP_READER_DONE
  177. || status == HTTP_READER_ERROR);
  178. break;
  179. case HTTP_READER_DOWNLOADING:
  180. assert(status == HTTP_READER_DOWNLOADING
  181. || status == HTTP_READER_DONE
  182. || status == HTTP_READER_ERROR);
  183. break;
  184. case HTTP_READER_DONE:
  185. assert(status == HTTP_READER_DONE);
  186. break;
  187. case HTTP_READER_ERROR:
  188. assert(status == HTTP_READER_ERROR);
  189. break;
  190. default:
  191. printf("Unknown status %dn", (int) status);
  192. abort();
  193. break;
  194. };
  195. Sleep(10);
  196. } while (status != HTTP_READER_DONE && status != HTTP_READER_ERROR);
  198. Sleep(1000);
  199. if (status == HTTP_READER_DONE) {
  200. assert(http->getStatus() == HTTP_READER_DONE);
  201. } else {
  202. assert(http->getStatus() == HTTP_READER_ERROR);
  203. assert(http->getSize() == -2);
  204. }
  205. delete http;
  206. return status == HTTP_READER_DONE;
  207. }
  209. // Test whether getData() works
  210. bool
  211. testGetData(const char *url, const char *content, unsigned int size) {
  212. HttpReader *http = createHttpReader(url);
  213. while (http->getStatus() != HTTP_READER_DONE
  214.     && http->getStatus() != HTTP_READER_ERROR) {
  215. Sleep(10);
  216. }
  218. if (http->getStatus() != HTTP_READER_DONE) {
  219. assert(http->getSize() == -2);
  220. delete http;
  221. return false;
  222. }
  224. unsigned int downloadedLen = 0;
  225. const char *downloadedData = http->getData(downloadedLen);
  226. assert(downloadedLen == size);
  227. assert(http->getSize() == (int) size);
  228. if (content != NULL) {
  229. assert(strcmp(downloadedData, content) == 0);
  230. }
  231. delete http;
  232. return true;
  233. }
  235. // Test whether pullData() works
  236. bool
  237. testPullData(const char *url, unsigned int expectedSize, unsigned int expectedChecksum) {
  238. HttpReader *http = createHttpReader(url);
  239. bool result;
  240. unsigned int checksum = 0;
  241. unsigned int size = 0;
  242. char buffer[1024];
  243. int ret;
  244. bool done = false;
  246. while (http->getStatus() == HTTP_READER_CONNECTING) {
  247. Sleep(10);
  248. }
  249. while (!done) {
  250. ret = http->pullData(buffer, sizeof(buffer));
  251. if (ret == -1) {
  252. Sleep(10);
  254. } else if (ret > 0) {
  255. checksum = calcChecksum(buffer, ret, checksum);
  256. size += ret;
  258. } else if (ret == -2 || ret == 0) {
  259. done = true;
  261. } else {
  262. printf("pullData() returned an invalid value: %dn", ret);
  263. abort();
  264. }
  265. }
  267. result = http->getStatus() == HTTP_READER_DONE;
  268. if (result) {
  269. assert(expectedSize == size);
  270. assert(expectedChecksum == checksum);
  271. } else {
  272. assert(http->getSize() == -2);
  273. }
  275. delete http;
  276. return result;
  277. }
  279. // Test whether cancellation while connecting works.
  280. void
  281. testConnectCancellation(const char *url) {
  282. HttpReader *http = createHttpReader(url);
  283. time_t time1, time2;
  285. Sleep(1000);
  286. assert(http->getStatus() == HTTP_READER_CONNECTING
  287. || http->getStatus() == HTTP_READER_ERROR);
  288. time1 = time(NULL);
  289. delete http;
  290. time2 = time(NULL);
  291. // Verify that cancellation doesn't take more than 2 seconds
  292. assert(time1 + 2 > time2);
  293. }
  295. // Test whether cancellation while downloading works.
  296. // You must pass an URL to a large file so that download
  297. // takes a while to complete.
  298. void
  299. testDownloadCancellation(const char *url) {
  300. HttpReader *http = createHttpReader(url);
  301. time_t time1, time2;
  303. while (http->getStatus() == HTTP_READER_CONNECTING) {
  304. Sleep(10);
  305. }
  306. assert(http->getStatus() == HTTP_READER_DOWNLOADING);
  307. Sleep(1000);
  309. time1 = time(NULL);
  310. delete http;
  311. time2 = time(NULL);
  312. assert(time1 + 2 > time2);
  313. }
  315. void testPOST(const char *url, const char *data) {
  316. HttpReader *http = createHttpReaderPost(url, data, -1);
  317. while (http->getStatus() != HTTP_READER_DONE
  318.     && http->getStatus() != HTTP_READER_ERROR) {
  319. Sleep(10);
  320. }
  322. assert(http->getStatus() == HTTP_READER_DONE);
  324. unsigned int downloadedLen = 0;
  325. const char *downloadedData = http->getData(downloadedLen);
  326. assert(strcmp(downloadedData, "yes") == 0);
  327. delete http;
  328. }
  329. };
  331. /**
  332.  * A class for testing MirrorHttpReader.
  333.  */
  334. class MirrorTester: public Tester {
  335. public:
  336. MirrorTester() : Tester(createMirrorHttpReader, NULL) {
  337. }
  339. virtual void
  340. run() {
  341. list<const char *> urls;
  342. Tester::run();
  344. printf("Testing usage of multiple mirrors (1)...n");
  345. urls.push_back(INVALID_URL);
  346. urls.push_back(ERROR_URL);
  347. urls.push_back(LARGE_TEST_URL);
  348. urls.push_back(SECURE_URL); // Will never be used
  349. assert( testMirrors(urls, LARGE_TEST_SIZE, LARGE_TEST_CHECKSUM) );
  351. printf("Testing usage of multiple mirrors (2)...n");
  352. urls.clear();
  353. urls.push_back(INVALID_URL);
  354. urls.push_back(ERROR_URL);
  355. urls.push_back("http://www.gnome.org:90");
  356. assert( !testMirrors(urls, 0, 0) );
  358. printf("Testing usage of multiple mirrors (3)...n");
  359. urls.clear();
  360. urls.push_back(SECURE_URL);
  361. urls.push_back(INVALID_URL); // Never used
  362. urls.push_back(ERROR_URL);   // ditto
  363. assert( testMirrors(urls, 0, 0) );
  365. printf("Testing getData (5)...n");
  366. assert( !testGetData(INVALID_URL, NULL, 0) );
  368. printf("Testing pullData (5)...n");
  369. assert( !testPullData(INVALID_URL, 0, 0) );
  370. }
  372. private:
  373. bool
  374. testMirrors(const list<const char *> &urls, unsigned int expectedSize,
  375.     unsigned int expectedChecksum) {
  376. HttpReader *http = new MirrorHttpReader(urls, 3000);
  377. HttpReaderStatus status;
  379. status = http->getStatus();
  380. while (status != HTTP_READER_DONE && status != HTTP_READER_ERROR) {
  381. Sleep(10);
  382. status = http->getStatus();
  383. }
  385. if (status == HTTP_READER_DONE && expectedChecksum != 0) {
  386. unsigned int len, checksum;
  387. const char *data;
  389. data = http->getData(len);
  390. assert(len == expectedSize);
  391. checksum = calcChecksum(data, len);
  392. assert(checksum == expectedChecksum);
  393. }
  394. delete http;
  395. return status == HTTP_READER_DONE;
  396. }
  397. };
  399. int
  400. main() {
  401. StdHttpReader::init();
  402. Tester *tester;
  404. printf("### StdHttpReadern");
  405. tester = new Tester(createStdHttpReader, createStdHttpReaderPost);
  406. tester->run();
  407. delete tester;
  409. printf("### MirrorHttpReadern");
  410. tester = new MirrorTester();
  411. tester->run();
  412. delete tester;
  414. return 0;
  415. }