diff --git a/src/tests/kits/net/Jamfile b/src/tests/kits/net/Jamfile index 1c4697578e..37d6ae27fa 100644 --- a/src/tests/kits/net/Jamfile +++ b/src/tests/kits/net/Jamfile @@ -26,12 +26,15 @@ SimpleTest NetAddressTest : NetAddressTest.cpp SimpleTest NetEndpointTest : NetEndpointTest.cpp : $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) be $(TARGET_LIBSUPC++) ; +SubInclude HAIKU_TOP src tests kits net cookie ; SubInclude HAIKU_TOP src tests kits net DialUpPreflet ; +SubInclude HAIKU_TOP src tests kits net icmp ; +SubInclude HAIKU_TOP src tests kits net ipv6 ; SubInclude HAIKU_TOP src tests kits net multicast ; SubInclude HAIKU_TOP src tests kits net netperf ; SubInclude HAIKU_TOP src tests kits net preflet ; SubInclude HAIKU_TOP src tests kits net sock ; SubInclude HAIKU_TOP src tests kits net tcp_shell ; SubInclude HAIKU_TOP src tests kits net tcptester ; -SubInclude HAIKU_TOP src tests kits net icmp ; -SubInclude HAIKU_TOP src tests kits net ipv6 ; +SubInclude HAIKU_TOP src tests kits net url ; +SubInclude HAIKU_TOP src tests kits net urlRequest ; diff --git a/src/tests/kits/net/cookie/Jamfile b/src/tests/kits/net/cookie/Jamfile new file mode 100644 index 0000000000..074d9ac3f9 --- /dev/null +++ b/src/tests/kits/net/cookie/Jamfile @@ -0,0 +1,6 @@ +SubDir HAIKU_TOP src tests kits net cookie ; + +Application cookie_test + : cookie_test.cpp + : be $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) $(TARGET_LIBSTDC++) + ; diff --git a/src/tests/kits/net/cookie/cookie_test.cpp b/src/tests/kits/net/cookie/cookie_test.cpp new file mode 100644 index 0000000000..ded674ce34 --- /dev/null +++ b/src/tests/kits/net/cookie/cookie_test.cpp @@ -0,0 +1,173 @@ +#include +#include +#include +#include +#include + +#include +#include + +#ifdef ASSERT +#undef ASSERT +#endif + +#define REPORT(i, assert, line) cout << "ASSERT() failed at line " << line \ + << ": " << #assert << " (test #" << i << ")" << endl +#define ASSERT(index, assertion) { if (!(assertion)) { REPORT(index, assertion, __LINE__ ); } } + + +using std::cout; +using std::endl; + + +typedef struct +{ + const char* cookieString; + + struct + { + const char* name; + const char* value; + const char* domain; + const char* path; + bool secure; + bool discard; + bool session; + int32 maxAge; + } expected; +} ExplodeTest; + +const ExplodeTest kTestExplode[] = + // Cookie string + // Name Value Domain Path Secure Discard Session maxAge + // -------- --------- --------- --------- ------ ------- -------- ------- + { + { "name=value", + { "name", "value", "", "", false, false, true, 0 } }, + { "name=value;secure=true", + { "name", "value", "", "", true, false, true, 0 } }, + { "name=value;secure=false;maxage=5", + { "name", "value", "", "", false, false, false, 5 } }, + { "name=value;discard=true", + { "name", "value", "", "", false, true, true, 0 } }, + }; + + +void explodeImplodeTest() +{ + uint8 testIndex; + BNetworkCookie cookie; + + for (testIndex = 0; testIndex < (sizeof(kTestExplode) / sizeof(ExplodeTest)); testIndex++) + { + cookie.ParseCookieString(kTestExplode[testIndex].cookieString); + + ASSERT(testIndex, BString(kTestExplode[testIndex].expected.name) == BString(cookie.Name())); + ASSERT(testIndex, BString(kTestExplode[testIndex].expected.value) == BString(cookie.Value())); + ASSERT(testIndex, BString(kTestExplode[testIndex].expected.domain) == BString(cookie.Domain())); + ASSERT(testIndex, BString(kTestExplode[testIndex].expected.path) == BString(cookie.Path())); + ASSERT(testIndex, kTestExplode[testIndex].expected.secure == cookie.Secure()); + ASSERT(testIndex, kTestExplode[testIndex].expected.discard == cookie.Discard()); + ASSERT(testIndex, kTestExplode[testIndex].expected.session == cookie.IsSessionCookie()); + + if (!cookie.IsSessionCookie()) + ASSERT(testIndex, kTestExplode[testIndex].expected.maxAge == cookie.MaxAge()); + } +} + + +void stressTest(int32 domainNumber, int32 totalCookies, char** flat, ssize_t* size) +{ + char **domains = new char*[domainNumber]; + + cout << "Creating random domains" << endl; + srand(time(NULL)); + for (int32 i = 0; i < domainNumber; i++) { + int16 charNum = (rand() % 16) + 1; + + domains[i] = new char[charNum + 5]; + + // Random domain + for (int32 c = 0; c < charNum; c++) + domains[i][c] = (rand() % 26) + 'a'; + + domains[i][charNum] = '.'; + + // Random tld + for (int32 c = 0; c < 3; c++) + domains[i][charNum+1+c] = (rand() % 26) + 'a'; + + domains[i][charNum+4] = 0; + } + + BNetworkCookieJar j; + BStopWatch* watch = new BStopWatch("Cookie insertion"); + for (int32 i = 0; i < totalCookies; i++) { + BNetworkCookie c; + int16 domain = (rand() % domainNumber); + BString name("Foo"); + name << i; + + c.SetName(name); + c.SetValue("Bar"); + c.SetDomain(domains[domain]); + c.SetPath("/"); + + j.AddCookie(c); + } + delete watch; + + BNetworkCookie* c; + int16 domain = (rand() % domainNumber); + BString host("http://"); + host << domains[domain] << "/"; + + watch = new BStopWatch("Cookie filtering"); + BUrl url(host); + int32 count = 0; + for (BNetworkCookieJar::UrlIterator it(j.GetUrlIterator(url)); (c = it.Next()); ) { + //for (BNetworkCookieJar::Iterator it(j.GetIterator()); c = it.Next(); ) { + count++; + } + delete watch; + cout << "Count for " << host << ": " << count << endl; + + + cout << "Flat view of cookie jar is " << j.FlattenedSize() << " bytes large." << endl; + *flat = new char[j.FlattenedSize()]; + *size = j.FlattenedSize(); + + if (j.Flatten(*flat, j.FlattenedSize()) == B_OK) + cout << "Flatten() success!" << endl; + else + cout << "Flatten() error!" << endl; + + delete[] domains; +} + + +int +main(int, char**) +{ + cout << "Running explodeImplodeTest:" << endl; + explodeImplodeTest(); + cout << endl << endl; + + cout << "Running stressTest:" << endl; + char* flatJar; + ssize_t size; + stressTest(10000, 40000, &flatJar, &size); + + BNetworkCookieJar j; + j.Unflatten(B_ANY_TYPE, flatJar, size); + + int32 count = 0; + BNetworkCookie* c; + for (BNetworkCookieJar::Iterator it(j.GetIterator()); (c = it.Next()); ) + count++; + cout << "Count : " << count << endl; + + delete[] flatJar; + + return EXIT_SUCCESS; +} diff --git a/src/tests/kits/net/url/Jamfile b/src/tests/kits/net/url/Jamfile new file mode 100644 index 0000000000..a5900b2398 --- /dev/null +++ b/src/tests/kits/net/url/Jamfile @@ -0,0 +1,6 @@ +SubDir HAIKU_TOP src tests kits net url ; + +Application url_test + : url_test.cpp + : be $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) $(TARGET_LIBSTDC++) + ; diff --git a/src/tests/kits/net/url/url_test.cpp b/src/tests/kits/net/url/url_test.cpp new file mode 100644 index 0000000000..c23010a595 --- /dev/null +++ b/src/tests/kits/net/url/url_test.cpp @@ -0,0 +1,116 @@ +#include +#include +#include +#include + +#include + +#ifdef ASSERT +#undef ASSERT +#endif + +#define REPORT(assert, line) cout << "ASSERT() failed at line " << line << ": " << #assert << endl +#define ASSERT(assertion) { if (!(assertion)) { REPORT(assertion, __LINE__ ); } } + +using namespace std; + +typedef struct +{ + const char* url; + + struct + { + const char* protocol; + const char* userName; + const char* password; + const char* host; + int16 port; + const char* path; + const char* request; + const char* fragment; + } expected; +} ExplodeTest; + + +const char* kTestLength[] = + { + "http://user:pass@www.foo.com:80/path?query#fragment", + "http://user:pass@www.foo.com:80/path?query#", + "http://user:pass@www.foo.com:80/path?query", + "http://user:pass@www.foo.com:80/path?", + "http://user:pass@www.foo.com:80/path", + "http://user:pass@www.foo.com:80/", + "http://user:pass@www.foo.com", + "http://user:pass@", + "http://www.foo.com", + "http://", + "http:" + }; + +const ExplodeTest kTestExplode[] = + // Url + // Protocol User Password Hostname Port Path Request Fragment + // -------- --------- --------- --------- ---- ---------- ---------- ------------ + { + { "http://user:pass@host:80/path?query#fragment", + { "http", "user", "pass", "host", 80, "/path", "query", "fragment" } }, + { "http://www.host.tld/path?query#fragment", + { "http", "", "", "www.host.tld",0, "/path", "query", "fragment" } } + }; + +// Test if rebuild url are the same length of parsed one +void lengthTest() +{ + int8 testIndex; + BUrl testUrl; + + for (testIndex = 0; kTestLength[testIndex] != NULL; testIndex++) + { + testUrl.SetUrlString(kTestLength[testIndex]); + + cout << "`" << kTestLength[testIndex] << "' vs `" << testUrl.UrlString() << "'" << endl; + ASSERT(strlen(kTestLength[testIndex]) == strlen(testUrl.UrlString())); + } +} + +void explodeImplodeTest() +{ + uint8 testIndex; + BUrl testUrl; + + for (testIndex = 0; testIndex < (sizeof(kTestExplode) / sizeof(ExplodeTest)); testIndex++) + { + testUrl.SetUrlString(kTestExplode[testIndex].url); + + ASSERT(BString(kTestExplode[testIndex].url) == BString(testUrl.UrlString())); + ASSERT(BString(kTestExplode[testIndex].expected.protocol) == BString(testUrl.Protocol())); + ASSERT(BString(kTestExplode[testIndex].expected.userName) == BString(testUrl.UserName())); + ASSERT(BString(kTestExplode[testIndex].expected.password) == BString(testUrl.Password())); + ASSERT(BString(kTestExplode[testIndex].expected.host) == BString(testUrl.Host())); + ASSERT(kTestExplode[testIndex].expected.port == testUrl.Port()); + ASSERT(BString(kTestExplode[testIndex].expected.path) == BString(testUrl.Path())); + ASSERT(BString(kTestExplode[testIndex].expected.request) == BString(testUrl.Request())); + ASSERT(BString(kTestExplode[testIndex].expected.fragment) == BString(testUrl.Fragment())); + } +} + +using std::cout; +using std::endl; + +int +main(int, char**) +{ + cout << "Running lengthTest:" << endl; + lengthTest(); + cout << endl; + + cout << "Running explodeImplodeTest:" << endl; + explodeImplodeTest(); + cout << endl; + + BUrl test = "lol"; + cout << "Path: " << test.HasPath() << " -> " << test.Path() << endl; + cout << "Rebuild: " << test.UrlString() << endl; + + return EXIT_SUCCESS; +} diff --git a/src/tests/kits/net/urlRequest/Jamfile b/src/tests/kits/net/urlRequest/Jamfile new file mode 100644 index 0000000000..93ac30039c --- /dev/null +++ b/src/tests/kits/net/urlRequest/Jamfile @@ -0,0 +1,26 @@ +SubDir HAIKU_TOP src tests kits net urlRequest ; + +Application urlRequest_test + : urlRequest_test.cpp + : be $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) $(TARGET_LIBSTDC++) + ; + +Application urlAuth_test + : urlAuth_test.cpp + : be $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) $(TARGET_LIBSTDC++) + ; + +Application urlUpload_test + : urlUpload_test.cpp + : be $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) $(TARGET_LIBSTDC++) + ; + +Application urlAuthBasic_test + : urlAuthBasic_test.cpp + : be $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) $(TARGET_LIBSTDC++) + ; + +Application urlProtocolListener_test + : urlProtocolListener_test.cpp + : be $(TARGET_NETWORK_LIBS) $(HAIKU_NETAPI_LIB) $(TARGET_LIBSTDC++) + ; diff --git a/src/tests/kits/net/urlRequest/myFile b/src/tests/kits/net/urlRequest/myFile new file mode 100644 index 0000000000..16f5be74fe --- /dev/null +++ b/src/tests/kits/net/urlRequest/myFile @@ -0,0 +1,3 @@ +Hello, world ! + +this is a file ... diff --git a/src/tests/kits/net/urlRequest/urlAuthBasic_test.cpp b/src/tests/kits/net/urlRequest/urlAuthBasic_test.cpp new file mode 100644 index 0000000000..515eaf71da --- /dev/null +++ b/src/tests/kits/net/urlRequest/urlAuthBasic_test.cpp @@ -0,0 +1,44 @@ +#include +#include +#include +#include + +#include +#include + +using std::cout; +using std::endl; + +int +main(int, char**) +{ + BUrl authTest("http://192.168.1.11/~chris/auth_basic/"); + BUrlRequest t(authTest); + BUrlContext c; + + t.SetContext(&c); + + t.SetProtocolOption(B_HTTPOPT_AUTHUSERNAME, (void*)"haiku"); + t.SetProtocolOption(B_HTTPOPT_AUTHPASSWORD, (void*)"haiku"); + + if (t.Perform() != B_OK) { + cout << "Error while performing request!" << endl; + return EXIT_FAILURE; + } + + // Do nothing while the request is not finished + while (t.IsRunning()) { + cout << std::flush; + snooze(10000); + } + + // Print the result + cout << "Request result : " << t.Result().StatusCode() << " (" << t.Result().StatusText() << ")" << endl; + //cout << " * " << c.GetCookieJar().CountCookies() << " cookies in context after request" << endl; + cout << " * " << t.Result().Headers().CountHeaders() << " headers received" << endl; + cout << " * " << t.Result().RawData().Position() << " bytes of raw data:" << endl; + cout << t.Result() << endl; + cout << "End of request" << endl << endl; + + return EXIT_SUCCESS; +} diff --git a/src/tests/kits/net/urlRequest/urlAuth_test.cpp b/src/tests/kits/net/urlRequest/urlAuth_test.cpp new file mode 100644 index 0000000000..8f2d658da0 --- /dev/null +++ b/src/tests/kits/net/urlRequest/urlAuth_test.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include + +#include +#include + +#ifdef ASSERT +#undef ASSERT +#endif + +#define REPORT(i, assert, line) cout << "ASSERT() failed at line " << line \ + << ": " << #assert << " (test #" << i << ")" << endl +#define ASSERT(index, assertion) { if (!(assertion)) { REPORT(index, assertion, __LINE__ ); } } + +using std::cout; +using std::endl; + +int +main(int, char**) +{ + BUrl authTest("http://192.168.1.11/~chris/auth_digest/"); + BUrlRequest t(authTest); + BUrlContext c; + + t.SetContext(&c); + + t.SetProtocolOption(B_HTTPOPT_AUTHUSERNAME, (void*)"haiku"); + t.SetProtocolOption(B_HTTPOPT_AUTHPASSWORD, (void*)"haiku"); + + if (t.Perform() != B_OK) { + cout << "Error while performing request!" << endl; + return EXIT_FAILURE; + } + + // Do nothing while the request is not finished + while (t.IsRunning()) { + cout << std::flush; + snooze(10000); + } + + // Print the result + cout << "Request result : " << t.Result().StatusCode() << " (" << t.Result().StatusText() << ")" << endl; + //cout << " * " << c.GetCookieJar().CountCookies() << " cookies in context after request" << endl; + cout << " * " << t.Result().Headers().CountHeaders() << " headers received" << endl; + cout << " * " << t.Result().RawData().Position() << " bytes of raw data:" << endl; + cout << t.Result() << endl; + cout << "End of request" << endl << endl; +} diff --git a/src/tests/kits/net/urlRequest/urlProtocolListener_test.cpp b/src/tests/kits/net/urlRequest/urlProtocolListener_test.cpp new file mode 100644 index 0000000000..e2e533f4aa --- /dev/null +++ b/src/tests/kits/net/urlRequest/urlProtocolListener_test.cpp @@ -0,0 +1,136 @@ +#include +#include +#include +#include + +#include +#include +#include +#include + + +class TestSyncListener : public BUrlProtocolListener { +public: + void ConnectionOpened(BUrlProtocol* caller) { + printf("Thread<#%5d> ", find_thread(NULL)); + printf("TestSyncListener::ConnectionOpened(%p)\n", caller); + } +}; + + +class TestAsyncListener : public BUrlProtocolAsynchronousListener { +public: + TestAsyncListener(bool transparent) + : + BUrlProtocolAsynchronousListener(transparent) + { } + + void ConnectionOpened(BUrlProtocol* caller) { + printf("Thread<#%5d> ", find_thread(NULL)); + printf("TestAsyncListener::ConnectionOpened(%p)\n", caller); + } +}; + + +class Test { + // Synchronous listener + TestSyncListener s; + + // Asynchronous listener with dispatcher not embedded + TestAsyncListener a; + BUrlProtocolDispatchingListener a_sync; + + // Asynchronous listener with embedded dispatcher + TestAsyncListener a_transparent; + +public: + Test() + : + a(false), + a_sync(&a), + a_transparent(true) + { } + + void testListener(BUrlProtocolListener* listener) + { + listener->ConnectionOpened((BUrlProtocol*)0xdeadbeef); + } + + + void DoTest() { + // Tests + printf("Launching test from thread #%5ld\n", find_thread(NULL)); + testListener(&s); + testListener(&a_sync); + testListener(a_transparent.SynchronousListener()); + } +}; + + +class TestThread { + Test t; + thread_id fThreadId; + +public: + thread_id Run() { + fThreadId = spawn_thread(&TestThread::_ThreadEntry, "TestThread", + B_NORMAL_PRIORITY, this); + + if (fThreadId < B_OK) + return fThreadId; + + status_t launchErr = resume_thread(fThreadId); + + if (launchErr < B_OK) + return launchErr; + + return fThreadId; + } + + static status_t _ThreadEntry(void* ptr) { + TestThread* parent = (TestThread*)ptr; + + parent->t.DoTest(); + return B_OK; + } +}; + + +class TestApp : public BApplication { + Test t; + TestThread t2; + +public: + TestApp() + : + BApplication("application/x-vnd.urlprotocollistener-test") + { } + + void ReadyToRun() { + t2.Run(); + t.DoTest(); + SetPulseRate(1000000); + } + + void Pulse() { + static int count = 0; + count++; + + if (count == 1) { + Quit(); + } + } +}; + + +int +main(int, char**) +{ + new TestApp(); + + // Let the async calls be handled + be_app->Run(); + + delete be_app; + return EXIT_SUCCESS; +} diff --git a/src/tests/kits/net/urlRequest/urlRequest_test.cpp b/src/tests/kits/net/urlRequest/urlRequest_test.cpp new file mode 100644 index 0000000000..00d9ed290a --- /dev/null +++ b/src/tests/kits/net/urlRequest/urlRequest_test.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include + +#include +#include + +using std::cout; +using std::endl; + +int +main(int, char**) +{ + BUrl yahoo("http://www.yahoo.fr"); + BUrlContext c; + BUrlRequest t(yahoo); + + t.SetContext(&c); + + if (!t.InitCheck()) { + cout << "URL request failed to initialize" << endl; + return EXIT_FAILURE; + } + + if (t.Perform() != B_OK) { + cout << "Error while performing request!" << endl; + return EXIT_FAILURE; + } + + // Do nothing while the request is not finished + while (t.IsRunning()) { + cout << std::flush; + snooze(10000); + } + + // Print the result + cout << "Request result : " << t.Result().StatusCode() << " (" << t.Result().StatusText() << ")" << endl; + //cout << " * " << c.GetCookieJar().CountCookies() << " cookies in context after request" << endl; + cout << " * " << t.Result().Headers().CountHeaders() << " headers received" << endl; + cout << " * " << t.Result().RawData().Position() << " bytes of raw data:" << endl; + cout << t.Result() << endl; + cout << "End of request" << endl << endl; + + // Flat view of the cookie jar : + cout << "cookie.txt :" << endl; + + ssize_t flatSize = c.GetCookieJar().FlattenedSize(); + char *flatCookieJar = new char[flatSize]; + + c.GetCookieJar().Flatten(flatCookieJar, flatSize); + + cout << flatCookieJar << endl << endl; + + return EXIT_SUCCESS; +} diff --git a/src/tests/kits/net/urlRequest/urlUpload_test.cpp b/src/tests/kits/net/urlRequest/urlUpload_test.cpp new file mode 100644 index 0000000000..80ce896019 --- /dev/null +++ b/src/tests/kits/net/urlRequest/urlUpload_test.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include + +#include +#include + +using std::cout; +using std::endl; + +int +main(int, char**) +{ + BUrl google("http://192.168.1.11/~chris/post.php"); + BUrlSynchronousRequest t(google); + BHttpForm f; + + f.AddString("hello", "world"); + if (f.AddFile("_uploadfile", BPath("libservices.so")) != B_OK) { + cout << "File upload failed" << endl; + return EXIT_FAILURE; + } + + // Print form + for (BHttpForm::Iterator it(f.GetIterator()); BHttpFormData* element = it.Next(); ) { + cout << element->Name() << ": " << element->Type() << endl; + } + + if (!t.InitCheck()) { + cout << "URL request failed to initialize" << endl; + return EXIT_FAILURE; + } + + // Inject form in request + bool discard = true; + t.SetProtocolOption(B_HTTPOPT_DISCARD_DATA, &discard); + t.SetProtocolOption(B_HTTPOPT_POSTFIELDS, &f); + + if (t.Perform() != B_OK) { + cout << "Error while performing request!" << endl; + return EXIT_FAILURE; + } + + t.WaitUntilCompletion(); + + cout << "Request finished!" << endl; + cout << t.Result() << endl; + + return EXIT_SUCCESS; +}