nat: nat44-ed pool address allocation improvement

[vpp.git] / test / remote_test.py

diff --git a/test/remote_test.py b/test/remote_test.py
index d084133..19bad89 100644 (file)
--- a/test/remote_test.py
+++ b/test/remote_test.py
@@ -1,22 +1,18 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 
 import inspect
 import os
 
 import inspect
 import os

+import reprlib

 import unittest
 from framework import VppTestCase
 from multiprocessing import Process, Pipe
 from pickle import dumps
 import unittest
 from framework import VppTestCase
 from multiprocessing import Process, Pipe
 from pickle import dumps

-import six
-from six import moves

 import sys
 
 import sys
 

-if sys.version_info < (3,):
-    from aenum import IntEnum, IntFlag
-else:
-    from enum import IntEnum, IntFlag
+from enum import IntEnum, IntFlag

 
 
 
 

-class SerializableClassCopy(object):
+class SerializableClassCopy:

     """
     Empty class used as a basis for a serializable copy of another class.
     """
     """
     Empty class used as a basis for a serializable copy of another class.
     """


@@ -26,7 +22,7 @@ class SerializableClassCopy(object):
         return '<SerializableClassCopy dict=%s>' % self.__dict__
 
 
         return '<SerializableClassCopy dict=%s>' % self.__dict__
 
 

-class RemoteClassAttr(object):
+class RemoteClassAttr:

     """
     Wrapper around attribute of a remotely executed class.
     """
     """
     Wrapper around attribute of a remotely executed class.
     """


@@ -73,23 +69,33 @@ class RemoteClass(Process):
     """
     This class can wrap around and adapt the interface of another class,
     and then delegate its execution to a newly forked child process.
     """
     This class can wrap around and adapt the interface of another class,
     and then delegate its execution to a newly forked child process.

+

     Usage:
     Usage:

-        # Create a remotely executed instance of MyClass
-        object = RemoteClass(MyClass, arg1='foo', arg2='bar')
-        object.start_remote()
-        # Access the object normally as if it was an instance of your class.
-        object.my_attribute = 20
-        print object.my_attribute
-        print object.my_method(object.my_attribute)
-        object.my_attribute.nested_attribute = 'test'
-        # If you need the value of a remote attribute, use .get_remote_value
-        method. This method is automatically called when needed in the context
-        of a remotely executed class. E.g.:
-        if (object.my_attribute.get_remote_value() > 20):
-            object.my_attribute2 = object.my_attribute
-        # Destroy the instance
-        object.quit_remote()
-        object.terminate()
+
+        #. Create a remotely executed instance of MyClass. ::
+
+            object = RemoteClass(MyClass, arg1='foo', arg2='bar')
+            object.start_remote()
+
+        #. Access the object normally as if it was an instance of your
+           class. ::
+
+            object.my_attribute = 20
+            print object.my_attribute
+            print object.my_method(object.my_attribute)
+            object.my_attribute.nested_attribute = 'test'
+
+        #. If you need the value of a remote attribute, use .get_remote_value
+           method. This method is automatically called when needed in the
+           context of a remotely executed class. E.g. ::
+
+            if (object.my_attribute.get_remote_value() > 20):
+                object.my_attribute2 = object.my_attribute
+
+        #. Destroy the instance. ::
+
+            object.quit_remote()
+            object.terminate()

     """
 
     GET = 0       # Get attribute remotely
     """
 
     GET = 0       # Get attribute remotely


@@ -113,7 +119,7 @@ class RemoteClass(Process):
         self._pipe = Pipe()  # pipe for input/output arguments
 
     def __repr__(self):
         self._pipe = Pipe()  # pipe for input/output arguments
 
     def __repr__(self):

-        return moves.reprlib.repr(RemoteClassAttr(self, None))
+        return reprlib.repr(RemoteClassAttr(self, None))

 
     def __str__(self):
         return str(RemoteClassAttr(self, None))
 
     def __str__(self):
         return str(RemoteClassAttr(self, None))


@@ -147,7 +153,7 @@ class RemoteClass(Process):
                     isinstance(val, RemoteClassAttr):
                 mutable_args[i] = val.get_remote_value()
         args = tuple(mutable_args)
                     isinstance(val, RemoteClassAttr):
                 mutable_args[i] = val.get_remote_value()
         args = tuple(mutable_args)

-        for key, val in six.iteritems(kwargs):
+        for key, val in kwargs.items():

             if isinstance(val, RemoteClass) or \
                     isinstance(val, RemoteClassAttr):
                 kwargs[key] = val.get_remote_value()
             if isinstance(val, RemoteClass) or \
                     isinstance(val, RemoteClassAttr):
                 kwargs[key] = val.get_remote_value()


@@ -204,7 +210,7 @@ class RemoteClass(Process):
     def _get_local_repr(self, path):
         try:
             obj = self._get_local_object(path)
     def _get_local_repr(self, path):
         try:
             obj = self._get_local_object(path)

-            return moves.reprlib.repr(obj)
+            return reprlib.repr(obj)

         except AttributeError:
             return None
 
         except AttributeError:
             return None
 


@@ -358,32 +364,32 @@ class RemoteClass(Process):
 class RemoteVppTestCase(VppTestCase):
     """ Re-use VppTestCase to create remote VPP segment
 
 class RemoteVppTestCase(VppTestCase):
     """ Re-use VppTestCase to create remote VPP segment
 

-        In your test case:
+        In your test case::

 
 

-        @classmethod
-        def setUpClass(cls):
-            # fork new process before client connects to VPP
-            cls.remote_test = RemoteClass(RemoteVppTestCase)
+            @classmethod
+            def setUpClass(cls):
+                # fork new process before client connects to VPP
+                cls.remote_test = RemoteClass(RemoteVppTestCase)

 
 

-            # start remote process
-            cls.remote_test.start_remote()
+                # start remote process
+                cls.remote_test.start_remote()

 
 

-            # set up your test case
-            super(MyTestCase, cls).setUpClass()
+                # set up your test case
+                super(MyTestCase, cls).setUpClass()

 
 

-            # set up remote test
-            cls.remote_test.setUpClass(cls.tempdir)
+                # set up remote test
+                cls.remote_test.setUpClass(cls.tempdir)

 
 

-        @classmethod
-        def tearDownClass(cls):
-            # tear down remote test
-            cls.remote_test.tearDownClass()
+            @classmethod
+            def tearDownClass(cls):
+                # tear down remote test
+                cls.remote_test.tearDownClass()

 
 

-            # stop remote process
-            cls.remote_test.quit_remote()
+                # stop remote process
+                cls.remote_test.quit_remote()

 
 

-            # tear down your test case
-            super(MyTestCase, cls).tearDownClass()
+                # tear down your test case
+                super(MyTestCase, cls).tearDownClass()

     """
 
     def __init__(self):
     """
 
     def __init__(self):