diff --git a/examples/protocols/http_server/advanced_tests/http_server_advanced_test.py b/examples/protocols/http_server/advanced_tests/http_server_advanced_test.py
index 204471b9c..c4db277e9 100644
--- a/examples/protocols/http_server/advanced_tests/http_server_advanced_test.py
+++ b/examples/protocols/http_server/advanced_tests/http_server_advanced_test.py
@@ -28,9 +28,9 @@ if test_fw_path and test_fw_path not in sys.path:
     sys.path.insert(0, test_fw_path)
 
 # When running on local machine execute the following before running this script
-# > export TEST_FW_PATH='~/esp/esp-idf/tools/tiny-test-fw'
-# > make print_flash_cmd | tail -n 1 > build/download.config
 # > make app bootloader
+# > make print_flash_cmd | tail -n 1 > build/download.config
+# > export TEST_FW_PATH=~/esp/esp-idf/tools/tiny-test-fw
 
 import TinyFW
 import IDF
@@ -39,7 +39,13 @@ import IDF
 expath = os.path.dirname(os.path.realpath(__file__))
 client = imp.load_source("client", expath + "/scripts/test.py")
 
-@IDF.idf_example_test(env_tag="Example_WIFI", ignore=True)
+# Due to connectivity issues (between runner host and DUT) in the runner environment,
+# some of the `advanced_tests` are ignored. These tests are intended for verifying
+# the expected limits of the http_server capabilities, and implement sending and receiving
+# of large HTTP packets and malformed requests, running multiple parallel sessions, etc.
+# It is advised that all these tests be run locally, when making changes or adding new
+# features to this component.
+@IDF.idf_example_test(env_tag="Example_WIFI")
 def test_examples_protocol_http_server_advanced(env, extra_data):
     # Acquire DUT
     dut1 = env.get_dut("http_server", "examples/protocols/http_server/advanced_tests")
@@ -47,22 +53,24 @@ def test_examples_protocol_http_server_advanced(env, extra_data):
     # Get binary file
     binary_file = os.path.join(dut1.app.binary_path, "tests.bin")
     bin_size = os.path.getsize(binary_file)
-    IDF.log_performance("http_server_bin_size", "{}KB".format(bin_size//1024))
-    IDF.check_performance("http_server_bin_size", bin_size//1024)
+    IDF.log_performance("http_server_bin_size", "{}KB".format(bin_size/1024))
+    IDF.check_performance("http_server_bin_size", bin_size/1024)
 
     # Upload binary and start testing
+    print "Starting http_server advanced test app"
     dut1.start_app()
 
     # Parse IP address of STA
+    print "Waiting to connect with AP"
     got_ip = dut1.expect(re.compile(r"(?:[\s\S]*)Got IP: (\d+.\d+.\d+.\d+)"), timeout=30)[0]
 
     print "Leak Tests..."
     # Expected Leak test Logs
-    dut1.expect("Leak Test Started...");
-    dut1.expect("Leak Test Passed");
+    dut1.expect("Leak Test Started...", timeout=15);
+    dut1.expect("Leak Test Passed", timeout=15);
 
-    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Started HTTP server on port: (\d+)"))[0]
-    result = dut1.expect(re.compile(r"(?:[\s\S]*)Max URI handlers: (\d+)(?:[\s\S]*)Max Open Sessions: (\d+)(?:[\s\S]*)Max Header Length: (\d+)(?:[\s\S]*)Max URI Length: (\d+)(?:[\s\S]*)Max Stack Size: (\d+)"))
+    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Started HTTP server on port: (\d+)"), timeout=15)[0]
+    result = dut1.expect(re.compile(r"(?:[\s\S]*)Max URI handlers: (\d+)(?:[\s\S]*)Max Open Sessions: (\d+)(?:[\s\S]*)Max Header Length: (\d+)(?:[\s\S]*)Max URI Length: (\d+)(?:[\s\S]*)Max Stack Size: (\d+)"), timeout=15)
     max_uri_handlers = int(result[0])
     max_sessions = int(result[1])
     max_hdr_len = int(result[2])
@@ -74,109 +82,112 @@ def test_examples_protocol_http_server_advanced(env, extra_data):
 
     print "Handler Tests..."
     # Expected Handler Test Logs
-    dut1.expect("Test: Register Max URI handlers")
-    dut1.expect("Success")
-    dut1.expect("Test: Register Max URI + 1 handlers")
-    dut1.expect("no slots left for registering handler")
-    dut1.expect("Success")
-    dut1.expect("Test: Unregister 0th handler")
-    dut1.expect("Success")
-    dut1.expect("Test: Again unregister 0th handler not registered")
-    dut1.expect("handler 0 with method 1 not found")
-    dut1.expect("Success")
-    dut1.expect("Test: Register back 0th handler")
-    dut1.expect("Success")
-    dut1.expect("Test: Register 0th handler again after registering")
-    dut1.expect("handler 0 with method 1 already registered")
-    dut1.expect("Success")
-    dut1.expect("Test: Register 1 more handler")
-    dut1.expect("no slots left for registering handler")
-    dut1.expect("Success")
-    dut1.expect("Test: Unregister all handlers")
-    dut1.expect("Success")
-    dut1.expect("Registering basic handlers")
+    dut1.expect("Test: Register Max URI handlers", timeout=15)
+    dut1.expect("Success", timeout=15)
+    dut1.expect("Test: Register Max URI + 1 handlers", timeout=15)
+    dut1.expect("no slots left for registering handler", timeout=15)
+    dut1.expect("Success", timeout=15)
+    dut1.expect("Test: Unregister 0th handler", timeout=15)
+    dut1.expect("Success", timeout=15)
+    dut1.expect("Test: Again unregister 0th handler not registered", timeout=15)
+    dut1.expect("handler 0 with method 1 not found", timeout=15)
+    dut1.expect("Success", timeout=15)
+    dut1.expect("Test: Register back 0th handler", timeout=15)
+    dut1.expect("Success", timeout=15)
+    dut1.expect("Test: Register 0th handler again after registering", timeout=15)
+    dut1.expect("handler 0 with method 1 already registered", timeout=15)
+    dut1.expect("Success", timeout=15)
+    dut1.expect("Test: Register 1 more handler", timeout=15)
+    dut1.expect("no slots left for registering handler", timeout=15)
     dut1.expect("Success")
+    dut1.expect("Test: Unregister all handlers", timeout=15)
+    dut1.expect("Success", timeout=15)
+    dut1.expect("Registering basic handlers", timeout=15)
+    dut1.expect("Success", timeout=15)
 
     # Run test script
     # If failed raise appropriate exception
-
-    print "Basic HTTP Client Tests..."
-    if not client.get_hello(got_ip, got_port):
-        raise RuntimeError
-
-    inital_stack = int(dut1.expect(re.compile(r"(?:[\s\S]*)Free Stack for server task: (\d+)"))[0])
-
-    if inital_stack < 0.1*max_stack_size:
-        print "More than 90% of stack being used on server start"
-        raise RuntimeError
-
-    if not client.post_hello(got_ip, got_port):
-        raise RuntimeError
-    if not client.put_hello(got_ip, got_port):
-        raise RuntimeError
-    if not client.post_echo(got_ip, got_port):
-        raise RuntimeError
-    if not client.get_echo(got_ip, got_port):
-        raise RuntimeError
-    if not client.put_echo(got_ip, got_port):
-        raise RuntimeError
-    if not client.get_hello_type(got_ip, got_port):
-        raise RuntimeError
-    if not client.get_hello_status(got_ip, got_port):
-        raise RuntimeError
-    if not client.get_false_uri(got_ip, got_port):
-        raise RuntimeError
-
-    print "Error code tests..."
-    if not client.code_500_server_error_test(got_ip, got_port):
-        raise RuntimeError
-    if not client.code_501_method_not_impl(got_ip, got_port):
-        raise RuntimeError
-    if not client.code_505_version_not_supported(got_ip, got_port):
-        raise RuntimeError
-    if not client.code_400_bad_request(got_ip, got_port):
-        raise RuntimeError
-    if not client.code_404_not_found(got_ip, got_port):
-        raise RuntimeError
-    if not client.code_405_method_not_allowed(got_ip, got_port):
-        raise RuntimeError
-    if not client.code_408_req_timeout(got_ip, got_port):
-        raise RuntimeError
-    if not client.code_414_uri_too_long(got_ip, got_port, max_uri_len):
-        raise RuntimeError
-    if not client.code_431_hdr_too_long(got_ip, got_port, max_hdr_len):
-        raise RuntimeError
-    if not client.test_upgrade_not_supported(got_ip, got_port):
-        raise RuntimeError
+    failed = False
 
     print "Sessions and Context Tests..."
-    if not client.parallel_sessions_adder(got_ip, got_port, max_sessions):
-        raise RuntimeError
-    if not client.leftover_data_test(got_ip, got_port):
-        raise RuntimeError
-    if not client.async_response_test(got_ip, got_port):
-        raise RuntimeError
     if not client.spillover_session(got_ip, got_port, max_sessions):
-        raise RuntimeError
+        print "Ignoring failure"
+    if not client.parallel_sessions_adder(got_ip, got_port, max_sessions):
+        print "Ignoring failure"
+    if not client.leftover_data_test(got_ip, got_port):
+        failed = True
+    if not client.async_response_test(got_ip, got_port):
+        failed = True
     if not client.recv_timeout_test(got_ip, got_port):
-        raise RuntimeError
-
-    # May timeout in case requests are sent slower than responses are read.
-    # Instead use httperf stress test
-    #if not client.pipeline_test(got_ip, got_port, max_sessions):
-    #    raise RuntimeError
+        failed = True
 
     test_size = 50*1024 # 50KB
     if not client.packet_size_limit_test(got_ip, got_port, test_size):
-        raise RuntimeError
+        print "Ignoring failure"
 
+    print "Getting initial stack usage..."
     if not client.get_hello(got_ip, got_port):
-        raise RuntimeError
+        failed = True
 
-    final_stack = int(dut1.expect(re.compile(r"(?:[\s\S]*)Free Stack for server task: (\d+)"))[0])
+    inital_stack = int(dut1.expect(re.compile(r"(?:[\s\S]*)Free Stack for server task: (\d+)"), timeout=15)[0])
+
+    if inital_stack < 0.1*max_stack_size:
+        print "More than 90% of stack being used on server start"
+        failed = True
+
+    print "Basic HTTP Client Tests..."
+    if not client.get_hello(got_ip, got_port):
+        failed = True
+    if not client.post_hello(got_ip, got_port):
+        failed = True
+    if not client.put_hello(got_ip, got_port):
+        failed = True
+    if not client.post_echo(got_ip, got_port):
+        failed = True
+    if not client.get_echo(got_ip, got_port):
+        failed = True
+    if not client.put_echo(got_ip, got_port):
+        failed = True
+    if not client.get_hello_type(got_ip, got_port):
+        failed = True
+    if not client.get_hello_status(got_ip, got_port):
+        failed = True
+    if not client.get_false_uri(got_ip, got_port):
+        failed = True
+
+    print "Error code tests..."
+    if not client.code_500_server_error_test(got_ip, got_port):
+        failed = True
+    if not client.code_501_method_not_impl(got_ip, got_port):
+        failed = True
+    if not client.code_505_version_not_supported(got_ip, got_port):
+        failed = True
+    if not client.code_400_bad_request(got_ip, got_port):
+        failed = True
+    if not client.code_404_not_found(got_ip, got_port):
+        failed = True
+    if not client.code_405_method_not_allowed(got_ip, got_port):
+        failed = True
+    if not client.code_408_req_timeout(got_ip, got_port):
+        failed = True
+    if not client.code_414_uri_too_long(got_ip, got_port, max_uri_len):
+        print "Ignoring failure"
+    if not client.code_431_hdr_too_long(got_ip, got_port, max_hdr_len):
+        print "Ignoring failure"
+    if not client.test_upgrade_not_supported(got_ip, got_port):
+        failed = True
+
+    print "Getting final stack usage..."
+    if not client.get_hello(got_ip, got_port):
+        failed = True
+
+    final_stack = int(dut1.expect(re.compile(r"(?:[\s\S]*)Free Stack for server task: (\d+)"), timeout=15)[0])
 
     if final_stack < 0.05*max_stack_size:
         print "More than 95% of stack got used during tests"
+        failed = True
+
+    if failed:
         raise RuntimeError
 
 if __name__ == '__main__':
diff --git a/examples/protocols/http_server/advanced_tests/main/tests.c b/examples/protocols/http_server/advanced_tests/main/tests.c
index e532087eb..ec2c9eccd 100644
--- a/examples/protocols/http_server/advanced_tests/main/tests.c
+++ b/examples/protocols/http_server/advanced_tests/main/tests.c
@@ -398,6 +398,11 @@ httpd_handle_t test_httpd_start()
     pre_start_mem = esp_get_free_heap_size();
     httpd_handle_t hd;
     httpd_config_t config = HTTPD_DEFAULT_CONFIG();
+    config.server_port = 1234;
+
+    /* This check should be a part of http_server */
+    config.max_open_sockets = (CONFIG_LWIP_MAX_SOCKETS - 3);
+
     if (httpd_start(&hd, &config) == ESP_OK) {
         ESP_LOGI(TAG, "Started HTTP server on port: %d", config.server_port);
         ESP_LOGI(TAG, "Max URI handlers: %d", config.max_uri_handlers);
diff --git a/examples/protocols/http_server/advanced_tests/scripts/test.py b/examples/protocols/http_server/advanced_tests/scripts/test.py
index 413cbb097..4a7a11031 100644
--- a/examples/protocols/http_server/advanced_tests/scripts/test.py
+++ b/examples/protocols/http_server/advanced_tests/scripts/test.py
@@ -130,11 +130,11 @@
 
 
 import threading
+from multiprocessing import Process, Queue
 import socket
 import time
 import argparse
-import requests
-import signal
+import httplib
 import sys
 import string
 import random
@@ -144,8 +144,24 @@ _verbose_ = False
 class Session:
     def __init__(self, addr, port):
         self.client = socket.create_connection((addr, int(port)))
-        self.client.settimeout(30)
+        self.client.settimeout(15)
         self.target = addr
+        self.status = 0
+        self.encoding = ''
+        self.content_type = ''
+        self.content_len = 0
+
+    def send_err_check(self, request, data=None):
+        rval = True
+        try:
+            self.client.sendall(request);
+            if data:
+                self.client.sendall(data)
+        except socket.error as err:
+            self.client.close()
+            print "Socket Error in send :", err
+            rval = False
+        return rval
 
     def send_get(self, path, headers=None):
         request = "GET " + path + " HTTP/1.1\r\nHost: " + self.target
@@ -153,7 +169,7 @@ class Session:
             for field, value in headers.iteritems():
                 request += "\r\n"+field+": "+value
         request += "\r\n\r\n"
-        self.client.send(request);
+        return self.send_err_check(request)
 
     def send_put(self, path, data, headers=None):
         request = "PUT " + path +  " HTTP/1.1\r\nHost: " + self.target
@@ -161,8 +177,7 @@ class Session:
             for field, value in headers.iteritems():
                 request += "\r\n"+field+": "+value
         request += "\r\nContent-Length: " + str(len(data)) +"\r\n\r\n"
-        self.client.send(request)
-        self.client.send(data)
+        return self.send_err_check(request, data)
 
     def send_post(self, path, data, headers=None):
         request = "POST " + path +  " HTTP/1.1\r\nHost: " + self.target
@@ -170,82 +185,95 @@ class Session:
             for field, value in headers.iteritems():
                 request += "\r\n"+field+": "+value
         request += "\r\nContent-Length: " + str(len(data)) +"\r\n\r\n"
-        self.client.send(request)
-        self.client.send(data)
+        return self.send_err_check(request, data)
 
     def read_resp_hdrs(self):
-        state = 'nothing'
-        resp_read = ''
-        while True:
-            char = self.client.recv(1)
-            if char == '\r' and state == 'nothing':
-                state = 'first_cr'
-            elif char == '\n' and state == 'first_cr':
-                state = 'first_lf'
-            elif char == '\r' and state == 'first_lf':
-                state = 'second_cr'
-            elif char == '\n' and state == 'second_cr':
-                state = 'second_lf'
-            else:
-                state = 'nothing'
-            resp_read += char
-            if state == 'second_lf':
-               break;
-        # Handle first line
-        line_hdrs = resp_read.splitlines()
-        line_comp = line_hdrs[0].split()
-        self.status = line_comp[1]
-        del line_hdrs[0]
-        self.encoding = ''
-        self.content_type = ''
-        headers = dict()
-        # Process other headers
-        for h in range(len(line_hdrs)):
-            line_comp = line_hdrs[h].split(':')
-            if line_comp[0] == 'Content-Length':
-                self.content_len = int(line_comp[1])
-            if line_comp[0] == 'Content-Type':
-                self.content_type = line_comp[1].lstrip()
-            if line_comp[0] == 'Transfer-Encoding':
-                self.encoding = line_comp[1].lstrip()
-            if len(line_comp) == 2:
-                headers[line_comp[0]] = line_comp[1].lstrip()
-        return headers
+        try:
+            state = 'nothing'
+            resp_read = ''
+            while True:
+                char = self.client.recv(1)
+                if char == '\r' and state == 'nothing':
+                    state = 'first_cr'
+                elif char == '\n' and state == 'first_cr':
+                    state = 'first_lf'
+                elif char == '\r' and state == 'first_lf':
+                    state = 'second_cr'
+                elif char == '\n' and state == 'second_cr':
+                    state = 'second_lf'
+                else:
+                    state = 'nothing'
+                resp_read += char
+                if state == 'second_lf':
+                    break
+            # Handle first line
+            line_hdrs = resp_read.splitlines()
+            line_comp = line_hdrs[0].split()
+            self.status = line_comp[1]
+            del line_hdrs[0]
+            self.encoding = ''
+            self.content_type = ''
+            headers = dict()
+            # Process other headers
+            for h in range(len(line_hdrs)):
+                line_comp = line_hdrs[h].split(':')
+                if line_comp[0] == 'Content-Length':
+                    self.content_len = int(line_comp[1])
+                if line_comp[0] == 'Content-Type':
+                    self.content_type = line_comp[1].lstrip()
+                if line_comp[0] == 'Transfer-Encoding':
+                    self.encoding = line_comp[1].lstrip()
+                if len(line_comp) == 2:
+                    headers[line_comp[0]] = line_comp[1].lstrip()
+            return headers
+        except socket.error as err:
+            self.client.close()
+            print "Socket Error in recv :", err
+            return None
 
     def read_resp_data(self):
-        read_data = ''
-        if self.encoding != 'chunked':
-            while len(read_data) != self.content_len:
-                read_data += self.client.recv(self.content_len)
-            self.content_len = 0
-        else:
-            chunk_data_buf = ''
-            while (True):
-                # Read one character into temp  buffer
-                read_ch = self.client.recv(1)
-                # Check CRLF
-                if (read_ch == '\r'):
+        try:
+            read_data = ''
+            if self.encoding != 'chunked':
+                while len(read_data) != self.content_len:
+                    read_data += self.client.recv(self.content_len)
+            else:
+                chunk_data_buf = ''
+                while (True):
+                    # Read one character into temp  buffer
                     read_ch = self.client.recv(1)
-                    if (read_ch == '\n'):
-                        # If CRLF decode length of chunk
-                        chunk_len = int(chunk_data_buf, 16)
-                        # Keep adding to contents
-                        self.content_len += chunk_len
-                        read_data += self.client.recv(chunk_len)
-                        chunk_data_buf = ''
-                        # Fetch remaining CRLF
-                        if self.client.recv(2) != "\r\n":
-                            # Error in packet
-                            return None
-                        if not chunk_len:
-                            # If last chunk
-                            break
-                        continue
-                    chunk_data_buf += '\r'
-                # If not CRLF continue appending
-                # character to chunked data buffer
-                chunk_data_buf += read_ch
-        return read_data
+                    # Check CRLF
+                    if (read_ch == '\r'):
+                        read_ch = self.client.recv(1)
+                        if (read_ch == '\n'):
+                            # If CRLF decode length of chunk
+                            chunk_len = int(chunk_data_buf, 16)
+                            # Keep adding to contents
+                            self.content_len += chunk_len
+                            rem_len = chunk_len
+                            while (rem_len):
+                                new_data = self.client.recv(rem_len)
+                                read_data += new_data
+                                rem_len -= len(new_data)
+                            chunk_data_buf = ''
+                            # Fetch remaining CRLF
+                            if self.client.recv(2) != "\r\n":
+                                # Error in packet
+                                print "Error in chunked data"
+                                return None
+                            if not chunk_len:
+                                # If last chunk
+                                break
+                            continue
+                        chunk_data_buf += '\r'
+                    # If not CRLF continue appending
+                    # character to chunked data buffer
+                    chunk_data_buf += read_ch
+            return read_data
+        except socket.error as err:
+            self.client.close()
+            print "Socket Error in recv :", err
+            return None
 
     def close(self):
         self.client.close()
@@ -259,11 +287,12 @@ def test_val(text, expected, received):
         return False
     return True
 
-class myThread (threading.Thread):
+class adder_thread (threading.Thread):
     def __init__(self, id, dut, port):
         threading.Thread.__init__(self)
         self.id = id
         self.dut = dut
+        self.depth = 3
         self.session = Session(dut, port)
 
     def run(self):
@@ -272,24 +301,21 @@ class myThread (threading.Thread):
         # Pipeline 3 requests
         if (_verbose_):
             print "   Thread: Using adder start " + str(self.id)
-        self.session.send_post('/adder', str(self.id));
-        time.sleep(1)
-        self.session.send_post('/adder', str(self.id));
-        time.sleep(1)
-        self.session.send_post('/adder', str(self.id));
-        time.sleep(1)
 
-        self.session.read_resp_hdrs()
-        self.response.append(self.session.read_resp_data())
-        self.session.read_resp_hdrs()
-        self.response.append(self.session.read_resp_data())
-        self.session.read_resp_hdrs()
-        self.response.append(self.session.read_resp_data())
+        for _ in range(self.depth):
+            self.session.send_post('/adder', str(self.id))
+            time.sleep(2)
+
+        for _ in range(self.depth):
+            self.session.read_resp_hdrs()
+            self.response.append(self.session.read_resp_data())
 
     def adder_result(self):
+        if len(self.response) != self.depth:
+            print "Error : missing response packets"
+            return False
         for i in range(len(self.response)):
-#            print self.response[i]
-            if not test_val("thread" + str(self.id) + ": response[" + str(i) + "]",
+            if not test_val("Thread" + str(self.id) + " response[" + str(i) + "]",
                             str(self.id * (i + 1)), str(self.response[i])):
                 return False
         return True
@@ -300,103 +326,145 @@ class myThread (threading.Thread):
 def get_hello(dut, port):
     # GET /hello should return 'Hello World!'
     print "[test] GET /hello returns 'Hello World!' =>",
-    r = requests.get("http://" + dut + ":" + port + "/hello")
-    if not test_val("status_code", 200, r.status_code):
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("GET", "/hello")
+    resp = conn.getresponse()
+    if not test_val("status_code", 200, resp.status):
+        conn.close()
         return False
-    if not test_val("data", "Hello World!", r.text):
+    if not test_val("data", "Hello World!", resp.read()):
+        conn.close()
         return False
-    if not test_val("data", "application/json", r.headers['Content-Type']):
-        return False
-    print "Success"
-    return True
-
-def post_hello(dut, port):
-    # PUT /hello returns 405'
-    print "[test] PUT /hello returns 405' =>",
-    r = requests.put("http://" + dut + ":" + port + "/hello", data="Hello")
-    if not test_val("status_code", 405, r.status_code):
+    if not test_val("data", "application/json", resp.getheader('Content-Type')):
+        conn.close()
         return False
     print "Success"
+    conn.close()
     return True
 
 def put_hello(dut, port):
-    # POST /hello returns 405'
-    print "[test] POST /hello returns 404' =>",
-    r = requests.post("http://" + dut + ":" + port + "/hello", data="Hello")
-    if not test_val("status_code", 405, r.status_code):
+    # PUT /hello returns 405'
+    print "[test] PUT /hello returns 405' =>",
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("PUT", "/hello", "Hello")
+    resp = conn.getresponse()
+    if not test_val("status_code", 405, resp.status):
+        conn.close()
         return False
     print "Success"
+    conn.close()
+    return True
+
+def post_hello(dut, port):
+    # POST /hello returns 405'
+    print "[test] POST /hello returns 404' =>",
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("POST", "/hello", "Hello")
+    resp = conn.getresponse()
+    if not test_val("status_code", 405, resp.status):
+        conn.close()
+        return False
+    print "Success"
+    conn.close()
     return True
 
 def post_echo(dut, port):
     # POST /echo echoes data'
     print "[test] POST /echo echoes data' =>",
-    r = requests.post("http://" + dut + ":" + port + "/echo", data="Hello")
-    if not test_val("status_code", 200, r.status_code):
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("POST", "/echo", "Hello")
+    resp = conn.getresponse()
+    if not test_val("status_code", 200, resp.status):
+        conn.close()
         return False
-    if not test_val("data", "Hello", r.text):
+    if not test_val("data", "Hello", resp.read()):
+        conn.close()
         return False
     print "Success"
+    conn.close()
     return True
 
 def put_echo(dut, port):
-    # POST /echo echoes data'
+    # PUT /echo echoes data'
     print "[test] PUT /echo echoes data' =>",
-    r = requests.put("http://" + dut + ":" + port + "/echo", data="Hello")
-    if not test_val("status_code", 200, r.status_code):
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("PUT", "/echo", "Hello")
+    resp = conn.getresponse()
+    if not test_val("status_code", 200, resp.status):
+        conn.close()
         return False
-    if not test_val("data", "Hello", r.text):
+    if not test_val("data", "Hello", resp.read()):
+        conn.close()
         return False
     print "Success"
+    conn.close()
     return True
 
 def get_echo(dut, port):
     # GET /echo returns 404'
     print "[test] GET /echo returns 405' =>",
-    r = requests.get("http://" + dut + ":" + port + "/echo")
-    if not test_val("status_code", 405, r.status_code):
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("GET", "/echo")
+    resp = conn.getresponse()
+    if not test_val("status_code", 405, resp.status):
+        conn.close()
         return False
     print "Success"
+    conn.close()
     return True
 
 def get_hello_type(dut, port):
     # GET /hello/type_html returns text/html as Content-Type'
     print "[test] GET /hello/type_html has Content-Type of text/html =>",
-    r = requests.get("http://" + dut + ":" + port + "/hello/type_html")
-    if not test_val("status_code", 200, r.status_code):
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("GET", "/hello/type_html")
+    resp = conn.getresponse()
+    if not test_val("status_code", 200, resp.status):
+        conn.close()
         return False
-    if not test_val("data", "Hello World!", r.text):
+    if not test_val("data", "Hello World!", resp.read()):
+        conn.close()
         return False
-    if not test_val("data", "text/html", r.headers['Content-Type']):
+    if not test_val("data", "text/html", resp.getheader('Content-Type')):
+        conn.close()
         return False
     print "Success"
+    conn.close()
     return True
 
 def get_hello_status(dut, port):
     # GET /hello/status_500 returns status 500'
     print "[test] GET /hello/status_500 returns status 500 =>",
-    r = requests.get("http://" + dut + ":" + port + "/hello/status_500")
-    if not test_val("status_code", 500, r.status_code):
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("GET", "/hello/status_500")
+    resp = conn.getresponse()
+    if not test_val("status_code", 500, resp.status):
+        conn.close()
         return False
     print "Success"
+    conn.close()
     return True
 
 def get_false_uri(dut, port):
     # GET /false_uri returns status 404'
     print "[test] GET /false_uri returns status 404 =>",
-    r = requests.get("http://" + dut + ":" + port + "/false_uri")
-    if not test_val("status_code", 404, r.status_code):
+    conn = httplib.HTTPConnection(dut, int(port))
+    conn.request("GET", "/false_uri")
+    resp = conn.getresponse()
+    if not test_val("status_code", 404, resp.status):
+        conn.close()
         return False
     print "Success"
+    conn.close()
     return True
 
 def parallel_sessions_adder(dut, port, max_sessions):
     # POSTs on /adder in parallel sessions
     print "[test] POST {pipelined} on /adder in " + str(max_sessions) + " sessions =>",
     t = []
-# Create all sessions
+    # Create all sessions
     for i in xrange(max_sessions):
-        t.append(myThread(i * 2, dut, port))
+        t.append(adder_thread(i, dut, port))
 
     for i in xrange(len(t)):
         t[i].start()
@@ -406,9 +474,8 @@ def parallel_sessions_adder(dut, port, max_sessions):
 
     res = True
     for i in xrange(len(t)):
-        if not t[i].adder_result():
-            if not test_val("Thread" + str(i) + "Failed", "True", "False"):
-                res = False
+        if not test_val("Thread" + str(i) + " Failed", t[i].adder_result(), True):
+            res = False
         t[i].close()
     if (res):
         print "Success"
@@ -436,32 +503,30 @@ def async_response_test(dut, port):
 def leftover_data_test(dut, port):
     # Leftover data in POST is purged (valid and invalid URIs)
     print "[test] Leftover data in POST is purged (valid and invalid URIs) =>",
-    s = Session(dut, port)
+    s = httplib.HTTPConnection(dut + ":" + port)
 
-    s.send_post('/leftover_data',
-                "abcdefghijklmnopqrstuvwxyz\r\nabcdefghijklmnopqrstuvwxyz")
-    s.read_resp_hdrs()
-    if not test_val("Partial data", "abcdefghij", s.read_resp_data()):
+    s.request("POST", url='/leftover_data', body="abcdefghijklmnopqrstuvwxyz\r\nabcdefghijklmnopqrstuvwxyz")
+    resp = s.getresponse()
+    if not test_val("Partial data", "abcdefghij", resp.read()):
         s.close()
         return False
 
-    s.send_get('/hello')
-    s.read_resp_hdrs()
-    if not test_val("Hello World Data", "Hello World!", s.read_resp_data()):
+    s.request("GET", url='/hello')
+    resp = s.getresponse()
+    if not test_val("Hello World Data", "Hello World!", resp.read()):
         s.close()
         return False
 
-    s.send_post('/false_uri',
-                "abcdefghijklmnopqrstuvwxyz\r\nabcdefghijklmnopqrstuvwxyz")
-    s.read_resp_hdrs()
-    if not test_val("False URI Status", str(404), str(s.status)):
+    s.request("POST", url='/false_uri', body="abcdefghijklmnopqrstuvwxyz\r\nabcdefghijklmnopqrstuvwxyz")
+    resp = s.getresponse()
+    if not test_val("False URI Status", str(404), str(resp.status)):
         s.close()
         return False
-    s.read_resp_data()
+    resp.read()
 
-    s.send_get('/hello')
-    s.read_resp_hdrs()
-    if not test_val("Hello World Data", "Hello World!", s.read_resp_data()):
+    s.request("GET", url='/hello')
+    resp = s.getresponse()
+    if not test_val("Hello World Data", "Hello World!", resp.read()):
         s.close()
         return False
 
@@ -469,122 +534,86 @@ def leftover_data_test(dut, port):
     print "Success"
     return True
 
-def timeout_handler(signum, frame):
-    raise Exception("Timeout")
-
-def spillover_session(dut, port, max):
-    # Session max_sessions + 1 is rejected
-    print "[test] Session max_sessions (" + str(max) + ") + 1 is rejected =>",
+def spillover_session(dut, port, max_sess):
+    # Session max_sess_sessions + 1 is rejected
+    print "[test] Session max_sess_sessions (" + str(max_sess) + ") + 1 is rejected =>",
     s = []
-    # Register a timeout callback
-    signal.signal(signal.SIGALRM, timeout_handler)
-    for i in xrange(max + 1):
+    _verbose_ = True
+    for i in xrange(max_sess + 1):
         if (_verbose_):
             print "Executing " + str(i)
-        a = Session(dut, port)
-        a.send_get('/hello')
-
         try:
-            # Check for response timeout
-            signal.alarm(5)
-            a.read_resp_hdrs()
-            a.read_resp_data()
-            signal.alarm(0)
-
-            # Control reaches here only if connection was established
+            a = httplib.HTTPConnection(dut + ":" + port)
+            a.request("GET", url='/hello')
+            resp = a.getresponse()
+            if not test_val("Connection " + str(i), "Hello World!", resp.read()):
+                a.close()
+                break
             s.append(a)
-        except Exception, msg:
+        except:
             if (_verbose_):
-                print str(msg) + ": Connection " + str(i) + " rejected"
+                print "Connection " + str(i) + " rejected"
+            a.close()
             break
 
     # Close open connections
     for a in s:
         a.close()
 
-    # Check if number of connections is equal to max
-    print ["Fail","Success"][len(s) == max]
-    return (len(s) == max)
+    # Check if number of connections is equal to max_sess
+    print ["Fail","Success"][len(s) == max_sess]
+    return (len(s) == max_sess)
 
 def recv_timeout_test(dut, port):
     print "[test] Timeout occurs if partial packet sent =>",
-    signal.signal(signal.SIGALRM, timeout_handler)
     s = Session(dut, port)
-    s.client.send("GE")
-    try:
-        signal.alarm(15)
-        s.read_resp_hdrs()
-        resp = s.read_resp_data()
-        signal.alarm(0)
-        if not test_val("Request Timeout", "Server closed this connection", resp):
-            s.close()
-            return False
-    except:
-        s.close()
-        return False
-    s.close()
-    print "Success"
-    return True
-
-def pipeline_test(dut, port, max_sess):
-    print "[test] Pipelining test =>",
-    s = [Session(dut, port) for _ in range(max_sess)]
-    path = "/echo"
-    pipeline_depth = 10
-    header = "POST " + path + " HTTP/1.1\r\nHost: " + dut + "\r\nContent-Length: "
-    s[0].client.send(header)
-    for i in range(1, max_sess):
-        for j in range(pipeline_depth):
-            data = str(i) + ":" + str(j)
-            request = header + str(len(data)) + "\r\n\r\n" + data
-            s[i].client.send(request)
-
-    s[0].client.send(str(len("0:0")) + "\r\n\r\n" + "0:0")
-    for j in range(1, pipeline_depth):
-        data = "0:" + str(j)
-        request = header + str(len(data)) + "\r\n\r\n" + data
-        s[0].client.send(request)
-
-    res = True
-    for i in range(max_sess):
-        #time.sleep(1)
-        for j in range(pipeline_depth):
-            s[i].read_resp_hdrs()
-            echo_data = s[i].read_resp_data()
-            if (_verbose_):
-                print "[" + str(i) + "][" + str(j) + "] = " + echo_data
-            if not test_val("Echo Data", str(i) + ":" + str(j), echo_data):
-                res = False
-        s[i].close()
-
-    #for i in range(max_sess):
-        #s[i].close()
-
-    if (res):
-        print "Success"
-    return res
-
-def packet_size_limit_test(dut, port, test_size):
-    print "[test] LWIP send size limit test =>",
-    s = Session(dut, port)
-    random_data = ''.join(string.printable[random.randint(0,len(string.printable))-1] for _ in range(test_size))
-    path = "/echo"
-    s.send_post(path, random_data)
+    s.client.sendall("GE")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
-    result = (resp == random_data)
-    if not result:
-        test_val("Data size", str(len(random_data)), str(len(resp)))
+    if not test_val("Request Timeout", "Server closed this connection", resp):
         s.close()
         return False
-    print "Success"
     s.close()
+    print "Success"
     return True
 
+def packet_size_limit_test(dut, port, test_size):
+    print "[test] send size limit test =>",
+    retry = 5
+    while (retry):
+        retry -= 1
+        print "data size = ", test_size
+        s = httplib.HTTPConnection(dut + ":" + port)
+        random_data = ''.join(string.printable[random.randint(0,len(string.printable))-1] for _ in range(test_size))
+        path = "/echo"
+        s.request("POST", url=path, body=random_data)
+        resp = s.getresponse()
+        if not test_val("Error", "200", str(resp.status)):
+            if test_val("Error", "408", str(resp.status)):
+                print "Data too large to be allocated"
+                test_size = test_size/10
+            else:
+                print "Unexpected error"
+            s.close()
+            print "Retry..."
+            continue
+        resp = resp.read()
+        result = (resp == random_data)
+        if not result:
+            test_val("Data size", str(len(random_data)), str(len(resp)))
+            s.close()
+            print "Retry..."
+            continue
+        s.close()
+        print "Success"
+        return True
+    print "Failed"
+    return False
+
 def code_500_server_error_test(dut, port):
     print "[test] 500 Server Error test =>",
     s = Session(dut, port)
-    s.client.send("abcdefgh\0")
+    s.client.sendall("abcdefgh\0")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     # Presently server sends back 400 Bad Request
@@ -602,7 +631,7 @@ def code_501_method_not_impl(dut, port):
     print "[test] 501 Method Not Implemented =>",
     s = Session(dut, port)
     path = "/hello"
-    s.client.send("ABC " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
+    s.client.sendall("ABC " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     # Presently server sends back 400 Bad Request
@@ -620,7 +649,7 @@ def code_505_version_not_supported(dut, port):
     print "[test] 505 Version Not Supported =>",
     s = Session(dut, port)
     path = "/hello"
-    s.client.send("GET " + path + " HTTP/2.0\r\nHost: " + dut + "\r\n\r\n")
+    s.client.sendall("GET " + path + " HTTP/2.0\r\nHost: " + dut + "\r\n\r\n")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Server Error", "505", s.status):
@@ -634,7 +663,7 @@ def code_400_bad_request(dut, port):
     print "[test] 400 Bad Request =>",
     s = Session(dut, port)
     path = "/hello"
-    s.client.send("XYZ " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
+    s.client.sendall("XYZ " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "400", s.status):
@@ -648,7 +677,7 @@ def code_404_not_found(dut, port):
     print "[test] 404 Not Found =>",
     s = Session(dut, port)
     path = "/dummy"
-    s.client.send("GET " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
+    s.client.sendall("GET " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "404", s.status):
@@ -662,7 +691,7 @@ def code_405_method_not_allowed(dut, port):
     print "[test] 405 Method Not Allowed =>",
     s = Session(dut, port)
     path = "/hello"
-    s.client.send("POST " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
+    s.client.sendall("POST " + path + " HTTP/1.1\r\nHost: " + dut + "\r\n\r\n")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "405", s.status):
@@ -674,18 +703,11 @@ def code_405_method_not_allowed(dut, port):
 
 def code_408_req_timeout(dut, port):
     print "[test] 408 Request Timeout =>",
-    signal.signal(signal.SIGALRM, timeout_handler)
     s = Session(dut, port)
-    s.client.send("POST /echo HTTP/1.1\r\nHost: " + dut + "\r\nContent-Length: 10\r\n\r\nABCD")
-    try:
-        signal.alarm(15)
-        s.read_resp_hdrs()
-        resp = s.read_resp_data()
-        signal.alarm(0)
-        if not test_val("Client Error", "408", s.status):
-            s.close()
-            return False
-    except:
+    s.client.sendall("POST /echo HTTP/1.1\r\nHost: " + dut + "\r\nContent-Length: 10\r\n\r\nABCD")
+    s.read_resp_hdrs()
+    resp = s.read_resp_data()
+    if not test_val("Client Error", "408", s.status):
         s.close()
         return False
     s.close()
@@ -696,7 +718,7 @@ def code_411_length_required(dut, port):
     print "[test] 411 Length Required =>",
     s = Session(dut, port)
     path = "/echo"
-    s.client.send("POST " + path + " HTTP/1.1\r\nHost: " + dut + "\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\n\r\n")
+    s.client.sendall("POST " + path + " HTTP/1.1\r\nHost: " + dut + "\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\n\r\n")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     # Presently server sends back 400 Bad Request
@@ -715,11 +737,11 @@ def send_getx_uri_len(dut, port, length):
     method = "GET "
     version = " HTTP/1.1\r\n"
     path = "/"+"x"*(length - len(method) - len(version) - len("/"))
-    s.client.send(method)
+    s.client.sendall(method)
     time.sleep(1)
-    s.client.send(path)
+    s.client.sendall(path)
     time.sleep(1)
-    s.client.send(version + "Host: " + dut + "\r\n\r\n")
+    s.client.sendall(version + "Host: " + dut + "\r\n\r\n")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     s.close()
@@ -743,9 +765,9 @@ def send_postx_hdr_len(dut, port, length):
     custom_hdr_field = "\r\nCustom: "
     custom_hdr_val = "x"*(length - len(host) - len(custom_hdr_field) - len("\r\n\r\n") + len("0"))
     request = "POST " + path + " HTTP/1.1\r\n" + host + custom_hdr_field + custom_hdr_val + "\r\n\r\n"
-    s.client.send(request[:length/2])
+    s.client.sendall(request[:length/2])
     time.sleep(1)
-    s.client.send(request[length/2:])
+    s.client.sendall(request[length/2:])
     hdr = s.read_resp_hdrs()
     resp = s.read_resp_data()
     s.close()
@@ -768,7 +790,7 @@ def test_upgrade_not_supported(dut, port):
     print "[test] Upgrade Not Supported =>",
     s = Session(dut, port)
     path = "/hello"
-    s.client.send("OPTIONS * HTTP/1.1\r\nHost:" + dut + "\r\nUpgrade: TLS/1.0\r\nConnection: Upgrade\r\n\r\n");
+    s.client.sendall("OPTIONS * HTTP/1.1\r\nHost:" + dut + "\r\nUpgrade: TLS/1.0\r\nConnection: Upgrade\r\n\r\n");
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "200", s.status):
@@ -831,10 +853,6 @@ if __name__ == '__main__':
     async_response_test(dut, port)
     spillover_session(dut, port, max_sessions)
     recv_timeout_test(dut, port)
-
-    # May timeout in case requests are sent slower than responses are read.
-    # Instead use httperf stress test
-    pipeline_test(dut, port, max_sessions)
     packet_size_limit_test(dut, port, 50*1024)
     get_hello(dut, port)
 
diff --git a/examples/protocols/http_server/persistent_sockets/http_server_persistence_test.py b/examples/protocols/http_server/persistent_sockets/http_server_persistence_test.py
index bcc6000c3..756cd14be 100644
--- a/examples/protocols/http_server/persistent_sockets/http_server_persistence_test.py
+++ b/examples/protocols/http_server/persistent_sockets/http_server_persistence_test.py
@@ -28,9 +28,9 @@ if test_fw_path and test_fw_path not in sys.path:
     sys.path.insert(0, test_fw_path)
 
 # When running on local machine execute the following before running this script
-# > export TEST_FW_PATH='~/esp/esp-idf/tools/tiny-test-fw'
-# > make print_flash_cmd | tail -n 1 > build/download.config
 # > make app bootloader
+# > make print_flash_cmd | tail -n 1 > build/download.config
+# > export TEST_FW_PATH=~/esp/esp-idf/tools/tiny-test-fw
 
 import TinyFW
 import IDF
@@ -47,21 +47,23 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
     # Get binary file
     binary_file = os.path.join(dut1.app.binary_path, "persistent_sockets.bin")
     bin_size = os.path.getsize(binary_file)
-    IDF.log_performance("http_server_bin_size", "{}KB".format(bin_size//1024))
-    IDF.check_performance("http_server_bin_size", bin_size//1024)
+    IDF.log_performance("http_server_bin_size", "{}KB".format(bin_size/1024))
+    IDF.check_performance("http_server_bin_size", bin_size/1024)
 
     # Upload binary and start testing
+    print "Starting http_server persistance test app"
     dut1.start_app()
 
     # Parse IP address of STA
-    got_ip   = dut1.expect(re.compile(r"(?:[\s\S]*)Got IP: (\d+.\d+.\d+.\d+)"), timeout=30)[0]
-    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Starting server on port: (\d+)"))[0]
+    print "Waiting to connect with AP"
+    got_ip   = dut1.expect(re.compile(r"(?:[\s\S]*)Got IP: (\d+.\d+.\d+.\d+)"), timeout=120)[0]
+    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Starting server on port: (\d+)"), timeout=30)[0]
 
     print "Got IP   : " + got_ip
     print "Got Port : " + got_port
 
     # Expected Logs
-    dut1.expect("Registering URI handlers")
+    dut1.expect("Registering URI handlers", timeout=30)
 
     # Run test script
     conn = client.start_session(got_ip, got_port)
@@ -72,9 +74,9 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
     num = random.randint(0,100)
     client.putreq(conn, "/adder", str(num))
     visitor += 1
-    dut1.expect("/adder visitor count = " + str(visitor))
-    dut1.expect("/adder PUT handler read " + str(num))
-    dut1.expect("PUT allocating new session")
+    dut1.expect("/adder visitor count = " + str(visitor), timeout=30)
+    dut1.expect("/adder PUT handler read " + str(num), timeout=30)
+    dut1.expect("PUT allocating new session", timeout=30)
 
     # Retest PUT request and change session context value
     num = random.randint(0,100)
@@ -82,11 +84,11 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
     client.putreq(conn, "/adder", str(num))
     visitor += 1
     adder += num
-    dut1.expect("/adder visitor count = " + str(visitor))
-    dut1.expect("/adder PUT handler read " + str(num))
+    dut1.expect("/adder visitor count = " + str(visitor), timeout=30)
+    dut1.expect("/adder PUT handler read " + str(num), timeout=30)
     try:
         # Re allocation shouldn't happen
-        dut1.expect("PUT allocating new session")
+        dut1.expect("PUT allocating new session", timeout=30)
         # Not expected
         raise RuntimeError
     except:
@@ -100,21 +102,21 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
         client.postreq(conn, "/adder", str(num))
         visitor += 1
         adder += num
-        dut1.expect("/adder visitor count = " + str(visitor))
-        dut1.expect("/adder handler read " + str(num))
+        dut1.expect("/adder visitor count = " + str(visitor), timeout=30)
+        dut1.expect("/adder handler read " + str(num), timeout=30)
 
     # Test GET request and session persistence
     print "Matching final sum :", adder
     if client.getreq(conn, "/adder") != str(adder):
         raise RuntimeError
     visitor += 1
-    dut1.expect("/adder visitor count = " + str(visitor))
-    dut1.expect("/adder GET handler send " + str(adder))
+    dut1.expect("/adder visitor count = " + str(visitor), timeout=30)
+    dut1.expect("/adder GET handler send " + str(adder), timeout=30)
 
     print "Ending session"
     # Close connection and check for invocation of context "Free" function
     client.end_session(conn)
-    dut1.expect("/adder Free Context function called")
+    dut1.expect("/adder Free Context function called", timeout=30)
 
     print "Validating user context data"
     # Start another session to check user context data
@@ -122,11 +124,11 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
     num = random.randint(0,100)
     client.putreq(conn, "/adder", str(num))
     visitor += 1
-    dut1.expect("/adder visitor count = " + str(visitor))
-    dut1.expect("/adder PUT handler read " + str(num))
-    dut1.expect("PUT allocating new session")
+    dut1.expect("/adder visitor count = " + str(visitor), timeout=30)
+    dut1.expect("/adder PUT handler read " + str(num), timeout=30)
+    dut1.expect("PUT allocating new session", timeout=30)
     client.end_session(conn)
-    dut1.expect("/adder Free Context function called")
+    dut1.expect("/adder Free Context function called", timeout=30)
 
 if __name__ == '__main__':
     test_examples_protocol_http_server_persistence()
diff --git a/examples/protocols/http_server/simple/http_server_simple_test.py b/examples/protocols/http_server/simple/http_server_simple_test.py
index e8ae1dee5..b08ec14cb 100644
--- a/examples/protocols/http_server/simple/http_server_simple_test.py
+++ b/examples/protocols/http_server/simple/http_server_simple_test.py
@@ -28,9 +28,9 @@ if test_fw_path and test_fw_path not in sys.path:
     sys.path.insert(0, test_fw_path)
 
 # When running on local machine execute the following before running this script
-# > export TEST_FW_PATH='~/esp/esp-idf/tools/tiny-test-fw'
-# > make print_flash_cmd | tail -n 1 > build/download.config
 # > make app bootloader
+# > make print_flash_cmd | tail -n 1 > build/download.config
+# > export TEST_FW_PATH=~/esp/esp-idf/tools/tiny-test-fw
 
 import TinyFW
 import IDF
@@ -39,7 +39,7 @@ import IDF
 expath = os.path.dirname(os.path.realpath(__file__))
 client = imp.load_source("client", expath + "/scripts/client.py")
 
-@IDF.idf_example_test(env_tag="Example_WIFI", ignore=True)
+@IDF.idf_example_test(env_tag="Example_WIFI")
 def test_examples_protocol_http_server_simple(env, extra_data):
     # Acquire DUT
     dut1 = env.get_dut("http_server", "examples/protocols/http_server/simple")
@@ -47,21 +47,23 @@ def test_examples_protocol_http_server_simple(env, extra_data):
     # Get binary file
     binary_file = os.path.join(dut1.app.binary_path, "simple.bin")
     bin_size = os.path.getsize(binary_file)
-    IDF.log_performance("http_server_bin_size", "{}KB".format(bin_size//1024))
-    IDF.check_performance("http_server_bin_size", bin_size//1024)
+    IDF.log_performance("http_server_bin_size", "{}KB".format(bin_size/1024))
+    IDF.check_performance("http_server_bin_size", bin_size/1024)
 
     # Upload binary and start testing
+    print "Starting http_server simple test app"
     dut1.start_app()
 
     # Parse IP address of STA
-    got_ip   = dut1.expect(re.compile(r"(?:[\s\S]*)Got IP: (\d+.\d+.\d+.\d+)"), timeout=30)[0]
-    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Starting server on port: (\d+)"))[0]
+    print "Waiting to connect with AP"
+    got_ip   = dut1.expect(re.compile(r"(?:[\s\S]*)Got IP: (\d+.\d+.\d+.\d+)"), timeout=120)[0]
+    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Starting server on port: (\d+)"), timeout=30)[0]
 
     print "Got IP   : " + got_ip
     print "Got Port : " + got_port
 
     # Expected Logs
-    dut1.expect("Registering URI handlers")
+    dut1.expect("Registering URI handlers", timeout=30)
 
     # Run test script
     # If failed raise appropriate exception
@@ -70,24 +72,24 @@ def test_examples_protocol_http_server_simple(env, extra_data):
         raise RuntimeError
 
     # Acquire host IP. Need a way to check it
-    host_ip = dut1.expect(re.compile(r"(?:[\s\S]*)Found header => Host: (\d+.\d+.\d+.\d+)"))[0]
+    host_ip = dut1.expect(re.compile(r"(?:[\s\S]*)Found header => Host: (\d+.\d+.\d+.\d+)"), timeout=30)[0]
 
     # Match additional headers sent in the request
-    dut1.expect("Found header => Test-Header-2: Test-Value-2")
-    dut1.expect("Found header => Test-Header-1: Test-Value-1")
-    dut1.expect("Found URL query parameter => query1=value1")
-    dut1.expect("Found URL query parameter => query3=value3")
-    dut1.expect("Found URL query parameter => query2=value2")
-    dut1.expect("Request headers lost")
+    dut1.expect("Found header => Test-Header-2: Test-Value-2", timeout=30)
+    dut1.expect("Found header => Test-Header-1: Test-Value-1", timeout=30)
+    dut1.expect("Found URL query parameter => query1=value1", timeout=30)
+    dut1.expect("Found URL query parameter => query3=value3", timeout=30)
+    dut1.expect("Found URL query parameter => query2=value2", timeout=30)
+    dut1.expect("Request headers lost", timeout=30)
 
     print "Test /ctrl PUT handler and realtime handler de/registration"
     if not client.test_put_handler(got_ip, got_port):
         raise RuntimeError
-    dut1.expect("Unregistering /hello and /echo URIs")
-    dut1.expect("Registering /hello and /echo URIs")
+    dut1.expect("Unregistering /hello and /echo URIs", timeout=30)
+    dut1.expect("Registering /hello and /echo URIs", timeout=30)
 
     # Generate random data of 10KB
-    random_data = ''.join(string.printable[random.randint(0,len(string.printable))-1] for _ in range(1024*10))
+    random_data = ''.join(string.printable[random.randint(0,len(string.printable))-1] for _ in range(10*1024))
     print "Test /echo POST handler with random data"
     if not client.test_post_handler(got_ip, got_port, random_data):
         raise RuntimeError
@@ -96,19 +98,19 @@ def test_examples_protocol_http_server_simple(env, extra_data):
     print "Test /hello with custom query : " + query
     if not client.test_custom_uri_query(got_ip, got_port, query):
         raise RuntimeError
-    dut1.expect("Found URL query => " + query)
+    dut1.expect("Found URL query => " + query, timeout=30)
 
     query = "abcd+1234%20xyz"
     print "Test /hello with custom query : " + query
     if not client.test_custom_uri_query(got_ip, got_port, query):
         raise RuntimeError
-    dut1.expect("Found URL query => " + query)
+    dut1.expect("Found URL query => " + query, timeout=30)
 
     query = "abcd\nyz"
     print "Test /hello with invalid query"
     if client.test_custom_uri_query(got_ip, got_port, query):
         raise RuntimeError
-    dut1.expect("400 Bad Request - Server unable to understand request due to invalid syntax")
+    dut1.expect("400 Bad Request - Server unable to understand request due to invalid syntax", timeout=30)
 
 if __name__ == '__main__':
     test_examples_protocol_http_server_simple()
diff --git a/examples/protocols/http_server/simple/scripts/client.py b/examples/protocols/http_server/simple/scripts/client.py
index fccf5f6c7..aa7148154 100644
--- a/examples/protocols/http_server/simple/scripts/client.py
+++ b/examples/protocols/http_server/simple/scripts/client.py
@@ -14,117 +14,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import socket
+import httplib
 import argparse
 
-class Session:
-    def __init__(self, addr, port):
-        self.client = socket.create_connection((addr, int(port)))
-        self.target = addr
-
-    def send_get(self, path, headers=None):
-        request = "GET " + path + " HTTP/1.1\r\nHost: " + self.target
-        if headers:
-            for field, value in headers.iteritems():
-                request += "\r\n"+field+": "+value
-        request += "\r\n\r\n"
-        self.client.send(request);
-
-    def send_put(self, path, data, headers=None):
-        request = "PUT " + path +  " HTTP/1.1\r\nHost: " + self.target
-        if headers:
-            for field, value in headers.iteritems():
-                request += "\r\n"+field+": "+value
-        request += "\r\nContent-Length: " + str(len(data)) +"\r\n\r\n"
-        self.client.send(request)
-        self.client.send(data)
-
-    def send_post(self, path, data, headers=None):
-        request = "POST " + path +  " HTTP/1.1\r\nHost: " + self.target
-        if headers:
-            for field, value in headers.iteritems():
-                request += "\r\n"+field+": "+value
-        request += "\r\nContent-Length: " + str(len(data)) +"\r\n\r\n"
-        self.client.send(request)
-        self.client.send(data)
-
-    def read_resp_hdrs(self):
-        state = 'nothing'
-        resp_read = ''
-        while True:
-            char = self.client.recv(1)
-            if char == '\r' and state == 'nothing':
-                state = 'first_cr'
-            elif char == '\n' and state == 'first_cr':
-                state = 'first_lf'
-            elif char == '\r' and state == 'first_lf':
-                state = 'second_cr'
-            elif char == '\n' and state == 'second_cr':
-                state = 'second_lf'
-            else:
-                state = 'nothing'
-            resp_read += char
-            if state == 'second_lf':
-               break;
-        # Handle first line
-        line_hdrs = resp_read.splitlines()
-        line_comp = line_hdrs[0].split()
-        self.status = line_comp[1]
-        del line_hdrs[0]
-        self.encoding = ''
-        self.content_type = ''
-        headers = dict()
-        # Process other headers
-        for h in range(len(line_hdrs)):
-            line_comp = line_hdrs[h].split(':')
-            if line_comp[0] == 'Content-Length':
-                self.content_len = int(line_comp[1])
-            if line_comp[0] == 'Content-Type':
-                self.content_type = line_comp[1].lstrip()
-            if line_comp[0] == 'Transfer-Encoding':
-                self.encoding = line_comp[1].lstrip()
-            if len(line_comp) == 2:
-                headers[line_comp[0]] = line_comp[1].lstrip()
-        return headers
-
-    def read_resp_data(self):
-        read_data = ''
-        if self.encoding != 'chunked':
-            while len(read_data) != self.content_len:
-                read_data += self.client.recv(self.content_len)
-            self.content_len = 0
-        else:
-            chunk_data_buf = ''
-            while (True):
-                # Read one character into temp  buffer
-                read_ch = self.client.recv(1)
-                # Check CRLF
-                if (read_ch == '\r'):
-                    read_ch = self.client.recv(1)
-                    if (read_ch == '\n'):
-                        # If CRLF decode length of chunk
-                        chunk_len = int(chunk_data_buf, 16)
-                        # Keep adding to contents
-                        self.content_len += chunk_len
-                        read_data += self.client.recv(chunk_len)
-                        chunk_data_buf = ''
-                        # Fetch remaining CRLF
-                        if self.client.recv(2) != "\r\n":
-                            # Error in packet
-                            return None
-                        if not chunk_len:
-                            # If last chunk
-                            break
-                        continue
-                    chunk_data_buf += '\r'
-                # If not CRLF continue appending
-                # character to chunked data buffer
-                chunk_data_buf += read_ch
-        return read_data
-
-    def close(self):
-        self.client.close()
-
 def verbose_print(verbosity, *args):
     if (verbosity):
         print ''.join(str(elems) for elems in args)
@@ -133,7 +25,7 @@ def test_get_handler(ip, port, verbosity = False):
     verbose_print(verbosity, "========  GET HANDLER TEST =============")
     # Establish HTTP connection
     verbose_print(verbosity, "Connecting to => " + ip + ":" + port)
-    sess = Session(ip, port)
+    sess = httplib.HTTPConnection(ip + ":" + port)
 
     uri = "/hello?query1=value1&query2=value2&query3=value3"
     # GET hello response
@@ -142,13 +34,14 @@ def test_get_handler(ip, port, verbosity = False):
     verbose_print(verbosity, "Sending additional headers : ")
     for k, v in test_headers.iteritems():
         verbose_print(verbosity, "\t", k, ": ", v)
-    sess.send_get(uri, test_headers)
-    resp_hdrs = sess.read_resp_hdrs()
-    resp_data = sess.read_resp_data()
+    sess.request("GET", url=uri, headers=test_headers)
+    resp = sess.getresponse()
+    resp_hdrs = resp.getheaders()
+    resp_data = resp.read()
     try:
-        if resp_hdrs["Custom-Header-1"] != "Custom-Value-1":
+        if resp.getheader("Custom-Header-1") != "Custom-Value-1":
             return False
-        if resp_hdrs["Custom-Header-2"] != "Custom-Value-2":
+        if resp.getheader("Custom-Header-2") != "Custom-Value-2":
             return False
     except:
         return False
@@ -156,7 +49,7 @@ def test_get_handler(ip, port, verbosity = False):
     verbose_print(verbosity, "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv")
     verbose_print(verbosity, "Server response to GET /hello")
     verbose_print(verbosity, "Response Headers : ")
-    for k, v in resp_hdrs.iteritems():
+    for k, v in resp_hdrs:
         verbose_print(verbosity, "\t", k, ": ", v)
     verbose_print(verbosity, "Response Data : " + resp_data)
     verbose_print(verbosity, "========================================\n")
@@ -169,12 +62,12 @@ def test_post_handler(ip, port, msg, verbosity = False):
     verbose_print(verbosity, "========  POST HANDLER TEST ============")
     # Establish HTTP connection
     verbose_print(verbosity, "Connecting to => " + ip + ":" + port)
-    sess = Session(ip, port)
+    sess = httplib.HTTPConnection(ip + ":" + port)
 
     # POST message to /echo and get back response
-    sess.send_post("/echo", msg)
-    resp_hdrs = sess.read_resp_hdrs()
-    resp_data = sess.read_resp_data()
+    sess.request("POST", url="/echo", body=msg)
+    resp = sess.getresponse()
+    resp_data = resp.read()
     verbose_print(verbosity, "Server response to POST /echo (" + msg + ")")
     verbose_print(verbosity, "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv")
     verbose_print(verbosity, resp_data)
@@ -188,30 +81,28 @@ def test_put_handler(ip, port, verbosity = False):
     verbose_print(verbosity, "========  PUT HANDLER TEST =============")
     # Establish HTTP connection
     verbose_print(verbosity, "Connecting to => " + ip + ":" + port)
-    sess = Session(ip, port)
+    sess = httplib.HTTPConnection(ip + ":" + port)
 
     # PUT message to /ctrl to disable /hello URI handler
     verbose_print(verbosity, "Disabling /hello handler")
-    sess.send_put("/ctrl", "0")
-    sess.read_resp_hdrs()
-    if sess.content_len:
-        sess.read_resp_data()
+    sess.request("PUT", url="/ctrl", body="0")
+    resp = sess.getresponse()
+    resp.read()
 
-    sess.send_get("/hello")
-    sess.read_resp_hdrs()
-    resp_data1 = sess.read_resp_data()
+    sess.request("GET", url="/hello")
+    resp = sess.getresponse()
+    resp_data1 = resp.read()
     verbose_print(verbosity, "Response on GET /hello : " + resp_data1)
 
     # PUT message to /ctrl to enable /hello URI handler
     verbose_print(verbosity, "Enabling /hello handler")
-    sess.send_put("/ctrl", "1")
-    sess.read_resp_hdrs()
-    if sess.content_len:
-        sess.read_resp_data()
+    sess.request("PUT", url="/ctrl", body="1")
+    resp = sess.getresponse()
+    resp.read()
 
-    sess.send_get("/hello")
-    sess.read_resp_hdrs()
-    resp_data2 = sess.read_resp_data()
+    sess.request("GET", url="/hello")
+    resp = sess.getresponse()
+    resp_data2 = resp.read()
     verbose_print(verbosity, "Response on GET /hello : " + resp_data2)
 
     # Close HTTP connection
@@ -222,14 +113,14 @@ def test_custom_uri_query(ip, port, query, verbosity = False):
     verbose_print(verbosity, "========  GET HANDLER TEST =============")
     # Establish HTTP connection
     verbose_print(verbosity, "Connecting to => " + ip + ":" + port)
-    sess = Session(ip, port)
+    sess = httplib.HTTPConnection(ip + ":" + port)
 
     uri = "/hello?" + query
     # GET hello response
     verbose_print(verbosity, "Sending GET to URI : ", uri)
-    sess.send_get(uri, {})
-    resp_hdrs = sess.read_resp_hdrs()
-    resp_data = sess.read_resp_data()
+    sess.request("GET", url=uri, headers={})
+    resp = sess.getresponse()
+    resp_data = resp.read()
 
     verbose_print(verbosity, "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv")
     verbose_print(verbosity, "Server response to GET /hello")
@@ -253,6 +144,9 @@ if __name__ == '__main__':
     port = args['port']
     msg  = args['msg']
 
-    test_get_handler (ip, port, True)
-    test_post_handler(ip, port, msg, True)
-    test_put_handler (ip, port, True)
+    if not test_get_handler (ip, port, True):
+        print "Failed!"
+    if not test_post_handler(ip, port, msg, True):
+        print "Failed!"
+    if not test_put_handler (ip, port, True):
+        print "Failed!"