Python API: Add enum and union support.

As well as a rewrite of the encoders/decoders to make it more readable and extensible.
(Re-commit after fix to verify build.)

Change-Id: Ic244d3cebe070bb2570491f8a24f4a1e203f889a
Signed-off-by: Ole Troan <ot@cisco.com>

6 files changed, 226 insertions, 711 deletions

diff --git a/src/vpp-api/python/tests/test_cli.py b/src/vpp-api/python/tests/test_cli.py
deleted file mode 100755
index 66fb6943e70..00000000000
--- a/src/vpp-api/python/tests/test_cli.py
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import print_function
-import unittest, sys, time, threading, struct
-import test_base
-import vpp_papi
-from ipaddress import *
-
-import glob, subprocess
-class TestPAPI(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        #
-        # Start main VPP process
-        cls.vpp_bin = glob.glob(test_base.scriptdir+'/../../../build-root/install-vpp*-native/vpp/bin/vpp')[0]
-        print("VPP BIN:", cls.vpp_bin)
-        cls.vpp = subprocess.Popen([cls.vpp_bin, "unix", "nodaemon"], stderr=subprocess.PIPE)
-        print('Started VPP')
-        # For some reason unless we let VPP start up the API cannot connect.
-        time.sleep(0.3)
-    @classmethod
-    def tearDownClass(cls):
-        cls.vpp.terminate()
-
-    def setUp(self):
-        print("Connecting API")
-        r = vpp_papi.connect("test_papi")
-        self.assertEqual(r, 0)
-
-    def tearDown(self):
-        r = vpp_papi.disconnect()
-        self.assertEqual(r, 0)
-
-    #
-    # The tests themselves
-    #
-
-    #
-    # Basic request / reply
-    #
-    def test_cli_request(self):
-        print(vpp_papi.cli_exec('show version verbose'))
-        #t = vpp_papi.cli_inband_request(len(cmd), cmd)
-        #print('T:',t)
-        #reply = t.reply[0].decode().rstrip('\x00')
-        #print(reply)
-        #program = t.program.decode().rstrip('\x00')
-        #self.assertEqual('vpe', program)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/src/vpp-api/python/tests/test_modules.py b/src/vpp-api/python/tests/test_modules.py
deleted file mode 100755
index fdcd092c927..00000000000
--- a/src/vpp-api/python/tests/test_modules.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from __future__ import print_function
-import unittest
-import vpp_papi
-import pot, snat
-print('Plugins:')
-vpp_papi.plugin_show()
-r = vpp_papi.connect('ole')
-
-r = vpp_papi.show_version()
-print('R:', r)
-
-r = snat.snat_interface_add_del_feature(1, 1, 1)
-print('R:', r)
-
-list_name = 'foobar'
-r = pot.pot_profile_add(0, 1, 123, 123, 0, 12, 0, 23, len(list_name), list_name)
-print('R:', r)
-vpp_papi.disconnect()
diff --git a/src/vpp-api/python/tests/test_papi.py b/src/vpp-api/python/tests/test_papi.py
deleted file mode 100755
index 8cbbfc59e03..00000000000
--- a/src/vpp-api/python/tests/test_papi.py
+++ /dev/null
@@ -1,119 +0,0 @@
-from __future__ import print_function
-import unittest, sys, time, threading, struct, logging, os
-import vpp_papi
-from ipaddress import *
-scriptdir = os.path.dirname(os.path.realpath(__file__))
-papi_event = threading.Event()
-print(vpp_papi.vpe.VL_API_SW_INTERFACE_SET_FLAGS)
-def papi_event_handler(result):
-    if result.vl_msg_id == vpp_papi.vpe.VL_API_SW_INTERFACE_SET_FLAGS:
-        return
-    if result.vl_msg_id == vpp_papi.vpe.VL_API_VNET_INTERFACE_COUNTERS:
-        print('Interface counters', result)
-        return
-    if result.vl_msg_id == vpp_papi.vpe.VL_API_VNET_IP6_FIB_COUNTERS:
-        print('IPv6 FIB counters', result)
-        papi_event.set()
-        return
-
-    print('Unknown message id:', result.vl_msg_id)
-
-import glob, subprocess
-class TestPAPI(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        #
-        # Start main VPP process
-        cls.vpp_bin = glob.glob(scriptdir+'/../../../build-root/install-vpp*-native/vpp/bin/vpp')[0]
-        print("VPP BIN:", cls.vpp_bin)
-        cls.vpp = subprocess.Popen([cls.vpp_bin, "unix", "nodaemon"], stderr=subprocess.PIPE)
-        print('Started VPP')
-        # For some reason unless we let VPP start up the API cannot connect.
-        time.sleep(0.3)
-    @classmethod
-    def tearDownClass(cls):
-        cls.vpp.terminate()
-
-    def setUp(self):
-        print("Connecting API")
-        r = vpp_papi.connect("test_papi")
-        self.assertEqual(r, 0)
-
-    def tearDown(self):
-        r = vpp_papi.disconnect()
-        self.assertEqual(r, 0)
-
-    #
-    # The tests themselves
-    #
-
-    #
-    # Basic request / reply
-    #
-    def test_show_version(self):
-        t = vpp_papi.show_version()
-        print('T', t);
-        program = t.program.decode().rstrip('\x00')
-        self.assertEqual('vpe', program)
-
-    #
-    # Details / Dump
-    #
-    def test_details_dump(self):
-        t = vpp_papi.sw_interface_dump(0, b'')
-        print('Dump/details T', t)
-
-    #
-    # Arrays
-    #
-    def test_arrays(self):
-        t = vpp_papi.vnet_get_summary_stats()
-        print('Summary stats', t)
-        print('Packets:', t.total_pkts[0])
-        print('Packets:', t.total_pkts[1])
-    #
-    # Variable sized arrays and counters
-    #
-    #@unittest.skip("stats")
-    def test_want_stats(self):
-        pid = 123
-        vpp_papi.register_event_callback(papi_event_handler)
-        papi_event.clear()
-
-        # Need to configure IPv6 to get som IPv6 FIB stats
-        t = vpp_papi.create_loopback('')
-        print(t)
-        self.assertEqual(t.retval, 0)
-
-        ifindex = t.sw_if_index
-        addr = str(IPv6Address(u'1::1').packed)
-        t = vpp_papi.sw_interface_add_del_address(ifindex, 1, 1, 0, 16, addr)
-        print(t)
-        self.assertEqual(t.retval, 0)
-
-        # Check if interface is up
-        # XXX: Add new API to query interface state based on ifindex, instead of dump all.
-        t = vpp_papi.sw_interface_set_flags(ifindex, 1, 1, 0)
-        self.assertEqual(t.retval, 0)
-
-        t = vpp_papi.want_stats(True, pid)
-
-        print (t)
-
-        #
-        # Wait for some stats
-        #
-        self.assertEqual(papi_event.wait(15), True)
-        t = vpp_papi.want_stats(False, pid)
-        print (t)
-
-
-    #
-    # Plugins?
-    #
-
-if __name__ == '__main__':
-    #logging.basicConfig(level=logging.DEBUG)
-    unittest.main()
-def test_papi():
-    print('test')
diff --git a/src/vpp-api/python/tests/test_version.py b/src/vpp-api/python/tests/test_version.py
deleted file mode 100755
index de39cc24ebd..00000000000
--- a/src/vpp-api/python/tests/test_version.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from __future__ import print_function
-import unittest, sys, time, threading, struct
-
-import vpp_papi
-from ipaddress import *
-import glob, subprocess
-class TestPAPI(unittest.TestCase):
-    def setUp(self):
-        print("Connecting API")
-        r = vpp_papi.connect("test_papi")
-        self.assertEqual(r, 0)
-
-    def tearDown(self):
-        r = vpp_papi.disconnect()
-        self.assertEqual(r, 0)
-
-    #
-    # The tests themselves
-    #
-
-    #
-    # Basic request / reply
-    #
-    def test_show_version(self):
-        print(vpp_papi.show_version())
-
-    #
-    # Details / Dump
-    #
-    def test_details_dump(self):
-        t = vpp_papi.sw_interface_dump(0, b'')
-        print('Dump/details T', t)
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/src/vpp-api/python/tests/test_vpp_papi2.py b/src/vpp-api/python/tests/test_vpp_papi2.py
deleted file mode 100755
index f45f791e627..00000000000
--- a/src/vpp-api/python/tests/test_vpp_papi2.py
+++ /dev/null
@@ -1,487 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import print_function
-import unittest, sys, threading, struct, logging, os
-from vpp_papi import VPP
-from ipaddress import *
-import glob, json
-
-papi_event = threading.Event()
-import glob
-
-import fnmatch
-import os
-
-jsonfiles = []
-for root, dirnames, filenames in os.walk('../../../build-root/'):
-    if root.find('install-') == -1: continue
-    for filename in fnmatch.filter(filenames, '*.api.json'):
-        jsonfiles.append(os.path.join(root, filename))
-
-class TestPAPI(unittest.TestCase):
-    show_version_msg = '''["show_version",
-              ["u16", "_vl_msg_id"],
-              ["u32", "client_index"],
-              ["u32", "context"],
-              {"crc" : "0xf18f9480"}
-        ]'''
-
-    ip_address_details_msg = '''["ip_address_details",
-            ["u16", "_vl_msg_id"],
-            ["u32", "client_index"],
-            ["u32", "context"],
-            ["u8", "ip", 16],
-            ["u8", "prefix_length"],
-            {"crc" : "0x87d522a1"}
-        ]'''
-
-    cli_inband_msg = '''["cli_inband",
-            ["u16", "_vl_msg_id"],
-            ["u32", "client_index"],
-            ["u32", "context"],
-            ["u32", "length"],
-            ["u8", "cmd", 0, "length"],
-            {"crc" : "0x22345937"}
-        ]'''
-
-    def test_adding_new_message_object(self):
-        p = json.loads(TestPAPI.show_version_msg)
-        msglist = VPP(testmode=json)
-        msgdef = msglist.add_message(p[0], p[1:])
-
-        # Verify that message can be retrieved
-        self.assertTrue(msglist['show_version'])
-        self.assertFalse(msglist['foobar'])
-
-        # Test duplicate
-        self.assertRaises(ValueError, msglist.add_message, p[0], p[1:])
-
-        # Look at return tuple
-        self.assertTrue(msglist.ret_tup('show_version'))
-
-    def test_adding_new_message_object_with_array(self):
-        p = json.loads(TestPAPI.ip_address_details_msg)
-        msglist = VPP(testmode=True)
-        msglist.add_message(p[0], p[1:])
-
-        self.assertTrue(msglist['ip_address_details'])
-
-    def test_message_to_bytes(self):
-        msglist = VPP(testmode=True)
-        p = json.loads(TestPAPI.show_version_msg)
-        msgdef = msglist.add_message(p[0], p[1:])
-
-        # Give me a byte string for given message and given arguments
-
-        b = msglist.encode(msgdef, {'_vl_msg_id' : 50, 'context' : 123 })
-        self.assertEqual(10, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(rv._0, 50)
-        self.assertEqual(rv.context, 123)
-
-
-        p = json.loads(TestPAPI.ip_address_details_msg)
-        msgdef = msglist.add_message(p[0], p[1:])
-
-        # Give me a byte string for given message and given arguments
-        b = msglist.encode(msgdef, {'_vl_msg_id' : 50, 'context' : 123,
-                                    'ip' : b'\xf0\xf1\xf2',
-                                    'prefix_length' :  12})
-        self.assertEqual(27, len(b))
-        rv = msglist.decode(msgdef, b)
-
-        self.assertEqual(rv.context, 123)
-        self.assertEqual(rv.ip, b'\xf0\xf1\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
-        self.assertEqual(rv.prefix_length, 12)
-
-        p = json.loads(TestPAPI.cli_inband_msg)
-        msgdef = msglist.add_message(p[0], p[1:])
-
-        # Give me a byte string for given message and given arguments
-        b = msglist.encode(msgdef, { '_vl_msg_id' : 50, 'context' : 123,
-                                     'length' : 20, 'cmd' : 'show version verbose'})
-        self.assertEqual(34, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(rv._0, 50)
-        self.assertEqual(rv.context, 123)
-        self.assertEqual(rv.cmd.decode('ascii'), 'show version verbose')
-
-        variable_array_16_msg = '''["variable_array_16",
-            ["u32", "length"],
-            ["u16", "list", 0, "length"]
-        ]'''
-
-        p = json.loads(variable_array_16_msg)
-        msgdef = msglist.add_message(p[0], p[1:])
-
-        # Give me a byte string for given message and given arguments
-        b = msglist.encode(msgdef, { 'list' : [1, 2], 'length' :2})
-        self.assertEqual(8, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(2, rv.length)
-        self.assertEqual([1,2], rv.list)
-
-    def test_add_new_types(self):
-        counter_type = '''["ip4_fib_counter",
-            ["u32", "address"],
-            ["u8", "address_length"],
-            ["u64", "packets"],
-            ["u64", "bytes"],
-            {"crc" : "0xb2739495"}
-        ]'''
-
-        with_type_msg = '''["with_type_msg",
-            ["u32", "length"],
-            ["u16", "list", 0, "length"],
-            ["vl_api_ip4_fib_counter_t", "counter"]
-        ]'''
-
-        # Add new type
-        msglist = VPP(testmode=True)
-        p = json.loads(counter_type)
-        msglist.add_type(p[0], p[1:])
-        p = json.loads(with_type_msg)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length' : 2, 'list' : [1,2],
-                           'counter' : { 'address' : 4, 'address_length' : 12,
-                                       'packets': 1235, 'bytes' : 5678}})
-        self.assertEqual(29, len(b)) # feil
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(2, rv.length)
-        self.assertEqual(5678, rv.counter.bytes)
-
-    def test_add_new_compound_type_with_array(self):
-        counter_type = '''["ip4_fib_counter",
-            ["u32", "address"],
-            ["u8", "address_length"],
-            ["u64", "packets"],
-            ["u64", "bytes"],
-            {"crc" : "0xb2739495"}
-        ]'''
-
-        with_type_msg = '''["with_type_msg",
-            ["u32", "length"],
-            ["u16", "list", 0, "length"],
-            ["vl_api_ip4_fib_counter_t", "counter", 2]
-
-        ]'''
-
-        # Add new type
-        msglist = VPP(testmode=True)
-        p = json.loads(counter_type)
-        msglist.add_type(p[0], p[1:])
-        p = json.loads(with_type_msg)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length' : 2, 'list' : [1,2],
-                           'counter' : [{ 'address' : 4, 'address_length' : 12,
-                                        'packets': 1235, 'bytes' : 5678},
-                                      { 'address' : 111, 'address_length' : 222,
-                                        'packets': 333, 'bytes' : 444}]})
-        self.assertEqual(50, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual([1,2], rv.list)
-        self.assertEqual(1235, rv.counter[0].packets)
-
-        with_type_variable_msg = '''["with_type_variable_msg",
-            ["u32", "length"],
-            ["vl_api_ip4_fib_counter_t", "counter", 0, "length"]
-
-        ]'''
-
-        p = json.loads(with_type_variable_msg)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length' : 2,
-                           'counter' : [{ 'address' : 4, 'address_length' : 12,
-                                        'packets': 1235, 'bytes' : 5678},
-                                      { 'address' : 111, 'address_length' : 222,
-                                        'packets': 333, 'bytes' : 444}]})
-        self.assertEqual(46, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(2, rv.length)
-        self.assertEqual(1235, rv.counter[0].packets)
-        self.assertEqual(333, rv.counter[1].packets)
-
-    def test_simple_array(self):
-        msglist = VPP(testmode=True)
-
-        simple_byte_array = '''["simple_byte_array",
-            ["u32", "length"],
-            ["u8", "namecommand", 64]
-
-        ]'''
-        p = json.loads(simple_byte_array)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length': 2, 'namecommand': 'foobar'})
-        self.assertEqual(68, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(2, rv.length)
-
-        simple_array = '''["simple_array",
-            ["u32", "length"],
-            ["u32", "list", 2]
-
-        ]'''
-        p = json.loads(simple_array)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length': 2, 'list': [1,2]})
-        self.assertEqual(12, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(2, rv.length)
-        self.assertEqual([1,2], rv.list)
-
-        simple_variable_array = '''["simple_variable_array",
-            ["u32", "length"],
-            ["u32", "list", 0, "length"]
-
-        ]'''
-        p = json.loads(simple_variable_array)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length':2, 'list': [1,2]})
-        self.assertEqual(12, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(2, rv.length)
-        self.assertEqual([1,2], rv.list)
-
-        simple_variable_byte_array = '''["simple_variable_byte_array",
-            ["u32", "length"],
-            ["u8", "list", 0, "length"]
-        ]'''
-        p = json.loads(simple_variable_byte_array)
-        msgdef =msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length': 6, 'list' : 'foobar'})
-        self.assertEqual(10, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(6, rv.length)
-        self.assertEqual('foobar', rv.list)
-
-    def test_old_vla_array(self):
-        msglist = VPP(testmode = True)
-
-        # VLA
-        vla_byte_array = '''["vla_byte_array",
-            ["u32", "foobar"],
-            ["u32", "list", 2],
-            ["u32", "propercount"],
-            ["u8", "propermask", 0, "propercount"],
-            ["u8", "oldmask", 0],
-            {"crc" : "0xb2739495"}
-        ]'''
-        p = json.loads(vla_byte_array)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'list' : [123, 456], 'oldmask': b'foobar',
-                                    'propercount' : 2,
-                                    'propermask' : [8,9]})
-        self.assertEqual(24, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(b'foobar', rv.oldmask)
-
-    def test_old_vla_array_not_last_member(self):
-        msglist = VPP(testmode = True)
-
-        # VLA
-        vla_byte_array = '''["vla_byte_array",
-            ["u8", "oldmask", 0],
-            ["u32", "foobar"],
-            {"crc" : "0xb2739495"}
-        ]'''
-        p = json.loads(vla_byte_array)
-        self.assertRaises(ValueError, msglist.add_message, p[0], p[1:])
-
-    def test_old_vla_array_u32(self):
-        msglist = VPP(testmode = True)
-
-        # VLA
-        vla_byte_array = '''["vla_byte_array",
-            ["u32", "foobar"],
-            ["u32", "oldmask", 0],
-            {"crc" : "0xb2739495"}
-        ]'''
-        p = json.loads(vla_byte_array)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'foobar' : 123, 'oldmask': [123, 456, 789]})
-        self.assertEqual(16, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual([123, 456, 789], rv.oldmask)
-
-    def test_old_vla_array_compound(self):
-        msglist = VPP(testmode = True)
-
-        # VLA
-        counter_type = '''["ip4_fib_counter",
-            ["u32", "address"],
-            ["u8", "address_length"],
-            ["u64", "packets"],
-            ["u64", "bytes"],
-            {"crc" : "0xb2739495"}
-        ]'''
-
-        vla_byte_array = '''["vla_byte_array",
-            ["vl_api_ip4_fib_counter_t", "counter", 0],
-            {"crc" : "0xb2739495"}
-        ]'''
-
-        p = json.loads(counter_type)
-        msglist.add_type(p[0], p[1:])
-
-        p = json.loads(vla_byte_array)
-        with self.assertRaises(NotImplementedError):
-            msgdef = msglist.add_message(p[0], p[1:])
-
-    def test_array_count_not_previous(self):
-        msglist = VPP(testmode = True)
-
-        # VLA
-        vla_byte_array = '''["vla_byte_array",
-            ["u32", "count"],
-            ["u32", "filler"],
-            ["u32", "lst", 0, "count"],
-            {"crc" : "0xb2739495"}
-        ]'''
-
-        p = json.loads(vla_byte_array)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'count': 3, 'lst': [1,2,3], 'filler' : 1 })
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(rv.lst, [1,2,3])
-
-    def test_argument_name(self):
-        msglist = VPP(testmode=True)
-
-
-        simple_name = '''["simple_name",
-            ["u32", "length"],
-            ["u8", "name"]
-        ]'''
-        p = json.loads(simple_name)
-        msgdef = msglist.add_message(p[0], p[1:])
-        b = msglist.encode(msgdef, {'length': 6, 'name': 1})
-        self.assertEqual(5, len(b))
-        rv = msglist.decode(msgdef, b)
-        self.assertEqual(6, rv.length)
-        self.assertEqual(1, rv.name)
-
-class TestConnectedPAPI(unittest.TestCase):
-    def test_request_reply_function(self):
-        vpp = VPP(jsonfiles)
-
-        vpp.connect('test_vpp_papi2')
-
-        rv = vpp.show_version()
-        self.assertEqual(0, rv.retval)
-        self.assertEqual('vpe', rv.program.decode().rstrip('\0x00'))
-        vpp.disconnect()
-
-
-    def test_dump_details_function(self):
-        vpp = VPP(jsonfiles)
-        vpp.connect('test_vpp_papi3')
-
-        rv = vpp.sw_interface_dump()
-        #self.assertEqual(0, rv.retval)
-        print('RV', rv)
-        vpp.disconnect()
-
-    def test_vla(self):
-        vpp = VPP(jsonfiles)
-
-        vpp.connect('test_vpp_papi3')
-
-        cmd = 'show version verbose'
-        rv = vpp.cli_inband(length=len(cmd), cmd=cmd)
-        self.assertEqual(0, rv.retval)
-        print('RV', rv.reply)
-
-        cmd = 'show vlib graph'
-        rv = vpp.cli_inband(length=len(cmd), cmd=cmd)
-        self.assertEqual(0, rv.retval)
-        print('RV', rv.reply)
-        vpp.disconnect()
-
-    def test_events(self):
-        vpp = VPP(jsonfiles)
-
-        vpp.connect('test_vpp_papi3')
-
-        vpp.register_event_callback(event_handler)
-
-        rv = vpp.want_interface_events(enable_disable = True)
-        self.assertEqual(0, rv.retval)
-        print('RV', rv)
-
-        rv = vpp.create_loopback()
-        print('RV', rv)
-        self.assertEqual(0, rv.retval)
-
-        rv = vpp.sw_interface_set_flags(sw_if_index = 1, admin_up_down = 1)
-        print('RV', rv)
-        self.assertEqual(0, rv.retval)
-        rv = vpp.sw_interface_set_flags(sw_if_index = 1, admin_up_down = 0)
-        print('RV', rv)
-        self.assertEqual(0, rv.retval)
-        self.assertEqual(papi_event.wait(10), True)
-
-        vpp.disconnect()
-
-def event_handler(msgname, result):
-    print('IN EVENT HANDLER:', msgname, result)
-    papi_event.set()
-
-class TestACL(unittest.TestCase):
-    def test_acl_create(self):
-        vpp = VPP(jsonfiles)
-
-        vpp.connect('acl-test')
-
-        rv = vpp.acl_plugin_get_version()
-        print('RV', rv)
-        self.assertEqual(rv.major, 1)
-        self.assertEqual(rv.minor, 1)
-
-        rv = vpp.acl_add_replace(acl_index = 0xFFFFFFFF,
-            r = [{
-                "is_permit" : 1,
-                "is_ipv6" : 0,
-                "proto" : 6,
-                "srcport_or_icmptype_first" : 80,
-                }],
-            count = 1)
-        print ('RV', rv)
-        rv = vpp.acl_add_replace(acl_index = 0xFFFFFFFF,
-            r = [{
-                "is_permit" : 1,
-                "is_ipv6" : 0,
-                "proto" : 6,
-                "srcport_or_icmptype_first" : 81,
-                }],
-            count = 1)
-        self.assertEqual(rv.retval, 0)
-        print ('RV', rv)
-        ai = rv.acl_index
-        rv = vpp.acl_dump()
-        print ('RV', rv)
-
-        #rv = vpp.acl_del(acl_index = ai)
-        #self.assertEqual(rv.retval, 0)
-
-        #rv = vpp.acl_dump()
-        #self.assertEqual([], vpp.acl_dump())
-
-        vpp.disconnect()
-
-    def test_status(self):
-        vpp = VPP(jsonfiles)
-        vpp.status()
-
-    def test_acl_interface_get(self):
-        vpp = VPP(jsonfiles)
-
-        vpp.connect('test_vpp_papi2')
-
-        rv = vpp.macip_acl_interface_get()
-
-        print('RV', rv)
-
-        vpp.disconnect()
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/src/vpp-api/python/tests/test_vpp_serializer.py b/src/vpp-api/python/tests/test_vpp_serializer.py
new file mode 100755
index 00000000000..0c194b46d22
--- /dev/null
+++ b/src/vpp-api/python/tests/test_vpp_serializer.py
@@ -0,0 +1,226 @@
+#!/usr/bin/env python
+
+import unittest
+from vpp_papi.vpp_serializer import VPPType, VPPEnumType
+from vpp_papi.vpp_serializer import VPPUnionType, VPPMessage
+from socket import inet_pton, AF_INET, AF_INET6
+import logging
+import sys
+
+
+class TestAddType(unittest.TestCase):
+
+    def test_union(self):
+        un = VPPUnionType('test_union',
+                          [['u8', 'is_bool'],
+                           ['u32', 'is_int']])
+
+        b = un.pack({'is_int': 0x1234})
+        self.assertEqual(len(b), 4)
+        nt = un.unpack(b)
+        self.assertEqual(nt.is_bool, 52)
+        self.assertEqual(nt.is_int, 0x1234)
+
+    def test_address(self):
+        af = VPPEnumType('vl_api_address_family_t', [["ADDRESS_IP4", 0],
+                                                     ["ADDRESS_IP6", 1],
+                                                     {"enumtype": "u32"}])
+        ip4 = VPPType('vl_api_ip4_address_t', [['u8', 'address', 4]])
+        ip6 = VPPType('vl_api_ip6_address_t', [['u8', 'address', 16]])
+        VPPUnionType('vl_api_address_union_t',
+                     [["vl_api_ip4_address_t", "ip4"],
+                      ["vl_api_ip6_address_t", "ip6"]])
+
+        address = VPPType('address', [['vl_api_address_family_t', 'af'],
+                                      ['vl_api_address_union_t', 'un']])
+
+        b = ip4.pack({'address': inet_pton(AF_INET, '1.1.1.1')})
+        self.assertEqual(len(b), 4)
+        nt = ip4.unpack(b)
+        self.assertEqual(nt.address, inet_pton(AF_INET, '1.1.1.1'))
+
+        b = ip6.pack({'address': inet_pton(AF_INET6, '1::1')})
+        self.assertEqual(len(b), 16)
+
+        b = address.pack({'af': af.ADDRESS_IP4,
+                          'un':
+                          {'ip4':
+                           {'address': inet_pton(AF_INET, '2.2.2.2')}}})
+        self.assertEqual(len(b), 20)
+
+        nt = address.unpack(b)
+        self.assertEqual(nt.af, af.ADDRESS_IP4)
+        self.assertEqual(nt.un.ip4.address,
+                         inet_pton(AF_INET, '2.2.2.2'))
+        self.assertEqual(nt.un.ip6.address,
+                         inet_pton(AF_INET6, '::0202:0202'))
+
+    def test_arrays(self):
+        # Test cases
+        # 1. Fixed list
+        # 2. Fixed list of variable length sub type
+        # 3. Variable length type
+        #
+        ip4 = VPPType('ip4_address', [['u8', 'address', 4]])
+        listip4 = VPPType('list_ip4_t', [['ip4_address', 'addresses', 4]])
+        valistip4 = VPPType('list_ip4_t',
+                            [['u8', 'count'],
+                             ['ip4_address', 'addresses', 0, 'count']])
+
+        valistip4_legacy = VPPType('list_ip4_t',
+                                   [['u8', 'foo'],
+                                    ['ip4_address', 'addresses', 0]])
+
+        addresses = []
+        for i in range(4):
+            addresses.append({'address': inet_pton(AF_INET, '2.2.2.2')})
+        b = listip4.pack({'addresses': addresses})
+        self.assertEqual(len(b), 16)
+        nt = listip4.unpack(b)
+
+        self.assertEqual(nt.addresses[0].address,
+                         inet_pton(AF_INET, '2.2.2.2'))
+
+        b = valistip4.pack({'count': len(addresses), 'addresses': addresses})
+        self.assertEqual(len(b), 17)
+
+        nt = valistip4.unpack(b)
+        self.assertEqual(nt.count, 4)
+        self.assertEqual(nt.addresses[0].address,
+                         inet_pton(AF_INET, '2.2.2.2'))
+
+        b = valistip4_legacy.pack({'foo': 1, 'addresses': addresses})
+        self.assertEqual(len(b), 17)
+        nt = valistip4_legacy.unpack(b)
+        self.assertEqual(len(nt.addresses), 4)
+        self.assertEqual(nt.addresses[0].address,
+                         inet_pton(AF_INET, '2.2.2.2'))
+
+    def test_message(self):
+        foo = VPPMessage('foo', [['u16', '_vl_msg_id'],
+                                 ['u8', 'client_index'],
+                                 ['u8', 'something'],
+                                 {"crc": "0x559b9f3c"}])
+        b = foo.pack({'_vl_msg_id': 1, 'client_index': 5,
+                      'something': 200})
+        self.assertEqual(len(b), 4)
+        nt = foo.unpack(b)
+        self.assertEqual(nt.something, 200)
+
+    def test_abf(self):
+
+        fib_mpls_label = VPPType('vl_api_fib_mpls_label_t',
+                                 [['u8', 'is_uniform'],
+                                  ['u32', 'label'],
+                                  ['u8', 'ttl'],
+                                  ['u8', 'exp']])
+
+        label_stack = {'is_uniform': 0,
+                       'label': 0,
+                       'ttl': 0,
+                       'exp': 0}
+
+        b = fib_mpls_label.pack(label_stack)
+        self.assertEqual(len(b), 7)
+
+        fib_path = VPPType('vl_api_fib_path_t',
+                           [['u32', 'sw_if_index'],
+                            ['u32', 'table_id'],
+                            ['u8', 'weight'],
+                            ['u8', 'preference'],
+                            ['u8', 'is_local'],
+                            ['u8', 'is_drop'],
+                            ['u8', 'is_udp_encap'],
+                            ['u8', 'is_unreach'],
+                            ['u8', 'is_prohibit'],
+                            ['u8', 'is_resolve_host'],
+                            ['u8', 'is_resolve_attached'],
+                            ['u8', 'is_dvr'],
+                            ['u8', 'is_source_lookup'],
+                            ['u8', 'afi'],
+                            ['u8', 'next_hop', 16],
+                            ['u32', 'next_hop_id'],
+                            ['u32', 'rpf_id'],
+                            ['u32', 'via_label'],
+                            ['u8', 'n_labels'],
+                            ['vl_api_fib_mpls_label_t', 'label_stack', 16]])
+        label_stack_list = []
+        for i in range(16):
+            label_stack_list.append(label_stack)
+
+        paths = {'is_udp_encap': 0,
+                 'next_hop': b'\x10\x02\x02\xac',
+                 'table_id': 0,
+                 'afi': 0,
+                 'weight': 1,
+                 'next_hop_id': 4294967295,
+                 'label_stack': label_stack_list,
+                 'n_labels': 0,
+                 'sw_if_index': 4294967295,
+                 'preference': 0}
+
+        b = fib_path.pack(paths)
+        self.assertEqual(len(b), (7*16) + 49)
+
+        abf_policy = VPPType('vl_api_abf_policy_t',
+                             [['u32', 'policy_id'],
+                              ['u32', 'acl_index'],
+                              ['u8', 'n_paths'],
+                              ['vl_api_fib_path_t', 'paths', 0, 'n_paths']])
+
+        policy = {
+            'n_paths': 1,
+            'paths': [paths],
+            'acl_index': 0,
+            'policy_id': 10}
+
+        b = abf_policy.pack(policy)
+        self.assertEqual(len(b), (7*16) + 49 + 9)
+
+        abf_policy_add_del = VPPMessage('abf_policy_add_del',
+                                        [['u16', '_vl_msg_id'],
+                                         ['u32', 'client_index'],
+                                         ['u32', 'context'],
+                                         ['u8', 'is_add'],
+                                         ['vl_api_abf_policy_t', 'policy']])
+
+        b = abf_policy_add_del.pack({'is_add': 1,
+                                     'context': 66,
+                                     '_vl_msg_id': 1066,
+                                     'policy': policy})
+
+        nt = abf_policy_add_del.unpack(b)
+        self.assertEqual(nt.policy.paths[0].next_hop,
+                         b'\x10\x02\x02\xac\x00\x00\x00\x00'
+                         b'\x00\x00\x00\x00\x00\x00\x00\x00')
+
+    def test_bier(self):
+
+        bier_table_id = VPPType('vl_api_bier_table_id_t',
+                                [['u8', 'bt_set'],
+                                 ['u8', 'bt_sub_domain'],
+                                 ['u8', 'bt_hdr_len_id']])
+
+        bier_imp_add = VPPMessage('bier_imp_add',
+                                  [['u32', 'client_index'],
+                                   ['u32', 'context'],
+                                   ['vl_api_bier_table_id_t', 'bi_tbl_id'],
+                                   ['u16', 'bi_src'],
+                                   ['u8', 'bi_n_bytes'],
+                                   ['u8', 'bi_bytes', 0, 'bi_n_bytes']])
+
+        table_id = {'bt_set': 0,
+                    'bt_sub_domain': 0,
+                    'bt_hdr_len_id': 0}
+
+        bibytes = b'foobar'
+
+        b = bier_imp_add.pack({'bi_tbl_id': table_id,
+                               'bi_n_bytes': len(bibytes),
+                               'bi_bytes': bibytes})
+
+        self.assertEqual(len(b), 20)
+
+
+if __name__ == '__main__':
+    unittest.main()