GIF89a=( õ' 7IAXKgNgYvYx\%wh…hŽth%ˆs%—x¨}9®Œ©€&©‰%¶†(¹–.¹5·œD¹&Çš)ÇŸ5ǘ;Í£*È¡&Õ²)ׯ7×µ<Ñ»4ï°3ø‘HÖ§KͯT÷¨Yÿšqÿ»qÿÔFØ !ù ' !ÿ NETSCAPE2.0 , =( þÀ“pH,È¤rÉl:ŸÐ¨tJ­Z¯Ø¬vËíz¿à°xL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~Ïïûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§gª«ªE¯°¨¬ª±²Œ¹º¹E¾­”´ÂB¶¯ §Åȸ»ÑD¾¿Á•ÄÅ®° ÝH¾ÒLÀÆDÙ«D¶BÝïðÀ¾DÑÑÔTÌÍíH òGö¨A RÎڐ |¥ ٭&ºìE8œ¹kGÔAÞpx­a¶­ã R2XB®åE8I€Õ6Xî:vT)äžþÀq¦è³¥ì仕F~%xñ  4#ZÔ‰O|-4Bs‘X:= QÉ œš lºÒyXJŠGȦ|s hÏíK–3l7·B|¥$'7Jީܪ‰‡àá”Dæn=Pƒ ¤Òëí‰`䌨ljóá¯Éüv>á–Á¼5 ½.69ûϸd«­ºÀûnlv©‹ªîf{¬ÜãPbŸ  l5‘Ž¯pß ´ ˜3aÅùäI«O’ý·‘áÞ‡˜¾Æ‚ÙÏiÇÿ‹Àƒ #öó)pâš Þ½ ‘Ý{ó)vmÞü%D~ 6f s}ŃƒDØW Eþ`‡þ À…L8xá†ç˜{)x`X/> Ì}mø‚–RØ‘*|`D=‚Ø_ ^ð5 !_…'aä“OÚ—7âcð`D”Cx`ÝÂ¥ä‹éY¹—F¼¤¥Š?¡Õ™ n@`} lď’ÄÉ@4>ñd œ à‘vÒxNÃ×™@žd=ˆgsžG±æ ´²æud &p8Qñ)ˆ«lXD©øÜéAžHìySun jª×k*D¤LH] †¦§C™Jä–´Xb~ʪwStŽ6K,°£qÁœ:9ت:¨þªl¨@¡`‚ûÚ ».Û¬¯t‹ÆSÉ[:°=Š‹„‘Nåû”Ìî{¿ÂA ‡Rà›ÀÙ6úë°Ÿð0Ä_ ½;ÃϱîÉì^ÇÛÇ#Ëë¼ôº!±Ä˜íUîÅÇ;0L1óÁµö«p% AÀºU̬ݵ¼á%霼€‡¯Á~`ÏG¯»À× ­²± =4ªnpð3¾¤³¯­ü¾¦îuÙuµÙ®|%2ÊIÿür¦#0·ÔJ``8È@S@5ê¢ ö×Þ^`8EÜ]ý.뜃Âç 7 ú ȉÞj œ½Dç zý¸iþœÑÙûÄë!ˆÞÀl§Ïw‹*DçI€nEX¯¬¼ &A¬Go¼QföõFç°¯;é¦÷îŽêJ°îúôF5¡ÌQ|îúöXªæ»TÁÏyñêï]ê² o óÎC=öõ›ÒÓPB@ D×½œä(>èCÂxŽ`±«Ÿ–JЀ»Û á¤±p+eE0`ëŽ`A Ú/NE€Ø†À9‚@¤à H½7”à‡%B‰`Àl*ƒó‘–‡8 2ñ%¸ —€:Ù1Á‰E¸àux%nP1ð!‘ðC)¾P81lÑɸF#ˆ€{´âé°ÈB„0>±û °b¡Š´±O‚3È–Ù()yRpbµ¨E.Z‘D8ÊH@% òŒx+%Ù˜Æcü »¸˜fõ¬b·d`Fê™8èXH"ÉÈ-±|1Ô6iI, 2““¬$+](A*jÐ QTÂo‰.ÛU슬Œã„Ž`¯SN¡–¶Äåyše¯ª’­¬‚´b¦Éož œ)åyâ@Ì®3 ÎtT̉°&Ø+žLÀf"Ø-|žçÔ>‡Ðv¦Ðžì\‚ Q1)Ž@Žh#aP72”ˆ™¨$‚ !ù " , =( …7IAXG]KgNgYvYxR"k\%w]'}hŽth%ˆg+ˆs%—r.—m3šx3˜x¨}9®€&©€+¨‡7§‰%¶†(¹–.¹œD¹&ǘ;Í•&ײ)×»4ïÌ6ò§KÍ þ@‘pH,È¤rÉl:ŸÐ¨tJ­Z¯Ø¬vËíz¿à°xL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~Ïïûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§g «¬ E ±± ¨­¶°ººE Á´”·®C¬²§Ç¶Œ»ÓDÃÕƷ¯Ê±H½ºM×ÁGÚ¬D¶BËÁ½î½DÓôTÏÛßîG»ôõC×CÌ l&âž:'òtU³6ɹ#·Ø)€'Ü.6±&ëÍÈ» K(8p0N?!æ2"ÛˆNIJX>R¼ÐO‚M '¡¨2¸*Ÿþ>#n↠å@‚<[:¡Iïf’ ¤TÚ˘CdbÜÙ“[«ŽEú5MBo¤×@€`@„€Êt W-3 ¶Ÿ¡BíêäjIÝ…Eò9[T…$íêﯧ„…•s»Óȳ¹€ÅÚdc®UUρ#±Ùïldj?´í¼²`\ŽÁðÞu|3'ÖŒ]ë6 ¶S#²‡˜FKLÈ *N E´‘áäŠ$˜›eÄYD„ºq«.è촁ƒs \-ÔjA 9²õ÷å- üúM[Âx(ís÷ì®x€|í¡Ù’p¦‚ ŽkÛTÇDpE@WÜ ²Ç]kŠ1¨ þ€·Yb ÓÁ‰l°*n0 ç™—žzBdОu¾7ĉBl€â‰-ºx~|UåU‰  h*Hœ|e"#"?vpÄiŠe6^ˆ„+qâŠm8 #VÇá ‘å–ÄV„œ|Šè•m"сœn|@›U¶ÆΞ—Špb¥G¨ED”€±Úê2FÌIç? >Éxå Œ± ¡¤„%‘žjŸ‘ꄯ<Ìaà9ijÐ2˜D¦È&›†Z`‚å]wþ¼Â:ç6àB¤7eFJ|õÒ§Õ,¨äàFÇ®cS·Ê¶+B°,‘Þ˜ºNûãØ>PADÌHD¹æž«ÄÀnÌ¥}­#Ë’ë QÀÉSÌÂÇ2ÌXÀ{æk²lQÁ2«ÊðÀ¯w|2Í h‹ÄÂG€,m¾¶ë3ÐÙ6-´ÅE¬L°ÆIij*K½ÀÇqï`DwVÍQXœÚÔpeœ±¬Ñ q˜§Tœ½µƒ°Œìu Â<¶aØ*At¯lmEØ ü ôÛN[P1ÔÛ¦­±$ÜÆ@`ùåDpy¶yXvCAyåB`ŽD¶ 0QwG#¯ æš[^Äþ $ÀÓÝǦ{„L™[±úKÄgÌ;ï£S~¹ìGX.ôgoT.»åˆ°ùŸûù¡?1zö¦Ÿž:ÅgÁ|ìL¹ „®£œŠ‚à0œ]PÁ^p F<"•ç?!,ñ‡N4—…PÄ Á„ö¨Û:Tè@hÀ‹%táÿ:ø-žI<`þ‹p I….)^ 40D#p@ƒj4–؀:²‰1Øâr˜¼F2oW¼#Z†;$Q q” ‘ ÂK¦ñNl#29 !’F@¥Bh·ᏀL!—XFóLH‘Kh¤.«hE&JòG¨¥<™WN!€ÑÙÚˆY„@†>Œž19J" 2,/ &.GXB%ÌRÈ9B6¹W]’î×ÔW¥’IÎ$ ñ‹ÓŒE8YÆ ¼³™ñA5“à®Q.aŸB€&Ø©³ JÁ—! ¦t)K%tœ-¦JF bòNMxLôþ)ÐR¸Ð™‘ èÝ6‘O!THÌ„HÛ ‰ !ù ) , =( …AXKgNgYvYxR"k\%wh…hŽh%ˆg+ˆs%—r.—x3˜x¨}9®€&©€+¨Œ,©‡7§‰%¶†(¹–.¹5·&Çš)ǘ;Í•&×£*Ȳ)ׯ7×»4ï°3øÌ6ò‘HÖ§KÍ»Hó¯T÷¨Yÿ»qÿÇhÿ þÀ”pH,È¤rÉl:ŸÐ¨tJ­Z¯Ø¬vËíz¿à°xL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~Ïïûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§g ª« E$±²¨ª­ · °²½$E$ÂÕ««D· Í ¿¦Ç¶¸ÌŒ¾³CÃÅÆ E ééH½MÛÂGâªD­ çBêêϾD²ÒaÀà€Š1r­ðÓ¤ ÔožzU!L˜C'¾yW½UGtäÇïÙllê0×àÂuGþ)AÀs[þ·xì ÁxO%ƒûX2ó—  P£n›R/¡ÑšHše+êDm?# —‘Ç£6¡8íJ¡ŸâDiäªM¥Ö„ôj“¬¹£5oQ7°- <‡ *´lãÓŒ2r/a!l)dÈ A™ÈE¢ôÔ͆…ð ;Ö˜c ¡%ß‚’Ùˆâ¸b½—pe~C"BíëÚHïeF2§æŠ8qb t_`urŠeü wÅu3êæPv§h•"ß`íÍxçLĹÜÖ3á  ~Öº“®›¸ÏMDfJÙ °„ÛµáWõ%§œ‚à©–‚X Ó؁)@®Ñ›Eþ´wëuÅSxb8y\mÖzœ¥§ZbºE—ÂLªÌw!y(>¡™wú=Ç|ÅÝs¢d €CÁW)HÜcC$€L Ä7„r.á\{)@ð` @ äXÈ$PD” `šaG:§æˆOˆ72EÐamn]ù"ŒcÊxÑŒ° &dR8`g«iÙŸLR!¦P …d’ä¡“¦ðÎTƒ¦ià|À _ ¥ Qi#¦Šg›Æ ›noMµ ›V ã£)p ç£ÎW…š=Âeªk§†j„ ´®1ß²sÉxéW«jšl|0¯B0Û, \jÛ´›6±¬¶C ÛíWþï|ëÙ‹¸ñzĸV {ì;Ýñn¼òVˆm³I¼³.Ðã¤PN¥ ²µ¼„µCã+¹ÍByî£Ñ¾HŸ›ëê 7ìYÆFTk¨SaoaY$Dµœìï¿Ã29RÈkt Çïfñ ÇÒ:ÀÐSp¹3ÇI¨â¥DZÄ ü9Ïýögñ½­uÔ*3)O‘˜Ö[_hv ,àî×Et Ÿé¶BH€ Õ[ü±64M@ÔSÌM7dÐl5-ÄÙU܍´©zߌ3Ô€3ž„ „ ¶ÛPô½5×g› êÚ˜kN„Ý…0Îj4€Ìë°“#{þÕ3S2çKÜ'ợlø¼Ú2K{° {Û¶?žm𸧠ËI¼nEò='êüóºè^üæÃ_Û=°óž‚ì#Oý¿Í'¡½áo..ÏYìnüñCœO±Áa¿¢Kô½o,üÄËbö²çºíï{ËC Ú— "”Ï{ËK ÍÒw„õ±Oz dÕ¨à:$ ƒô—«v»] A#ð «€¿šéz)Rx׿ˆ¥‚d``èw-îyÏf×K!ð€þ­Ð|ìPľ„=Ì`ý(f” 'Pa ¥ÐBJa%Ðâf§„%Š¡}FàáÝ×6>ÉäŠG"éŽè=ø!oŠ°^FP¼Ø©Q„ÀCÙÁ`(Ž\ÄÝ® ©Â$<n@dÄ E#ììUÒI! ‚#lù‹`k¦ÐÇ'Rró’ZýNBÈMF Í[¤+‹ðɈ-áwj¨¥þ8¾rá ,VÂh„"|½œ=×G_¦Ñ™EØ 0i*%̲˜Æda0mV‚k¾)›;„&6 p>ÓjK “¦Ç# âDÂ:ûc?:R Ó¬fÞéI-Ì“•Ã<ä=™Ï7˜3œ¨˜c2ŒW ,ˆ”8(T™P‰F¡Jhç"‚ ; 403WebShell
403Webshell
Server IP : 104.21.83.152  /  Your IP : 216.73.216.195
Web Server : LiteSpeed
System : Linux premium229.web-hosting.com 4.18.0-553.45.1.lve.el8.x86_64 #1 SMP Wed Mar 26 12:08:09 UTC 2025 x86_64
User : akhalid ( 749)
PHP Version : 8.3.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : ON  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /opt/cpanel/ea-ruby27/src/passenger-release-6.0.23/test/cxx/IOTools/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /opt/cpanel/ea-ruby27/src/passenger-release-6.0.23/test/cxx/IOTools/IOUtilsTest.cpp
#include <TestSupport.h>
#include <IOTools/IOUtils.h>
#include <SystemTools/SystemTime.h>
#include <oxt/system_calls.hpp>
#include <boost/bind/bind.hpp>
#include <sys/types.h>
#include <cerrno>
#include <string>

using namespace Passenger;
using namespace std;
using namespace boost;
using namespace oxt;

namespace tut {
	static ssize_t writevResult;
	static int writevErrno;
	static int writevCalled;
	static string writevData;

	static ssize_t writev_mock(int fildes, const struct iovec *iov, int iovcnt) {
		if (writevResult >= 0) {
			string data;
			for (int i = 0; i < iovcnt && data.size() < (size_t) writevResult; i++) {
				data.append(
					(const char *) iov[i].iov_base,
					iov[i].iov_len);
			}
			data.resize(writevResult);
			writevData.append(data);
		}
		writevCalled++;
		errno = writevErrno;
		return writevResult;
	}

	struct IOTools_IOUtilsTest: public TestBase {
		string restBuffer;

		IOTools_IOUtilsTest() {
			writevResult = 0;
			writevErrno = 0;
			writevCalled = 0;
			writevData.clear();
			setWritevFunction(writev_mock);
		}

		~IOTools_IOUtilsTest() {
			setWritevFunction(NULL);
		}

		Pipe createNonBlockingPipe() {
			Pipe p = createPipe(__FILE__, __LINE__);
			setNonBlocking(p.second);
			return p;
		}

		static void writeDataAfterSomeTime(int fd, unsigned int sleepTimeInUsec) {
			try {
				syscalls::usleep(sleepTimeInUsec);
				syscalls::write(fd, "hi", 2);
			} catch (const boost::thread_interrupted &) {
				// Do nothing.
			}
		}

		static void writeDataSlowly(int fd, unsigned int bytesToWrite, unsigned int bytesPerSec) {
			try {
				for (unsigned i = 0; i < bytesToWrite && !boost::this_thread::interruption_requested(); i++) {
					syscalls::write(fd, "x", 1);
					syscalls::usleep(1000000 / bytesPerSec);
				}
			} catch (const boost::thread_interrupted &) {
				// Do nothing.
			}
		}

		static void readDataAfterSomeTime(int fd, unsigned int sleepTimeInUsec) {
			try {
				char buf[1024 * 8];
				syscalls::usleep(sleepTimeInUsec);
				syscalls::read(fd, buf, sizeof(buf));
			} catch (const boost::thread_interrupted &) {
				// Do nothing.
			}
		}

		static void readDataSlowly(int fd, int bytesToRead, int bytesPerSec) {
			try {
				unsigned long long start = SystemTime::getUsec();
				unsigned long long deadline = start +
					(bytesToRead * 1000000.0 / bytesPerSec);
				int alreadyRead = 0;

				while (alreadyRead < bytesToRead && !boost::this_thread::interruption_requested()) {
					unsigned long long elapsed = SystemTime::getUsec();
					double progress = (elapsed - start) / (double) (deadline - start);
					int shouldHaveRead = progress * bytesToRead;
					int shouldNowRead = shouldHaveRead - alreadyRead;

					if (shouldNowRead > 0) {
						char *buf = new char[shouldNowRead];
						ssize_t ret = syscalls::read(fd, buf, shouldNowRead);
						int e = errno;
						delete[] buf;
						if (ret == -1) {
							throw SystemException("read error", e);
						} else if (ret == 0) {
							break;
						}
						alreadyRead += ret;
					}
					syscalls::usleep(1000);
				}
			} catch (const boost::thread_interrupted &) {
				// Do nothing.
			}
		}
	};

	DEFINE_TEST_GROUP_WITH_LIMIT(IOTools_IOUtilsTest, 100);

	/***** Test gatheredWrite() with empty input rest buffer *****/

	TEST_METHOD(1) {
		// Test complete write of a single data buffer.
		StaticString data = "hello world";
		writevResult = data.size();
		ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult);
		ensure_equals(writevData, "hello world");
		ensure(restBuffer.empty());
	}

	TEST_METHOD(2) {
		// Test complete write of multiple data buffers.
		StaticString data[] = { "hello ", "world", "!!!!!!" };
		writevResult = strlen("hello world!!!!!!");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "hello world!!!!!!");
		ensure(restBuffer.empty());
	}

	TEST_METHOD(3) {
		// Test partial write of a single data buffer.
		StaticString data = "hello world";
		writevResult = 3;
		ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult);
		ensure_equals(writevData, "hel");
		ensure_equals(restBuffer, "lo world");
	}

	TEST_METHOD(4) {
		// Test partial write of multiple data buffers:
		// first buffer is partially written.
		StaticString data[] = { "hello ", "world", "!!!!!!" };
		writevResult = 2;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "he");
		ensure_equals(restBuffer, "llo world!!!!!!");
	}

	TEST_METHOD(5) {
		// Test partial write of multiple data buffers:
		// first buffer is completely written.
		StaticString data[] = { "hello ", "world", "!!!!!!" };
		writevResult = 6;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "hello ");
		ensure_equals(restBuffer, "world!!!!!!");
	}

	TEST_METHOD(6) {
		// Test partial write of multiple data buffers:
		// non-first buffer is partially written.
		StaticString data[] = { "hello ", "world", "!!!!!!" };
		writevResult = 8;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "hello wo");
		ensure_equals(restBuffer, "rld!!!!!!");
	}

	TEST_METHOD(7) {
		// Test partial write of multiple data buffers:
		// non-first buffer is completely written.
		StaticString data[] = { "hello ", "world", "!!!!!!" };
		writevResult = 11;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "hello world");
		ensure_equals(restBuffer, "!!!!!!");
	}

	TEST_METHOD(8) {
		// Test failed write of a single data buffer: blocking error.
		StaticString data = "hello world";
		writevResult = -1;
		writevErrno = EAGAIN;
		ensure_equals(gatheredWrite(0, &data, 1, restBuffer), 0);
		ensure_equals(restBuffer, "hello world");
	}

	TEST_METHOD(9) {
		// Test failed write of a single data buffer: other error.
		StaticString data = "hello world";
		writevResult = -1;
		writevErrno = EBADF;
		ssize_t ret = gatheredWrite(0, &data, 1, restBuffer);
		int e = errno;
		ensure_equals(ret, -1);
		ensure_equals(e, EBADF);
		ensure_equals("Rest buffer remains untouched", restBuffer, "");
	}

	TEST_METHOD(10) {
		// Test failed write of multiple data buffers: blocking error.
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = -1;
		writevErrno = EAGAIN;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), 0);
		ensure_equals(restBuffer, "hello world!!!");
	}

	TEST_METHOD(11) {
		// Test failed write of multiple data buffers: other error.
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = -1;
		writevErrno = EBADF;
		ssize_t ret = gatheredWrite(0, data, 3, restBuffer);
		int e = errno;
		ensure_equals(ret, -1);
		ensure_equals(e, EBADF);
		ensure_equals("Rest buffer remains untouched", restBuffer, "");
	}

	TEST_METHOD(12) {
		// Test writing nothing.
		StaticString data[] = { "", "", "" };
		ssize_t ret = gatheredWrite(0, data, 3, restBuffer);
		int e = errno;
		ensure_equals(ret, 0);
		ensure_equals(e, 0);
		ensure_equals(writevCalled, 0);
		ensure_equals(restBuffer, "");
	}

	TEST_METHOD(13) {
		// Test writing multiple buffers where some are empty.
		StaticString data[] = { "hello ", "", "world" };
		writevResult = strlen("hello world");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "hello world");
		ensure_equals(restBuffer, "");
	}

	/***** Test gatheredWrite() with non-empty input rest buffer *****/

	TEST_METHOD(15) {
		// Test complete write with a single data buffer.
		restBuffer = "oh ";
		StaticString data = "hello world";
		writevResult = restBuffer.size() + data.size();
		ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult);
		ensure_equals(writevData, "oh hello world");
		ensure(restBuffer.empty());
	}

	TEST_METHOD(16) {
		// Test complete write with multiple data buffers.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = strlen("oh hello world!!!");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh hello world!!!");
		ensure(restBuffer.empty());
	}

	TEST_METHOD(17) {
		// Test partial write of a single data buffer.
		StaticString data = "hello world";
		writevResult = 3;
		ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult);
		ensure_equals(writevData, "hel");
		ensure_equals(restBuffer, "lo world");
	}

	TEST_METHOD(18) {
		// Test partial write of multiple data buffers:
		// rest buffer is partially written.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = 2;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh");
		ensure_equals(restBuffer, " hello world!!!");
	}

	TEST_METHOD(19) {
		// Test partial write of multiple data buffers:
		// rest buffer is completely written.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = strlen("oh ");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh ");
		ensure_equals(restBuffer, "hello world!!!");
	}

	TEST_METHOD(20) {
		// Test partial write of multiple data buffers:
		// first buffer is partially written.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = strlen("oh h");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh h");
		ensure_equals(restBuffer, "ello world!!!");
	}

	TEST_METHOD(21) {
		// Test partial write of multiple data buffers:
		// first buffer is completely written.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = strlen("oh hello ");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh hello ");
		ensure_equals(restBuffer, "world!!!");
	}

	TEST_METHOD(22) {
		// Test partial write of multiple data buffers:
		// non-first buffer is partially written.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = strlen("oh hello wo");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh hello wo");
		ensure_equals(restBuffer, "rld!!!");
	}

	TEST_METHOD(23) {
		// Test partial write of multiple data buffers:
		// non-first buffer is completely written.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = strlen("oh hello world");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh hello world");
		ensure_equals(restBuffer, "!!!");
	}

	TEST_METHOD(24) {
		// Test failed write of a single data buffer: blocking error.
		restBuffer = "oh ";
		StaticString data = "hello world";
		writevResult = -1;
		writevErrno = EAGAIN;
		ensure_equals(gatheredWrite(0, &data, 1, restBuffer), 0);
		ensure_equals(restBuffer, "oh hello world");
	}

	TEST_METHOD(25) {
		// Test failed write of a single data buffer: other error.
		restBuffer = "oh ";
		StaticString data = "hello world";
		writevResult = -1;
		writevErrno = EBADF;
		ssize_t ret = gatheredWrite(0, &data, 1, restBuffer);
		int e = errno;
		ensure_equals(ret, -1);
		ensure_equals(e, EBADF);
		ensure_equals("Rest buffer remains untouched", restBuffer, "oh ");
	}

	TEST_METHOD(26) {
		// Test failed write of multiple data buffers: blocking error.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = -1;
		writevErrno = EAGAIN;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), 0);
		ensure_equals(restBuffer, "oh hello world!!!");
	}

	TEST_METHOD(27) {
		// Test failed write of multiple data buffers: other error.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "world", "!!!" };
		writevResult = -1;
		writevErrno = EBADF;
		ssize_t ret = gatheredWrite(0, data, 3, restBuffer);
		int e = errno;
		ensure_equals(ret, -1);
		ensure_equals(e, EBADF);
		ensure_equals("Rest buffer remains untouched", restBuffer, "oh ");
	}

	TEST_METHOD(28) {
		// Test writing multiple buffers that are all empty.
		restBuffer = "oh ";
		StaticString data[] = { "", "", "" };
		writevResult = 3;
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh ");
		ensure_equals(restBuffer, "");
	}

	TEST_METHOD(29) {
		// Test writing multiple buffers where one is empty.
		restBuffer = "oh ";
		StaticString data[] = { "hello ", "", "world" };
		writevResult = strlen("oh hello world");
		ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult);
		ensure_equals(writevData, "oh hello world");
		ensure_equals(restBuffer, "");
	}


	/***** Test gatheredWrite() blocking version *****/

	TEST_METHOD(35) {
		// It doesn't call writev() if requested to send 0 bytes.
		StaticString data[2] = { "", "" };
		gatheredWrite(0, data, 2);
		ensure_equals(writevCalled, 0);
	}

	TEST_METHOD(36) {
		// Test sending all data in a single writev() call.
		StaticString data[] = { "hello", "my", "world" };
		writevResult = strlen("hellomyworld");
		gatheredWrite(0, data, 3);
		ensure_equals(writevData, "hellomyworld");
		ensure_equals(writevCalled, 1);
	}

	TEST_METHOD(42) {
		// Test writing byte-by-byte.
		StaticString data[] = { "hello", "my", "world", "!!" };
		writevResult = 1;
		gatheredWrite(0, data, 4);
		ensure_equals(writevCalled, (int) strlen("hellomyworld!!"));
		ensure_equals(writevData, "hellomyworld!!");
	}

	TEST_METHOD(43) {
		// Test writev() writing in chunks of 2 bytes.
		StaticString data[] = { "hello", "my", "world", "!!" };
		writevResult = 2;
		gatheredWrite(0, data, 4);
		ensure_equals(writevCalled, (int) strlen("hellomyworld!!") / 2);
		ensure_equals(writevData, "hellomyworld!!");
	}

	static ssize_t writev_mock_44(int fildes, const struct iovec *iov, int iovcnt) {
		if (writevCalled == 3) {
			// Have the last call return 2 instead of 4.
			writevResult = 2;
		}
		return writev_mock(fildes, iov, iovcnt);
	}

	TEST_METHOD(44) {
		// Test writev() writing in chunks of 4 bytes.
		setWritevFunction(writev_mock_44);
		StaticString data[] = { "hello", "my", "world", "!!" };
		writevResult = 4;
		gatheredWrite(0, data, 4);
		ensure_equals(writevCalled, 4);
		ensure_equals(writevData, "hellomyworld!!");
	}

	TEST_METHOD(45) {
		// Test writev() timeout support.
		setWritevFunction(NULL);
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long startTime = SystemTime::getUsec();
		unsigned long long timeout = 30000;
		char data1[1024], data2[1024];
		StaticString data[] = {
			StaticString(data1, sizeof(data1) - 1),
			StaticString(data2, sizeof(data2) - 1)
		};
		memset(data1, 'x', sizeof(data1));
		memset(data2, 'y', sizeof(data2));

		try {
			for (int i = 0; i < 1024; i++) {
				gatheredWrite(p[1], data, 2, &timeout);
			}
			fail("TimeoutException expected");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure("At least 29 msec have passed", elapsed >= 29000);
			ensure("At most 95 msec have passed", elapsed <= 95000);
			ensure(timeout <= 2000);
		}
	}

	/***** Test waitUntilReadable() *****/

	TEST_METHOD(50) {
		// waitUntilReadable() waits for the specified timeout if no data is readable.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 25000;
		ensure("No data is available", !waitUntilReadable(p.first, &timeout));
		ensure("The passed time is deducted from the timeout", timeout < 5000);
	}

	TEST_METHOD(51) {
		// waitUntilReadable() waits for less than the specified timeout if data
		// is not available immediately but still available before the timeout.
		Pipe p = createPipe(__FILE__, __LINE__);
		TempThread thr(boost::bind(&writeDataAfterSomeTime, p.second, 35000));

		unsigned long long timeout = 1000000;
		ensure("Data is available", waitUntilReadable(p.first, &timeout));
		ensure("At least 35 msec passed.", timeout <= 1000000 - 35000);
		ensure("At most 70 msec passed.", timeout >= 1000000 - 70000);  // depends on system scheduler though
	}

	TEST_METHOD(52) {
		// waitUntilReadable() returns immediately if timeout is 0.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 0;
		ensure("No data is available", !waitUntilReadable(p.first, &timeout));
		ensure_equals("Timeout is not modified", timeout, 0u);

		write(p.second, "hi", 2);
		ensure("Data is available", waitUntilReadable(p.first, &timeout));
		ensure_equals("Timeout is not modified", timeout, 0u);
	}

	TEST_METHOD(53) {
		// waitUntilReadable() returns immediately if there's data immediately available.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 100000;
		write(p.second, "hi", 2);
		ensure("Data is available", waitUntilReadable(p.first, &timeout));
		ensure("Timeout is not modified", timeout >= 100000 - 5000);
	}

	/***** Test readExact() *****/

	TEST_METHOD(54) {
		// readExact() throws TimeoutException if no data is received within the timeout.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 50000;
		char buf;
		try {
			readExact(p.first, &buf, 1, &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure("The passed time is deducted from timeout", timeout < 5000);
		}
	}

	TEST_METHOD(55) {
		// readExact() throws TimeoutException if not enough data is received within the timeout.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 20000;
		char buf[100];

		TempThread thr(boost::bind(&writeDataSlowly, p.second, sizeof(buf), 1));

		try {
			readExact(p.first, &buf, sizeof(buf), &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure("The passed time is deducted from timeout", timeout < 5000);
		}
	}

	TEST_METHOD(56) {
		// readExact() throws TimeoutException if timeout is 0 and no data is immediately available.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 0;
		char buf;
		try {
			readExact(p.first, &buf, 1, &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure_equals("Timeout unchanged", timeout, 0u);
		}
	}

	TEST_METHOD(57) {
		// readExact() throws TimeoutException if timeout is 0 and not enough data is
		// immediately available.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 0;
		write(p.second, "hi", 2);
		try {
			char buf[100];
			readExact(p.first, &buf, sizeof(buf), &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure_equals("Timeout is unchanged", timeout, 0u);
		}
	}

	TEST_METHOD(58) {
		// readExact() deducts the amount of time spent on waiting from the timeout variable.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 100000;
		char buf[3];

		// Spawn a thread that writes 100 bytes per second, i.e. each byte takes 10 msec.
		TempThread thr(boost::bind(&writeDataSlowly, p.second, 1000, 100));

		// We read 3 bytes.
		ensure_equals(readExact(p.first, &buf, sizeof(buf), &timeout), 3u);
		ensure("Should have taken at least 20 msec", timeout <= 100000 - 20000);
        #if defined(__FreeBSD__) || defined(BOOST_OS_MACOS)
			// Stupid timer resolution on FreeBSD...
			ensure("Should have taken at most 95 msec", timeout >= 100000 - 95000);
		#else
			ensure("Should have taken at most 50 msec", timeout >= 100000 - 40000);
		#endif
	}

	TEST_METHOD(59) {
		// readExact() does not wait and does not modify the timeout variable if there's
		// immediately enough data available.
		Pipe p = createPipe(__FILE__, __LINE__);
		unsigned long long timeout = 100000;
		char buf[2];

		write(p.second, "hi", 2);
		ensure_equals(readExact(p.first, &buf, 2, &timeout), 2u);
		ensure("Timeout not modified", timeout >= 95000);
	}

	/***** Test waitUntilWritable() *****/

	TEST_METHOD(60) {
		// waitUntilWritable() waits for the specified timeout if no data is writable.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		unsigned long long timeout = 25000;
		ensure("Socket did not become writable", !waitUntilWritable(p.second, &timeout));
		ensure("The passed time is deducted from the timeout", timeout < 5000);
	}

	TEST_METHOD(61) {
		// waitUntilWritable() waits for less than the specified timeout if the fd
		// is not immediately writable but still writable before the timeout.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		TempThread thr(boost::bind(&readDataAfterSomeTime, p.first, 35000));

		unsigned long long timeout = 1000000;
		ensure("Socket became writable", waitUntilWritable(p.second, &timeout));
		ensure("At least 35 msec passed.", timeout <= 1000000 - 35000);
		ensure("At most 70 msec passed.", timeout >= 1000000 - 70000);  // depends on system scheduler though
	}

	TEST_METHOD(62) {
		// waitUntilWritable() returns immediately if timeout is 0.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		unsigned long long timeout = 0;
		ensure("Socket is not writable", !waitUntilWritable(p.second, &timeout));
		ensure_equals("Timeout is not modified", timeout, 0u);

		char buf[1024 * 8];
		read(p.first, buf, sizeof(buf));
		ensure("Socket became writable", waitUntilWritable(p.second, &timeout));
		ensure_equals("Timeout is not modified", timeout, 0u);
	}

	TEST_METHOD(63) {
		// waitUntilWritable() returns immediately if the fd is immediately writable.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		unsigned long long timeout = 100000;
		char buf[1024 * 8];
		read(p.first, buf, sizeof(buf));
		ensure("Socket became writable", waitUntilWritable(p.second, &timeout));
		ensure("Timeout is not modified", timeout >= 100000 - 5000);
	}

	/***** Test readExact() *****/

	TEST_METHOD(64) {
		// writeExact() throws TimeoutException if fd does not become writable within the timeout.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		unsigned long long timeout = 50000;
		try {
			writeExact(p.second, "x", 1, &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure("The passed time is deducted from timeout", timeout < 5000);
		}
	}

	TEST_METHOD(65) {
		// writeExact() throws TimeoutException if not enough data is written within the timeout.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		unsigned long long timeout = 20000;
		char buf[1024 * 3];

		TempThread thr(boost::bind(&readDataSlowly, p.first, sizeof(buf), 512));

		try {
			writeExact(p.second, "x", 1, &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure("The passed time is deducted from timeout", timeout < 5000);
		}
	}

	TEST_METHOD(66) {
		// writeExact() throws TimeoutException if timeout is 0 and the fd is not immediately writable.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		unsigned long long timeout = 0;
		try {
			writeExact(p.second, "x", 1, &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure_equals("Timeout unchanged", timeout, 0u);
		}
	}

	TEST_METHOD(67) {
		// writeExact() throws TimeoutException if timeout is 0 not enough data could be written immediately.
		Pipe p = createNonBlockingPipe();
		writeUntilFull(p.second);
		unsigned long long timeout = 0;

		char buf[1024];
		read(p.first, buf, sizeof(buf));

		char buf2[1024 * 8];
		memset(buf2, 0, sizeof(buf2));

		try {
			writeExact(p.second, buf2, sizeof(buf2), &timeout);
			fail("No TimeoutException thrown.");
		} catch (const TimeoutException &) {
			ensure_equals("Timeout is unchanged", timeout, 0u);
		}
	}

	TEST_METHOD(68) {
		// readExact() deducts the amount of time spent on waiting from the timeout variable.
		Pipe p = createNonBlockingPipe();
		unsigned long long timeout = 100000;

		// Spawn a thread that reads 200000 bytes in 35 msec.
		TempThread thr(boost::bind(&readDataSlowly, p.first, 5714286, 5714286));

		// We write 200000 bytes.
		char buf[200000];
		memset(buf, 0, sizeof(buf));
		writeExact(p.second, &buf, sizeof(buf), &timeout);
		ensure("Should have taken at least 20 msec", timeout <= 100000 - 20000);
		ensure("Should have taken at most 95 msec", timeout >= 100000 - 95000);
	}

	TEST_METHOD(69) {
		// writeExact() does not wait and does not modify the timeout variable if
		// all data can be written immediately.
		Pipe p = createNonBlockingPipe();
		unsigned long long timeout = 100000;
		char buf[1024];
		memset(buf, 0, sizeof(buf));
		writeExact(p.second, buf, sizeof(buf), &timeout);
		ensure("Timeout not modified", timeout >= 95000);
	}

	/***** Test getSocketAddressType() *****/

	TEST_METHOD(70) {
		ensure_equals(getSocketAddressType(""), SAT_UNKNOWN);
		ensure_equals(getSocketAddressType("/foo.socket"), SAT_UNKNOWN);
		ensure_equals(getSocketAddressType("unix:"), SAT_UNKNOWN);
		ensure_equals(getSocketAddressType("unix:/"), SAT_UNIX);
		ensure_equals(getSocketAddressType("unix:/foo.socket"), SAT_UNIX);
		ensure_equals(getSocketAddressType("tcp:"), SAT_UNKNOWN);
		ensure_equals(getSocketAddressType("tcp://"), SAT_UNKNOWN);
		// Doesn't check whether it contains port
		ensure_equals(getSocketAddressType("tcp://127.0.0.1"), SAT_TCP);
		ensure_equals(getSocketAddressType("tcp://127.0.0.1:80"), SAT_TCP);
	}

	TEST_METHOD(71) {
		ensure_equals(parseUnixSocketAddress("unix:/foo.socket"), "/foo.socket");
		try {
			parseUnixSocketAddress("unix:");
			fail("ArgumentException expected");
		} catch (const ArgumentException &e) {
			// Pass.
		}
	}

	TEST_METHOD(72) {
		string host;
		unsigned short port;

		parseTcpSocketAddress("tcp://127.0.0.1:80", host, port);
		ensure_equals(host, "127.0.0.1");
		ensure_equals(port, 80);

		parseTcpSocketAddress("tcp://[::1]:80", host, port);
		ensure_equals(host, "::1");
		ensure_equals(port, 80);

		try {
			parseTcpSocketAddress("tcp://", host, port);
			fail("ArgumentException expected (1)");
		} catch (const ArgumentException &e) {
			// Pass.
		}

		try {
			parseTcpSocketAddress("tcp://127.0.0.1", host, port);
			fail("ArgumentException expected (2)");
		} catch (const ArgumentException &e) {
			// Pass.
		}

		try {
			parseTcpSocketAddress("tcp://127.0.0.1:", host, port);
			fail("ArgumentException expected (3)");
		} catch (const ArgumentException &e) {
			// Pass.
		}

		try {
			parseTcpSocketAddress("tcp://[::1]", host, port);
			fail("ArgumentException expected (4)");
		} catch (const ArgumentException &e) {
			// Pass.
		}

		try {
			parseTcpSocketAddress("tcp://[::1]:", host, port);
			fail("ArgumentException expected (5)");
		} catch (const ArgumentException &e) {
			// Pass.
		}
	}

	/***** Test readFileDescriptor() and writeFileDescriptor() *****/

	TEST_METHOD(80) {
		// Test whether it works.
		SocketPair sockets = createUnixSocketPair(__FILE__, __LINE__);
		Pipe pipes = createPipe(__FILE__, __LINE__);
		writeFileDescriptor(sockets[0], pipes[1]);
		FileDescriptor fd(readFileDescriptor(sockets[1]), __FILE__, __LINE__);
		writeExact(fd, "hello");
		char buf[6];
		ensure_equals(readExact(pipes[0], buf, 5), 5u);
		buf[5] = '\0';
		ensure_equals(StaticString(buf), "hello");
	}

	TEST_METHOD(81) {
		// Test whether timeout works.
		SocketPair sockets = createUnixSocketPair(__FILE__, __LINE__);
		Pipe pipes = createPipe(__FILE__, __LINE__);

		unsigned long long timeout = 30000;
		unsigned long long startTime = SystemTime::getUsec();
		try {
			FileDescriptor fd(readFileDescriptor(sockets[0], &timeout),
				__FILE__, __LINE__);
			fail("TimeoutException expected");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure("readFileDescriptor() timed out after at least 29 msec",
				elapsed >= 29000);
			ensure("readFileDescriptor() timed out after at most 95 msec",
				elapsed <= 95000);
			ensure(timeout <= 2000);
		}

		writeUntilFull(sockets[0]);

		startTime = SystemTime::getUsec();
		timeout = 30000;
		try {
			writeFileDescriptor(sockets[0], pipes[0], &timeout);
			fail("TimeoutException expected");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure("writeFileDescriptor() timed out after 30 msec",
				elapsed >= 29000 && elapsed <= 95000);
			ensure(timeout <= 2000);
		}
	}


	/***** Test readAll() *****/

	TEST_METHOD(85) {
		set_test_name("readAll() with unlimited maxSize");
		Pipe p = createPipe(__FILE__, __LINE__);
		writeExact(p[1], "hello world");
		p[1].close();
		pair<string, bool> result = readAll(p[0],
			std::numeric_limits<size_t>::max());
		ensure_equals(result.first, "hello world");
		ensure(result.second);
	}

	TEST_METHOD(86) {
		set_test_name("readAll() with size smaller than actual data");
		Pipe p = createPipe(__FILE__, __LINE__);
		writeExact(p[1], "hello world");
		p[1].close();
		pair<string, bool> result = readAll(p[0], 5);
		ensure_equals(result.first, "hello");
		ensure(!result.second);
	}
}

Youez - 2016 - github.com/yon3zu
LinuXploit