diff --git a/TestON/tests/MultiProd/MultiProd.py b/TestON/tests/MultiProd/MultiProd.py
index 6b67f63..4d342ca 100644
--- a/TestON/tests/MultiProd/MultiProd.py
+++ b/TestON/tests/MultiProd/MultiProd.py
@@ -29,13 +29,13 @@
         onos-install -f
         onos-wait-for-start
         """
-        cell_name = main.params[ 'ENV' ][ 'cellName' ]
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
-        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
-        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
-        ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
-        ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
-        ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
+        ONOS2Port = main.params[ 'CTRL' ][ 'port2' ]
+        ONOS3Port = main.params[ 'CTRL' ][ 'port3' ]
 
         main.case( "Setting up test environment" )
         main.log.report(
@@ -43,141 +43,141 @@
         main.log.report( "__________________________________" )
 
         main.step( "Applying cell variable to environment" )
-        cell_result1 = main.ONOSbench.set_cell( cell_name )
-        #cell_result2 = main.ONOScli1.set_cell( cell_name )
-        #cell_result3 = main.ONOScli2.set_cell( cell_name )
-        #cell_result4 = main.ONOScli3.set_cell( cell_name )
-        verify_result = main.ONOSbench.verify_cell()
-        cell_result = cell_result1
+        cellResult1 = main.ONOSbench.setCell( cellName )
+        #cellResult2 = main.ONOScli1.setCell( cellName )
+        #cellResult3 = main.ONOScli2.setCell( cellName )
+        #cellResult4 = main.ONOScli3.setCell( cellName )
+        verifyResult = main.ONOSbench.verifyCell()
+        cellResult = cellResult1
 
         main.step( "Removing raft logs before a clen installation of ONOS" )
-        remove_log_Result = main.ONOSbench.onos_remove_raft_logs()
+        removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
 
         main.step( "Git checkout and pull master and get version" )
-        main.ONOSbench.git_checkout( "master" )
-        git_pull_result = main.ONOSbench.git_pull()
-        print "git_pull_result = ", git_pull_result
-        version_result = main.ONOSbench.get_version( report=True )
+        main.ONOSbench.gitCheckout( "master" )
+        gitPullResult = main.ONOSbench.gitPull()
+        print "git_pull_result = ", gitPullResult
+        versionResult = main.ONOSbench.getVersion( report=True )
 
-        if git_pull_result == 1:
+        if gitPullResult == 1:
             main.step( "Using mvn clean & install" )
-            clean_install_result = main.ONOSbench.clean_install()
-            #clean_install_result = main.TRUE
+            cleanInstallResult = main.ONOSbench.cleanInstall()
+            #cleanInstallResult = main.TRUE
 
         main.step( "Creating ONOS package" )
-        package_result = main.ONOSbench.onos_package()
+        packageResult = main.ONOSbench.onosPackage()
 
         #main.step( "Creating a cell" )
-        # cell_create_result = main.ONOSbench.create_cell_file( **************
+        # cellCreateResult = main.ONOSbench.createCellFile( **************
         # )
 
         main.step( "Installing ONOS package" )
-        onos1_install_result = main.ONOSbench.onos_install(
+        onos1InstallResult = main.ONOSbench.onosInstall(
             options="-f",
-            node=ONOS1_ip )
-        onos2_install_result = main.ONOSbench.onos_install(
+            node=ONOS1Ip )
+        onos2InstallResult = main.ONOSbench.onosInstall(
             options="-f",
-            node=ONOS2_ip )
-        onos3_install_result = main.ONOSbench.onos_install(
+            node=ONOS2Ip )
+        onos3InstallResult = main.ONOSbench.onosInstall(
             options="-f",
-            node=ONOS3_ip )
-        onos_install_result = onos1_install_result and onos2_install_result and onos3_install_result
-        if onos_install_result == main.TRUE:
+            node=ONOS3Ip )
+        onosInstallResult = onos1InstallResult and onos2InstallResult and onos3InstallResult
+        if onosInstallResult == main.TRUE:
             main.log.report( "Installing ONOS package successful" )
         else:
             main.log.report( "Installing ONOS package failed" )
 
-        onos1_isup = main.ONOSbench.isup( ONOS1_ip )
-        onos2_isup = main.ONOSbench.isup( ONOS2_ip )
-        onos3_isup = main.ONOSbench.isup( ONOS3_ip )
-        onos_isup = onos1_isup and onos2_isup and onos3_isup
-        if onos_isup == main.TRUE:
+        onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+        onos2Isup = main.ONOSbench.isup( ONOS2Ip )
+        onos3Isup = main.ONOSbench.isup( ONOS3Ip )
+        onosIsup = onos1Isup and onos2Isup and onos3Isup
+        if onosIsup == main.TRUE:
             main.log.report( "ONOS instances are up and ready" )
         else:
             main.log.report( "ONOS instances may not be up" )
 
         main.step( "Starting ONOS service" )
-        start_result = main.TRUE
-        #start_result = main.ONOSbench.onos_start( ONOS1_ip )
-        startcli1 = main.ONOScli1.start_onos_cli( ONOS_ip=ONOS1_ip )
-        startcli2 = main.ONOScli2.start_onos_cli( ONOS_ip=ONOS2_ip )
-        startcli3 = main.ONOScli3.start_onos_cli( ONOS_ip=ONOS3_ip )
+        startResult = main.TRUE
+        #startResult = main.ONOSbench.onosStart( ONOS1Ip )
+        startcli1 = main.ONOScli1.startOnosCli( ONOSIp=ONOS1Ip )
+        startcli2 = main.ONOScli2.startOnosCli( ONOSIp=ONOS2Ip )
+        startcli3 = main.ONOScli3.startOnosCli( ONOSIp=ONOS3Ip )
         print startcli1
         print startcli2
         print startcli3
 
-        case1_result = ( package_result and
-                         cell_result and verify_result and onos_install_result and
-                         onos_isup and start_result )
-        utilities.assert_equals( expect=main.TRUE, actual=case1_result,
-                                 onpass="Test startup successful",
-                                 onfail="Test startup NOT successful" )
+        case1Result = ( packageResult and
+                        cellResult and verifyResult and onosInstallResult and
+                        onosIsup and startResult )
+        utilities.assertEquals( expect=main.TRUE, actual=case1Result,
+                                onpass="Test startup successful",
+                                onfail="Test startup NOT successful" )
 
     def CASE11( self, main ):
         """
         Cleanup sequence:
-        onos-service <node_ip> stop
+        onos-service <nodeIp> stop
         onos-uninstall
 
         TODO: Define rest of cleanup
 
         """
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
-        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
-        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
 
         main.case( "Cleaning up test environment" )
 
         main.step( "Testing ONOS kill function" )
-        kill_result1 = main.ONOSbench.onos_kill( ONOS1_ip )
-        kill_result2 = main.ONOSbench.onos_kill( ONOS2_ip )
-        kill_result3 = main.ONOSbench.onos_kill( ONOS3_ip )
+        killResult1 = main.ONOSbench.onosKill( ONOS1Ip )
+        killResult2 = main.ONOSbench.onosKill( ONOS2Ip )
+        killResult3 = main.ONOSbench.onosKill( ONOS3Ip )
 
         main.step( "Stopping ONOS service" )
-        stop_result1 = main.ONOSbench.onos_stop( ONOS1_ip )
-        stop_result2 = main.ONOSbench.onos_stop( ONOS2_ip )
-        stop_result3 = main.ONOSbench.onos_stop( ONOS3_ip )
+        stopResult1 = main.ONOSbench.onosStop( ONOS1Ip )
+        stopResult2 = main.ONOSbench.onosStop( ONOS2Ip )
+        stopResult3 = main.ONOSbench.onosStop( ONOS3Ip )
 
         main.step( "Uninstalling ONOS service" )
-        uninstall_result = main.ONOSbench.onos_uninstall()
+        uninstallResult = main.ONOSbench.onosUninstall()
 
     def CASE3( self, main ):
         """
         Test 'onos' command and its functionality in driver
         """
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
-        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
-        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
 
         main.case( "Testing 'onos' command" )
 
         main.step( "Sending command 'onos -w <onos-ip> system:name'" )
         cmdstr1 = "system:name"
-        cmd_result1 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr1 )
-        main.log.info( "onos command returned: " + cmd_result1 )
-        cmd_result2 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr1 )
-        main.log.info( "onos command returned: " + cmd_result2 )
-        cmd_result3 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr1 )
-        main.log.info( "onos command returned: " + cmd_result3 )
+        cmdResult1 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmdResult1 )
+        cmdResult2 = main.ONOSbench.onosCli( ONOS2Ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmdResult2 )
+        cmdResult3 = main.ONOSbench.onosCli( ONOS3Ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmdResult3 )
 
         main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
         cmdstr2 = "onos:topology"
-        cmd_result4 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr2 )
-        main.log.info( "onos command returned: " + cmd_result4 )
-        cmd_result5 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr2 )
-        main.log.info( "onos command returned: " + cmd_result5 )
-        cmd_result6 = main.ONOSbench.onos_cli( ONOS6_ip, cmdstr2 )
-        main.log.info( "onos command returned: " + cmd_result6 )
+        cmdResult4 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmdResult4 )
+        cmdResult5 = main.ONOSbench.onosCli( ONOS2Ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmdResult5 )
+        cmdResult6 = main.ONOSbench.onosCli( ONOS6Ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmdResult6 )
 
     def CASE4( self, main ):
         import re
         import time
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
-        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
-        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
-        ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
-        ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
-        ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
+        ONOS2Port = main.params[ 'CTRL' ][ 'port2' ]
+        ONOS3Port = main.params[ 'CTRL' ][ 'port3' ]
 
         main.log.report(
             "This testcase is testing the assignment of all the switches to all controllers and discovering the hosts in reactive mode" )
@@ -185,48 +185,48 @@
         main.case( "Pingall Test(No intents are added)" )
         main.step( "Assigning switches to controllers" )
         for i in range( 1, 29 ):  # 1 to ( num of switches +1 )
-            main.Mininet1.assign_sw_controller(
+            main.Mininet1.assignSwController(
                 sw=str( i ),
                 count=3,
-                ip1=ONOS1_ip,
-                port1=ONOS1_port,
-                ip2=ONOS2_ip,
-                port2=ONOS2_port,
-                ip3=ONOS3_ip,
-                port3=ONOS3_port )
+                ip1=ONOS1Ip,
+                port1=ONOS1Port,
+                ip2=ONOS2Ip,
+                port2=ONOS2Port,
+                ip3=ONOS3Ip,
+                port3=ONOS3Port )
 
-        switch_mastership = main.TRUE
+        switchMastership = main.TRUE
         for i in range( 1, 29 ):
-            response = main.Mininet1.get_sw_controller( "s" + str( i ) )
+            response = main.Mininet1.getSwController( "s" + str( i ) )
             print( "Response is " + str( response ) )
-            if re.search( "tcp:" + ONOS1_ip, response ):
-                switch_mastership = switch_mastership and main.TRUE
+            if re.search( "tcp:" + ONOS1Ip, response ):
+                switchMastership = switchMastership and main.TRUE
             else:
-                switch_mastership = main.FALSE
+                switchMastership = main.FALSE
 
-        if switch_mastership == main.TRUE:
+        if switchMastership == main.TRUE:
             main.log.report( "Controller assignment successfull" )
         else:
             main.log.report( "Controller assignment failed" )
         # REACTIVE FWD test
         main.step( "Pingall" )
-        ping_result = main.FALSE
+        pingResult = main.FALSE
         time1 = time.time()
-        ping_result = main.Mininet1.pingall()
+        pingResult = main.Mininet1.pingall()
         time2 = time.time()
         print "Time for pingall: %2f seconds" % ( time2 - time1 )
 
-        case4_result = switch_mastership and ping_result
-        if ping_result == main.TRUE:
+        case4Result = switchMastership and pingResult
+        if pingResult == main.TRUE:
             main.log.report(
                 "Pingall Test in reactive mode to discover the hosts successful" )
         else:
             main.log.report(
                 "Pingall Test in reactive mode to discover the hosts failed" )
 
-        utilities.assert_equals(
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=case4_result,
+            actual=case4Result,
             onpass="Controller assignment and Pingall Test successful",
             onfail="Controller assignment and Pingall Test NOT successful" )
 
@@ -235,9 +235,9 @@
         from subprocess import Popen, PIPE
         # assumes that sts is already in you PYTHONPATH
         from sts.topology.teston_topology import TestONTopology
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
-        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
-        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
 
         main.log.report(
             "This testcase is testing if all ONOS nodes are in topology sync with mininet and its peer ONOS nodes" )
@@ -336,85 +336,85 @@
             ctrls )  # can also add Intent API info for intent operations
         MNTopo = Topo
 
-        Topology_Check = main.TRUE
+        TopologyCheck = main.TRUE
         main.step( "Compare ONOS Topology to MN Topology" )
 
-        switches_results1 = main.Mininet1.compare_switches(
+        switchesResults1 = main.Mininet1.compareSwitches(
             MNTopo,
             json.loads( devices1 ) )
-        print "switches_Result1 = ", switches_results1
-        utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
-                                 onpass="ONOS1 Switches view is correct",
-                                 onfail="ONOS1 Switches view is incorrect" )
+        print "switches_Result1 = ", switchesResults1
+        utilities.assertEquals( expect=main.TRUE, actual=switchesResults1,
+                                onpass="ONOS1 Switches view is correct",
+                                onfail="ONOS1 Switches view is incorrect" )
 
-        switches_results2 = main.Mininet1.compare_switches(
+        switchesResults2 = main.Mininet1.compareSwitches(
             MNTopo,
             json.loads( devices2 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
-                                 onpass="ONOS2 Switches view is correct",
-                                 onfail="ONOS2 Switches view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=switchesResults2,
+                                onpass="ONOS2 Switches view is correct",
+                                onfail="ONOS2 Switches view is incorrect" )
 
-        switches_results3 = main.Mininet1.compare_switches(
+        switchesResults3 = main.Mininet1.compareSwitches(
             MNTopo,
             json.loads( devices3 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
-                                 onpass="ONOS3 Switches view is correct",
-                                 onfail="ONOS3 Switches view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=switchesResults3,
+                                onpass="ONOS3 Switches view is correct",
+                                onfail="ONOS3 Switches view is incorrect" )
 
         """
-        ports_results1 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports1 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+        portsResults1 =  main.Mininet1.comparePorts( MNTopo, json.loads( ports1 ) )
+        utilities.assertEquals( expect=main.TRUE, actual=portsResults1,
                 onpass="ONOS1 Ports view is correct",
                 onfail="ONOS1 Ports view is incorrect" )
 
-        ports_results2 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports2 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+        portsResults2 =  main.Mininet1.comparePorts( MNTopo, json.loads( ports2 ) )
+        utilities.assertEquals( expect=main.TRUE, actual=portsResults2,
                 onpass="ONOS2 Ports view is correct",
                 onfail="ONOS2 Ports view is incorrect" )
 
-        ports_results3 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+        portsResults3 =  main.Mininet1.comparePorts( MNTopo, json.loads( ports3 ) )
+        utilities.assertEquals( expect=main.TRUE, actual=portsResults3,
                 onpass="ONOS3 Ports view is correct",
                 onfail="ONOS3 Ports view is incorrect" )
         """
-        links_results1 = main.Mininet1.compare_links(
+        linksResults1 = main.Mininet1.compareLinks(
             MNTopo,
             json.loads( links1 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=links_results1,
-                                 onpass="ONOS1 Links view is correct",
-                                 onfail="ONOS1 Links view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=linksResults1,
+                                onpass="ONOS1 Links view is correct",
+                                onfail="ONOS1 Links view is incorrect" )
 
-        links_results2 = main.Mininet1.compare_links(
+        linksResults2 = main.Mininet1.compareLinks(
             MNTopo,
             json.loads( links2 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=links_results2,
-                                 onpass="ONOS2 Links view is correct",
-                                 onfail="ONOS2 Links view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=linksResults2,
+                                onpass="ONOS2 Links view is correct",
+                                onfail="ONOS2 Links view is incorrect" )
 
-        links_results3 = main.Mininet1.compare_links(
+        linksResults3 = main.Mininet1.compareLinks(
             MNTopo,
             json.loads( links3 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=links_results3,
-                                 onpass="ONOS2 Links view is correct",
-                                 onfail="ONOS2 Links view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=linksResults3,
+                                onpass="ONOS2 Links view is correct",
+                                onfail="ONOS2 Links view is incorrect" )
 
-        #topo_result = switches_results1 and switches_results2 and switches_results3\
-        # and ports_results1 and ports_results2 and ports_results3\
-        # and links_results1 and links_results2 and links_results3
+        #topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+        # and portsResults1 and portsResults2 and portsResults3\
+        # and linksResults1 and linksResults2 and linksResults3
 
-        topo_result = switches_results1 and switches_results2 and switches_results3\
-            and links_results1 and links_results2 and links_results3
+        topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+            and linksResults1 and linksResults2 and linksResults3
 
-        if topo_result == main.TRUE:
+        if topoResult == main.TRUE:
             main.log.report(
                 "Topology Check Test with mininet and ONOS instances successful" )
         else:
             main.log.report(
                 "Topology Check Test with mininet and ONOS instances failed" )
 
-        utilities.assert_equals( expect=main.TRUE, actual=topo_result,
-                                 onpass="Topology Check Test successful",
-                                 onfail="Topology Check Test NOT successful" )
+        utilities.assertEquals( expect=main.TRUE, actual=topoResult,
+                                onpass="Topology Check Test successful",
+                                onfail="Topology Check Test NOT successful" )
 
     def CASE10( self ):
         main.log.report(
@@ -422,11 +422,11 @@
         main.log.report( "__________________________________" )
         main.case( "Uninstalling reactive forwarding app" )
         # Unistall onos-app-fwd app to disable reactive forwarding
-        appUninstall_result1 = main.ONOScli1.feature_uninstall(
+        appUninstallResult1 = main.ONOScli1.featureUninstall(
             "onos-app-fwd" )
-        appUninstall_result2 = main.ONOScli2.feature_uninstall(
+        appUninstallResult2 = main.ONOScli2.featureUninstall(
             "onos-app-fwd" )
-        appUninstall_result3 = main.ONOScli3.feature_uninstall(
+        appUninstallResult3 = main.ONOScli3.featureUninstall(
             "onos-app-fwd" )
         main.log.info( "onos-app-fwd uninstalled" )
 
@@ -437,10 +437,10 @@
         hosts = main.ONOScli1.hosts()
         main.log.info( hosts )
 
-        case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
-        utilities.assert_equals(
+        case10Result = appUninstallResult1 and appUninstallResult2 and appUninstallResult3
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=case10_result,
+            actual=case10Result,
             onpass="Reactive forwarding app uninstallation successful",
             onfail="Reactive forwarding app uninstallation failed" )
 
@@ -454,24 +454,24 @@
         main.log.info( hosts )
 
         main.step( "Get all devices id" )
-        devices_id_list = main.ONOScli1.get_all_devices_id()
-        main.log.info( devices_id_list )
+        devicesIdList = main.ONOScli1.getAllDevicesId()
+        main.log.info( devicesIdList )
 
         # ONOS displays the hosts in hex format unlike mininet which does in decimal format
         # So take care while adding intents
 
         """
         main.step( "Add host intents for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
-        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+        hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
         """
         for i in range( 8, 18 ):
             main.log.info(
@@ -482,9 +482,9 @@
                 str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
             # NOTE: get host can return None
             # TODO: handle this
-            host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
-            host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
-            tmp_result = main.ONOScli1.add_host_intent( host1_id, host2_id )
+            host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
+            host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
+            tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
 
         flowHandle = main.ONOScli1.flows()
         # print "flowHandle = ", flowHandle
@@ -492,7 +492,7 @@
 
         count = 1
         i = 8
-        Ping_Result = main.TRUE
+        PingResult = main.TRUE
         while i < 18:
             main.log.info(
                 "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -501,7 +501,7 @@
             if ping == main.FALSE and count < 5:
                 count += 1
                 #i = 8
-                Ping_Result = main.FALSE
+                PingResult = main.FALSE
                 main.log.report( "Ping between h" +
                                  str( i ) +
                                  " and h" +
@@ -519,7 +519,7 @@
                                       10 ) +
                                  "have failed" )
                 i = 19
-                Ping_Result = main.FALSE
+                PingResult = main.FALSE
             elif ping == main.TRUE:
                 main.log.info( "Ping test between h" +
                                str( i ) +
@@ -528,30 +528,30 @@
                                     10 ) +
                                "passed!" )
                 i += 1
-                Ping_Result = main.TRUE
+                PingResult = main.TRUE
             else:
                 main.log.info( "Unknown error" )
-                Ping_Result = main.ERROR
-        if Ping_Result == main.FALSE:
+                PingResult = main.ERROR
+        if PingResult == main.FALSE:
             main.log.report(
                 "Host intents have not ben installed correctly. Cleaning up" )
             # main.cleanup()
             # main.exit()
-        if Ping_Result == main.TRUE:
+        if PingResult == main.TRUE:
             main.log.report( "Host intents have been installed correctly" )
 
-        case6_result = Ping_Result
-        utilities.assert_equals(
+        case6Result = PingResult
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=case6_result,
+            actual=case6Result,
             onpass="Host intent addition and Pingall Test successful",
             onfail="Host intent addition and Pingall Test NOT successful" )
 
     def CASE7( self, main ):
 
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
 
-        link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+        linkSleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
 
         main.log.report(
             "This testscase is killing a link to ensure that link discovery is consistent" )
@@ -602,10 +602,10 @@
             pingTime=500 )
 
         main.step( "Determine the current number of switches and links" )
-        topology_output = main.ONOScli1.topology()
-        topology_result = main.ONOSbench.get_topology( topology_output )
-        activeSwitches = topology_result[ 'devices' ]
-        links = topology_result[ 'links' ]
+        topologyOutput = main.ONOScli1.topology()
+        topologyResult = main.ONOSbench.getTopology( topologyOutput )
+        activeSwitches = topologyResult[ 'devices' ]
+        links = topologyResult[ 'links' ]
         print "activeSwitches = ", type( activeSwitches )
         print "links = ", type( links )
         main.log.info(
@@ -614,37 +614,37 @@
 
         main.step( "Kill Link between s3 and s28" )
         main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
-        time.sleep( link_sleep )
-        topology_output = main.ONOScli2.topology()
-        Link_Down = main.ONOSbench.check_status(
-            topology_output, activeSwitches, str(
+        time.sleep( linkSleep )
+        topologyOutput = main.ONOScli2.topology()
+        LinkDown = main.ONOSbench.checkStatus(
+            topologyOutput, activeSwitches, str(
                 int( links ) - 2 ) )
-        if Link_Down == main.TRUE:
+        if LinkDown == main.TRUE:
             main.log.report( "Link Down discovered properly" )
-        utilities.assert_equals(
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=Link_Down,
+            actual=LinkDown,
             onpass="Link Down discovered properly",
             onfail="Link down was not discovered in " +
-            str( link_sleep ) +
+            str( linkSleep ) +
             " seconds" )
 
         main.step( "Bring link between s3 and s28 back up" )
-        Link_Up = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
-        time.sleep( link_sleep )
-        topology_output = main.ONOScli2.topology()
-        Link_Up = main.ONOSbench.check_status(
-            topology_output,
+        LinkUp = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+        time.sleep( linkSleep )
+        topologyOutput = main.ONOScli2.topology()
+        LinkUp = main.ONOSbench.checkStatus(
+            topologyOutput,
             activeSwitches,
             str( links ) )
-        if Link_Up == main.TRUE:
+        if LinkUp == main.TRUE:
             main.log.report( "Link up discovered properly" )
-        utilities.assert_equals(
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=Link_Up,
+            actual=LinkUp,
             onpass="Link up discovered properly",
             onfail="Link up was not discovered in " +
-            str( link_sleep ) +
+            str( linkSleep ) +
             " seconds" )
 
         main.step( "Compare ONOS Topology to MN Topology" )
@@ -742,78 +742,78 @@
             ctrls )  # can also add Intent API info for intent operations
         MNTopo = Topo
 
-        Topology_Check = main.TRUE
+        TopologyCheck = main.TRUE
         main.step( "Compare ONOS Topology to MN Topology" )
 
-        switches_results1 = main.Mininet1.compare_switches(
+        switchesResults1 = main.Mininet1.compareSwitches(
             MNTopo,
             json.loads( devices1 ) )
-        print "switches_Result1 = ", switches_results1
-        utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
-                                 onpass="ONOS1 Switches view is correct",
-                                 onfail="ONOS1 Switches view is incorrect" )
+        print "switches_Result1 = ", switchesResults1
+        utilities.assertEquals( expect=main.TRUE, actual=switchesResults1,
+                                onpass="ONOS1 Switches view is correct",
+                                onfail="ONOS1 Switches view is incorrect" )
 
-        switches_results2 = main.Mininet1.compare_switches(
+        switchesResults2 = main.Mininet1.compareSwitches(
             MNTopo,
             json.loads( devices2 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
-                                 onpass="ONOS2 Switches view is correct",
-                                 onfail="ONOS2 Switches view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=switchesResults2,
+                                onpass="ONOS2 Switches view is correct",
+                                onfail="ONOS2 Switches view is incorrect" )
 
-        switches_results3 = main.Mininet1.compare_switches(
+        switchesResults3 = main.Mininet1.compareSwitches(
             MNTopo,
             json.loads( devices3 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
-                                 onpass="ONOS3 Switches view is correct",
-                                 onfail="ONOS3 Switches view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=switchesResults3,
+                                onpass="ONOS3 Switches view is correct",
+                                onfail="ONOS3 Switches view is incorrect" )
 
         """
-        ports_results1 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports1 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+        portsResults1 =  main.Mininet1.comparePorts( MNTopo, json.loads( ports1 ) )
+        utilities.assertEquals( expect=main.TRUE, actual=portsResults1,
                 onpass="ONOS1 Ports view is correct",
                 onfail="ONOS1 Ports view is incorrect" )
 
-        ports_results2 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports2 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+        portsResults2 =  main.Mininet1.comparePorts( MNTopo, json.loads( ports2 ) )
+        utilities.assertEquals( expect=main.TRUE, actual=portsResults2,
                 onpass="ONOS2 Ports view is correct",
                 onfail="ONOS2 Ports view is incorrect" )
 
-        ports_results3 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+        portsResults3 =  main.Mininet1.comparePorts( MNTopo, json.loads( ports3 ) )
+        utilities.assertEquals( expect=main.TRUE, actual=portsResults3,
                 onpass="ONOS3 Ports view is correct",
                 onfail="ONOS3 Ports view is incorrect" )
         """
-        links_results1 = main.Mininet1.compare_links(
+        linksResults1 = main.Mininet1.compareLinks(
             MNTopo,
             json.loads( links1 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=links_results1,
-                                 onpass="ONOS1 Links view is correct",
-                                 onfail="ONOS1 Links view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=linksResults1,
+                                onpass="ONOS1 Links view is correct",
+                                onfail="ONOS1 Links view is incorrect" )
 
-        links_results2 = main.Mininet1.compare_links(
+        linksResults2 = main.Mininet1.compareLinks(
             MNTopo,
             json.loads( links2 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=links_results2,
-                                 onpass="ONOS2 Links view is correct",
-                                 onfail="ONOS2 Links view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=linksResults2,
+                                onpass="ONOS2 Links view is correct",
+                                onfail="ONOS2 Links view is incorrect" )
 
-        links_results3 = main.Mininet1.compare_links(
+        linksResults3 = main.Mininet1.compareLinks(
             MNTopo,
             json.loads( links3 ) )
-        utilities.assert_equals( expect=main.TRUE, actual=links_results3,
-                                 onpass="ONOS2 Links view is correct",
-                                 onfail="ONOS2 Links view is incorrect" )
+        utilities.assertEquals( expect=main.TRUE, actual=linksResults3,
+                                onpass="ONOS2 Links view is correct",
+                                onfail="ONOS2 Links view is incorrect" )
 
-        #topo_result = switches_results1 and switches_results2 and switches_results3\
-        # and ports_results1 and ports_results2 and ports_results3\
-        # and links_results1 and links_results2 and links_results3
+        #topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+        # and portsResults1 and portsResults2 and portsResults3\
+        # and linksResults1 and linksResults2 and linksResults3
 
-        topo_result = switches_results1 and switches_results2 and switches_results3\
-            and links_results1 and links_results2 and links_results3
+        topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+            and linksResults1 and linksResults2 and linksResults3
 
-        utilities.assert_equals(
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=topo_result and Link_Up and Link_Down,
+            actual=topoResult and LinkUp and LinkDown,
             onpass="Topology Check Test successful",
             onfail="Topology Check Test NOT successful" )
 
@@ -827,11 +827,11 @@
         main.log.info( "Removing any previously installed intents" )
         main.case( "Removing intents" )
         main.step( "Obtain the intent id's" )
-        intent_result = main.ONOScli1.intents( json_format=False )
+        intentResult = main.ONOScli1.intents( jsonFormat=False )
 
-        intent_linewise = intent_result.split( "\n" )
+        intentLinewise = intentResult.split( "\n" )
         intentList = []
-        for line in intent_linewise:
+        for line in intentLinewise:
             if line.startswith( "id=" ):
                 intentList.append( line )
 
@@ -844,14 +844,14 @@
         main.step(
             "Iterate through the intentids list and remove each intent" )
         for id in intentids:
-            main.ONOScli1.remove_intent( intent_id=id )
+            main.ONOScli1.removeIntent( intentId=id )
 
-        intent_result = main.ONOScli1.intents( json_format=False )
-        main.log.info( "intent_result = " + intent_result )
-        case8_result = main.TRUE
+        intentResult = main.ONOScli1.intents( jsonFormat=False )
+        main.log.info( "intent_result = " + intentResult )
+        case8Result = main.TRUE
 
         i = 8
-        Ping_Result = main.TRUE
+        PingResult = main.TRUE
         while i < 18:
             main.log.info(
                 "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -859,33 +859,33 @@
                 src="h" + str( i ), target="h" + str( i + 10 ) )
             if ping == main.TRUE:
                 i = 19
-                Ping_Result = main.TRUE
+                PingResult = main.TRUE
             elif ping == main.FALSE:
                 i += 1
-                Ping_Result = main.FALSE
+                PingResult = main.FALSE
             else:
                 main.log.info( "Unknown error" )
-                Ping_Result = main.ERROR
+                PingResult = main.ERROR
 
         # Note: If the ping result failed, that means the intents have been
         # withdrawn correctly.
-        if Ping_Result == main.TRUE:
+        if PingResult == main.TRUE:
             main.log.report( "Host intents have not been withdrawn correctly" )
             # main.cleanup()
             # main.exit()
-        if Ping_Result == main.FALSE:
+        if PingResult == main.FALSE:
             main.log.report( "Host intents have been withdrawn correctly" )
 
-        case8_result = case8_result and Ping_Result
+        case8Result = case8Result and PingResult
 
-        if case8_result == main.FALSE:
+        if case8Result == main.FALSE:
             main.log.report( "Intent removal successful" )
         else:
             main.log.report( "Intent removal failed" )
 
-        utilities.assert_equals( expect=main.FALSE, actual=case8_result,
-                                 onpass="Intent removal test failed",
-                                 onfail="Intent removal test successful" )
+        utilities.assertEquals( expect=main.FALSE, actual=case8Result,
+                                onpass="Intent removal test failed",
+                                onfail="Intent removal test successful" )
 
     def CASE9( self ):
         """
@@ -900,183 +900,183 @@
             "Adding bidirectional point for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
         main.step(
             "Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003008/1",
             "of:0000000000006018/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006018/1",
             "of:0000000000003008/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003009/1",
             "of:0000000000006019/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006019/1",
             "of:0000000000003009/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003010/1",
             "of:0000000000006020/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006020/1",
             "of:0000000000003010/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003011/1",
             "of:0000000000006021/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006021/1",
             "of:0000000000003011/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003012/1",
             "of:0000000000006022/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006022/1",
             "of:0000000000003012/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003013/1",
             "of:0000000000006023/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006023/1",
             "of:0000000000003013/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003014/1",
             "of:0000000000006024/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006024/1",
             "of:0000000000003014/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003015/1",
             "of:0000000000006025/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006025/1",
             "of:0000000000003015/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003016/1",
             "of:0000000000006026/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006026/1",
             "of:0000000000003016/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         main.step(
             "Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B" )
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000003017/1",
             "of:0000000000006027/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
-        ptp_intent_result = main.ONOScli1.add_point_intent(
+        ptpIntentResult = main.ONOScli1.addPointIntent(
             "of:0000000000006027/1",
             "of:0000000000003017/1" )
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli1.intents()
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOScli1.intents()
             main.log.info( "Point to point intent install successful" )
-            # main.log.info( get_intent_result )
+            # main.log.info( getIntentResult )
 
         print(
             "_______________________________________________________________________________________" )
@@ -1087,7 +1087,7 @@
 
         count = 1
         i = 8
-        Ping_Result = main.TRUE
+        PingResult = main.TRUE
         while i < 18:
             main.log.info(
                 "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -1096,7 +1096,7 @@
             if ping == main.FALSE and count < 5:
                 count += 1
                 #i = 8
-                Ping_Result = main.FALSE
+                PingResult = main.FALSE
                 main.log.report( "Ping between h" +
                                  str( i ) +
                                  " and h" +
@@ -1114,7 +1114,7 @@
                                       10 ) +
                                  "have failed" )
                 i = 19
-                Ping_Result = main.FALSE
+                PingResult = main.FALSE
             elif ping == main.TRUE:
                 main.log.info( "Ping test between h" +
                                str( i ) +
@@ -1123,23 +1123,23 @@
                                     10 ) +
                                "passed!" )
                 i += 1
-                Ping_Result = main.TRUE
+                PingResult = main.TRUE
             else:
                 main.log.info( "Unknown error" )
-                Ping_Result = main.ERROR
-        if Ping_Result == main.FALSE:
+                PingResult = main.ERROR
+        if PingResult == main.FALSE:
             main.log.report(
                 "Ping all test after Point intents addition failed. Cleaning up" )
             # main.cleanup()
             # main.exit()
-        if Ping_Result == main.TRUE:
+        if PingResult == main.TRUE:
             main.log.report(
                 "Ping all test after Point intents addition successful" )
 
-        case8_result = Ping_Result
-        utilities.assert_equals(
+        case8Result = PingResult
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=case8_result,
+            actual=case8Result,
             onpass="Ping all test after Point intents addition successful",
             onfail="Ping all test after Point intents addition failed" )
 
@@ -1158,7 +1158,7 @@
         # --ethType=IPV4 --ipProto=1  of:0000000000003008/1
         # of:0000000000006018/1
 
-        hosts_json = json.loads( main.ONOScli1.hosts() )
+        hostsJson = json.loads( main.ONOScli1.hosts() )
         for i in range( 8, 11 ):
             main.log.info(
                 "Adding point intent between h" + str( i ) + " and h" + str( i + 10 ) )
@@ -1166,55 +1166,55 @@
                 str( hex( i )[ 2: ] ).zfill( 2 ).upper()
             host2 = "00:00:00:00:00:" + \
                 str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
-            host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
-            host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
-            for host in hosts_json:
-                if host[ 'id' ] == host1_id:
+            host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
+            host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
+            for host in hostsJson:
+                if host[ 'id' ] == host1Id:
                     ip1 = host[ 'ips' ][ 0 ]
                     ip1 = str( ip1 + "/32" )
                     device1 = host[ 'location' ][ 'device' ]
                     device1 = str( device1 + "/1" )
-                elif host[ 'id' ] == host2_id:
+                elif host[ 'id' ] == host2Id:
                     ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
                     device2 = host[ 'location' ][ "device" ]
                     device2 = str( device2 + "/1" )
 
-            p_intent_result1 = main.ONOScli1.add_point_intent(
-                ingress_device=device1,
-                egress_device=device2,
+            pIntentResult1 = main.ONOScli1.addPointIntent(
+                ingressDevice=device1,
+                egressDevice=device2,
                 ipSrc=ip1,
                 ipDst=ip2,
                 ethType=main.params[ 'SDNIP' ][ 'ethType' ],
                 ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
 
-            get_intent_result = main.ONOScli1.intents( json_format=False )
-            main.log.info( get_intent_result )
+            getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+            main.log.info( getIntentResult )
 
-            p_intent_result2 = main.ONOScli1.add_point_intent(
-                ingress_device=device2,
-                egress_device=device1,
+            pIntentResult2 = main.ONOScli1.addPointIntent(
+                ingressDevice=device2,
+                egressDevice=device1,
                 ipSrc=ip2,
                 ipDst=ip1,
                 ethType=main.params[ 'SDNIP' ][ 'ethType' ],
                 ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
 
-            get_intent_result = main.ONOScli1.intents( json_format=False )
-            main.log.info( get_intent_result )
-            if ( p_intent_result1 and p_intent_result2 ) == main.TRUE:
-                #get_intent_result = main.ONOScli1.intents()
-                # main.log.info( get_intent_result )
+            getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+            main.log.info( getIntentResult )
+            if ( pIntentResult1 and pIntentResult2 ) == main.TRUE:
+                #getIntentResult = main.ONOScli1.intents()
+                # main.log.info( getIntentResult )
                 main.log.info(
                     "Point intent related to SDN-IP matching on ICMP install successful" )
 
         time.sleep( 15 )
-        get_intent_result = main.ONOScli1.intents( json_format=False )
-        main.log.info( "intents = " + get_intent_result )
-        get_flows_result = main.ONOScli1.flows()
-        main.log.info( "flows = " + get_flows_result )
+        getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+        main.log.info( "intents = " + getIntentResult )
+        getFlowsResult = main.ONOScli1.flows()
+        main.log.info( "flows = " + getFlowsResult )
 
         count = 1
         i = 8
-        Ping_Result = main.TRUE
+        PingResult = main.TRUE
         while i < 11:
             main.log.info(
                 "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -1223,7 +1223,7 @@
             if ping == main.FALSE and count < 3:
                 count += 1
                 #i = 8
-                Ping_Result = main.FALSE
+                PingResult = main.FALSE
                 main.log.report( "Ping between h" +
                                  str( i ) +
                                  " and h" +
@@ -1241,7 +1241,7 @@
                                       10 ) +
                                  "have failed" )
                 i = 19
-                Ping_Result = main.FALSE
+                PingResult = main.FALSE
             elif ping == main.TRUE:
                 main.log.info( "Ping test between h" +
                                str( i ) +
@@ -1250,23 +1250,23 @@
                                     10 ) +
                                "passed!" )
                 i += 1
-                Ping_Result = main.TRUE
+                PingResult = main.TRUE
             else:
                 main.log.info( "Unknown error" )
-                Ping_Result = main.ERROR
-        if Ping_Result == main.FALSE:
+                PingResult = main.ERROR
+        if PingResult == main.FALSE:
             main.log.report(
                 "Ping test after Point intents related to SDN-IP matching on ICMP failed." )
             # main.cleanup()
             # main.exit()
-        if Ping_Result == main.TRUE:
+        if PingResult == main.TRUE:
             main.log.report(
                 "Ping all test after Point intents related to SDN-IP matching on ICMP successful" )
 
-        case31_result = Ping_Result and p_intent_result1 and p_intent_result2
-        utilities.assert_equals(
+        case31Result = PingResult and pIntentResult1 and pIntentResult2
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=case31_result,
+            actual=case31Result,
             onpass="Point intent related to SDN-IP matching on ICMP and ping test successful",
             onfail="Point intent related to SDN-IP matching on ICMP and ping test failed" )
 
@@ -1292,7 +1292,7 @@
         add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001  of:0000000000006018/1 of:0000000000003008/1
 
         """
-        hosts_json = json.loads( main.ONOScli1.hosts() )
+        hostsJson = json.loads( main.ONOScli1.hosts() )
         for i in range( 8, 9 ):
             main.log.info(
                 "Adding point intent between h" + str( i ) + " and h" + str( i + 10 ) )
@@ -1300,70 +1300,70 @@
                 str( hex( i )[ 2: ] ).zfill( 2 ).upper()
             host2 = "00:00:00:00:00:" + \
                 str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
-            host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
-            host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
-            for host in hosts_json:
-                if host[ 'id' ] == host1_id:
+            host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
+            host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
+            for host in hostsJson:
+                if host[ 'id' ] == host1Id:
                     ip1 = host[ 'ips' ][ 0 ]
                     ip1 = str( ip1 + "/32" )
                     device1 = host[ 'location' ][ 'device' ]
                     device1 = str( device1 + "/1" )
-                elif host[ 'id' ] == host2_id:
+                elif host[ 'id' ] == host2Id:
                     ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
                     device2 = host[ 'location' ][ "device" ]
                     device2 = str( device2 + "/1" )
 
-            p_intent_result1 = main.ONOScli1.add_point_intent(
-                ingress_device=device1,
-                egress_device=device2,
+            pIntentResult1 = main.ONOScli1.addPointIntent(
+                ingressDevice=device1,
+                egressDevice=device2,
                 ipSrc=ip1,
                 ipDst=ip2,
                 ethType=main.params[ 'SDNIP' ][ 'ethType' ],
                 ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
                 tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
-            p_intent_result2 = main.ONOScli1.add_point_intent(
-                ingress_device=device2,
-                egress_device=device1,
+            pIntentResult2 = main.ONOScli1.addPointIntent(
+                ingressDevice=device2,
+                egressDevice=device1,
                 ipSrc=ip2,
                 ipDst=ip1,
                 ethType=main.params[ 'SDNIP' ][ 'ethType' ],
                 ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
                 tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
 
-            p_intent_result3 = main.ONOScli1.add_point_intent(
-                ingress_device=device1,
-                egress_device=device2,
+            pIntentResult3 = main.ONOScli1.addPointIntent(
+                ingressDevice=device1,
+                egressDevice=device2,
                 ipSrc=ip1,
                 ipDst=ip2,
                 ethType=main.params[ 'SDNIP' ][ 'ethType' ],
                 ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
                 tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
-            p_intent_result4 = main.ONOScli1.add_point_intent(
-                ingress_device=device2,
-                egress_device=device1,
+            pIntentResult4 = main.ONOScli1.addPointIntent(
+                ingressDevice=device2,
+                egressDevice=device1,
                 ipSrc=ip2,
                 ipDst=ip1,
                 ethType=main.params[ 'SDNIP' ][ 'ethType' ],
                 ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
                 tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
 
-            p_intent_result = p_intent_result1 and p_intent_result2 and p_intent_result3 and p_intent_result4
-            if p_intent_result == main.TRUE:
-                get_intent_result = main.ONOScli1.intents( json_format=False )
-                main.log.info( get_intent_result )
+            pIntentResult = pIntentResult1 and pIntentResult2 and pIntentResult3 and pIntentResult4
+            if pIntentResult == main.TRUE:
+                getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+                main.log.info( getIntentResult )
                 main.log.info(
                     "Point intent related to SDN-IP matching on TCP install successful" )
 
-        iperf_result = main.Mininet1.iperf( 'h8', 'h18' )
-        if iperf_result == main.TRUE:
+        iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
+        if iperfResult == main.TRUE:
             main.log.report( "iperf test successful" )
         else:
             main.log.report( "iperf test failed" )
 
-        case32_result = p_intent_result and iperf_result
-        utilities.assert_equals(
+        case32Result = pIntentResult and iperfResult
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=case32_result,
+            actual=case32Result,
             onpass="Ping all test after Point intents addition related to SDN-IP on TCP match successful",
             onfail="Ping all test after Point intents addition related to SDN-IP on TCP match failed" )
 
@@ -1389,11 +1389,11 @@
             "Installing multipoint to single point intent with rewrite mac address" )
         main.step( "Uninstalling proxy arp app" )
         # Unistall onos-app-proxyarp app to disable reactive forwarding
-        appUninstall_result1 = main.ONOScli1.feature_uninstall(
+        appUninstallResult1 = main.ONOScli1.featureUninstall(
             "onos-app-proxyarp" )
-        appUninstall_result2 = main.ONOScli2.feature_uninstall(
+        appUninstallResult2 = main.ONOScli2.featureUninstall(
             "onos-app-proxyarp" )
-        appUninstall_result3 = main.ONOScli3.feature_uninstall(
+        appUninstallResult3 = main.ONOScli3.featureUninstall(
             "onos-app-proxyarp" )
         main.log.info( "onos-app-proxyarp uninstalled" )
 
@@ -1440,37 +1440,37 @@
         main.Mininet1.verifyStaticGWandMAC( host='h10' )
 
         main.step( "Adding multipoint to singlepoint intent" )
-        p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
-            ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
-            ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
-            egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+        pIntentResult1 = main.ONOScli1.addMultipointToSinglepointIntent(
+            ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+            ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+            egressDevice=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
             ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
             setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
 
-        p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
-            ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
-            ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
-            egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+        pIntentResult2 = main.ONOScli1.addMultipointToSinglepointIntent(
+            ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+            ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+            egressDevice=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
             ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
             setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
 
-        get_intent_result = main.ONOScli1.intents( json_format=False )
-        main.log.info( "intents = " + get_intent_result )
+        getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+        main.log.info( "intents = " + getIntentResult )
 
         time.sleep( 10 )
-        get_flows_result = main.ONOScli1.flows( json_format=False )
-        main.log.info( "flows = " + get_flows_result )
+        getFlowsResult = main.ONOScli1.flows( jsonFormat=False )
+        main.log.info( "flows = " + getFlowsResult )
 
         count = 1
         i = 8
-        Ping_Result = main.TRUE
+        PingResult = main.TRUE
 
         main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
         ping = main.Mininet1.pingHost(
             src="h" + str( i ), target="h" + str( i + 2 ) )
         if ping == main.FALSE and count < 3:
             count += 1
-            Ping_Result = main.FALSE
+            PingResult = main.FALSE
             main.log.report( "Ping between h" +
                              str( i ) +
                              " and h" +
@@ -1487,7 +1487,7 @@
                              str( i +
                                   10 ) +
                              "have failed" )
-            Ping_Result = main.FALSE
+            PingResult = main.FALSE
         elif ping == main.TRUE:
             main.log.info( "Ping test between h" +
                            str( i ) +
@@ -1495,29 +1495,29 @@
                            str( i +
                                 2 ) +
                            "passed!" )
-            Ping_Result = main.TRUE
+            PingResult = main.TRUE
         else:
             main.log.info( "Unknown error" )
-            Ping_Result = main.ERROR
+            PingResult = main.ERROR
 
-        if Ping_Result == main.FALSE:
+        if PingResult == main.FALSE:
             main.log.report( "Ping test failed." )
             # main.cleanup()
             # main.exit()
-        if Ping_Result == main.TRUE:
+        if PingResult == main.TRUE:
             main.log.report( "Ping all successful" )
 
-        p_intent_result = p_intent_result1 and p_intent_result2
-        if p_intent_result == main.TRUE:
+        pIntentResult = pIntentResult1 and pIntentResult2
+        if pIntentResult == main.TRUE:
             main.log.info(
                 "Multi point intent with rewrite mac address installation successful" )
         else:
             main.log.info(
                 "Multi point intent with rewrite mac address installation failed" )
 
-        case33_result = p_intent_result and Ping_Result
-        utilities.assert_equals(
+        case33Result = pIntentResult and PingResult
+        utilities.assertEquals(
             expect=main.TRUE,
-            actual=case33_result,
+            actual=case33Result,
             onpass="Ping all test after multipoint to single point intent addition with rewrite mac address successful",
             onfail="Ping all test after multipoint to single point intent addition with rewrite mac address failed" )