

class JamesTest :

    def __init__(self) :
        self.default = ''


#***************************************************************************************************************


    def CASE1(self,main) : 
        main.case("\nStart-Up of Zookeeper, RAMCloud, ONOS, and Mininet")
        import time 
        main.step("\n**********************Git pulls and Rebuilds******************")
        for i in range(2):
            main.log.report("ONOS1 Git Pull")
            uptodate = main.ONOS1.git_pull()
            ver1 = main.ONOS1.get_version()
            main.log.report("ONOS2 Git Pull")
            main.ONOS2.git_pull()
            main.log.report("ONOS3 Git Pull")
            main.ONOS3.git_pull()
            main.log.report("ONOS4 Git Pull")
            main.ONOS4.git_pull()
            ver2 = main.ONOS4.get_version()
            if ver1==ver2:
                break
            elif i==1:
                main.log.report("Versions differ. Doing Git pulls from ONOS1")
                main.ONOS2.git_pull("ONOS1 master")
                main.ONOS3.git_pull("ONOS1 master")
                main.ONOS4.git_pull("ONOS1 master")
        if uptodate==0:
            main.log.report("Building ONOS1")
            main.ONOS1.git_compile()
            main.log.report("Building ONOS2")
            main.ONOS2.git_compile()
            main.log.report("Building ONOS3")
            main.ONOS3.git_compile()
            main.log.report("Building ONOS4")
            main.ONOS4.git_compile()
        

        main.step("\n********************Testing Zookeeper Startup**************")
        data1 = main.Zookeeper1.isup()
        utilities.assert_equals(expect=main.TRUE,actual=data1,onpass="Zookeeper is up!",onfail="Zookeeper is down...")
        if data1==main.FALSE:
            main.log.report("Zookeeper is Down, Exiting the Test!")
            main.cleanup()
            main.exit()

        main.step("\n********************Starting Up RAMCloud*********************")
        main.RamCloud1.start_coor()
        time.sleep(2)
        main.RamCloud1.start_serv()
        main.RamCloud2.start_serv()
        main.RamCloud3.start_serv()
        main.RamCloud4.start_serv()
        time.sleep(5)
        
        main.step("\n********************Testing RAMCloud Startup**************")
        data2 = main.RamCloud1.status_serv()
        print(data2)
        for i in range(3):
            if data2 == main.FALSE:
                main.RamCloud1.stop_serv()
                main.RamCloud2.stop_serv()
                main.RamCloud3.stop_serv()
                main.RamCloud4.stop_serv()
                main.RamCloud1.stop_coor()
                main.RamCloud1.start_coor()
                time.sleep(2)
                main.RamCloud1.start_serv()
                main.RamCloud2.start_serv()
                main.RamCloud3.start_serv()
                main.RamCloud4.start_serv()
                time.sleep(5)
                data2 = main.RamCloud1.status_serv()
            else:
                break
        utilities.assert_equals(expect=main.TRUE,actual=data2,onpass="RAMCloud is up!",onfail="RAMCloud is down...")
        if data2==main.FALSE:
            main.log.report("RAMCloud is Down, Exiting the Test!")
            main.cleanup()
            main.exit()

        main.step("\n************************Starting Up ONOS and Rest*****************")
        main.ONOS1.start()
        time.sleep(10)
        main.ONOS2.start()
        main.ONOS3.start()
        main.ONOS4.start()
        main.ONOS1.start_rest()
        time.sleep(5)
        test = main.ONOS1.rest_status()
        for i in range(3):
            if test == main.FALSE:
                main.ONOS1.start_rest()
                time.sleep(5)
                test = main.ONOS1.rest_status()
            else:
                break
        
        main.step("\n************************Testing ONOS Startup***************")
        data3 = main.ONOS1.isup()
        for i in range(3):
            if data3 == main.FALSE:
                main.log.report("ONOS did not start, restarting ONOS")
                main.ONOS1.stop()
                main.ONOS2.stop()
                main.ONOS3.stop()
                main.ONOS4.stop()
                time.sleep(2)
                main.ONOS1.start()
                time.sleep(10)
                main.ONOS2.start()
                main.ONOS3.start()
                main.ONOS4.start()
                data3 = main.ONOS1.isup()
            else:
                break
        utilities.assert_equals(expect=main.TRUE,actual=data3,onpass="ONOS is up!",onfail="ONOS is down...")
        if data3==main.FALSE:
            main.log.report("ONOS did not START!! Exiting the Test")
            main.cleanup()
            main.exit() 

        main.step("\n****************************Testing Mininet Startup***************")
        data4 = main.Mininet1.checkIP(main.params['CASE1']['destination'])
        utilities.assert_equals(expect=main.TRUE,actual=data4,onpass="Host IP address configured",onfail="Host IP address not configured")

        finalAssert = data1 and data2 and data3
        utilities.assert_equals(expect=main.TRUE,actual=finalAssert,onpass="Good to Go!",onfail="NO GO FOR LAUNCH")

#*****************************************************************************************

    def CASE2(self,main) :
        import time
        main.case("\nAssign ONOS Controllers to Switches and run Initial Ping Test")
        main.step("\n**********************Assign initial master controller to switches**********************")
        for i in range(25):
            if i < 3:
                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'])
                time.sleep(1)
            elif i>=3 and i <5:
                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip2'],port1=main.params['CTRL']['port2'])
                time.sleep(1)
            elif i>=5 and i<15:
                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip3'],port1=main.params['CTRL']['port3'])
                time.sleep(1)
            else: 
                main.Mininet1.assign_sw_controller(sw=str(i+16),ip1=main.params['CTRL']['ip4'],port1=main.params['CTRL']['port4'])
                time.sleep(1)
        
        main.step("\n**********************Assign all ONOS instances to all Switches*************************")
        for i in range(25):
            if i < 15:
                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])                
                time.sleep(1)
            else:
                main.Mininet1.assign_sw_controller(sw=str(i+16),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])                
       

    def CASE3(self,main):
        main.case("\nPerforming Initial Ping Test")
        main.step("\n**********************Initial Ping Test***************")
        count = 1
        i = 6
        while i < 16:
            main.log.info("\n\t\t\th" + str(i) + " IS PINGING h" + str(i+25) )
            strtTime = time.time()
            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
            if ping == main.FALSE and count<6:
                count+=1
                i = 6
                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
                time.sleep(2)
            elif ping == main.FALSE and count==6:
                main.log.error("Ping test failed")
                i = 17
                result = main.FALSE
            elif ping == main.TRUE:
                i += 1
                result = main.TRUE
        endTime = time.time()
        if result == main.TRUE:
            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
        else:
            main.log.report("\tPING TEST FAILED!")
        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")


    def CASE4(self,main):
        main.case("\nWhat happens when 3 of the ONOS instances die?")
        main.step("\n********************Removing 3 ONOS instances****************************")
        main.ONOS2.stop()
        main.ONOS3.stop()
        main.ONOS4.stop()
        main.step("\n*******************Checking for the correct topology*********************")
        data1 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
        print("%s" % data1)
        for i in range(10):
            if data1 == main.FALSE:
                time.sleep(5)
                data1 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
            else:
                break
        main.step("\n********************Running PING Test****************************")
        count = 1
        i = 6
        while i < 16:
            main.log.info("\n\t\t\tH" + str(i) + " is PINGING H" + str(i+25))
            strtTime = time.time()
            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
            if ping == main.FALSE and count<6:
                count+=1
                i = 6
                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
                time.sleep(2)
            elif ping == main.FALSE and count==6:
                main.log.error("Ping test failed")
                i = 17
                result2 = main.FALSE
            elif ping == main.TRUE:
                i += 1
                result2 = main.TRUE
        endTime = time.time()
        if result2 == main.TRUE:
            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
        else:
            main.log.report("\tPING TEST FAILED!")
        finalResult = data1 and result2
        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")
        time.sleep(5)


    def CASE5(self,main):
        main.case("\nRestart the 3 ONOS instances and run a PING test")
        main.step("\n************************Bringing Back up ONOS Instances*****************************")
        main.ONOS2.start()
        main.ONOS3.start()
        main.ONOS4.start()
        time.sleep(4)
        main.step("\n********************Running PING Test****************************")
        count = 1
        i = 6
        while i < 16:
            main.log.info("\n\t\t\tH" + str(i) + " is PINGING H" + str(i+25))
            strtTime = time.time()
            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
            if ping == main.FALSE and count<6:
                count+=1
                i = 6
                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
                time.sleep(2)
            elif ping == main.FALSE and count==6:
                main.log.error("Ping test failed")
                i = 17
                result2 = main.FALSE
            elif ping == main.TRUE:
                i += 1
                result2 = main.TRUE
        endTime = time.time()
        if result2 == main.TRUE:
            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
        else:
            main.log.report("\tPING TEST FAILED!")
        finalResult = result2
        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")
        time.sleep(5)
       

    def CASE6(self,main):
        main.case("Bring links between S1 and S2 down, then ping untill all hosts are reachable or fail after 10 attempts")
        import time
        main.step("\n*****************Bringing Link DOWN!!!************************")
        data1 = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
        utilities.assert_equals(expect=main.TRUE,actual=data1,onpass="Link Brought DOWN!",onfail="Link still up...")
        main.step("\n******************Waiting for Topology Convergence****************")
        strtTime = time.time()
        data2 = main.FALSE
        data2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
        print("hello world")
        for i in range(2):
            if data2 == main.FALSE:
                time.sleep(5)
                data2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
            else:
                break
        utilities.assert_equals(expect=main.TRUE,actual=data2,onpass="Topology Converged",onfail="Topology FAILED to Converge")
        main.case("\n*******************Ping Test***********************")
        count = 1
        i = 6
        while i < 16:
            main.log.info("\n\t\t\tH" + str(i) + " is PINGING H" + str(i+25))
            strtTime = time.time()
            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
            if ping == main.FALSE and count<6:
                count+=1
                i = 6
                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
                time.sleep(2)
            elif ping == main.FALSE and count==6:
                main.log.error("Ping test failed")
                i = 17
                data3 = main.FALSE
            elif ping == main.TRUE:
                i += 1
                data3 = main.TRUE
        endTime = time.time()
        if data3 == main.TRUE:
            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
        else:
            main.log.report("\tPING TEST FAILED!")
        utilities.assert_equals(expect=main.TRUE,actual=data3,onpass="Ping test PASSED!",onfail="Ping Test FAILED!!!!")
        finalResult = data1 and data2 and data3
        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")
        time.sleep(5)
       
    def CASE31(self,main) : 
        import time
        main.case("\nClear out flows, then add flows from FLOWDEF file")
        main.step("\n\n***************Cleaning out OLD flows!*************")
        main.ONOS1.delete_flow("all")
        main.step("\n\n***************Adding Flows from FLOWDEF File**********")
        strtTime = time.time()
        main.ONOS1.add_flow(main.params['FLOWDEF'])
        main.step("\n\n**************Checking Flows***********************")
        count = 1
        i = 6
        while i <16:
            main.log.info("\n\t\t\t\th" + str(i) + " IS PINGING h" + str(i+25))
            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
            if ping == main.FALSE and count < 9:
                count +=1
                i = 6
                main.log.info("Ping failed, making attempt number " + str(count) + " in 2 seconds")
                time.sleep(2)
            elif ping == main.FALSE and count == 9:
                main.log.error("Ping test failed")
                i = 17
                result = main.FALSE
            elif ping == main.TRUE:
                i = i+1
                result = main.TRUE
        endTime = time.time()
        if result == main.TRUE:
            main.log.report("\tTime to add flows: " + str(round(endTime-strtTime,2))+" seconds")
        else:
            main.log.report("\tFlows failed check")
        result2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
        finalResult = result and result2
        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Flows added and Checked!",onfail="Flows did not add properly")


    def CASE21(self,main) : 
        import json
        main.case("Test device discovery function by attaching, metaching, moving host1 from s1 -> s6 -> s1. Per mininet naming, when switching ports, the host attaches will still remain as 's1-eth1' throughout the entire test")
        main.step("\n\n******Checking that the initial host MAC/IP exists on the mininet******")
        host = main.params['YANK']['hostname']
        mac = main.params['YANK']['hostmac']
        hostip = main.params['YANK']['hostip']
        RestIP1 = main.params['RESTCALL']['restIP1']
        RestPort = main.params['RESTCALL']['restPort']
        url = main.params['RESTCALL']['restURL']
        t_topowait = 0
        t_restwait = 10
        main.log.report("Wait time from topo change to ping set to " + str(t_topowait))
        main.log.report("Wait time from ping to rest call set to " + str(t_restwait))
        time.sleep(t_topowait)
        main.log.info("\n\t\t\t\t Ping: Issue 1 ping from " + str(host) + " to generate arp to switch. Ping result is not important")
        ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
        time.sleep(t_restwait)
        Reststatus, Swtich, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url,hostip)
        main.log.report("Number of hosts with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
        if Reststatus ==1:
            main.log.report("\t PASSED - Found host IP = " + hostip + "; MAC = " + "".join(MAC)+"; attached to switchDPPID = " + "".join(Switch)+ "; at port = " + "".join(Port))
            result1 = main.TRUE
        elif Reststatus >1:
            main.log.report("\t FAILED - Host " + host + " with MAC:" + mac + " has " + str(Reststatus) + " duplicated IP addresses. FAILED")
            main.log.report("switches are: " + "; ".join(Switch))
            main.log.report("Ports are: " + "; ".join(Port))
            main.log.report("MACS are: " + "; ".join(MAC))
            result1 = main.FALSE
        else:
            main.log.report("\]t FAILED - Host " + host + " with MAC:" + mac + " does not exist. FAILED")
            result1 = main.FALSE

#*****************Step to yank out s1-eth1 from s1

        main.step("Yank out s1-eth1")
        main.log.report("Yankout s6-eth1 (link to h1) from s1")
        result = main.Mininet1.yank(SW=main.params['YANK']['sw1'],INTF=main.params['YANK']['intf'])
        time.sleep(t_topowait)
        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Yank command suceeded",onfail="Yank command failed...")
       
        main.step("\n\n Ping: Issue 1 ping from " + str(host) + " to generate arp to switch. Ping result is not important")
        ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
        time.sleep(t_restwait)
        Reststatus, Switch, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url,hostip)
        main.log.report("Number of hosts with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
        if Reststatus ==1:
            main.log.report("\tFAILED - Found host IP = " + hostip + "; MAC = " + "".join(MAC) + "".join(Port))
            result2 = main.FALSE
        elif Reststatus >1:
            main.log.report("\t FAILED - Host " + host + " with MAC:" + str(mac) + " has " + str(Reststatus) + " duplicated IP addresses. FAILED")
            main.log.report("Switches are: " + "; ".join(Switch))
            main.log.report("Ports are: " + "; ".join(Port))
            main.log.report("MACs are: " + "; ".join(MAC))
            result2 = main.FALSE
        else:
            main.log.report("\t PASSED - Host" + host + " with MAC:" + str(mac) + " does not exist. PASSED - host is not supposed to be attached to the switch.")
            result2 = main.TRUE
        utilities.assert_equals(expect=main.TRUE,actual=result2,onpass="s1-eth1 yanked!",onfail="s1-eth1 failed to be yanked!")

# Step to plug "s1-eth1" to s6
        main.step("Plug s1-eth1 into s6")
        result3 = main.Mininet1.plug(SW=main.params['PLUG']['sw6'],INTF=main.params['PLUG']['intf'])
        time.sleep(t_topowait)
        utilities.assert_equals(expect=main.TRUE,actual=result3,onpass="Plug command suceeded",onfail="Plug command failed ... ")
        main.step("\n\nPing issue one ping from " + str(host) + "to generate arp to switch. Ping result is not important")
        ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
        time.sleep(t_restwait)
        Reststatus, Switch, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url,hostip)

        main.log.report("Number of hosts with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
        if Reststatus ==1:
            main.log.report("\t PASSED - Found host IP = " + hostip + "; MAC = " + "".join(MAC) + "; attached to switchDPID = " + "".join(Switch) + "; at port = " + "".join(Port))
            result4 = main.TRUE
        elif Reststatus >1:
            main.log.report("\t FAILED - Host " + host + " with MAC: " + str(mac) + " has " + str(Reststatus) + "duplicated IP addresses. FAILED")
            main.log.report("switches are: " + "; ".join(Switch))
            main.log.report("Ports are: " + "; ".join(Port))
            main.log.report("MACs are: " + "; ".join(MAC))
            result4 = main.FALSE
        else:
            main.log.report("\t FAILED - Host " + host + " with MAC: " + str(mac) + " does not exist. FAILED")
            result4 = main.FALSE

# Step to put "s1-eth1" back to s1
        main.step("Move s1-eth1 back to s1")
        result5 = main.Mininet1.yank(SW=main.params['YANK']['sw6'],INTF=main.params['YANK']['intf'])
        time.sleep(t_topowait)
        result6 = main.Mininet1.plug(SW=main.params['PLUG']['sw1'],INTF=main.params['PLUG']['intf'])
        utilities.assert_equals(expect=main.TRUE,actual=(result5 and result6),onpass="Yank/Plug command suceeded",onfail="Yank/Plug command failed...")   
        main.log.info("\n\t\t\t\t ping issue one ping from" + str(host) + "to generate arp to switch. Ping result is not important" )   
        ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
        time.sleep(t_restwait)
        Reststatus, Switch, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url, hostip)

        main.log.report("Number of host with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
        if Reststatus == 1:
            main.log.report("\tPASSED - Found host IP = " + hostip + "; MAC = " + "".join(MAC) + "; attached to switchDPID = " + "".join(Switch) + "; at port = " + "".join(Port))
            result7 = main.TRUE
        elif Reststatus > 1:
            main.log.report("\t FAILED - Host " + host + " with MAC:" + str(mac) + " has " + str(Reststatuas) + " duplicated IP addresses. FAILED")
            main.log.report("switches are: " + "; ".join(Switch))
            main.log.report("Ports are: " + "; ".join(Port))
            main.log.report("MACs are: " + "; ".join(MAC))      
            result7 = main.FALSE
        else:   
            main.log.report("\t FAILED -Host " + host + " with MAC:" + str(mac) + " does not exist. FAILED")
            result7 = main.FALSE

        result = result1 and result2 and result3 and result4 and result5 and result6 and result7
        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="DEVICE DISCOVERY TEST PASSED PLUG/UNPLUG/MOVE TEST",onfail="DEVICE DISCOVERY TEST FAILED")

    def CASE7(self, main) : 
        import time
        main.case("Bring Link between s1 and s2 up, then ping untill all hosts are reachable or fail after 10 attemtps!")
        main.step("Bringing Link up... " )
        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
        utilities.assert_equlas(expect=main.TRUE,actual=result,onpass="Link UP!",onfail="Link not brought up...")
        main.step("\n\n\t\tPing Test!")
        strtTime = time.time()
        result2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
        for i in range(2):
            if result2 == main.FALSE:
                time.sleep(5)
                result2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
            else:
                break
        strtTime = time.time()
        count = 1
        i = 6
        while i <16 :
            main.log.info("\n\t\t\t\th" + str(i) + " IS PINGING h" + str(i+25))
            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
            if ping ==main.FALSE and count<10:
                count +=1
                main.log.info("Ping failed, making attempt number " + str(count) + " in 2 seconds")
                i = 6
                time.sleep(2)
            elif ping ==main.FALSE and count==10:
                main.log.error("Ping test failed")
                i = 17
                result3 = main.FALSE
            elif ping ==main.TRUE:
                i += 1
                result3 = main.TRUE
        endTime = time.time()
        if result3 ==main.TRUE:
            main.log.report("\t Time to complete ping test: " + str(round(endTime-strtTime,2)) + " seconds")
        else:
            main.log.report("\tPing Tests FAILED!!")
        finalResult = result and result2 and result3 and result4
        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")