diff --git a/lang_python.py b/lang_python.py
index 4d64e8d..396b524 100644
--- a/lang_python.py
+++ b/lang_python.py
@@ -45,8 +45,8 @@
                 const.py        # OpenFlow constants
                 message.py      # Message classes
                 util.py         # Utility functions
-            of12: ...
             of13: ...
+                oxm.py          # OXM classes
 
 The user will add the pyloxi directory to PYTHONPATH. Then they can
 "import loxi" or "import loxi.of10". The idiomatic import is
@@ -65,12 +65,17 @@
     1: "of10",
     2: "of11",
     3: "of12",
-    4: "of13"
+    4: "of13",
 }
 
 prefix = 'pyloxi/loxi'
 
-modules = ["action", "common", "const", "message", "util"]
+modules = {
+    1: ["action", "common", "const", "message", "util"],
+    2: ["action", "common", "const", "message", "util"],
+    3: ["action", "common", "const", "message", "oxm", "util"],
+    4: ["action", "common", "const", "message", "oxm", "util"],
+}
 
 def make_gen(name, version):
     fn = getattr(py_gen.codegen, "generate_" + name)
@@ -86,6 +91,6 @@
 
 for version, subdir in versions.items():
     targets['%s/%s/__init__.py' % (prefix, subdir)] = make_gen('init', version)
-    for module in modules:
+    for module in modules[version]:
         filename = '%s/%s/%s.py' % (prefix, subdir, module)
         targets[filename] = make_gen(module, version)
diff --git a/loxi_front_end/translation.py b/loxi_front_end/translation.py
index 9ffc210..c889a5f 100644
--- a/loxi_front_end/translation.py
+++ b/loxi_front_end/translation.py
@@ -116,6 +116,7 @@
         dict(OFPMP_ = "OF_MULTIPART_"),
         dict(OFPMPF_ = "OF_MULTIPART_FLAG_"),
         dict(OFPTFPT_ = "OF_TABLE_FEATURE_"),
+        dict(OFPHET = "OF_HELLO_ELEM_TYPE_"),
         dict(NX_ROLE_ = "OF_NICIRA_CONTROLLER_ROLE_"),
         ]
 
diff --git a/openflow_input/standard-1.3 b/openflow_input/standard-1.3
index bf7503b..591e254 100644
--- a/openflow_input/standard-1.3
+++ b/openflow_input/standard-1.3
@@ -544,6 +544,10 @@
     OFPCR_ROLE_SLAVE = 3,
 };
 
+enum ofp_hello_elem_type {
+    OFPHET_VERSIONBITMAP = 1,
+};
+
 struct ofp_header {
     uint8_t version;
     uint8_t type;
diff --git a/py_gen/codegen.py b/py_gen/codegen.py
index 67529e0..9765815 100644
--- a/py_gen/codegen.py
+++ b/py_gen/codegen.py
@@ -68,13 +68,24 @@
             type_values['subtype'] = type_maps.extension_action_to_subtype(cls, version)
     elif utils.class_is_queue_prop(cls):
         type_values['type'] = util.constant_for_value(version, "ofp_queue_properties", util.primary_wire_type(cls, version))
+    elif utils.class_is_hello_elem(cls):
+        type_values['type'] = util.constant_for_value(version, "ofp_hello_elem_type", util.primary_wire_type(cls, version))
+    elif utils.class_is_oxm(cls):
+        oxm_class = 0x8000
+        oxm_type = util.primary_wire_type(cls, version)
+        oxm_masked = cls.find('masked') != -1 and 1 or 0
+        oxm_len = of_g.base_length[(cls, version)]
+        type_values['type_len'] = '%#x' % (oxm_class << 16 | oxm_type << 8 | \
+                                           oxm_masked << 8 | oxm_len)
 
     return type_values
 
 # Create intermediate representation
 def build_ofclasses(version):
     blacklist = ["of_action", "of_action_header", "of_header", "of_queue_prop",
-                 "of_queue_prop_header", "of_experimenter", "of_action_experimenter"]
+                 "of_queue_prop_header", "of_experimenter", "of_action_experimenter",
+                 "of_oxm", "of_oxm_header", "of_oxm_experimenter_header",
+                 "of_hello_elem", "of_hello_elem_header"]
     ofclasses = []
     for cls in of_g.standard_class_order:
         if version not in of_g.unified[cls] or cls in blacklist:
@@ -84,6 +95,8 @@
         # Name for the generated Python class
         if utils.class_is_action(cls):
             pyname = cls[10:]
+        elif utils.class_is_oxm(cls):
+            pyname = cls[7:]
         else:
             pyname = cls[3:]
 
@@ -130,19 +143,25 @@
     return ofclasses
 
 def generate_init(out, name, version):
-    util.render_template(out, 'init.py')
+    util.render_template(out, 'init.py', version=version)
 
 def generate_action(out, name, version):
     ofclasses = [x for x in build_ofclasses(version)
                  if utils.class_is_action(x.name)]
-    util.render_template(out, 'action.py', ofclasses=ofclasses)
+    util.render_template(out, 'action.py', ofclasses=ofclasses, version=version)
+
+def generate_oxm(out, name, version):
+    ofclasses = [x for x in build_ofclasses(version)
+                 if utils.class_is_oxm(x.name)]
+    util.render_template(out, 'oxm.py', ofclasses=ofclasses, version=version)
 
 def generate_common(out, name, version):
     ofclasses = [x for x in build_ofclasses(version)
                  if not utils.class_is_message(x.name)
                     and not utils.class_is_action(x.name)
+                    and not utils.class_is_oxm(x.name)
                     and not utils.class_is_list(x.name)]
-    util.render_template(out, 'common.py', ofclasses=ofclasses)
+    util.render_template(out, 'common.py', ofclasses=ofclasses, version=version)
 
 def generate_const(out, name, version):
     groups = {}
diff --git a/py_gen/oftype.py b/py_gen/oftype.py
index ee5040c..481321c 100644
--- a/py_gen/oftype.py
+++ b/py_gen/oftype.py
@@ -51,6 +51,8 @@
             v = "0"
         elif self.base == 'of_mac_addr_t':
             v = '[0,0,0,0,0,0]'
+        elif self.base == 'of_ipv6_t':
+            v = repr('\x00' * 16)
         elif self.base == 'of_wc_bmap_t':
             v = 'const.OFPFW_ALL'
         elif self.base in ['of_octets_t', 'of_port_name_t', 'of_table_name_t',
@@ -80,6 +82,8 @@
             return '"".join([x.pack() for x in %s])' % expr_expr
         elif self.base == 'of_mac_addr_t':
             return 'struct.pack("!6B", *%s)' % expr_expr
+        elif self.base == 'of_ipv6_t':
+            return 'struct.pack("!16s", %s)' % expr_expr
         elif self.base in ['of_match_t', 'of_port_desc_t']:
             return '%s.pack()' % expr_expr
         elif self.base == 'of_port_name_t':
@@ -104,6 +108,8 @@
             return "%s[%s:]" % (buf_expr, offset_expr)
         elif self.base == 'of_mac_addr_t':
             return "list(struct.unpack_from('!6B', %s, %s))" % (buf_expr, offset_expr)
+        elif self.base == 'of_ipv6_t':
+            return "struct.unpack_from('!16s', %s, %s)[0]" % (buf_expr, offset_expr)
         elif self.base == 'of_match_t':
             return 'common.match.unpack(buffer(%s, %s))' % (buf_expr, offset_expr)
         elif self.base == 'of_port_desc_t':
@@ -116,6 +122,8 @@
             return 'common.unpack_list_queue_prop(buffer(%s, %s))' % (buf_expr, offset_expr)
         elif self.base == 'of_list_packet_queue_t':
             return 'common.unpack_list_packet_queue(buffer(%s, %s))' % (buf_expr, offset_expr)
+        elif self.base == 'of_list_hello_elem_t':
+            return 'common.unpack_list_hello_elem(buffer(%s, %s))' % (buf_expr, offset_expr)
         elif self.base == 'of_port_name_t':
             return self._gen_string_unpack_expr(16, buf_expr, offset_expr)
         elif self.base == 'of_table_name_t' or self.base == 'of_serial_num_t':
diff --git a/py_gen/templates/action.py b/py_gen/templates/action.py
index 089cc53..8462dfd 100644
--- a/py_gen/templates/action.py
+++ b/py_gen/templates/action.py
@@ -26,6 +26,7 @@
 :: # under the EPL.
 ::
 :: import itertools
+:: import of_g
 :: include('_copyright.py')
 
 :: include('_autogen.py')
@@ -54,7 +55,11 @@
 
 :: #endfor
 
+:: if version == of_g.VERSION_1_0:
 def parse_vendor(buf):
+:: else:
+def parse_experimenter(buf):
+:: #endif
     if len(buf) < 16:
         raise loxi.ProtocolError("experimenter action too short")
 
diff --git a/py_gen/templates/common.py b/py_gen/templates/common.py
index c9af309..2f9310e 100644
--- a/py_gen/templates/common.py
+++ b/py_gen/templates/common.py
@@ -53,9 +53,23 @@
 def unpack_list_packet_queue(buf):
     return util.unpack_list(packet_queue.unpack, "!4xH", buf)
 
+def unpack_list_hello_elem(buf):
+    def deserializer(buf):
+        type, = struct.unpack_from("!H", buf)
+        if type == const.OFPHET_VERSIONBITMAP:
+            return hello_elem_versionbitmap.unpack(buf)
+        else:
+            return None
+    return [x for x in util.unpack_list(deserializer, "!2xH", buf) if x != None]
+
 :: for ofclass in ofclasses:
 :: include('_ofclass.py', ofclass=ofclass, superclass="object")
 
 :: #endfor
 
+:: if version == 1:
 match = match_v1
+:: elif version == 4:
+:: # HACK
+match = match_v3
+:: #endif
diff --git a/py_gen/templates/init.py b/py_gen/templates/init.py
index abc8d70..4a14228 100644
--- a/py_gen/templates/init.py
+++ b/py_gen/templates/init.py
@@ -30,6 +30,9 @@
 :: include('_autogen.py')
 
 import action, common, const, message
+:: if version >= 4:
+import oxm
+:: #endif
 from const import *
 from common import *
 from loxi import ProtocolError
diff --git a/py_gen/templates/message.py b/py_gen/templates/message.py
index 71a2871..69c3fe1 100644
--- a/py_gen/templates/message.py
+++ b/py_gen/templates/message.py
@@ -26,6 +26,7 @@
 :: # under the EPL.
 ::
 :: import itertools
+:: import of_g
 :: include('_copyright.py')
 
 :: include('_autogen.py')
@@ -128,6 +129,7 @@
     else:
         raise loxi.ProtocolError("unexpected flow mod cmd %u" % cmd)
 
+:: if version < of_g.VERSION_1_3:
 def parse_stats_reply(buf):
     if len(buf) < 8 + 2:
         raise loxi.ProtocolError("message too short")
@@ -145,8 +147,31 @@
         return stats_request_parsers[stats_type](buf)
     else:
         raise loxi.ProtocolError("unexpected stats type %u" % stats_type)
+:: else:
+def parse_multipart_reply(buf):
+    if len(buf) < 8 + 2:
+        raise loxi.ProtocolError("message too short")
+    multipart_type, = struct.unpack_from("!H", buf, 8)
+    if multipart_type in multipart_reply_parsers:
+        return multipart_reply_parsers[multipart_type](buf)
+    else:
+        raise loxi.ProtocolError("unexpected multipart type %u" % multipart_type)
 
+def parse_multipart_request(buf):
+    if len(buf) < 8 + 2:
+        raise loxi.ProtocolError("message too short")
+    multipart_type, = struct.unpack_from("!H", buf, 8)
+    if multipart_type in multipart_request_parsers:
+        return multipart_request_parsers[multipart_type](buf)
+    else:
+        raise loxi.ProtocolError("unexpected multipart type %u" % multipart_type)
+:: #endif
+
+:: if version == of_g.VERSION_1_0:
 def parse_vendor(buf):
+:: else:
+def parse_experimenter(buf):
+:: #endif
     if len(buf) < 16:
         raise loxi.ProtocolError("experimenter message too short")
 
@@ -184,6 +209,7 @@
     const.OFPFC_DELETE_STRICT : flow_delete_strict.unpack,
 }
 
+:: if version < of_g.VERSION_1_3:
 stats_reply_parsers = {
     const.OFPST_DESC : desc_stats_reply.unpack,
     const.OFPST_FLOW : flow_stats_reply.unpack,
@@ -203,6 +229,9 @@
     const.OFPST_QUEUE : queue_stats_request.unpack,
     const.OFPST_VENDOR : experimenter_stats_request.unpack,
 }
+:: else:
+
+:: #endif
 
 :: experimenter_ofclasses = [x for x in ofclasses if x.type_members[1].value == 'const.OFPT_VENDOR']
 :: sort_key = lambda x: x.type_members[2].value
diff --git a/py_gen/templates/oxm.py b/py_gen/templates/oxm.py
new file mode 100644
index 0000000..c210874
--- /dev/null
+++ b/py_gen/templates/oxm.py
@@ -0,0 +1,93 @@
+:: # Copyright 2013, Big Switch Networks, Inc.
+:: #
+:: # LoxiGen is licensed under the Eclipse Public License, version 1.0 (EPL), with
+:: # the following special exception:
+:: #
+:: # LOXI Exception
+:: #
+:: # As a special exception to the terms of the EPL, you may distribute libraries
+:: # generated by LoxiGen (LoxiGen Libraries) under the terms of your choice, provided
+:: # that copyright and licensing notices generated by LoxiGen are not altered or removed
+:: # from the LoxiGen Libraries and the notice provided below is (i) included in
+:: # the LoxiGen Libraries, if distributed in source code form and (ii) included in any
+:: # documentation for the LoxiGen Libraries, if distributed in binary form.
+:: #
+:: # Notice: "Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler."
+:: #
+:: # You may not use this file except in compliance with the EPL or LOXI Exception. You may obtain
+:: # a copy of the EPL at:
+:: #
+:: # http://www.eclipse.org/legal/epl-v10.html
+:: #
+:: # Unless required by applicable law or agreed to in writing, software
+:: # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+:: # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+:: # EPL for the specific language governing permissions and limitations
+:: # under the EPL.
+::
+:: import itertools
+:: import of_g
+:: include('_copyright.py')
+
+:: include('_autogen.py')
+
+import struct
+import const
+import util
+import loxi
+
+class OXM(object):
+    type_len = None # override in subclass
+    pass
+
+:: for ofclass in ofclasses:
+:: nonskip_members = [m for m in ofclass.members if not m.skip]
+class ${ofclass.pyname}(OXM):
+:: for m in ofclass.type_members:
+    ${m.name} = ${m.value}
+:: #endfor
+
+    def __init__(self, ${', '.join(["%s=None" % m.name for m in nonskip_members])}):
+:: for m in nonskip_members:
+        if ${m.name} != None:
+            self.${m.name} = ${m.name}
+        else:
+            self.${m.name} = ${m.oftype.gen_init_expr()}
+:: #endfor
+
+    def pack(self):
+        packed = []
+:: include("_pack.py", ofclass=ofclass)
+        return ''.join(packed)
+
+    @staticmethod
+    def unpack(buf):
+        obj = ${ofclass.pyname}()
+:: include("_unpack.py", ofclass=ofclass)
+        return obj
+
+    def __eq__(self, other):
+        if type(self) != type(other): return False
+:: for m in nonskip_members:
+        if self.${m.name} != other.${m.name}: return False
+:: #endfor
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def show(self):
+        import loxi.pp
+        return loxi.pp.pp(self)
+
+    def pretty_print(self, q):
+:: include('_pretty_print.py', ofclass=ofclass)
+
+:: #endfor
+
+parsers = {
+:: key = lambda x: int(x.type_members[0].value, 16)
+:: for ofclass in sorted(ofclasses, key=key):
+    ${key(ofclass)} : ${ofclass.pyname}.unpack,
+:: #endfor
+}
diff --git a/py_gen/tests/of13.py b/py_gen/tests/of13.py
new file mode 100644
index 0000000..68cbb1a
--- /dev/null
+++ b/py_gen/tests/of13.py
@@ -0,0 +1,300 @@
+#!/usr/bin/env python
+# Copyright 2013, Big Switch Networks, Inc.
+#
+# LoxiGen is licensed under the Eclipse Public License, version 1.0 (EPL), with
+# the following special exception:
+#
+# LOXI Exception
+#
+# As a special exception to the terms of the EPL, you may distribute libraries
+# generated by LoxiGen (LoxiGen Libraries) under the terms of your choice, provided
+# that copyright and licensing notices generated by LoxiGen are not altered or removed
+# from the LoxiGen Libraries and the notice provided below is (i) included in
+# the LoxiGen Libraries, if distributed in source code form and (ii) included in any
+# documentation for the LoxiGen Libraries, if distributed in binary form.
+#
+# Notice: "Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler."
+#
+# You may not use this file except in compliance with the EPL or LOXI Exception. You may obtain
+# a copy of the EPL at:
+#
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# EPL for the specific language governing permissions and limitations
+# under the EPL.
+import unittest
+
+try:
+    import loxi.of13 as ofp
+except ImportError:
+    exit("loxi package not found. Try setting PYTHONPATH.")
+
+class TestImports(unittest.TestCase):
+    def test_toplevel(self):
+        import loxi
+        self.assertTrue(hasattr(loxi, "ProtocolError"))
+        ofp = loxi.protocol(4)
+        self.assertEquals(ofp.OFP_VERSION, 4)
+        self.assertTrue(hasattr(ofp, "action"))
+        self.assertTrue(hasattr(ofp, "common"))
+        self.assertTrue(hasattr(ofp, "const"))
+        self.assertTrue(hasattr(ofp, "message"))
+
+    def test_version(self):
+        import loxi
+        self.assertTrue(hasattr(loxi.of13, "ProtocolError"))
+        self.assertTrue(hasattr(loxi.of13, "OFP_VERSION"))
+        self.assertEquals(loxi.of13.OFP_VERSION, 4)
+        self.assertTrue(hasattr(loxi.of13, "action"))
+        self.assertTrue(hasattr(loxi.of13, "common"))
+        self.assertTrue(hasattr(loxi.of13, "const"))
+        self.assertTrue(hasattr(loxi.of13, "message"))
+
+class TestCommon(unittest.TestCase):
+    sample_hello_elem_buf = ''.join([
+        '\x00\x01', # type
+        '\x00\x0c', # length
+        '\x01\x23\x45\x67', # bitmaps[0]
+        '\x89\xab\xcd\xef', # bitmaps[1]
+    ])
+
+    def test_hello_elem_versionbitmap_pack(self):
+        obj = ofp.hello_elem_versionbitmap(bitmaps=[ofp.uint32(0x01234567),ofp.uint32(0x89abcdef)])
+        self.assertEquals(self.sample_hello_elem_buf, obj.pack())
+
+    def test_hello_elem_versionbitmap_unpack(self):
+        obj = ofp.hello_elem_versionbitmap.unpack(self.sample_hello_elem_buf)
+        self.assertEquals(len(obj.bitmaps), 2)
+        self.assertEquals(obj.bitmaps[0], ofp.uint32(0x01234567))
+        self.assertEquals(obj.bitmaps[1], ofp.uint32(0x89abcdef))
+
+    def test_list_hello_elem_unpack(self):
+        buf = ''.join([
+            '\x00\x01\x00\x04', # versionbitmap
+            '\x00\x00\x00\x04', # unknown type
+            '\x00\x01\x00\x04', # versionbitmap
+        ])
+        l = ofp.unpack_list_hello_elem(buf)
+        self.assertEquals(len(l), 2)
+        self.assertTrue(isinstance(l[0], ofp.hello_elem_versionbitmap))
+        self.assertTrue(isinstance(l[1], ofp.hello_elem_versionbitmap))
+
+class TestOXM(unittest.TestCase):
+    def test_oxm_in_phy_port_pack(self):
+        import loxi.of13 as ofp
+        obj = ofp.oxm.in_phy_port(value=42)
+        expected = ''.join([
+            '\x80\x00', # class
+            '\x02', # type/masked
+            '\x08', # length
+            '\x00\x00\x00\x2a' # value
+        ])
+        self.assertEquals(expected, obj.pack())
+
+    def test_oxm_in_phy_port_masked_pack(self):
+        import loxi.of13 as ofp
+        obj = ofp.oxm.in_phy_port_masked(value=42, value_mask=0xaabbccdd)
+        expected = ''.join([
+            '\x80\x00', # class
+            '\x03', # type/masked
+            '\x0c', # length
+            '\x00\x00\x00\x2a', # value
+            '\xaa\xbb\xcc\xdd' # mask
+        ])
+        self.assertEquals(expected, obj.pack())
+
+    def test_oxm_ipv6_dst_pack(self):
+        import loxi.of13 as ofp
+        obj = ofp.oxm.ipv6_dst(value='\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0d\x0f')
+        expected = ''.join([
+            '\x80\x00', # class
+            '\x36', # type/masked
+            '\x14', # length
+            '\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0d\x0f', # value
+        ])
+        self.assertEquals(expected, obj.pack())
+
+class TestAllOF13(unittest.TestCase):
+    """
+    Round-trips every class through serialization/deserialization.
+    Not a replacement for handcoded tests because it only uses the
+    default member values.
+    """
+
+    def setUp(self):
+        mods = [ofp.action,ofp.message,ofp.common,ofp.oxm]
+        self.klasses = [klass for mod in mods
+                              for klass in mod.__dict__.values()
+                              if hasattr(klass, 'show')]
+        self.klasses.sort(key=lambda x: str(x))
+
+    def test_serialization(self):
+        expected_failures = [
+            ofp.common.action_id,
+            ofp.common.action_id_bsn_mirror,
+            ofp.common.action_id_bsn_set_tunnel_dst,
+            ofp.common.action_id_copy_ttl_in,
+            ofp.common.action_id_copy_ttl_out,
+            ofp.common.action_id_dec_mpls_ttl,
+            ofp.common.action_id_dec_nw_ttl,
+            ofp.common.action_id_experimenter,
+            ofp.common.action_id_group,
+            ofp.common.action_id_header,
+            ofp.common.action_id_nicira_dec_ttl,
+            ofp.common.action_id_output,
+            ofp.common.action_id_pop_mpls,
+            ofp.common.action_id_pop_pbb,
+            ofp.common.action_id_pop_vlan,
+            ofp.common.action_id_push_mpls,
+            ofp.common.action_id_push_pbb,
+            ofp.common.action_id_push_vlan,
+            ofp.common.action_id_set_field,
+            ofp.common.action_id_set_mpls_ttl,
+            ofp.common.action_id_set_nw_ttl,
+            ofp.common.action_id_set_queue,
+            ofp.common.flow_stats_entry,
+            ofp.common.group_desc_stats_entry,
+            ofp.common.instruction,
+            ofp.common.instruction_apply_actions,
+            ofp.common.instruction_clear_actions,
+            ofp.common.instruction_experimenter,
+            ofp.common.instruction_goto_table,
+            ofp.common.instruction_header,
+            ofp.common.instruction_meter,
+            ofp.common.instruction_write_actions,
+            ofp.common.instruction_write_metadata,
+            ofp.common.match_v3,
+            ofp.common.meter_band,
+            ofp.common.meter_band_drop,
+            ofp.common.meter_band_dscp_remark,
+            ofp.common.meter_band_experimenter,
+            ofp.common.meter_band_header,
+            ofp.common.table_feature_prop,
+            ofp.common.table_feature_prop_apply_actions,
+            ofp.common.table_feature_prop_apply_actions_miss,
+            ofp.common.table_feature_prop_apply_setfield,
+            ofp.common.table_feature_prop_apply_setfield_miss,
+            ofp.common.table_feature_prop_experimenter,
+            ofp.common.table_feature_prop_header,
+            ofp.common.table_feature_prop_instructions,
+            ofp.common.table_feature_prop_instructions_miss,
+            ofp.common.table_feature_prop_match,
+            ofp.common.table_feature_prop_next_tables,
+            ofp.common.table_feature_prop_next_tables_miss,
+            ofp.common.table_feature_prop_wildcards,
+            ofp.common.table_feature_prop_write_actions,
+            ofp.common.table_feature_prop_write_actions_miss,
+            ofp.common.table_feature_prop_write_setfield,
+            ofp.common.table_feature_prop_write_setfield_miss,
+            ofp.message.aggregate_stats_request,
+            ofp.message.flow_add,
+            ofp.message.flow_delete,
+            ofp.message.flow_delete_strict,
+            ofp.message.flow_modify,
+            ofp.message.flow_modify_strict,
+            ofp.message.flow_removed,
+            ofp.message.flow_stats_request,
+            ofp.message.group_desc_stats_reply,
+            ofp.message.group_mod,
+            ofp.message.group_stats_reply,
+            ofp.message.meter_features_stats_reply,
+            ofp.message.meter_stats_reply,
+            ofp.message.packet_in,
+            ofp.message.table_features_stats_reply,
+            ofp.message.table_features_stats_request,
+        ]
+        for klass in self.klasses:
+            def fn():
+                obj = klass()
+                if hasattr(obj, "xid"): obj.xid = 42
+                buf = obj.pack()
+                obj2 = klass.unpack(buf)
+                self.assertEquals(obj, obj2)
+            if klass in expected_failures:
+                self.assertRaises(Exception, fn)
+            else:
+                fn()
+
+    def test_show(self):
+        expected_failures = [
+            ofp.common.action_id,
+            ofp.common.action_id_bsn_mirror,
+            ofp.common.action_id_bsn_set_tunnel_dst,
+            ofp.common.action_id_copy_ttl_in,
+            ofp.common.action_id_copy_ttl_out,
+            ofp.common.action_id_dec_mpls_ttl,
+            ofp.common.action_id_dec_nw_ttl,
+            ofp.common.action_id_experimenter,
+            ofp.common.action_id_group,
+            ofp.common.action_id_header,
+            ofp.common.action_id_nicira_dec_ttl,
+            ofp.common.action_id_output,
+            ofp.common.action_id_pop_mpls,
+            ofp.common.action_id_pop_pbb,
+            ofp.common.action_id_pop_vlan,
+            ofp.common.action_id_push_mpls,
+            ofp.common.action_id_push_pbb,
+            ofp.common.action_id_push_vlan,
+            ofp.common.action_id_set_field,
+            ofp.common.action_id_set_mpls_ttl,
+            ofp.common.action_id_set_nw_ttl,
+            ofp.common.action_id_set_queue,
+            ofp.common.flow_stats_entry,
+            ofp.common.group_desc_stats_entry,
+            ofp.common.instruction,
+            ofp.common.instruction_apply_actions,
+            ofp.common.instruction_clear_actions,
+            ofp.common.instruction_experimenter,
+            ofp.common.instruction_goto_table,
+            ofp.common.instruction_header,
+            ofp.common.instruction_meter,
+            ofp.common.instruction_write_actions,
+            ofp.common.instruction_write_metadata,
+            ofp.common.match_v3,
+            ofp.common.meter_band,
+            ofp.common.meter_band_drop,
+            ofp.common.meter_band_dscp_remark,
+            ofp.common.meter_band_experimenter,
+            ofp.common.meter_band_header,
+            ofp.common.table_feature_prop,
+            ofp.common.table_feature_prop_apply_actions,
+            ofp.common.table_feature_prop_apply_actions_miss,
+            ofp.common.table_feature_prop_apply_setfield,
+            ofp.common.table_feature_prop_apply_setfield_miss,
+            ofp.common.table_feature_prop_experimenter,
+            ofp.common.table_feature_prop_header,
+            ofp.common.table_feature_prop_instructions,
+            ofp.common.table_feature_prop_instructions_miss,
+            ofp.common.table_feature_prop_match,
+            ofp.common.table_feature_prop_next_tables,
+            ofp.common.table_feature_prop_next_tables_miss,
+            ofp.common.table_feature_prop_wildcards,
+            ofp.common.table_feature_prop_write_actions,
+            ofp.common.table_feature_prop_write_actions_miss,
+            ofp.common.table_feature_prop_write_setfield,
+            ofp.common.table_feature_prop_write_setfield_miss,
+            ofp.message.aggregate_stats_request,
+            ofp.message.flow_add,
+            ofp.message.flow_delete,
+            ofp.message.flow_delete_strict,
+            ofp.message.flow_modify,
+            ofp.message.flow_modify_strict,
+            ofp.message.flow_removed,
+            ofp.message.flow_stats_request,
+            ofp.message.packet_in,
+        ]
+        for klass in self.klasses:
+            def fn():
+                obj = klass()
+                if hasattr(obj, "xid"): obj.xid = 42
+                obj.show()
+            if klass in expected_failures:
+                self.assertRaises(Exception, fn)
+            else:
+                fn()
+
+if __name__ == '__main__':
+    unittest.main()