replacing assertEquals into assertEqual

diff --git a/test/execution/ec.py b/test/execution/ec.py
index 1bf20b1..ff7a8fa 100755 (executable)
--- a/test/execution/ec.py
+++ b/test/execution/ec.py
@@ -41,7 +41,7 @@ class ExecuteControllersTestCase(unittest.TestCase):
 
             time.sleep(1)
 
-        self.assertEquals('hola!', task.result)
+        self.assertEqual('hola!', task.result)
 
         ec.shutdown()
 
@@ -87,7 +87,7 @@ class ExecuteControllersTestCase(unittest.TestCase):
 
             time.sleep(1)
 
-        self.assertEquals(task.status, TaskStatus.ERROR)
+        self.assertEqual(task.status, TaskStatus.ERROR)
 
 if __name__ == '__main__':
     unittest.main()

diff --git a/test/execution/resource.py b/test/execution/resource.py
index 5644938..6a4fd8c 100755 (executable)
--- a/test/execution/resource.py
+++ b/test/execution/resource.py
@@ -141,16 +141,16 @@ class ResourceFactoryTestCase(unittest.TestCase):
         ResourceFactory.register_type(AnotherResource)
 
         # Take into account default 'Critical' attribute
-        self.assertEquals(MyResource.get_rtype(), "MyResource")
-        self.assertEquals(len(MyResource._attributes), 3)
+        self.assertEqual(MyResource.get_rtype(), "MyResource")
+        self.assertEqual(len(MyResource._attributes), 3)
 
-        self.assertEquals(ResourceManager.get_rtype(), "Resource")
-        self.assertEquals(len(ResourceManager._attributes), 2)
+        self.assertEqual(ResourceManager.get_rtype(), "Resource")
+        self.assertEqual(len(ResourceManager._attributes), 2)
 
-        self.assertEquals(AnotherResource.get_rtype(), "AnotherResource")
-        self.assertEquals(len(AnotherResource._attributes), 2)
+        self.assertEqual(AnotherResource.get_rtype(), "AnotherResource")
+        self.assertEqual(len(AnotherResource._attributes), 2)
 
-        self.assertEquals(len(ResourceFactory.resource_types()), 2)
+        self.assertEqual(len(ResourceFactory.resource_types()), 2)
         
         # restore factory state for other tests
         from nepi.execution.resource import populate_factory
@@ -175,7 +175,7 @@ class ResourceManagerTestCase(unittest.TestCase):
         for (group, state, time) in conditions:
             waiting_for.extend(group)
 
-        self.assertEquals(waiting_for, [1, 3, 5, 7, 10, 8])
+        self.assertEqual(waiting_for, [1, 3, 5, 7, 10, 8])
 
         group = [1, 2, 3, 4, 6]
         rm.unregister_condition(group)
@@ -185,7 +185,7 @@ class ResourceManagerTestCase(unittest.TestCase):
         for (group, state, time) in conditions:
             waiting_for.extend(group)
 
-        self.assertEquals(waiting_for, [5, 7, 10, 8])
+        self.assertEqual(waiting_for, [5, 7, 10, 8])
 
     def test_deploy_in_order(self):
         """
@@ -306,7 +306,7 @@ class ResourceManagerTestCase(unittest.TestCase):
 
         ec.shutdown()
 
-        self.assertEquals(ec._fm._failure_level, FailureLevel.RM_FAILURE)
+        self.assertEqual(ec._fm._failure_level, FailureLevel.RM_FAILURE)
 
     def test_critical(self):
         from nepi.execution.resource import ResourceFactory
@@ -337,17 +337,17 @@ class ResourceManagerTestCase(unittest.TestCase):
         ec.wait_finished(apps)
         
         state = ec.state(eapp)
-        self.assertEquals(state, ResourceState.FAILED)
+        self.assertEqual(state, ResourceState.FAILED)
       
         apps.remove(eapp)
 
         for app in apps:
             state = ec.state(app)
-            self.assertEquals(state, ResourceState.STOPPED)
+            self.assertEqual(state, ResourceState.STOPPED)
         
         ec.shutdown()
 
-        self.assertEquals(ec._fm._failure_level, FailureLevel.OK)
+        self.assertEqual(ec._fm._failure_level, FailureLevel.OK)
 
     def test_start_with_condition(self):
         from nepi.execution.resource import ResourceFactory

diff --git a/test/execution/runner.py b/test/execution/runner.py
index 1b2163b..e6f43be 100755 (executable)
--- a/test/execution/runner.py
+++ b/test/execution/runner.py
@@ -123,7 +123,7 @@ class RunnerTestCase(unittest.TestCase):
         runs = rnr.run(ec, min_runs = 5, max_runs = 10, wait_guids = apps, 
                 wait_time = 0)
 
-        self.assertEquals(runs, 10)
+        self.assertEqual(runs, 10)
 
     def test_runner_convergence(self):
         node_count = 4
@@ -167,7 +167,7 @@ class RunnerTestCase(unittest.TestCase):
                 wait_guids = apps, 
                 wait_time = 0)
 
-        self.assertEquals(runs, 10)
+        self.assertEqual(runs, 10)
                        
 if __name__ == '__main__':
     unittest.main()

diff --git a/test/execution/scheduler.py b/test/execution/scheduler.py
index 033a750..b36a86b 100755 (executable)
--- a/test/execution/scheduler.py
+++ b/test/execution/scheduler.py
@@ -50,13 +50,13 @@ class SchedulerTestCase(unittest.TestCase):
 
         # Make sure tasks are retrieved in teh correct order
         tsk = scheduler.next()
-        self.assertEquals(tsk.callback(), 1)
+        self.assertEqual(tsk.callback(), 1)
         
         tsk = scheduler.next()
-        self.assertEquals(tsk.callback(), 2)
+        self.assertEqual(tsk.callback(), 2)
         
         tsk = scheduler.next()
-        self.assertEquals(tsk.callback(), 3)
+        self.assertEqual(tsk.callback(), 3)
 
 
 if __name__ == '__main__':

diff --git a/test/resources/linux/application.py b/test/resources/linux/application.py
index bd6b0fe..cdd6fe7 100755 (executable)
--- a/test/resources/linux/application.py
+++ b/test/resources/linux/application.py
@@ -93,15 +93,15 @@ class LinuxApplicationTestCase(unittest.TestCase):
 
         stdout = ec.trace(app, "stdout")
         size = ec.trace(app, "stdout", attr = TraceAttr.SIZE)
-        self.assertEquals(len(stdout), size)
+        self.assertEqual(len(stdout), size)
         
         block = ec.trace(app, "stdout", attr = TraceAttr.STREAM, block = 5, offset = 1)
-        self.assertEquals(block, stdout[5:10])
+        self.assertEqual(block, stdout[5:10])
 
         path = ec.trace(app, "stdout", attr = TraceAttr.PATH)
         rm = ec.get_resource(app)
         p = os.path.join(rm.run_home, "stdout")
-        self.assertEquals(path, p)
+        self.assertEqual(path, p)
 
         ec.shutdown()
 
@@ -140,7 +140,7 @@ main (void)
         ec.wait_finished(app)
 
         out = ec.trace(app, 'stdout')
-        self.assertEquals(out, "Hello, world!\n")
+        self.assertEqual(out, "Hello, world!\n")
 
         ec.shutdown()
 
@@ -176,15 +176,15 @@ main (void)
         for app in apps:
             stdout = ec.trace(app, 'stdout')
             size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
-            self.assertEquals(len(stdout), size)
+            self.assertEqual(len(stdout), size)
             
             block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
-            self.assertEquals(block, stdout[5:10])
+            self.assertEqual(block, stdout[5:10])
 
             path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
             rm = ec.get_resource(app)
             p = os.path.join(rm.run_home, 'stdout')
-            self.assertEquals(path, p)
+            self.assertEqual(path, p)
 
         ec.shutdown()
 

diff --git a/test/resources/linux/multirun.py b/test/resources/linux/multirun.py
index bb82107..2d4568a 100755 (executable)
--- a/test/resources/linux/multirun.py
+++ b/test/resources/linux/multirun.py
@@ -91,9 +91,9 @@ class LinuxMultiRunTestCase(unittest.TestCase):
             if os.path.isdir(path):
                 dircount += 1
                 logs = glob.glob(os.path.join(path, "*.stdout"))
-                self.assertEquals(len(logs), 1)
+                self.assertEqual(len(logs), 1)
         
-        self.assertEquals(runs, dircount)
+        self.assertEqual(runs, dircount)
 
         shutil.rmtree(dirpath)
 

diff --git a/test/resources/linux/node.py b/test/resources/linux/node.py
index 10f306a..c9fb8ae 100755 (executable)
--- a/test/resources/linux/node.py
+++ b/test/resources/linux/node.py
@@ -98,7 +98,7 @@ class LinuxNodeTestCase(unittest.TestCase):
  
         # get the pid of the process
         ecode = node.exitcode(app_home)
-        self.assertEquals(ecode, ExitCode.OK)
+        self.assertEqual(ecode, ExitCode.OK)
 
     @skipIfNotAlive
     def t_exitcode_kill(self, host, user):
@@ -125,17 +125,17 @@ class LinuxNodeTestCase(unittest.TestCase):
 
         # The process is still running, so no retfile has been created yet
         ecode = node.exitcode(app_home)
-        self.assertEquals(ecode, ExitCode.FILENOTFOUND)
+        self.assertEqual(ecode, ExitCode.FILENOTFOUND)
         
         (out, err), proc = node.check_errors(app_home)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
         
         # Now kill the app
         pid, ppid = node.getpid(app_home)
         node.kill(pid, ppid)
          
         (out, err), proc = node.check_errors(app_home)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
     @skipIfNotAlive
     def t_exitcode_error(self, host, user):
@@ -160,7 +160,7 @@ class LinuxNodeTestCase(unittest.TestCase):
         ecode = node.exitcode(app_home)
 
         # bash erro 127 - command not found
-        self.assertEquals(ecode, 127)
+        self.assertEqual(ecode, 127)
  
         (out, err), proc = node.check_errors(app_home)
 
@@ -172,16 +172,16 @@ class LinuxNodeTestCase(unittest.TestCase):
 
         node.find_home()
         (out, err), proc = node.mkdir(node.node_home, clean = True)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
         (out, err), proc = node.install_packages("gcc", node.node_home)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
         (out, err), proc = node.remove_packages("gcc", node.node_home)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
         (out, err), proc = node.rmdir(node.exp_home)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
     @skipIfNotAlive
     def t_clean(self, host, user):
@@ -194,24 +194,24 @@ class LinuxNodeTestCase(unittest.TestCase):
         command1 = " [ -d %s ] && echo 'Found'" % node.lib_dir
         (out, err), proc = node.execute(command1)
     
-        self.assertEquals(out.strip(), "Found")
+        self.assertEqual(out.strip(), "Found")
 
         command2 = " [ -d %s ] && echo 'Found'" % node.node_home
         (out, err), proc = node.execute(command2)
     
-        self.assertEquals(out.strip(), "Found")
+        self.assertEqual(out.strip(), "Found")
 
         node.clean_experiment()
         
         (out, err), proc = node.execute(command2)
 
-        self.assertEquals(out.strip(), "")
+        self.assertEqual(out.strip(), "")
 
         node.clean_home()
         
         (out, err), proc = node.execute(command1)
 
-        self.assertEquals(out.strip(), "")
+        self.assertEqual(out.strip(), "")
 
     @skipIfNotAlive
     def t_xterm(self, host, user):
@@ -219,16 +219,16 @@ class LinuxNodeTestCase(unittest.TestCase):
 
         node.find_home()
         (out, err), proc = node.mkdir(node.node_home, clean = True)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
         
         node.install_packages("xterm", node.node_home)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
         (out, err), proc = node.execute("xterm", forward_x11 = True)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
         (out, err), proc = node.remove_packages("xterm", node.node_home)
-        self.assertEquals(err, "")
+        self.assertEqual(err, "")
 
     @skipIfNotAlive
     def t_compile(self, host, user):
@@ -262,7 +262,7 @@ main (void)
         command = "%s/hello" % app_home 
         (out, err), proc = node.execute(command)
 
-        self.assertEquals(out, "Hello, world!\n")
+        self.assertEqual(out, "Hello, world!\n")
 
         # execute the program and get the output from a file
         command = "%(home)s/hello > %(home)s/hello.out" % {
@@ -282,7 +282,7 @@ main (void)
         with open(dst, "r") as f:
             out = f.read()
         
-        self.assertEquals(out, "Hello, world!\n")
+        self.assertEqual(out, "Hello, world!\n")
 
     @skipIfNotAlive
     def t_copy_files(self, host, user):

diff --git a/test/resources/linux/ns3/ns3simulation.py b/test/resources/linux/ns3/ns3simulation.py
index 5f7ce29..f00dcad 100755 (executable)
--- a/test/resources/linux/ns3/ns3simulation.py
+++ b/test/resources/linux/ns3/ns3simulation.py
@@ -474,16 +474,16 @@ class LinuxNS3SimulationTest(unittest.TestCase):
                 output = ec.trace(guid, trace)
 
                 size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
-                self.assertEquals(size, len(output))
+                self.assertEqual(size, len(output))
                 self.assertTrue(size > 100)
                 
                 block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
-                self.assertEquals(block, output[5:10])
+                self.assertEqual(block, output[5:10])
 
                 trace_path = ec.trace(guid, trace, attr = TraceAttr.PATH)
                 rm = ec.get_resource(guid)
                 path = os.path.join(rm_simu.run_home, rm._trace_filename.get(trace))
-                self.assertEquals(trace_path, path)
+                self.assertEqual(trace_path, path)
 
         ec.shutdown()
 

diff --git a/test/resources/linux/ns3/serialization.py b/test/resources/linux/ns3/serialization.py
index 2eea5b6..2685bb8 100755 (executable)
--- a/test/resources/linux/ns3/serialization.py
+++ b/test/resources/linux/ns3/serialization.py
@@ -205,7 +205,7 @@ class LinuxNS3SimulationSerializationTest(unittest.TestCase):
 
         ec2.wait_finished([ping])
         
-        self.assertEquals(len(ec.resources), len(ec2.resources))
+        self.assertEqual(len(ec.resources), len(ec2.resources))
         
         stdout = ec2.trace(simu, "stdout")
  
@@ -345,7 +345,7 @@ class LinuxNS3SimulationSerializationTest(unittest.TestCase):
 
         ec2.wait_finished([ping])
         
-        self.assertEquals(len(ec.resources), len(ec2.resources))
+        self.assertEqual(len(ec.resources), len(ec2.resources))
         
         stdout = ec2.trace(simu, "stdout")
  
@@ -442,7 +442,7 @@ class LinuxNS3SimulationSerializationTest(unittest.TestCase):
         # Give time to flush the streams
         time.sleep(5) 
        
-        self.assertEquals(len(ec.resources), len(ec2.resources))
+        self.assertEqual(len(ec.resources), len(ec2.resources))
  
         expected = "udp-perf --duration=10 --nodes=2"
         cmdline = ec2.trace(udp_perf, "cmdline")

diff --git a/test/resources/linux/serialization.py b/test/resources/linux/serialization.py
index adadf14..71651a3 100755 (executable)
--- a/test/resources/linux/serialization.py
+++ b/test/resources/linux/serialization.py
@@ -88,7 +88,7 @@ class LinuxSerializationTestCase(unittest.TestCase):
         ec2.deploy()
         ec2.wait_finished(apps)
         
-        self.assertEquals(len(ec.resources), len(ec2.resources))
+        self.assertEqual(len(ec.resources), len(ec2.resources))
         
         self.assertTrue(ec2.state(node) == ResourceState.STARTED)
         self.assertTrue(ec2.state(server) == ResourceState.STOPPED)

diff --git a/test/resources/ns3/ns3wrapper.py b/test/resources/ns3/ns3wrapper.py
index b9998cf..2051fdd 100755 (executable)
--- a/test/resources/ns3/ns3wrapper.py
+++ b/test/resources/ns3/ns3wrapper.py
@@ -214,7 +214,7 @@ class NS3WrapperTest(unittest.TestCase):
                 stderr = subprocess.PIPE, shell = True)
         (out, err) = p.communicate()
 
-        self.assertEquals(int(out), 8)
+        self.assertEqual(int(out), 8)
 
         p = subprocess.Popen("rm /tmp/csma-ping-*",  shell = True)
         p.communicate()

diff --git a/test/resources/omf/omf5_vlc_normal_case.py b/test/resources/omf/omf5_vlc_normal_case.py
index 763b026..4a45716 100755 (executable)
--- a/test/resources/omf/omf5_vlc_normal_case.py
+++ b/test/resources/omf/omf5_vlc_normal_case.py
@@ -35,17 +35,17 @@ import unittest
 class OMFResourceFactoryTestCase(unittest.TestCase):
     def test_creation_phase(self):
 
-        self.assertEquals(OMFNode.get_rtype(), "omf::Node")
-        self.assertEquals(len(OMFNode._attributes), 8)
+        self.assertEqual(OMFNode.get_rtype(), "omf::Node")
+        self.assertEqual(len(OMFNode._attributes), 8)
 
-        self.assertEquals(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
-        self.assertEquals(len(OMFWifiInterface._attributes), 12)
+        self.assertEqual(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
+        self.assertEqual(len(OMFWifiInterface._attributes), 12)
 
-        self.assertEquals(OMFChannel.get_rtype(), "omf::Channel")
-        self.assertEquals(len(OMFChannel._attributes), 8)
+        self.assertEqual(OMFChannel.get_rtype(), "omf::Channel")
+        self.assertEqual(len(OMFChannel._attributes), 8)
 
-        self.assertEquals(OMFApplication.get_rtype(), "omf::Application")
-        self.assertEquals(len(OMFApplication._attributes), 14)
+        self.assertEqual(OMFApplication.get_rtype(), "omf::Application")
+        self.assertEqual(len(OMFApplication._attributes), 14)
 
 class OMFEachTestCase(unittest.TestCase):
     def setUp(self):
@@ -113,50 +113,50 @@ class OMFEachTestCase(unittest.TestCase):
         self.ec.shutdown()
 
     def test_creation_and_configuration_node(self):
-        self.assertEquals(self.ec.get(self.node1, 'hostname'), 'omf.plexus.wlab17')
-        self.assertEquals(self.ec.get(self.node1, 'xmppUser'), 'nepi')
-        self.assertEquals(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
-        self.assertEquals(self.ec.get(self.node1, 'xmppPort'), '5222')
-        self.assertEquals(self.ec.get(self.node1, 'xmppPassword'), '1234')
-        self.assertEquals(self.ec.get(self.node1, 'version'), '5')
+        self.assertEqual(self.ec.get(self.node1, 'hostname'), 'omf.plexus.wlab17')
+        self.assertEqual(self.ec.get(self.node1, 'xmppUser'), 'nepi')
+        self.assertEqual(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+        self.assertEqual(self.ec.get(self.node1, 'xmppPort'), '5222')
+        self.assertEqual(self.ec.get(self.node1, 'xmppPassword'), '1234')
+        self.assertEqual(self.ec.get(self.node1, 'version'), '5')
 
 
     def test_creation_and_configuration_interface(self):
-        self.assertEquals(self.ec.get(self.iface1, 'name'), 'wlan0')
-        self.assertEquals(self.ec.get(self.iface1, 'mode'), 'adhoc')
-        self.assertEquals(self.ec.get(self.iface1, 'hw_mode'), 'g')
-        self.assertEquals(self.ec.get(self.iface1, 'essid'), 'vlcexp')
-        self.assertEquals(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
-        self.assertEquals(self.ec.get(self.iface1, 'version'), '5')
+        self.assertEqual(self.ec.get(self.iface1, 'name'), 'wlan0')
+        self.assertEqual(self.ec.get(self.iface1, 'mode'), 'adhoc')
+        self.assertEqual(self.ec.get(self.iface1, 'hw_mode'), 'g')
+        self.assertEqual(self.ec.get(self.iface1, 'essid'), 'vlcexp')
+        self.assertEqual(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
+        self.assertEqual(self.ec.get(self.iface1, 'version'), '5')
 
     def test_creation_and_configuration_channel(self):
-        self.assertEquals(self.ec.get(self.channel, 'channel'), '6')
-        self.assertEquals(self.ec.get(self.channel, 'xmppUser'), 'nepi')
-        self.assertEquals(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
-        self.assertEquals(self.ec.get(self.channel, 'xmppPort'), '5222')
-        self.assertEquals(self.ec.get(self.channel, 'xmppPassword'), '1234')
-        self.assertEquals(self.ec.get(self.channel, 'version'), '5')
+        self.assertEqual(self.ec.get(self.channel, 'channel'), '6')
+        self.assertEqual(self.ec.get(self.channel, 'xmppUser'), 'nepi')
+        self.assertEqual(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+        self.assertEqual(self.ec.get(self.channel, 'xmppPort'), '5222')
+        self.assertEqual(self.ec.get(self.channel, 'xmppPassword'), '1234')
+        self.assertEqual(self.ec.get(self.channel, 'version'), '5')
 
 
     def test_creation_and_configuration_application(self):
-        self.assertEquals(self.ec.get(self.app1, 'appid'), 'Vlc#1')
-        self.assertEquals(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
-        self.assertEquals(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
-        self.assertEquals(self.ec.get(self.app1, 'version'), '5')
+        self.assertEqual(self.ec.get(self.app1, 'appid'), 'Vlc#1')
+        self.assertEqual(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
+        self.assertEqual(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
+        self.assertEqual(self.ec.get(self.app1, 'version'), '5')
 
     def test_connection(self):
-        self.assertEquals(len(self.ec.get_resource(self.node1).connections), 6)
-        self.assertEquals(len(self.ec.get_resource(self.iface1).connections), 2)
-        self.assertEquals(len(self.ec.get_resource(self.channel).connections), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app1).connections), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app2).connections), 1)
+        self.assertEqual(len(self.ec.get_resource(self.node1).connections), 6)
+        self.assertEqual(len(self.ec.get_resource(self.iface1).connections), 2)
+        self.assertEqual(len(self.ec.get_resource(self.channel).connections), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app1).connections), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app2).connections), 1)
 
     def test_condition(self):
-        self.assertEquals(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
+        self.assertEqual(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
 
 class OMFVLCNormalCase(unittest.TestCase):
     def test_deploy(self):
@@ -236,31 +236,31 @@ class OMFVLCNormalCase(unittest.TestCase):
 
         ec.wait_finished([self.app1, self.app2, self.app3,self.app4, self.app5])
 
-        self.assertEquals(round(tdiffsec(ec.get_resource(self.app2).start_time, ec.get_resource(self.app1).start_time),0), 3.0)
-        self.assertEquals(round(tdiffsec(ec.get_resource(self.app3).start_time, ec.get_resource(self.app2).start_time),0), 2.0)
-        self.assertEquals(round(tdiffsec(ec.get_resource(self.app4).start_time, ec.get_resource(self.app3).start_time),0), 3.0)
-        self.assertEquals(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app3).start_time),0), 20.0)
-        self.assertEquals(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app1).start_time),0), 25.0)
-
-        self.assertEquals(ec.get_resource(self.node1).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.channel).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.app1).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app2).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app3).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app4).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app5).state, ResourceState.STOPPED)
+        self.assertEqual(round(tdiffsec(ec.get_resource(self.app2).start_time, ec.get_resource(self.app1).start_time),0), 3.0)
+        self.assertEqual(round(tdiffsec(ec.get_resource(self.app3).start_time, ec.get_resource(self.app2).start_time),0), 2.0)
+        self.assertEqual(round(tdiffsec(ec.get_resource(self.app4).start_time, ec.get_resource(self.app3).start_time),0), 3.0)
+        self.assertEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app3).start_time),0), 20.0)
+        self.assertEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app1).start_time),0), 25.0)
+
+        self.assertEqual(ec.get_resource(self.node1).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.channel).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.app1).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app2).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app4).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app5).state, ResourceState.STOPPED)
 
         ec.shutdown()
 
-        self.assertEquals(ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app3).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app4).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app5).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app4).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app5).state, ResourceState.RELEASED)
 
 
 if __name__ == '__main__':

diff --git a/test/resources/omf/omf5_vlc_wrong_critical.py b/test/resources/omf/omf5_vlc_wrong_critical.py
index 10b2d23..17960b6 100755 (executable)
--- a/test/resources/omf/omf5_vlc_wrong_critical.py
+++ b/test/resources/omf/omf5_vlc_wrong_critical.py
@@ -95,16 +95,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_hostname(self):
 
@@ -141,16 +141,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_iface(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -182,16 +182,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_ip(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -227,16 +227,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_channel(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -267,16 +267,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_app(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -318,17 +318,17 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
     def test_deploy_wo_app_path(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -371,17 +371,17 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
 
 if __name__ == '__main__':

diff --git a/test/resources/omf/omf5_vlc_wrong_non_critical.py b/test/resources/omf/omf5_vlc_wrong_non_critical.py
index fee1727..34209b2 100755 (executable)
--- a/test/resources/omf/omf5_vlc_wrong_non_critical.py
+++ b/test/resources/omf/omf5_vlc_wrong_non_critical.py
@@ -96,17 +96,17 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_with_node_and_iface_nc(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -140,17 +140,17 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_with_node_iface_channel_nc(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -182,18 +182,18 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_with_app_nc(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -237,18 +237,18 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
     def test_deploy_with_all_nc_and_app_critical(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -281,17 +281,17 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
 
 class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
@@ -375,19 +375,19 @@ class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2, self.app3])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
 
     def test_deploy_with_app_nc_and_critical_right(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -439,20 +439,20 @@ class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2, self.app3])
 
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
 
 
     def test_deploy_with_many_app_nc_and_critical(self):
@@ -529,26 +529,26 @@ class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2, self.app3, self.app4, self.app5, self.app6])
 
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
 
 
 if __name__ == '__main__':

diff --git a/test/resources/omf/omf6_vlc_normal_case.py b/test/resources/omf/omf6_vlc_normal_case.py
index 42d09b5..849770f 100755 (executable)
--- a/test/resources/omf/omf6_vlc_normal_case.py
+++ b/test/resources/omf/omf6_vlc_normal_case.py
@@ -35,17 +35,17 @@ import unittest
 class OMFResourceFactoryTestCase(unittest.TestCase):
     def test_creation_phase(self):
 
-        self.assertEquals(OMFNode.get_rtype(), "omf::Node")
-        self.assertEquals(len(OMFNode._attributes), 8)
+        self.assertEqual(OMFNode.get_rtype(), "omf::Node")
+        self.assertEqual(len(OMFNode._attributes), 8)
 
-        self.assertEquals(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
-        self.assertEquals(len(OMFWifiInterface._attributes), 12)
+        self.assertEqual(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
+        self.assertEqual(len(OMFWifiInterface._attributes), 12)
 
-        self.assertEquals(OMFChannel.get_rtype(), "omf::Channel")
-        self.assertEquals(len(OMFChannel._attributes), 8)
+        self.assertEqual(OMFChannel.get_rtype(), "omf::Channel")
+        self.assertEqual(len(OMFChannel._attributes), 8)
 
-        self.assertEquals(OMFApplication.get_rtype(), "omf::Application")
-        self.assertEquals(len(OMFApplication._attributes), 14)
+        self.assertEqual(OMFApplication.get_rtype(), "omf::Application")
+        self.assertEqual(len(OMFApplication._attributes), 14)
 
 class OMFEachTestCase(unittest.TestCase):
     def setUp(self):
@@ -105,50 +105,50 @@ class OMFEachTestCase(unittest.TestCase):
         self.ec.shutdown()
 
     def test_creation_and_configuration_node(self):
-        self.assertEquals(self.ec.get(self.node1, 'hostname'), 'wlab12')
-        self.assertEquals(self.ec.get(self.node1, 'xmppUser'), 'nepi')
-        self.assertEquals(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
-        self.assertEquals(self.ec.get(self.node1, 'xmppPort'), '5222')
-        self.assertEquals(self.ec.get(self.node1, 'xmppPassword'), '1234')
-        self.assertEquals(self.ec.get(self.node1, 'version'), '6')
+        self.assertEqual(self.ec.get(self.node1, 'hostname'), 'wlab12')
+        self.assertEqual(self.ec.get(self.node1, 'xmppUser'), 'nepi')
+        self.assertEqual(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+        self.assertEqual(self.ec.get(self.node1, 'xmppPort'), '5222')
+        self.assertEqual(self.ec.get(self.node1, 'xmppPassword'), '1234')
+        self.assertEqual(self.ec.get(self.node1, 'version'), '6')
 
 
     def test_creation_and_configuration_interface(self):
-        self.assertEquals(self.ec.get(self.iface1, 'name'), 'wlan0')
-        self.assertEquals(self.ec.get(self.iface1, 'mode'), 'adhoc')
-        self.assertEquals(self.ec.get(self.iface1, 'hw_mode'), 'g')
-        self.assertEquals(self.ec.get(self.iface1, 'essid'), 'vlcexp')
-        self.assertEquals(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
-        self.assertEquals(self.ec.get(self.iface1, 'version'), '6')
+        self.assertEqual(self.ec.get(self.iface1, 'name'), 'wlan0')
+        self.assertEqual(self.ec.get(self.iface1, 'mode'), 'adhoc')
+        self.assertEqual(self.ec.get(self.iface1, 'hw_mode'), 'g')
+        self.assertEqual(self.ec.get(self.iface1, 'essid'), 'vlcexp')
+        self.assertEqual(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
+        self.assertEqual(self.ec.get(self.iface1, 'version'), '6')
 
     def test_creation_and_configuration_channel(self):
-        self.assertEquals(self.ec.get(self.channel, 'channel'), '6')
-        self.assertEquals(self.ec.get(self.channel, 'xmppUser'), 'nepi')
-        self.assertEquals(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
-        self.assertEquals(self.ec.get(self.channel, 'xmppPort'), '5222')
-        self.assertEquals(self.ec.get(self.channel, 'xmppPassword'), '1234')
-        self.assertEquals(self.ec.get(self.channel, 'version'), '6')
+        self.assertEqual(self.ec.get(self.channel, 'channel'), '6')
+        self.assertEqual(self.ec.get(self.channel, 'xmppUser'), 'nepi')
+        self.assertEqual(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+        self.assertEqual(self.ec.get(self.channel, 'xmppPort'), '5222')
+        self.assertEqual(self.ec.get(self.channel, 'xmppPassword'), '1234')
+        self.assertEqual(self.ec.get(self.channel, 'version'), '6')
 
 
     def test_creation_and_configuration_application(self):
-        self.assertEquals(self.ec.get(self.app1, 'appid'), 'Vlc#1')
-        self.assertEquals(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
-        self.assertEquals(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
-        self.assertEquals(self.ec.get(self.app1, 'version'), '6')
+        self.assertEqual(self.ec.get(self.app1, 'appid'), 'Vlc#1')
+        self.assertEqual(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
+        self.assertEqual(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
+        self.assertEqual(self.ec.get(self.app1, 'version'), '6')
 
     def test_connection(self):
-        self.assertEquals(len(self.ec.get_resource(self.node1).connections), 6)
-        self.assertEquals(len(self.ec.get_resource(self.iface1).connections), 2)
-        self.assertEquals(len(self.ec.get_resource(self.channel).connections), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app1).connections), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app2).connections), 1)
+        self.assertEqual(len(self.ec.get_resource(self.node1).connections), 6)
+        self.assertEqual(len(self.ec.get_resource(self.iface1).connections), 2)
+        self.assertEqual(len(self.ec.get_resource(self.channel).connections), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app1).connections), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app2).connections), 1)
 
     def test_condition(self):
-        self.assertEquals(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
-        self.assertEquals(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
+        self.assertEqual(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
+        self.assertEqual(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
 
 class OMFVLCNormalCase(unittest.TestCase):
     def test_deploy(self):
@@ -226,25 +226,25 @@ class OMFVLCNormalCase(unittest.TestCase):
         self.assertGreaterEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app3).start_time),0), 2.0)
         self.assertGreaterEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app1).start_time),0), 25.0)
 
-        self.assertEquals(ec.get_resource(self.node1).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.channel).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.app1).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app2).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app3).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app4).state, ResourceState.STOPPED)
-        self.assertEquals(ec.get_resource(self.app5).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.node1).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.channel).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.app1).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app2).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app4).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.app5).state, ResourceState.STOPPED)
 
         ec.shutdown()
 
-        self.assertEquals(ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app3).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app4).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app5).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app4).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app5).state, ResourceState.RELEASED)
 
 
 if __name__ == '__main__':

diff --git a/test/resources/omf/omf6_vlc_traces.py b/test/resources/omf/omf6_vlc_traces.py
index c9ab328..7a922d1 100755 (executable)
--- a/test/resources/omf/omf6_vlc_traces.py
+++ b/test/resources/omf/omf6_vlc_traces.py
@@ -83,21 +83,21 @@ class OMFPingNormalCase(unittest.TestCase):
             with open("app1_err.txt", "w") as f:
                 f.write(stderr_1)
 
-        self.assertEquals(ec.get_resource(self.node1).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.channel).state, ResourceState.STARTED)
-        self.assertEquals(ec.get_resource(self.app1).state, ResourceState.STOPPED)
+        self.assertEqual(ec.get_resource(self.node1).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.channel).state, ResourceState.STARTED)
+        self.assertEqual(ec.get_resource(self.app1).state, ResourceState.STOPPED)
 
         ec.shutdown()
 
-        self.assertEquals(ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
         with open("app1_out.txt", "r") as t:
             l = t.readlines()
-            self.assertEquals(l[0], "PING 10.0.0.17 (10.0.0.17) 56(84) bytes of data.\n")
+            self.assertEqual(l[0], "PING 10.0.0.17 (10.0.0.17) 56(84) bytes of data.\n")
             self.assertIn("5 packets transmitted, 5 received, 0% packet loss, time", l[-2])
             self.assertIn("rtt min/avg/max/mdev = ", l[-1])
         

diff --git a/test/resources/omf/omf6_vlc_wrong_critical.py b/test/resources/omf/omf6_vlc_wrong_critical.py
index 2f36e06..5f155e5 100755 (executable)
--- a/test/resources/omf/omf6_vlc_wrong_critical.py
+++ b/test/resources/omf/omf6_vlc_wrong_critical.py
@@ -85,16 +85,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_hostname(self):
 
@@ -124,16 +124,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_iface(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -158,16 +158,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_channel(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -195,16 +195,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_ip(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -233,16 +233,16 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_wo_app(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -276,17 +276,17 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
     def test_deploy_wo_app_path(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -321,17 +321,17 @@ class OMFVLCWrongCaseAllCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
 
 if __name__ == '__main__':

diff --git a/test/resources/omf/omf6_vlc_wrong_non_critical.py b/test/resources/omf/omf6_vlc_wrong_non_critical.py
index 6bb271f..77f4441 100755 (executable)
--- a/test/resources/omf/omf6_vlc_wrong_non_critical.py
+++ b/test/resources/omf/omf6_vlc_wrong_non_critical.py
@@ -87,17 +87,17 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_with_node_and_iface_nc(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -124,17 +124,17 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_with_node_iface_channel_nc(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -163,17 +163,17 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1])
 
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
 
     def test_deploy_with_app_nc(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -209,18 +209,18 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
     def test_deploy_with_all_nc_and_app_critical(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -249,17 +249,17 @@ class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
 
 
 class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
@@ -331,19 +331,19 @@ class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2, self.app3])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
 
     def test_deploy_with_app_nc_and_critical_right(self):
         self.node2 = self.ec.register_resource("omf::Node")
@@ -386,19 +386,19 @@ class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2, self.app3])
 
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
-        #self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        #self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
 
 
     def test_deploy_with_many_app_nc_and_critical(self):
@@ -463,25 +463,25 @@ class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
 
         self.ec.wait_finished([self.app1, self.app2, self.app3, self.app4, self.app5, self.app6])
 
-        #self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
-        #self.assertEquals(self.ec.get_resource(self.app4).state, ResourceState.STOPPED)
-        self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
-        #self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
+        #self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+        #self.assertEqual(self.ec.get_resource(self.app4).state, ResourceState.STOPPED)
+        self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
+        #self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
 
         self.ec.shutdown()
 
-        self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
-        self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
+        self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
 
 
 if __name__ == '__main__':

diff --git a/test/resources/omf/set_hook.py b/test/resources/omf/set_hook.py
index f515f1e..1ac0693 100755 (executable)
--- a/test/resources/omf/set_hook.py
+++ b/test/resources/omf/set_hook.py
@@ -85,12 +85,12 @@ class OMFTestSet(unittest.TestCase):
         print("First try to change the STDIN")
         self.ec.set(self.app1, 'test', 3)
 
-        self.assertEquals(self.ec.get(self.app1, 'test'), 30)
+        self.assertEqual(self.ec.get(self.app1, 'test'), 30)
 
         time.sleep(3)
         print("Second try to change the STDIN")
         self.ec.set(self.app1, 'test', 101)
-        self.assertEquals(self.ec.get(self.app1, 'test'), 1010)
+        self.assertEqual(self.ec.get(self.app1, 'test'), 1010)
 
         self.ec.wait_finished([self.app1])
 

diff --git a/test/resources/omf/wilab_node.py b/test/resources/omf/wilab_node.py
index 7642e83..132ceb8 100755 (executable)
--- a/test/resources/omf/wilab_node.py
+++ b/test/resources/omf/wilab_node.py
@@ -34,8 +34,8 @@ class DummyEC(ExperimentController):
 class WilabtSfaNodeFactoryTestCase(unittest.TestCase):
 
     def test_creation_phase(self):
-        self.assertEquals(WilabtSfaNode._rtype, "WilabtSfaNode")
-        self.assertEquals(len(WilabtSfaNode._attributes), 17)
+        self.assertEqual(WilabtSfaNode._rtype, "WilabtSfaNode")
+        self.assertEqual(len(WilabtSfaNode._attributes), 17)
 
 class WilabtSfaNodeTestCase(unittest.TestCase):
     """
@@ -75,8 +75,8 @@ class WilabtSfaNodeTestCase(unittest.TestCase):
 
         api1 = wnode_rm1.sfaapi
         self.assertIsInstance(api1, SFAAPI)
-        self.assertEquals(len(api1._reserved), 0)
-        self.assertEquals(len(api1._blacklist), 0)
+        self.assertEqual(len(api1._reserved), 0)
+        self.assertEqual(len(api1._blacklist), 0)
 
         node2 = self.ec.register_resource("WilabtSfaNode")
         self.ec.set(node2, "host", "zotacM20")
@@ -88,7 +88,7 @@ class WilabtSfaNodeTestCase(unittest.TestCase):
 
         wnode_rm2 = self.ec.get_resource(node2)
         api2 = wnode_rm2.sfaapi
-        self.assertEquals(api1, api2)
+        self.assertEqual(api1, api2)
 
         wnode_rm1.sfaapi._reserved = set()
         wnode_rm1.sfaapi._blacklist = set()
@@ -111,11 +111,11 @@ class WilabtSfaNodeTestCase(unittest.TestCase):
         host = wnode_rm.get("host")
         self.assertIsNotNone(host)
 
-        self.assertEquals(wnode_rm.sfaapi._reserved, set())
+        self.assertEqual(wnode_rm.sfaapi._reserved, set())
 
         wnode_rm.do_discover()
-        self.assertEquals(len(wnode_rm.sfaapi._reserved), 1)
-        self.assertEquals(wnode_rm._node_to_provision, 'wilab2.ilabt.iminds.be.zotacE5')
+        self.assertEqual(len(wnode_rm.sfaapi._reserved), 1)
+        self.assertEqual(wnode_rm._node_to_provision, 'wilab2.ilabt.iminds.be.zotacE5')
 
         wnode_rm.sfaapi._reserved = set()
         wnode_rm.sfaapi._blacklist = set()
@@ -136,7 +136,7 @@ class WilabtSfaNodeTestCase(unittest.TestCase):
 
         wnode_rm = self.ec.get_resource(node)
 
-        self.assertEquals(wnode_rm.sfaapi._reserved, set())
+        self.assertEqual(wnode_rm.sfaapi._reserved, set())
         self.assertIsNone(wnode_rm._node_to_provision)
 
         wnode_rm.do_discover()
@@ -147,7 +147,7 @@ class WilabtSfaNodeTestCase(unittest.TestCase):
         if not self.ec.abort and self.ec.state(node) > 2:
             cmd = 'echo "IT WORKED"'
             ((out, err), proc) = wnode_rm.execute(cmd)
-            self.assertEquals(out.strip(), "IT WORKED")
+            self.assertEqual(out.strip(), "IT WORKED")
 
         #wnode_rm.sfaapi._reserved = set()
         #wnode_rm.sfaapi._blacklist = set()
@@ -240,8 +240,8 @@ class WilabtSfaNodeTestCase(unittest.TestCase):
         state1 = self.ec.state(node1)
         state2 = self.ec.state(node2)
         if not self.ec.abort:
-            self.assertEquals(state1, (3, 4))
-            self.assertEquals(state2, (3, 4))
+            self.assertEqual(state1, (3, 4))
+            self.assertEqual(state2, (3, 4))
 
         self.ec.shutdown() 
 

diff --git a/test/resources/planetlab/node.py b/test/resources/planetlab/node.py
index 5714645..a56bc6e 100755 (executable)
--- a/test/resources/planetlab/node.py
+++ b/test/resources/planetlab/node.py
@@ -73,8 +73,8 @@ def create_node(ec, username, pl_user=None, pl_password=None, pl_url=None,
 class PLNodeFactoryTestCase(unittest.TestCase):
 
     def test_creation_phase(self):
-        self.assertEquals(PlanetlabNode._rtype, "planetlab::Node")
-        self.assertEquals(len(PlanetlabNode._attributes), 32)
+        self.assertEqual(PlanetlabNode._rtype, "planetlab::Node")
+        self.assertEqual(len(PlanetlabNode._attributes), 32)
 
 class PLNodeTestCase(unittest.TestCase):
     """
@@ -115,8 +115,8 @@ class PLNodeTestCase(unittest.TestCase):
 
         api1 = plnode_rm1.plapi
         self.assertIsInstance(api1, PLCAPI)
-        self.assertEquals(len(api1.reserved()), 0)
-        self.assertEquals(len(api1.blacklisted()), 0)
+        self.assertEqual(len(api1.reserved()), 0)
+        self.assertEqual(len(api1.blacklisted()), 0)
 
         node2 = create_node(self.ec, self.username, pl_user=self.pl_user,   
             pl_password=self.pl_password, pl_url=self.pl_url, 
@@ -124,7 +124,7 @@ class PLNodeTestCase(unittest.TestCase):
         
         plnode_rm2 = self.ec.get_resource(node2)
         api2 = plnode_rm2.plapi
-        self.assertEquals(api1, api2)
+        self.assertEqual(api1, api2)
     
         # Set hostname attribute in order for the shutdown method not to fail
         plnode_rm1._set_hostname_attr(3)
@@ -161,7 +161,7 @@ class PLNodeTestCase(unittest.TestCase):
         self.assertIsNone(hostname)
 
         plnode_rm.do_discover()
-        self.assertEquals(plnode_rm._node_to_provision, 3)
+        self.assertEqual(plnode_rm._node_to_provision, 3)
 
        # Set hostname attribute in order for the shutdown method not to fail
         plnode_rm._set_hostname_attr(plnode_rm._node_to_provision)        
@@ -200,8 +200,8 @@ class PLNodeTestCase(unittest.TestCase):
         plnode_rm = self.ec.get_resource(node)
         plnode_rm.do_discover()
 
-        self.assertEquals(plnode_rm._node_to_provision, 3)
-        self.assertEquals(plnode_rm.plapi.reserved(), set([3]))
+        self.assertEqual(plnode_rm._node_to_provision, 3)
+        self.assertEqual(plnode_rm.plapi.reserved(), set([3]))
 
     @skipIfNotPLCredentials
     def test_discover_ip(self):
@@ -216,9 +216,9 @@ class PLNodeTestCase(unittest.TestCase):
         plnode_rm = self.ec.get_resource(node)
         plnode_rm.do_discover()
 
-        self.assertEquals(plnode_rm._node_to_provision, 3)
-        self.assertEquals(plnode_rm.plapi.reserved(), set([3]))
-        self.assertEquals(plnode_rm.get("hostname"), "nepi2.pl.sophia.inria.fr")
+        self.assertEqual(plnode_rm._node_to_provision, 3)
+        self.assertEqual(plnode_rm.plapi.reserved(), set([3]))
+        self.assertEqual(plnode_rm.get("hostname"), "nepi2.pl.sophia.inria.fr")
 
     @skipIfNotPLCredentials
     def test_discover_with_ranges(self):
@@ -250,7 +250,7 @@ class PLNodeTestCase(unittest.TestCase):
                 hostname="nepi1.pl.sophia.inria.fr")
 
         plnode_rm = self.ec.get_resource(node)
-        self.assertEquals(plnode_rm.plapi.blacklisted(), set())
+        self.assertEqual(plnode_rm.plapi.blacklisted(), set())
 
         # check that the node is actually malfunctioning
         api = plnode_rm.plapi
@@ -262,7 +262,7 @@ class PLNodeTestCase(unittest.TestCase):
         if not node_id:
             with self.assertRaises(RuntimeError):
                 plnode_rm.do_discover()
-                self.assertEquals(plnode_rm.plapi.blacklisted(), set([1]))
+                self.assertEqual(plnode_rm.plapi.blacklisted(), set([1]))
 
     @skipIfNotPLCredentials
     def test_provision_node_inslice(self):
@@ -274,14 +274,14 @@ class PLNodeTestCase(unittest.TestCase):
             architecture="x86_64", operatingSystem="f12")
 
         plnode_rm = self.ec.get_resource(node)
-        self.assertEquals(len(plnode_rm.plapi.blacklisted()), 0)
-        self.assertEquals(len(plnode_rm.plapi.reserved()), 0)
+        self.assertEqual(len(plnode_rm.plapi.blacklisted()), 0)
+        self.assertEqual(len(plnode_rm.plapi.reserved()), 0)
 
         plnode_rm.do_discover()
         plnode_rm.do_provision()
         ip = plnode_rm.get("ip")
-        self.assertEquals(ip, "138.96.116.32")
-        self.assertEquals(len(plnode_rm.plapi.reserved()), 1)
+        self.assertEqual(ip, "138.96.116.32")
+        self.assertEqual(len(plnode_rm.plapi.reserved()), 1)
 
     @skipIfNotPLCredentials
     def test_provision_node_not_inslice(self):
@@ -295,8 +295,8 @@ class PLNodeTestCase(unittest.TestCase):
             city='Paris')
 
         plnode_rm = self.ec.get_resource(node)
-        self.assertEquals(plnode_rm.plapi.blacklisted(), set())
-        self.assertEquals(plnode_rm.plapi.reserved(), set())
+        self.assertEqual(plnode_rm.plapi.blacklisted(), set())
+        self.assertEqual(plnode_rm.plapi.reserved(), set())
 
         plnode_rm.do_discover()
         plnode_rm.do_provision()

diff --git a/test/resources/planetlab/sfa_node.py b/test/resources/planetlab/sfa_node.py
index e32d561..d712de3 100755 (executable)
--- a/test/resources/planetlab/sfa_node.py
+++ b/test/resources/planetlab/sfa_node.py
@@ -36,8 +36,8 @@ class DummyEC(ExperimentController):
 class PLSfaNodeFactoryTestCase(unittest.TestCase):
 
     def test_creation_phase(self):
-        self.assertEquals(PlanetlabSfaNode._rtype, "planetlab::sfa::Node")
-        self.assertEquals(len(PlanetlabSfaNode._attributes), 31)
+        self.assertEqual(PlanetlabSfaNode._rtype, "planetlab::sfa::Node")
+        self.assertEqual(len(PlanetlabSfaNode._attributes), 31)
 
 class PLSfaNodeTestCase(unittest.TestCase):
     """
@@ -72,8 +72,8 @@ class PLSfaNodeTestCase(unittest.TestCase):
 
         api1 = plnode_rm1.sfaapi
         self.assertIsInstance(api1, SFAAPI)
-        self.assertEquals(len(api1._reserved), 0)
-        self.assertEquals(len(api1._blacklist), 0)
+        self.assertEqual(len(api1._reserved), 0)
+        self.assertEqual(len(api1._blacklist), 0)
 
         node2 = self.ec.register_resource("planetlab::sfa::Node")
         self.ec.set(node2, "hostname", "planetlab2.ionio.gr")
@@ -83,7 +83,7 @@ class PLSfaNodeTestCase(unittest.TestCase):
 
         plnode_rm2 = self.ec.get_resource(node2)
         api2 = plnode_rm2.sfaapi
-        self.assertEquals(api1, api2)
+        self.assertEqual(api1, api2)
     
     @skipIfNotSfaCredentials
     def test_discover(self):
@@ -101,12 +101,12 @@ class PLSfaNodeTestCase(unittest.TestCase):
         hostname = plnode_rm.get("hostname")
         self.assertIsNotNone(hostname)
 
-        self.assertEquals(len(plnode_rm.sfaapi._reserved), 0)
+        self.assertEqual(len(plnode_rm.sfaapi._reserved), 0)
 
         plnode_rm.do_discover()
 
-        self.assertEquals(len(plnode_rm.sfaapi._reserved), 1)
-        self.assertEquals(plnode_rm._node_to_provision, 'ple.mimuw.roti.mimuw.edu.pl')
+        self.assertEqual(len(plnode_rm.sfaapi._reserved), 1)
+        self.assertEqual(plnode_rm._node_to_provision, 'ple.mimuw.roti.mimuw.edu.pl')
         plnode_rm.sfaapi._reserved = set()
         plnode_rm.sfaapi._blacklist = set()
 
@@ -124,7 +124,7 @@ class PLSfaNodeTestCase(unittest.TestCase):
 
         plnode_rm = self.ec.get_resource(node)
 
-        self.assertEquals(plnode_rm.sfaapi._reserved, set())
+        self.assertEqual(plnode_rm.sfaapi._reserved, set())
         self.assertIsNone(plnode_rm._node_to_provision)
 
         plnode_rm.do_discover()
@@ -132,7 +132,7 @@ class PLSfaNodeTestCase(unittest.TestCase):
 
         cmd = 'echo "IT WORKED"'
         ((out, err), proc) = plnode_rm.execute(cmd)
-        self.assertEquals(out.strip(), "IT WORKED")
+        self.assertEqual(out.strip(), "IT WORKED")
 
         plnode_rm.sfaapi._reserved = set()
         plnode_rm.sfaapi._blacklist = set()

diff --git a/test/util/manifoldapi.py b/test/util/manifoldapi.py
index 47c4e08..95053be 100755 (executable)
--- a/test/util/manifoldapi.py
+++ b/test/util/manifoldapi.py
@@ -43,7 +43,7 @@ class MFAPIFactoryTestCase(unittest.TestCase):
 
         self.assertIsInstance(api1, MANIFOLDAPI)
         self.assertIsInstance(api2, MANIFOLDAPI)
-        self.assertEquals(api1, api2)
+        self.assertEqual(api1, api2)
         
 
 class MANIFOLDAPITestCase(unittest.TestCase):
@@ -65,33 +65,33 @@ class MANIFOLDAPITestCase(unittest.TestCase):
 
         r_info = self.api.get_resource_info(filters=filters)
         hostname = r_info[0]['hostname']
-        self.assertEquals(hostname, 'planetlab2.tlm.unavarra.es')
+        self.assertEqual(hostname, 'planetlab2.tlm.unavarra.es')
 
         # query with 2 filters
         filters['network'] = 'ple'
                 
         r_info = self.api.get_resource_info(filters=filters)
         hostname = r_info[0]['hostname']
-        self.assertEquals(hostname, 'planetlab2.tlm.unavarra.es')
+        self.assertEqual(hostname, 'planetlab2.tlm.unavarra.es')
 
         # query with fields only, without filters
         fields = ['latitude','longitude']
 
         r_info = self.api.get_resource_info(fields=fields)
         value = r_info[10]
-        self.assertEquals(value.keys(), fields)
+        self.assertEqual(value.keys(), fields)
 
         # query with 2 filters and 2 fields
         r_info = self.api.get_resource_info(filters, fields)
         value = r_info[0]
         result = {'latitude': '42.7993', 'longitude': '-1.63544'}
-        self.assertEquals(value, result)
+        self.assertEqual(value, result)
 
         # query with filters where the AND should be zero resources
         filters['network'] = 'omf'
         
         r_info = self.api.get_resource_info(filters, fields)
-        self.assertEquals(r_info, [])
+        self.assertEqual(r_info, [])
 
     def test_fail_if_invalid_field(self):
         """
@@ -118,7 +118,7 @@ class MANIFOLDAPITestCase(unittest.TestCase):
         'urn:publicid:IDN+ple:uttple+node+planetlab2.utt.fr', 
         'urn:publicid:IDN+ple:lilleple+node+node1pl.planet-lab.telecom-lille1.eu']
        
-        self.assertEquals(resources, result)
+        self.assertEqual(resources, result)
     
     def test_update_resources_from_slice(self):
         """

diff --git a/test/util/parallel.py b/test/util/parallel.py
index e5785c6..e239ec9 100755 (executable)
--- a/test/util/parallel.py
+++ b/test/util/parallel.py
@@ -38,7 +38,7 @@ class ParallelRunTestCase(unittest.TestCase):
 
         runner.destroy()
 
-        self.assertEquals(count[0], 10)
+        self.assertEqual(count[0], 10)
 
     def test_run_interrupt(self):
 
@@ -80,7 +80,7 @@ class ParallelRunTestCase(unittest.TestCase):
        
         runner.destroy()
       
-        self.assertEquals(count[0], 4)
+        self.assertEqual(count[0], 4)
         
         self.assertRaises(RuntimeError, runner.sync)
 

diff --git a/test/util/serializer.py b/test/util/serializer.py
index 3ee85c1..c0f0e3a 100755 (executable)
--- a/test/util/serializer.py
+++ b/test/util/serializer.py
@@ -136,7 +136,7 @@ class SerializerTestCase(unittest.TestCase):
         ec2.wait_finished(apps)
         ec2.shutdown()
         
-        self.assertEquals(len(ec.resources), len(ec2.resources))
+        self.assertEqual(len(ec.resources), len(ec2.resources))
 
         shutil.rmtree(dirpath)
                        

diff --git a/test/util/sshfuncs.py b/test/util/sshfuncs.py
index 44c272a..ba738b1 100755 (executable)
--- a/test/util/sshfuncs.py
+++ b/test/util/sshfuncs.py
@@ -178,7 +178,7 @@ class SSHfuncsTestCase(unittest.TestCase):
         (outremote, errrmote), premote = rexec(command, host, user, 
                 port = env.port, agent = True)
 
-        self.assertEquals(outlocal, outremote)
+        self.assertEqual(outlocal, outremote)
 
     def test_rcopy_list(self):
         env = test_environment()
@@ -271,7 +271,7 @@ class SSHfuncsTestCase(unittest.TestCase):
                 port = env.port, 
                 agent = True)
 
-        self.assertEquals(status, ProcStatus.RUNNING)
+        self.assertEqual(status, ProcStatus.RUNNING)
 
         rkill(pid, ppid,
                 host = host,
@@ -285,7 +285,7 @@ class SSHfuncsTestCase(unittest.TestCase):
                 port = env.port, 
                 agent = True)
         
-        self.assertEquals(status, ProcStatus.FINISHED)
+        self.assertEqual(status, ProcStatus.FINISHED)
 
 
 if __name__ == '__main__':

diff --git a/test/util/timefuncs.py b/test/util/timefuncs.py
index 9dfef19..7b0ff54 100755 (executable)
--- a/test/util/timefuncs.py
+++ b/test/util/timefuncs.py
@@ -33,7 +33,7 @@ class TimeFuncTestCase(unittest.TestCase):
         seconds1 = _get_total_seconds(date)
         seconds2 = date.total_seconds()
 
-        self.assertEquals(seconds1, seconds2)
+        self.assertEqual(seconds1, seconds2)
 
 
 if __name__ == '__main__':