-----------------------------------------------------------------------------
-- LuaSocket automated test module
-- client.lua
-- This is the client module. It connects with the server module and executes
-- all tests.
-----------------------------------------------------------------------------

-----------------------------------------------------------------------------
-- Prints a header to separate the test phases
-- Input
--   test: test phase name
-----------------------------------------------------------------------------
function new_test(test)
	write("----------------------------------------------\n",
		test, "\n",
		"----------------------------------------------\n")
end

-----------------------------------------------------------------------------
-- Get host and port from command line
-----------------------------------------------------------------------------
HOST = "127.0.0.1"
PORT = 2020
if arg then
    HOST = arg[1] or HOST
    PORT = arg[2] or PORT
end

-----------------------------------------------------------------------------
-- Read command definitions
-----------------------------------------------------------------------------
assert(dofile("testcmd.lua"))
test_debug_mode()

-----------------------------------------------------------------------------
-- Start control connection
-----------------------------------------------------------------------------
new_test("initializing...")
while control == nil do
	print("client: trying control connection...")
	control, err = connect(HOST, PORT)
	if control then
		print("client: control connection stablished!") 
	else
		sleep(2)
	end
end

-----------------------------------------------------------------------------
-- Make sure server is ready for data transmission
-----------------------------------------------------------------------------
function sync()
	send_command(SYNC)
	get_command()
end

-----------------------------------------------------------------------------
-- Close and reopen data connection, to get rid of any unread blocks
-----------------------------------------------------------------------------
function reconnect()
	if data then 
		close(data) 
		send_command(CLOSE)
		data = nil
	end
	while data == nil do
		send_command(CONNECT)
		data = connect(HOST, PORT)
		if not data then 
			print("client: waiting for data connection.") 
			sleep(1)
		end
	end
	sync()
end

-----------------------------------------------------------------------------
-- Tests the command connection
-----------------------------------------------------------------------------
function test_command(cmd, par)
	local cmd_back, par_back
	reconnect()
	send_command(COMMAND)
	write("testing command ")
	print_command(cmd, par)
	send_command(cmd, par)
	cmd_back, par_back = get_command()
	if cmd_back ~= cmd or par_back ~= par then
		fail(cmd)
	else
		pass()
	end
end

-----------------------------------------------------------------------------
-- Tests ASCII line transmission
-- Input
--   len: length of line to be tested
-----------------------------------------------------------------------------
function test_asciiline(len)
	local str, str10, back, err
	reconnect()
	send_command(ECHO_LINE)
	str = strrep("x", mod(len, 10))
	str10 = strrep("aZb.c#dAe?", floor(len/10))
	str = str .. str10
	write("testing ", len, " byte(s) line\n")
	err = send(data, str, "\n")
	if err then fail(err) end
	back, err = receive(data)
	if err then fail(err) end
	if back == str then pass("lines match")
	else fail("lines don't match") end
end

-----------------------------------------------------------------------------
-- Tests closed connection detection
-----------------------------------------------------------------------------
function test_closed()
	local str = "This is our little test line"
	local len = strlen(str)
	local back, err, total
	reconnect()
	print("testing close while reading line")
	send_command(ECHO_BLOCK, len)
	send(data, str)
	send_command(CLOSE)
	-- try to get a line 
	back, err = receive(data)
	if not err then fail("shold have gotten 'closed'.")
	elseif err ~= "closed" then fail("got '"..err.."' instead of 'closed'.")
	elseif str ~= back then fail("didn't receive what i should 'closed'.")
	else pass("rightfull 'closed' received") end
	reconnect()
	print("testing close while reading block")
	send_command(ECHO_BLOCK, len)
	send(data, str)
	send_command(CLOSE)
	-- try to get a line 
	back, err = receive(data, 2*len)
	if not err then fail("shold have gotten 'closed'.")
	elseif err ~= "closed" then fail("got '"..err.."' instead of 'closed'.")
	elseif str ~= back then fail("didn't receive what I should.")
	else pass("rightfull 'closed' received") end
end

-----------------------------------------------------------------------------
-- Tests binary line transmission
-- Input
--   len: length of line to be tested
-----------------------------------------------------------------------------
function test_rawline(len)
	local str, str10, back, err
	reconnect()
	send_command(ECHO_LINE)
	str = strrep(strchar(47), mod(len, 10))
	str10 = strrep(strchar(120,21,77,4,5,0,7,36,44,100), floor(len/10))
	str = str .. str10
	write("testing ", len, " byte(s) line\n")
	err = send(data, str, "\n")
	if err then fail(err) end
	back, err = receive(data)
	if err then fail(err) end
	if back == str then pass("lines match")
	else fail("lines don't match") end
end

-----------------------------------------------------------------------------
-- Tests block transmission
-- Input
--   len: length of block to be tested
-----------------------------------------------------------------------------
function test_block(len)
	local half = floor(len/2)
	local s1, s2, back, err
	reconnect()
	send_command(ECHO_BLOCK, len)
	write("testing ", len, " byte(s) block\n")
	s1 = strrep("x", half)
	err = send(data, s1)
	if err then fail(err) end
	s2 = strrep("y", len-half)
	err = send(data, s2)
	if err then fail(err) end
	back, err = receive(data, len)
	if err then fail(err) end
	if back == s1..s2 then pass("blocks match")
	else fail("blocks don't match") end
end

-----------------------------------------------------------------------------
-- Tests if return-timeout was respected 
--   delta: time elapsed during transfer
--   t: timeout value
--   s: time server slept
--   err: error code returned by I/O operation
--   o: operation being executed
-----------------------------------------------------------------------------
function blockedtimed_out(t, s, err, o)
	if err == "timeout" then
		if s >= t then
			pass("got rightfull forced timeout")
			return 1
		else
			pass("got natural cause timeout")
			return 1
		end
	elseif 0.9*s > t then
		if o == "send" then
			pass("must have been buffered (may be wrong)")
		else
			fail("should have gotten timeout")
		end
	end
end

-----------------------------------------------------------------------------
-- Tests blocked-timeout conformance
-- Input
--   len: length of block to be tested
--   t: timeout value
--   s: server sleep between transfers
-----------------------------------------------------------------------------
function test_blockedtimeout(len, t, s)
	local str, err, back, total
	reconnect()
	send_command(RECEIVE_BLOCK, len)
	send_command(SLEEP, s)
	send_command(RECEIVE_BLOCK, len)
	write("testing ", len, " bytes, ", t, 
		"s block timeout, ", s, "s sleep\n")
	timeout(data, t)
	str = strrep("a", 2*len)
	err, total = send(data, str)
	if blockedtimed_out(t, s, err, "send") then return end
	if err then fail(err) end
	send_command(SEND_BLOCK)
	send_command(SLEEP, s)
	send_command(SEND_BLOCK)
	back, err = receive(data, 2*len)
	if blockedtimed_out(t, s, err, "receive") then return end
	if err then fail(err) end
	if back == str then pass("blocks match")
	else fail("blocks don't match") end
end

-----------------------------------------------------------------------------
-- Tests if return-timeout was respected 
--   delta: time elapsed during transfer
--   t: timeout value
--   err: error code returned by I/O operation
-----------------------------------------------------------------------------
function returntimed_out(delta, t, err)
	if err == "timeout" then
		if 1.1*delta >= t then
			pass("got rightfull timeout")
			return 1
		else
			fail("shouldn't have gotten timeout")
		end
	elseif 0.9*delta > t then
		fail("should have gotten timeout")
	end
end

-----------------------------------------------------------------------------
-- Tests return-timeout conformance
-- Input
--   len: length of block to be tested
--   t: timeout value
--   s: server sleep between transfers
-----------------------------------------------------------------------------
function test_returntimeout(len, t, s)
	local str, err, back, delta, total
	reconnect()
	send_command(RECEIVE_BLOCK, len)
	send_command(SLEEP, s)
	send_command(RECEIVE_BLOCK, len)
	write("testing ", len, " bytes, ", t, 
		"s return timeout, ", s, "s sleep\n")
	timeout(data, t, "return")
	str = strrep("a", 2*len)
	err, total, delta = send(data, str)
	print("sent in " .. delta .. "s")
	if returntimed_out(delta, t, err) then return end
	if err then fail("unexpected error: " .. err) end
	send_command(SEND_BLOCK)
	send_command(SLEEP, s)
	send_command(SEND_BLOCK)
	back, err, delta = receive(data, 2*len)
	print("received in " .. delta .. "s")
	if returntimed_out(delta, t, err) then return end
	if err then fail("unexpected error: " .. err) end
	if back == str then pass("blocks match")
	else fail("blocks don't match") end
end

-----------------------------------------------------------------------------
-- Tests return-timeout conformance
-----------------------------------------------------------------------------
function test_patterns()
	local dos_line1 = "this the first dos line"
	local dos_line2 = "this is another dos line"
	local unix_line1 = "this the first unix line"
	local unix_line2 = "this is another unix line"
	local block = dos_line1 .. "\r\n" ..  dos_line2 .. "\r\n"
	reconnect()
    block = block .. unix_line1 .. "\n" .. unix_line2 .. "\n"
	block = block .. block
	send_command(ECHO_BLOCK, strlen(block))
	err = send(data, block)
	if err then fail(err) end
	local back = receive(data, "*l")
	if back ~= dos_line1 then fail("'*l' failed") end
	back = receive(data, "*l")
	if back ~= dos_line2 then fail("'*l' failed") end
	back = receive(data, "*lu")
	if back ~= unix_line1 then fail("'*lu' failed") end
	back = receive(data, "*lu")
	if back ~= unix_line2 then fail("'*lu' failed") end
	back = receive(data)
	if back ~= dos_line1 then fail("default failed") end
	back = receive(data)
	if back ~= dos_line2 then fail("default failed") end
	back = receive(data, "*lu")
	if back ~= unix_line1 then fail("'*lu' failed") end
	back = receive(data, "*lu")
	if back ~= unix_line2 then fail("'*lu' failed") end
	pass("line patterns are ok")
	send_command(ECHO_BLOCK, strlen(block))
	err = send(data, block)
	if err then fail(err) end
	back = receive(data, strlen(block))
	if back ~= block then fail("number failed") end
	pass("number is ok")
	send_command(ECHO_BLOCK, strlen(block))
	send_command(SLEEP, 1)
	send_command(CLOSE)
	err = send(data, block)
	if err then fail(err) end
	back = receive(data, "*a")
	if back ~= block then fail("'*a' failed") end
	pass("'*a' is ok")
end

-----------------------------------------------------------------------------
-- Execute all tests
-----------------------------------------------------------------------------
start = time()

new_test("control connection test")
test_command(EXIT)
test_command(CONNECT)
test_command(CLOSE)
test_command(ECHO_BLOCK, 12234)
test_command(SLEEP, 1111)
test_command(ECHO_LINE)

new_test("connection close test")
test_closed()

new_test("read pattern test")
test_patterns()

new_test("character string test")
test_asciiline(1)
test_asciiline(17)
test_asciiline(200)
test_asciiline(3000)
test_asciiline(80000)
test_asciiline(800000)

new_test("binary string test")
test_rawline(1)
test_rawline(17)
test_rawline(200)
test_rawline(3000)
test_rawline(8000)
test_rawline(80000)
test_rawline(800000)

new_test("blocking transfer test")
test_block(1)
test_block(17)
test_block(200)
test_block(3000)
test_block(80000)
test_block(800000)

new_test("non-blocking transfer test")
-- the value is not important, we only want 
-- to test non-blockin I/O anyways
timeout(data, 200)
test_block(1)
test_block(17)
test_block(200)
test_block(3000)
test_block(80000)
test_block(800000)

new_test("blocked timeout test")
test_blockedtimeout(80, .5, 1)
test_blockedtimeout(80, 1, 1)
test_blockedtimeout(80, 1.5, 1)
test_blockedtimeout(800, 1, 0)
test_blockedtimeout(8000, 1, 1.5)
test_blockedtimeout(80000, 1, 0)
test_blockedtimeout(800000, 0.01, 0)

new_test("return timeout test")
test_returntimeout(80, 1, 0.5)
test_returntimeout(80, 0.5, 1)
test_returntimeout(8000, .5, 1)
test_returntimeout(80000, 1, 0.5)
test_returntimeout(800000, 1, 0.5)

-----------------------------------------------------------------------------
-- Close connection and exit server. We are done.
-----------------------------------------------------------------------------
print("client: closing connection with server")
send_command(CLOSE)
send_command(EXIT)
close(control)

new_test("the library has passed all tests")
print(format("time elapsed: %6.2fs", time() - start))
print("client: exiting...")
exit()