diff --git a/examples/peripherals/i2s_adc_dac/tools/generate_audio_file.py b/examples/peripherals/i2s_adc_dac/tools/generate_audio_file.py
index 1c951b276..350280b6f 100644
--- a/examples/peripherals/i2s_adc_dac/tools/generate_audio_file.py
+++ b/examples/peripherals/i2s_adc_dac/tools/generate_audio_file.py
@@ -1,3 +1,5 @@
+from __future__ import print_function
+from builtins import range
 import os
 import wave
 import struct
@@ -13,7 +15,7 @@ def get_wave_array_str(filename, target_bits):
         cur_lim   = (1 << sampwidth) - 1
         #scale current data to 8-bit data
         val       = val * scale_val / cur_lim
-        val       = (val + ((scale_val + 1) / 2)) & scale_val
+        val       = int(val + ((scale_val + 1) // 2)) & scale_val
         array_str += "0x%x, "%(val)
         if (i + 1) % 16 == 0:
             array_str += "\n"
@@ -21,12 +23,12 @@ def get_wave_array_str(filename, target_bits):
 
 def gen_wave_table(wav_file_list, target_file_name, scale_bits = 8):
     with open(target_file_name, "w") as audio_table:
-        print >> audio_table, '#include <stdio.h>'
-        print >> audio_table, 'const unsigned char audio_table[] = {'
+        print('#include <stdio.h>', file=audio_table)
+        print('const unsigned char audio_table[] = {', file=audio_table)
         for wav in wav_file_list:
             print("processing: {}".format(wav))
-            print >> audio_table, get_wave_array_str(filename = wav, target_bits = scale_bits)
-        print >>audio_table,'};\n'
+            print(get_wave_array_str(filename = wav, target_bits = scale_bits), file=audio_table)
+        print('};\n', file=audio_table)
     print("Done...")
 
 if __name__=='__main__':
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 b520461e9..09cb47ba4 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
@@ -14,6 +14,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 import imp
 import re
 import os
@@ -53,15 +56,15 @@ 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"
+    print("Starting http_server advanced test app")
     dut1.start_app()
 
     # Parse IP address of STA
-    print "Waiting to connect with AP"
+    print("Waiting to connect with AP")
     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]*)Started HTTP server on port: '(\d+)'"), timeout=15)[0]
@@ -72,18 +75,18 @@ def test_examples_protocol_http_server_advanced(env, extra_data):
     max_uri_len = int(result[3])
     max_stack_size = int(result[4])
 
-    print "Got IP   : " + got_ip
-    print "Got Port : " + got_port
+    print("Got IP   : " + got_ip)
+    print("Got Port : " + got_port)
 
     # Run test script
     # If failed raise appropriate exception
     failed = False
 
-    print "Sessions and Context Tests..."
+    print("Sessions and Context Tests...")
     if not client.spillover_session(got_ip, got_port, max_sessions):
-        print "Ignoring failure"
+        print("Ignoring failure")
     if not client.parallel_sessions_adder(got_ip, got_port, max_sessions):
-        print "Ignoring failure"
+        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):
@@ -96,17 +99,17 @@ def test_examples_protocol_http_server_advanced(env, extra_data):
     #if not client.packet_size_limit_test(got_ip, got_port, test_size):
     #    print "Ignoring failure"
 
-    print "Getting initial stack usage..."
+    print("Getting initial stack usage...")
     if not client.get_hello(got_ip, got_port):
         failed = True
 
     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"
+        print("More than 90% of stack being used on server start")
         failed = True
 
-    print "Basic HTTP Client Tests..."
+    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):
@@ -126,7 +129,7 @@ def test_examples_protocol_http_server_advanced(env, extra_data):
     if not client.get_false_uri(got_ip, got_port):
         failed = True
 
-    print "Error code tests..."
+    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):
@@ -142,20 +145,20 @@ def test_examples_protocol_http_server_advanced(env, extra_data):
     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"
+        print("Ignoring failure")
     if not client.code_431_hdr_too_long(got_ip, got_port, max_hdr_len):
-        print "Ignoring failure"
+        print("Ignoring failure")
     if not client.test_upgrade_not_supported(got_ip, got_port):
         failed = True
 
-    print "Getting final stack usage..."
+    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"
+        print("More than 95% of stack got used during tests")
         failed = True
 
     if failed:
diff --git a/examples/protocols/http_server/advanced_tests/scripts/test.py b/examples/protocols/http_server/advanced_tests/scripts/test.py
index a4609eb04..7a6ee64ee 100644
--- a/examples/protocols/http_server/advanced_tests/scripts/test.py
+++ b/examples/protocols/http_server/advanced_tests/scripts/test.py
@@ -129,18 +129,25 @@
 #    - Simple GET on /hello/restart_results (returns the leak results)
 
 
+from __future__ import division
+from __future__ import print_function
+from future import standard_library
+standard_library.install_aliases()
+from builtins import str
+from builtins import range
+from builtins import object
 import threading
 import socket
 import time
 import argparse
-import httplib
+import http.client
 import sys
 import string
 import random
 
 _verbose_ = False
 
-class Session:
+class Session(object):
     def __init__(self, addr, port, timeout = 15):
         self.client = socket.create_connection((addr, int(port)), timeout = timeout)
         self.target = addr
@@ -152,19 +159,19 @@ class Session:
     def send_err_check(self, request, data=None):
         rval = True
         try:
-            self.client.sendall(request);
+            self.client.sendall(request.encode());
             if data:
-                self.client.sendall(data)
+                self.client.sendall(data.encode())
         except socket.error as err:
             self.client.close()
-            print "Socket Error in send :", err
+            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
         if headers:
-            for field, value in headers.iteritems():
+            for field, value in headers.items():
                 request += "\r\n"+field+": "+value
         request += "\r\n\r\n"
         return self.send_err_check(request)
@@ -172,7 +179,7 @@ class Session:
     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():
+            for field, value in headers.items():
                 request += "\r\n"+field+": "+value
         request += "\r\nContent-Length: " + str(len(data)) +"\r\n\r\n"
         return self.send_err_check(request, data)
@@ -180,7 +187,7 @@ class Session:
     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():
+            for field, value in headers.items():
                 request += "\r\n"+field+": "+value
         request += "\r\nContent-Length: " + str(len(data)) +"\r\n\r\n"
         return self.send_err_check(request, data)
@@ -190,7 +197,7 @@ class Session:
             state = 'nothing'
             resp_read = ''
             while True:
-                char = self.client.recv(1)
+                char = self.client.recv(1).decode()
                 if char == '\r' and state == 'nothing':
                     state = 'first_cr'
                 elif char == '\n' and state == 'first_cr':
@@ -226,7 +233,7 @@ class Session:
             return headers
         except socket.error as err:
             self.client.close()
-            print "Socket Error in recv :", err
+            print("Socket Error in recv :", err)
             return None
 
     def read_resp_data(self):
@@ -234,7 +241,7 @@ class Session:
             read_data = ''
             if self.encoding != 'chunked':
                 while len(read_data) != self.content_len:
-                    read_data += self.client.recv(self.content_len)
+                    read_data += self.client.recv(self.content_len).decode()
             else:
                 chunk_data_buf = ''
                 while (True):
@@ -242,7 +249,7 @@ class Session:
                     read_ch = self.client.recv(1)
                     # Check CRLF
                     if (read_ch == '\r'):
-                        read_ch = self.client.recv(1)
+                        read_ch = self.client.recv(1).decode()
                         if (read_ch == '\n'):
                             # If CRLF decode length of chunk
                             chunk_len = int(chunk_data_buf, 16)
@@ -257,7 +264,7 @@ class Session:
                             # Fetch remaining CRLF
                             if self.client.recv(2) != "\r\n":
                                 # Error in packet
-                                print "Error in chunked data"
+                                print("Error in chunked data")
                                 return None
                             if not chunk_len:
                                 # If last chunk
@@ -270,7 +277,7 @@ class Session:
             return read_data
         except socket.error as err:
             self.client.close()
-            print "Socket Error in recv :", err
+            print("Socket Error in recv :", err)
             return None
 
     def close(self):
@@ -278,10 +285,10 @@ class Session:
 
 def test_val(text, expected, received):
     if expected != received:
-        print " Fail!"
-        print "  [reason] " + text + ":"
-        print "        expected: " + str(expected)
-        print "        received: " + str(received)
+        print(" Fail!")
+        print("  [reason] " + text + ":")
+        print("        expected: " + str(expected))
+        print("        received: " + str(received))
         return False
     return True
 
@@ -298,7 +305,7 @@ class adder_thread (threading.Thread):
 
         # Pipeline 3 requests
         if (_verbose_):
-            print "   Thread: Using adder start " + str(self.id)
+            print("   Thread: Using adder start " + str(self.id))
 
         for _ in range(self.depth):
             self.session.send_post('/adder', str(self.id))
@@ -310,7 +317,7 @@ class adder_thread (threading.Thread):
 
     def adder_result(self):
         if len(self.response) != self.depth:
-            print "Error : missing response packets"
+            print("Error : missing response packets")
             return False
         for i in range(len(self.response)):
             if not test_val("Thread" + str(self.id) + " response[" + str(i) + "]",
@@ -323,166 +330,166 @@ class adder_thread (threading.Thread):
 
 def get_hello(dut, port):
     # GET /hello should return 'Hello World!'
-    print "[test] GET /hello returns 'Hello World!' =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] GET /hello returns 'Hello World!' =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     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!", resp.read()):
+    if not test_val("data", "Hello World!", resp.read().decode()):
         conn.close()
         return False
     if not test_val("data", "application/json", resp.getheader('Content-Type')):
         conn.close()
         return False
-    print "Success"
+    print("Success")
     conn.close()
     return True
 
 def put_hello(dut, port):
     # PUT /hello returns 405'
-    print "[test] PUT /hello returns 405' =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] PUT /hello returns 405' =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     conn.request("PUT", "/hello", "Hello")
     resp = conn.getresponse()
     if not test_val("status_code", 405, resp.status):
         conn.close()
         return False
-    print "Success"
+    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), timeout=15)
+    print("[test] POST /hello returns 404' =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     conn.request("POST", "/hello", "Hello")
     resp = conn.getresponse()
     if not test_val("status_code", 405, resp.status):
         conn.close()
         return False
-    print "Success"
+    print("Success")
     conn.close()
     return True
 
 def post_echo(dut, port):
     # POST /echo echoes data'
-    print "[test] POST /echo echoes data' =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] POST /echo echoes data' =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     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", resp.read()):
+    if not test_val("data", "Hello", resp.read().decode()):
         conn.close()
         return False
-    print "Success"
+    print("Success")
     conn.close()
     return True
 
 def put_echo(dut, port):
     # PUT /echo echoes data'
-    print "[test] PUT /echo echoes data' =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] PUT /echo echoes data' =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     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", resp.read()):
+    if not test_val("data", "Hello", resp.read().decode()):
         conn.close()
         return False
-    print "Success"
+    print("Success")
     conn.close()
     return True
 
 def get_echo(dut, port):
     # GET /echo returns 404'
-    print "[test] GET /echo returns 405' =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] GET /echo returns 405' =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     conn.request("GET", "/echo")
     resp = conn.getresponse()
     if not test_val("status_code", 405, resp.status):
         conn.close()
         return False
-    print "Success"
+    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 =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] GET /hello/type_html has Content-Type of text/html =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     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!", resp.read()):
+    if not test_val("data", "Hello World!", resp.read().decode()):
         conn.close()
         return False
     if not test_val("data", "text/html", resp.getheader('Content-Type')):
         conn.close()
         return False
-    print "Success"
+    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 =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] GET /hello/status_500 returns status 500 =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     conn.request("GET", "/hello/status_500")
     resp = conn.getresponse()
     if not test_val("status_code", 500, resp.status):
         conn.close()
         return False
-    print "Success"
+    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 =>",
-    conn = httplib.HTTPConnection(dut, int(port), timeout=15)
+    print("[test] GET /false_uri returns status 404 =>", end=' ')
+    conn = http.client.HTTPConnection(dut, int(port), timeout=15)
     conn.request("GET", "/false_uri")
     resp = conn.getresponse()
     if not test_val("status_code", 404, resp.status):
         conn.close()
         return False
-    print "Success"
+    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 =>",
+    print("[test] POST {pipelined} on /adder in " + str(max_sessions) + " sessions =>", end=' ')
     t = []
     # Create all sessions
-    for i in xrange(max_sessions):
+    for i in range(max_sessions):
         t.append(adder_thread(i, dut, port))
 
-    for i in xrange(len(t)):
+    for i in range(len(t)):
         t[i].start()
 
-    for i in xrange(len(t)):
+    for i in range(len(t)):
         t[i].join()
 
     res = True
-    for i in xrange(len(t)):
+    for i in range(len(t)):
         if not test_val("Thread" + str(i) + " Failed", t[i].adder_result(), True):
             res = False
         t[i].close()
     if (res):
-        print "Success"
+        print("Success")
     return res
 
 def async_response_test(dut, port):
     # Test that an asynchronous work is executed in the HTTPD's context
     # This is tested by reading two responses over the same session
-    print "[test] Test HTTPD Work Queue (Async response) =>",
+    print("[test] Test HTTPD Work Queue (Async response) =>", end=' ')
     s = Session(dut, port)
 
     s.send_get('/async_data')
@@ -495,23 +502,23 @@ def async_response_test(dut, port):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 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 = httplib.HTTPConnection(dut + ":" + port, timeout=15)
+    print("[test] Leftover data in POST is purged (valid and invalid URIs) =>", end=' ')
+    s = http.client.HTTPConnection(dut + ":" + port, timeout=15)
 
     s.request("POST", url='/leftover_data', body="abcdefghijklmnopqrstuvwxyz\r\nabcdefghijklmnopqrstuvwxyz")
     resp = s.getresponse()
-    if not test_val("Partial data", "abcdefghij", resp.read()):
+    if not test_val("Partial data", "abcdefghij", resp.read().decode()):
         s.close()
         return False
 
     s.request("GET", url='/hello')
     resp = s.getresponse()
-    if not test_val("Hello World Data", "Hello World!", resp.read()):
+    if not test_val("Hello World Data", "Hello World!", resp.read().decode()):
         s.close()
         return False
 
@@ -524,33 +531,33 @@ def leftover_data_test(dut, port):
 
     s.request("GET", url='/hello')
     resp = s.getresponse()
-    if not test_val("Hello World Data", "Hello World!", resp.read()):
+    if not test_val("Hello World Data", "Hello World!", resp.read().decode()):
         s.close()
         return False
 
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 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 =>",
+    print("[test] Session max_sess_sessions (" + str(max_sess) + ") + 1 is rejected =>", end=' ')
     s = []
     _verbose_ = True
-    for i in xrange(max_sess + 1):
+    for i in range(max_sess + 1):
         if (_verbose_):
-            print "Executing " + str(i)
+            print("Executing " + str(i))
         try:
-            a = httplib.HTTPConnection(dut + ":" + port, timeout=15)
+            a = http.client.HTTPConnection(dut + ":" + port, timeout=15)
             a.request("GET", url='/hello')
             resp = a.getresponse()
-            if not test_val("Connection " + str(i), "Hello World!", resp.read()):
+            if not test_val("Connection " + str(i), "Hello World!", resp.read().decode()):
                 a.close()
                 break
             s.append(a)
         except:
             if (_verbose_):
-                print "Connection " + str(i) + " rejected"
+                print("Connection " + str(i) + " rejected")
             a.close()
             break
 
@@ -559,59 +566,59 @@ def spillover_session(dut, port, max_sess):
         a.close()
 
     # Check if number of connections is equal to max_sess
-    print ["Fail","Success"][len(s) == 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 =>",
+    print("[test] Timeout occurs if partial packet sent =>", end=' ')
     s = Session(dut, port)
-    s.client.sendall("GE")
+    s.client.sendall(b"GE")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Request Timeout", "Server closed this connection", resp):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def packet_size_limit_test(dut, port, test_size):
-    print "[test] send size limit test =>",
+    print("[test] send size limit test =>", end=' ')
     retry = 5
     while (retry):
         retry -= 1
-        print "data size = ", test_size
-        s = httplib.HTTPConnection(dut + ":" + port, timeout=15)
-        random_data = ''.join(string.printable[random.randint(0,len(string.printable))-1] for _ in range(test_size))
+        print("data size = ", test_size)
+        s = http.client.HTTPConnection(dut + ":" + port, timeout=15)
+        random_data = ''.join(string.printable[random.randint(0,len(string.printable))-1] for _ in list(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
+                print("Data too large to be allocated")
+                test_size = test_size//10
             else:
-                print "Unexpected error"
+                print("Unexpected error")
             s.close()
-            print "Retry..."
+            print("Retry...")
             continue
-        resp = resp.read()
+        resp = resp.read().decode()
         result = (resp == random_data)
         if not result:
             test_val("Data size", str(len(random_data)), str(len(resp)))
             s.close()
-            print "Retry..."
+            print("Retry...")
             continue
         s.close()
-        print "Success"
+        print("Success")
         return True
-    print "Failed"
+    print("Failed")
     return False
 
 def code_500_server_error_test(dut, port):
-    print "[test] 500 Server Error test =>",
+    print("[test] 500 Server Error test =>", end=' ')
     s = Session(dut, port)
-    s.client.sendall("abcdefgh\0")
+    s.client.sendall(b"abcdefgh\0")
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     # Presently server sends back 400 Bad Request
@@ -622,14 +629,14 @@ def code_500_server_error_test(dut, port):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def code_501_method_not_impl(dut, port):
-    print "[test] 501 Method Not Implemented =>",
+    print("[test] 501 Method Not Implemented =>", end=' ')
     s = Session(dut, port)
     path = "/hello"
-    s.client.sendall("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").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     # Presently server sends back 400 Bad Request
@@ -640,83 +647,83 @@ def code_501_method_not_impl(dut, port):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def code_505_version_not_supported(dut, port):
-    print "[test] 505 Version Not Supported =>",
+    print("[test] 505 Version Not Supported =>", end=' ')
     s = Session(dut, port)
     path = "/hello"
-    s.client.sendall("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").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Server Error", "505", s.status):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def code_400_bad_request(dut, port):
-    print "[test] 400 Bad Request =>",
+    print("[test] 400 Bad Request =>", end=' ')
     s = Session(dut, port)
     path = "/hello"
-    s.client.sendall("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").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "400", s.status):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def code_404_not_found(dut, port):
-    print "[test] 404 Not Found =>",
+    print("[test] 404 Not Found =>", end=' ')
     s = Session(dut, port)
     path = "/dummy"
-    s.client.sendall("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").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "404", s.status):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def code_405_method_not_allowed(dut, port):
-    print "[test] 405 Method Not Allowed =>",
+    print("[test] 405 Method Not Allowed =>", end=' ')
     s = Session(dut, port)
     path = "/hello"
-    s.client.sendall("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").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "405", s.status):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def code_408_req_timeout(dut, port):
-    print "[test] 408 Request Timeout =>",
+    print("[test] 408 Request Timeout =>", end=' ')
     s = Session(dut, port)
-    s.client.sendall("POST /echo HTTP/1.1\r\nHost: " + dut + "\r\nContent-Length: 10\r\n\r\nABCD")
+    s.client.sendall(("POST /echo HTTP/1.1\r\nHost: " + dut + "\r\nContent-Length: 10\r\n\r\nABCD").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "408", s.status):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def code_411_length_required(dut, port):
-    print "[test] 411 Length Required =>",
+    print("[test] 411 Length Required =>", end=' ')
     s = Session(dut, port)
     path = "/echo"
-    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.client.sendall(("POST " + path + " HTTP/1.1\r\nHost: " + dut + "\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\n\r\n").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     # Presently server sends back 400 Bad Request
@@ -727,7 +734,7 @@ def code_411_length_required(dut, port):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 def send_getx_uri_len(dut, port, length):
@@ -735,25 +742,25 @@ 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.sendall(method)
+    s.client.sendall(method.encode())
     time.sleep(1)
-    s.client.sendall(path)
+    s.client.sendall(path.encode())
     time.sleep(1)
-    s.client.sendall(version + "Host: " + dut + "\r\n\r\n")
+    s.client.sendall((version + "Host: " + dut + "\r\n\r\n").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     s.close()
     return s.status
 
 def code_414_uri_too_long(dut, port, max_uri_len):
-    print "[test] 414 URI Too Long =>",
+    print("[test] 414 URI Too Long =>", end=' ')
     status = send_getx_uri_len(dut, port, max_uri_len)
     if not test_val("Client Error", "404", status):
         return False
     status = send_getx_uri_len(dut, port, max_uri_len + 1)
     if not test_val("Client Error", "414", status):
         return False
-    print "Success"
+    print("Success")
     return True
 
 def send_postx_hdr_len(dut, port, length):
@@ -762,10 +769,10 @@ def send_postx_hdr_len(dut, port, length):
     host = "Host: " + dut
     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.sendall(request[:length/2])
+    request = ("POST " + path + " HTTP/1.1\r\n" + host + custom_hdr_field + custom_hdr_val + "\r\n\r\n").encode()
+    s.client.sendall(request[:length//2])
     time.sleep(1)
-    s.client.sendall(request[length/2:])
+    s.client.sendall(request[length//2:])
     hdr = s.read_resp_hdrs()
     resp = s.read_resp_data()
     s.close()
@@ -774,28 +781,28 @@ def send_postx_hdr_len(dut, port, length):
     return False, s.status
 
 def code_431_hdr_too_long(dut, port, max_hdr_len):
-    print "[test] 431 Header Too Long =>",
+    print("[test] 431 Header Too Long =>", end=' ')
     res, status = send_postx_hdr_len(dut, port, max_hdr_len)
     if not res:
         return False
     res, status = send_postx_hdr_len(dut, port, max_hdr_len + 1)
     if not test_val("Client Error", "431", status):
         return False
-    print "Success"
+    print("Success")
     return True
 
 def test_upgrade_not_supported(dut, port):
-    print "[test] Upgrade Not Supported =>",
+    print("[test] Upgrade Not Supported =>", end=' ')
     s = Session(dut, port)
     path = "/hello"
-    s.client.sendall("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").encode())
     s.read_resp_hdrs()
     resp = s.read_resp_data()
     if not test_val("Client Error", "200", s.status):
         s.close()
         return False
     s.close()
-    print "Success"
+    print("Success")
     return True
 
 if __name__ == '__main__':
@@ -819,7 +826,7 @@ if __name__ == '__main__':
 
     _verbose_ = True
 
-    print "### Basic HTTP Client Tests"
+    print("### Basic HTTP Client Tests")
     get_hello(dut, port)
     post_hello(dut, port)
     put_hello(dut, port)
@@ -830,7 +837,7 @@ if __name__ == '__main__':
     get_hello_status(dut, port)
     get_false_uri(dut, port)
 
-    print "### Error code tests"
+    print("### Error code tests")
     code_500_server_error_test(dut, port)
     code_501_method_not_impl(dut, port)
     code_505_version_not_supported(dut, port)
@@ -845,7 +852,7 @@ if __name__ == '__main__':
     # Not supported yet (Error on chunked request)
     ###code_411_length_required(dut, port)
 
-    print "### Sessions and Context Tests"
+    print("### Sessions and Context Tests")
     parallel_sessions_adder(dut, port, max_sessions)
     leftover_data_test(dut, port)
     async_response_test(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 076e33c00..8fba7fbd2 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
@@ -14,6 +14,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+from builtins import str
+from builtins import range
 import imp
 import re
 import os
@@ -47,20 +52,20 @@ 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"
+    print("Starting http_server persistance test app")
     dut1.start_app()
 
     # Parse IP address of STA
-    print "Waiting to connect with AP"
+    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
+    print("Got IP   : " + got_ip)
+    print("Got Port : " + got_port)
 
     # Expected Logs
     dut1.expect("Registering URI handlers", timeout=30)
@@ -80,7 +85,7 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
 
     # Retest PUT request and change session context value
     num = random.randint(0,100)
-    print "Adding :", num
+    print("Adding :", num)
     client.putreq(conn, "/adder", str(num))
     visitor += 1
     adder += num
@@ -98,7 +103,7 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
     # Test POST request and session persistence
     random_nums = [random.randint(0,100) for _ in range(100)]
     for num in random_nums:
-        print "Adding :", num
+        print("Adding :", num)
         client.postreq(conn, "/adder", str(num))
         visitor += 1
         adder += num
@@ -106,19 +111,19 @@ def test_examples_protocol_http_server_persistence(env, extra_data):
         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):
+    print("Matching final sum :", adder)
+    if client.getreq(conn, "/adder").decode() != str(adder):
         raise RuntimeError
     visitor += 1
     dut1.expect("/adder visitor count = " + str(visitor), timeout=30)
     dut1.expect("/adder GET handler send " + str(adder), timeout=30)
 
-    print "Ending session"
+    print("Ending session")
     # Close connection and check for invocation of context "Free" function
     client.end_session(conn)
     dut1.expect("/adder Free Context function called", timeout=30)
 
-    print "Validating user context data"
+    print("Validating user context data")
     # Start another session to check user context data
     conn2 = client.start_session(got_ip, got_port)
     num = random.randint(0,100)
diff --git a/examples/protocols/http_server/persistent_sockets/scripts/adder.py b/examples/protocols/http_server/persistent_sockets/scripts/adder.py
index aed6c7657..aceb46623 100644
--- a/examples/protocols/http_server/persistent_sockets/scripts/adder.py
+++ b/examples/protocols/http_server/persistent_sockets/scripts/adder.py
@@ -14,11 +14,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import httplib
+from __future__ import print_function
+from __future__ import unicode_literals
+from future import standard_library
+standard_library.install_aliases()
+from builtins import str
+from builtins import range
+import http.client
 import argparse
 
 def start_session (ip, port):
-    return httplib.HTTPConnection(ip, int(port), timeout=15)
+    return http.client.HTTPConnection(ip, int(port), timeout=15)
 
 def end_session (conn):
     conn.close()
@@ -28,11 +34,11 @@ def getreq (conn, path, verbose = False):
     resp = conn.getresponse()
     data = resp.read()
     if verbose:
-        print "GET : ", path
-        print "Status : ", resp.status
-        print "Reason : ", resp.reason
-        print "Data length  : ", len(data)
-        print "Data content : ", data
+        print("GET : ", path)
+        print("Status : ", resp.status)
+        print("Reason : ", resp.reason)
+        print("Data length  : ", len(data))
+        print("Data content : ", data)
     return data
 
 def postreq (conn, path, data, verbose = False):
@@ -40,11 +46,11 @@ def postreq (conn, path, data, verbose = False):
     resp = conn.getresponse()
     data = resp.read()
     if verbose:
-        print "POST : ", data
-        print "Status : ", resp.status
-        print "Reason : ", resp.reason
-        print "Data length  : ", len(data)
-        print "Data content : ", data
+        print("POST : ", data)
+        print("Status : ", resp.status)
+        print("Reason : ", resp.reason)
+        print("Data length  : ", len(data))
+        print("Data content : ", data)
     return data
 
 def putreq (conn, path, body, verbose = False):
@@ -52,11 +58,11 @@ def putreq (conn, path, body, verbose = False):
     resp = conn.getresponse()
     data = resp.read()
     if verbose:
-        print "PUT : ", path, body
-        print "Status : ", resp.status
-        print "Reason : ", resp.reason
-        print "Data length  : ", len(data)
-        print "Data content : ", data
+        print("PUT : ", path, body)
+        print("Status : ", resp.status)
+        print("Reason : ", resp.reason)
+        print("Data length  : ", len(data))
+        print("Data content : ", data)
     return data
 
 if __name__ == '__main__':
@@ -73,22 +79,22 @@ if __name__ == '__main__':
     N    = args['N']
 
     # Establish HTTP connection
-    print "Connecting to => " + ip + ":" + port
+    print("Connecting to => " + ip + ":" + port)
     conn = start_session (ip, port)
 
     # Reset adder context to specified value(0)
     # -- Not needed as new connection will always
     # -- have zero value of the accumulator
-    print "Reset the accumulator to 0"
+    print("Reset the accumulator to 0")
     putreq (conn, "/adder", str(0))
 
     # Sum numbers from 1 to specified value(N)
-    print "Summing numbers from 1 to " + str(N)
-    for i in xrange(1, N+1):
+    print("Summing numbers from 1 to " + str(N))
+    for i in range(1, N+1):
         postreq (conn, "/adder", str(i))
 
     # Fetch the result
-    print "Result :", getreq  (conn, "/adder")
+    print("Result :", getreq  (conn, "/adder"))
 
     # Close HTTP connection
     end_session (conn)
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 6b6221973..6c0b0d9be 100644
--- a/examples/protocols/http_server/simple/http_server_simple_test.py
+++ b/examples/protocols/http_server/simple/http_server_simple_test.py
@@ -14,6 +14,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+from builtins import range
 import imp
 import re
 import os
@@ -47,27 +51,27 @@ 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"
+    print("Starting http_server simple test app")
     dut1.start_app()
 
     # Parse IP address of STA
-    print "Waiting to connect with AP"
+    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
+    print("Got IP   : " + got_ip)
+    print("Got Port : " + got_port)
 
     # Expected Logs
     dut1.expect("Registering URI handlers", timeout=30)
 
     # Run test script
     # If failed raise appropriate exception
-    print "Test /hello GET handler"
+    print("Test /hello GET handler")
     if not client.test_get_handler(got_ip, got_port):
         raise RuntimeError
 
@@ -82,7 +86,7 @@ def test_examples_protocol_http_server_simple(env, extra_data):
     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"
+    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", timeout=30)
@@ -90,24 +94,24 @@ def test_examples_protocol_http_server_simple(env, extra_data):
 
     # Generate random data of 10KB
     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"
+    print("Test /echo POST handler with random data")
     if not client.test_post_handler(got_ip, got_port, random_data):
         raise RuntimeError
 
     query = "http://foobar"
-    print "Test /hello with custom query : " + query
+    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, timeout=30)
 
     query = "abcd+1234%20xyz"
-    print "Test /hello with custom query : " + query
+    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, timeout=30)
 
     query = "abcd\nyz"
-    print "Test /hello with invalid query"
+    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", timeout=30)
diff --git a/examples/protocols/http_server/simple/scripts/client.py b/examples/protocols/http_server/simple/scripts/client.py
index 471eeb02a..dd95ee94d 100644
--- a/examples/protocols/http_server/simple/scripts/client.py
+++ b/examples/protocols/http_server/simple/scripts/client.py
@@ -14,30 +14,35 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import httplib
+from __future__ import print_function
+from __future__ import unicode_literals
+from future import standard_library
+standard_library.install_aliases()
+from builtins import str
+import http.client
 import argparse
 
 def verbose_print(verbosity, *args):
     if (verbosity):
-        print ''.join(str(elems) for elems in args)
+        print(''.join(str(elems) for elems in args))
 
 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 = httplib.HTTPConnection(ip + ":" + port, timeout = 15)
+    sess = http.client.HTTPConnection(ip + ":" + port, timeout = 15)
 
     uri = "/hello?query1=value1&query2=value2&query3=value3"
     # GET hello response
     test_headers = {"Test-Header-1":"Test-Value-1", "Test-Header-2":"Test-Value-2"}
     verbose_print(verbosity, "Sending GET to URI : ", uri)
     verbose_print(verbosity, "Sending additional headers : ")
-    for k, v in test_headers.iteritems():
+    for k, v in test_headers.items():
         verbose_print(verbosity, "\t", k, ": ", v)
     sess.request("GET", url=uri, headers=test_headers)
     resp = sess.getresponse()
     resp_hdrs = resp.getheaders()
-    resp_data = resp.read()
+    resp_data = resp.read().decode()
     try:
         if resp.getheader("Custom-Header-1") != "Custom-Value-1":
             return False
@@ -62,12 +67,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 = httplib.HTTPConnection(ip + ":" + port, timeout = 15)
+    sess = http.client.HTTPConnection(ip + ":" + port, timeout = 15)
 
     # POST message to /echo and get back response
     sess.request("POST", url="/echo", body=msg)
     resp = sess.getresponse()
-    resp_data = resp.read()
+    resp_data = resp.read().decode()
     verbose_print(verbosity, "Server response to POST /echo (" + msg + ")")
     verbose_print(verbosity, "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv")
     verbose_print(verbosity, resp_data)
@@ -81,7 +86,7 @@ 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 = httplib.HTTPConnection(ip + ":" + port, timeout = 15)
+    sess = http.client.HTTPConnection(ip + ":" + port, timeout = 15)
 
     # PUT message to /ctrl to disable /hello URI handler
     verbose_print(verbosity, "Disabling /hello handler")
@@ -91,7 +96,7 @@ def test_put_handler(ip, port, verbosity = False):
 
     sess.request("GET", url="/hello")
     resp = sess.getresponse()
-    resp_data1 = resp.read()
+    resp_data1 = resp.read().decode()
     verbose_print(verbosity, "Response on GET /hello : " + resp_data1)
 
     # PUT message to /ctrl to enable /hello URI handler
@@ -102,7 +107,7 @@ def test_put_handler(ip, port, verbosity = False):
 
     sess.request("GET", url="/hello")
     resp = sess.getresponse()
-    resp_data2 = resp.read()
+    resp_data2 = resp.read().decode()
     verbose_print(verbosity, "Response on GET /hello : " + resp_data2)
 
     # Close HTTP connection
@@ -113,14 +118,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 = httplib.HTTPConnection(ip + ":" + port, timeout = 15)
+    sess = http.client.HTTPConnection(ip + ":" + port, timeout = 15)
 
     uri = "/hello?" + query
     # GET hello response
     verbose_print(verbosity, "Sending GET to URI : ", uri)
     sess.request("GET", url=uri, headers={})
     resp = sess.getresponse()
-    resp_data = resp.read()
+    resp_data = resp.read().decode()
 
     verbose_print(verbosity, "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv")
     verbose_print(verbosity, "Server response to GET /hello")
@@ -145,8 +150,8 @@ if __name__ == '__main__':
     msg  = args['msg']
 
     if not test_get_handler (ip, port, True):
-        print "Failed!"
+        print("Failed!")
     if not test_post_handler(ip, port, msg, True):
-        print "Failed!"
+        print("Failed!")
     if not test_put_handler (ip, port, True):
-        print "Failed!"
+        print("Failed!")
diff --git a/examples/wifi/iperf/iperf_test.py b/examples/wifi/iperf/iperf_test.py
index 5782d299a..8d5e55802 100644
--- a/examples/wifi/iperf/iperf_test.py
+++ b/examples/wifi/iperf/iperf_test.py
@@ -19,6 +19,11 @@ The test env Example_ShieldBox do need the following config::
     apc_ip: "192.168.1.88"
     pc_nic: "eth0"
 """
+from __future__ import division
+from __future__ import unicode_literals
+from builtins import str
+from builtins import range
+from builtins import object
 import re
 import os
 import sys
@@ -75,7 +80,7 @@ class TestResult(object):
     BAD_POINT_PERCENTAGE_THRESHOLD = 0.3
 
     # we need at least 1/2 valid points to qualify the test result
-    THROUGHPUT_QUALIFY_COUNT = TEST_TIME / 2
+    THROUGHPUT_QUALIFY_COUNT = TEST_TIME//2
 
     def __init__(self, proto, direction, config_name):
         self.proto = proto
@@ -169,7 +174,7 @@ class TestResult(object):
         def analysis_bad_point(data, index_type):
             for ap_ssid in data:
                 result_dict = data[ap_ssid]
-                index_list = result_dict.keys()
+                index_list = list(result_dict.keys())
                 index_list.sort()
                 if index_type == "att":
                     index_list.reverse()
diff --git a/tools/tiny-test-fw/DUT.py b/tools/tiny-test-fw/DUT.py
index 97487525e..e49a121f3 100644
--- a/tools/tiny-test-fw/DUT.py
+++ b/tools/tiny-test-fw/DUT.py
@@ -37,6 +37,7 @@ User should implement their DUTTool classes.
 If they using different port then need to implement their DUTPort class as well.
 """
 
+from __future__ import print_function
 import time
 import re
 import threading
@@ -402,6 +403,21 @@ class BaseDUT(object):
         self._port_close()
         self.LOG_THREAD.flush_data()
 
+    @staticmethod
+    def u_to_bytearray(data):
+        """
+        if data is not bytearray then it tries to convert it
+
+        :param data: data which needs to be checked and maybe transformed
+        """
+        if type(data) is type(u''):
+            try:
+                data = data.encode('utf-8')
+            except:
+                print(u'Cannot encode {} of type {}'.format(data, type(data)))
+                raise
+        return data
+
     def write(self, data, eol="\r\n", flush=True):
         """
         :param data: data
@@ -416,7 +432,7 @@ class BaseDUT(object):
             self.data_cache.flush()
         # do write if cache
         if data is not None:
-            self._port_write(data + eol if eol else data)
+            self._port_write(self.u_to_bytearray(data) + self.u_to_bytearray(eol) if eol else self.u_to_bytearray(data))
 
     @_expect_lock
     def read(self, size=0xFFFFFFFF):
@@ -461,9 +477,13 @@ class BaseDUT(object):
         :return: match groups if match succeed otherwise None
         """
         ret = None
+        if type(pattern.pattern) is type(u''):
+            pattern = re.compile(BaseDUT.u_to_bytearray(pattern.pattern))
+        if type(data) is type(u''):
+            data = BaseDUT.u_to_bytearray(data)
         match = pattern.search(data)
         if match:
-            ret = match.groups()
+            ret = tuple(x.decode() for x in match.groups())
             index = match.end()
         else:
             index = -1
@@ -471,7 +491,8 @@ class BaseDUT(object):
 
     EXPECT_METHOD = [
         [type(re.compile("")), "_expect_re"],
-        [str, "_expect_str"],
+        [type(b''), "_expect_str"], # Python 2 & 3 hook to work without 'from builtins import str' from future
+        [type(u''), "_expect_str"],
     ]
 
     def _get_expect_method(self, pattern):
diff --git a/tools/tiny-test-fw/IDF/IDFDUT.py b/tools/tiny-test-fw/IDF/IDFDUT.py
index 28ea4867c..58d5c6e52 100644
--- a/tools/tiny-test-fw/IDF/IDFDUT.py
+++ b/tools/tiny-test-fw/IDF/IDFDUT.py
@@ -89,7 +89,7 @@ class IDFDUT(DUT.SerialDUT):
             address = self.partition_table["nvs"]["offset"]
             size = self.partition_table["nvs"]["size"]
             nvs_file = tempfile.NamedTemporaryFile()
-            nvs_file.write(chr(0xFF) * size)
+            nvs_file.write(b'\xff' * size)
             nvs_file.flush()
             download_config = self.download_config + [address, nvs_file.name]
         else: