diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java
index 6e9d047..420f176 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java
@@ -1,5 +1,7 @@
 package org.projectfloodlight.openflow.types;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -8,9 +10,12 @@
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
+import java.util.List;
 
 import org.junit.Test;
 
+import com.google.common.collect.ImmutableList;
+
 /**
  * Most tests are in IPv4AddressTest and IPv6AddressTest
  * Just exception testing here
@@ -92,6 +97,16 @@
     }
 
     @Test
+    public void testToInetAddress() throws Exception {
+        IPAddress<?> ip0 = IPAddress.of("201.202.3.4");
+        IPAddress<?> ip1 = IPAddress.of("2001:db8:abcd::1:2:3:4");
+        InetAddress ia0 = ip0.toInetAddress();
+        InetAddress ia1 = ip1.toInetAddress();
+        assertEquals(ia0, InetAddress.getByName("201.202.3.4"));
+        assertEquals(ia1, InetAddress.getByName("2001:db8:abcd:0:1:2:3:4"));
+    }
+
+    @Test
     public void testContains() {
 
         // Test IPv4 Mask
@@ -131,6 +146,93 @@
     }
 
     @Test
+    public void testIsUnspecified() {
+        IPAddress<?> unspecifiedV4 = IPAddress.of("0.0.0.0");
+        IPAddress<?> unspecifiedV6 = IPAddress.of("::");
+        assertThat(unspecifiedV4.isUnspecified(), is(true));
+        assertThat(unspecifiedV6.isUnspecified(), is(true));
+        List<String> others = ImmutableList.of(
+                "0.0.0.1",
+                "1.2.3.4",
+                "10.0.0.0",
+                "127.0.0.1",
+                "255.255.255.255",
+                "::1",
+                "2001:db8:1:2::5:6",
+                "fc00::4:5:6:7",
+                "fe80::1234",
+                "ff02::1");
+        for (String other : others) {
+            assertThat(IPAddress.of(other).isUnspecified(), is(false));
+        }
+    }
+
+    @Test
+    public void testIsLoopback() {
+        List<String> loopbacks = ImmutableList.of(
+                "127.0.0.0",
+                "127.0.0.1",
+                "127.0.0.2",
+                "127.0.0.255",
+                "127.1.2.3",
+                "127.101.102.103",
+                "127.201.202.203",
+                "127.255.255.255",
+                "::1");
+        for (String loopback : loopbacks) {
+            assertThat(IPAddress.of(loopback).isLoopback(), is(true));
+        }
+        List<String> others = ImmutableList.of(
+                "0.0.0.0",
+                "0.0.0.1",
+                "10.0.0.1",
+                "126.255.255.255",
+                "128.0.0.0",
+                "255.255.255.255",
+                "::",
+                "::2",
+                "2001:db8::1:2:3:4",
+                "fe80:7:6:5:4:3:2:1",
+                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
+        for (String other : others) {
+            assertThat(IPAddress.of(other).isLoopback(), is(false));
+        }
+    }
+
+    @Test
+    public void testIsLinkLocal() {
+        List<String> linkLocals = ImmutableList.of(
+                "169.254.0.0",
+                "169.254.0.1",
+                "169.254.1.2",
+                "169.254.101.102",
+                "169.254.201.202",
+                "169.254.255.255",
+                "fe80::",
+                "fe80::1",
+                "fe80::1:2:3:4:5:6:7",
+                "fe80:aaaa:bbbb:cccc:dddd:eeee:ffff:1234",
+                "febf::",
+                "febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
+        for (String linkLocal : linkLocals) {
+            assertThat(IPAddress.of(linkLocal).isLinkLocal(), is(true));
+        }
+        List<String> others = ImmutableList.of(
+                "0.0.0.0",
+                "1.2.3.4",
+                "169.253.255.255",
+                "169.255.0.0",
+                "255.255.255.255",
+                "::",
+                "fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
+                "fec0::",
+                "ff02::1");
+        for (String other : others) {
+            assertThat(IPAddress.of(other).isLinkLocal(), is(false));
+        }
+    }
+
+    @Test
     public void testMulticastIp() {
         IPAddress<?> ip0 = IPAddress.of("240.2.3.4");
         IPAddress<?> ip1 = IPAddress.of("224.0.1.1");
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java
index 5d95a5a..d0beb12 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java
@@ -8,13 +8,16 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import io.netty.buffer.Unpooled;
 
 import java.net.Inet4Address;
 import java.net.InetAddress;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
 
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -228,6 +231,84 @@
     }
 
     @Test
+    public void testOf4Integers() {
+        Map<IPv4Address, IPv4Address> map = new HashMap<>();
+        map.put(IPv4Address.of(0, 0, 0, 0), IPv4Address.of(0));
+        map.put(IPv4Address.of(1, 2, 3, 4), IPv4Address.of("1.2.3.4"));
+        map.put(IPv4Address.of(6, 7, 8, 9), IPv4Address.of("6.7.8.9"));
+        map.put(IPv4Address.of(10, 1, 2, 3), IPv4Address.of("10.1.2.3"));
+        map.put(IPv4Address.of(10, 201, 202, 203), IPv4Address.of("10.201.202.203"));
+        map.put(IPv4Address.of(192, 168, 0, 101), IPv4Address.of("192.168.0.101"));
+        map.put(IPv4Address.of(211, 212, 213, 214), IPv4Address.of("211.212.213.214"));
+        map.put(IPv4Address.of(255, 255, 255, 255), IPv4Address.of(0xFF_FF_FF_FF));
+        for (Entry<IPv4Address, IPv4Address> entry : map.entrySet()) {
+            assertThat(entry.getKey(), equalTo(entry.getValue()));
+        }
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative1() {
+        IPv4Address.of(-3, 4, 5, 6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative2() {
+        IPv4Address.of(3, -4, 5, 6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative3() {
+        IPv4Address.of(3, 4, -5, 6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative4() {
+        IPv4Address.of(3, 4, 5, -6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative5() {
+        // ((byte) 128) is actually -128
+        IPv4Address.of(101, 102, 103, (byte) 128);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative6() {
+        // ((byte) 255) is actually -1
+        IPv4Address.of(101, 102, 103, (byte) 255);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative7() {
+        IPv4Address.of(-1, -1, -1, -1);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig1() {
+        IPv4Address.of(1000, 2, 3, 4);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig2() {
+        IPv4Address.of(1, 20000, 3, 4);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig3() {
+        IPv4Address.of(1, 2, 300000, 4);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig4() {
+        IPv4Address.of(1, 2, 3, 4000000);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig5() {
+        IPv4Address.of(256, 256, 256, 256);
+    }
+
+    @Test
     public void testOfCidrMaskLength() {
         for (int i = 0; i <= 32; i++) {
             assertEquals(IPv4Address.ofCidrMaskLength(i).asCidrMaskLength(), i);
@@ -307,7 +388,7 @@
     @Test
     public void testReadFrom() throws OFParseError {
         for(int i=0; i < testAddresses.length; i++ ) {
-            IPv4Address ip = IPv4Address.read4Bytes(ChannelBuffers.copiedBuffer(testAddresses[i]));
+            IPv4Address ip = IPv4Address.read4Bytes(Unpooled.copiedBuffer(testAddresses[i]));
             assertEquals(testInts[i], ip.getInt());
             assertArrayEquals(testAddresses[i], ip.getBytes());
             assertEquals(testStrings[i], ip.toString());
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java
index a94f443..d778c1b 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java
@@ -1,6 +1,14 @@
 package org.projectfloodlight.openflow.types;
 
-import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import io.netty.buffer.Unpooled;
 
 import java.net.Inet6Address;
 import java.net.InetAddress;
@@ -8,7 +16,6 @@
 
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -277,7 +284,7 @@
     public void testReadFrom() throws OFParseError, UnknownHostException {
         for(int i=0; i < testStrings.length; i++ ) {
             byte[] bytes = Inet6Address.getByName(testStrings[i]).getAddress();
-            IPv6Address ip = IPv6Address.read16Bytes(ChannelBuffers.copiedBuffer(bytes));
+            IPv6Address ip = IPv6Address.read16Bytes(Unpooled.copiedBuffer(bytes));
             assertEquals(testStrings[i], ip.toString());
             assertArrayEquals(bytes, ip.getBytes());
         }
@@ -314,6 +321,13 @@
         assertEquals("0000:0000:0000:0000:0000:0000:0000:0000", IPv6Address.of("::").toString(false, true));
         assertEquals("1::4:5:6:0:8", IPv6Address.of("1:0:0:4:5:6:0:8").toString(true, false));
         assertEquals("1:0:0:4::8", IPv6Address.of("1:0:0:4:0:0:0:8").toString(true, false));
+        // Two equal length zero runs; should zero compress the first instance
+        assertEquals("1::4:2:0:0:8", IPv6Address.of("1:0:0:4:2:0:0:8").toString(true, false));
+        // Shouldn't zero compress a single zero
+        assertEquals("1:0:2:4:3:1:0:8", IPv6Address.of("1:0:2:4:3:1:0:8").toString(true, false));
+        // Test zero runs at the end of the address since that's a different code path in toString
+        assertEquals("1::4:2:8:0:0", IPv6Address.of("1:0:0:4:2:8:0:0").toString(true, false));
+        assertEquals("1:3:2:4:3:1:5:0", IPv6Address.of("1:3:2:4:3:1:5:0").toString(true, false));
     }
 
     @Test
@@ -427,4 +441,76 @@
         assertEquals("::", IPv6Address.of("::%eth0").toString(true, false));
         assertEquals("1:0:0:4::8", IPv6Address.of("1:0:0:4:0:0:0:8%2").toString(true, false));
     }
+
+    private void testModifiedEui64(
+            String network, String macAddress, String expectedIpAddress) {
+
+        IPv6AddressWithMask networkObj = IPv6AddressWithMask.of(network);
+        MacAddress macAddressObj = MacAddress.of(macAddress);
+        MacAddress macAddressAdd1 = MacAddress.of(
+                macAddressObj.getLong() + 1 & 0xFFFF_FFFF_FFFFL);
+        MacAddress macAddressSub1 = MacAddress.of(
+                macAddressObj.getLong() - 1 & 0xFFFF_FFFF_FFFFL);
+        IPv6Address ipAddressObj = IPv6Address.of(networkObj, macAddressObj);
+        IPv6Address expectedObj = IPv6Address.of(expectedIpAddress);
+
+        assertThat(ipAddressObj, is(expectedObj));
+        assertThat(ipAddressObj.isModifiedEui64Derived(macAddressObj), is(true));
+        assertThat(ipAddressObj.isModifiedEui64Derived(macAddressAdd1), is(false));
+        assertThat(ipAddressObj.isModifiedEui64Derived(macAddressSub1), is(false));
+    }
+
+    @Test
+    public void testModifiedEui64() throws Exception {
+        testModifiedEui64(
+                "fe80::/64", "00:00:00:00:00:00", "fe80::0200:ff:fe00:0");
+        testModifiedEui64(
+                "fe80::/64", "12:34:56:78:9a:bc", "fe80::1034:56ff:fe78:9abc");
+        testModifiedEui64(
+                "fe80::/64", "ff:ff:ff:ff:ff:ff", "fe80::fdff:ffff:feff:ffff");
+        testModifiedEui64(
+                "fe80::/10", "5c:16:c7:12:34:56", "fe80::5e16:c7ff:fe12:3456");
+        testModifiedEui64(
+                "2001:db8:9876:5400::/56", "00:0c:29:ab:cd:ef",
+                "2001:db8:9876:5400:20c:29ff:feab:cdef");
+        testModifiedEui64(
+                "fd00:9999:8888::/48", "52:54:00:78:56:34",
+                "fd00:9999:8888::5054:00ff:fe78:5634");
+        testModifiedEui64(
+                "2001:db8:7777:aabb::/64", "14:10:9f:00:00:cd",
+                "2001:db8:7777:aabb:1610:9fff:fe00:00cd");
+    }
+
+    @Test(expected=NullPointerException.class)
+    public void testModifiedEui64ExceptionNullNetwork() {
+        IPv6Address.of(
+                (IPv6AddressWithMask) null,
+                MacAddress.of("00:50:56:12:34:56"));
+    }
+
+    @Test(expected=NullPointerException.class)
+    public void testModifiedEui64ExceptionNullMacAddress() {
+        IPv6Address.of(
+                IPv6AddressWithMask.LINK_LOCAL_NETWORK,
+                (MacAddress) null);
+    }
+
+    @Test(expected=NullPointerException.class)
+    public void testModifiedEui64ExceptionNullDerivedMacAddress() {
+        IPv6Address.NONE.isModifiedEui64Derived(null);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testModifiedEui64ExceptionPrefixLengthNo() {
+        IPv6Address.of(
+                IPv6Address.of("fef::").withMask(IPv6Address.of("f0f0:1234::")),
+                MacAddress.of("5c:16:c7:00:00:00"));
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testModifiedEui64ExceptionPrefixLengthTooLong() {
+        IPv6Address.of(
+                IPv6AddressWithMask.of("fe80::/65"),
+                MacAddress.of("5c:16:c7:00:00:00"));
+    }
 }
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java
index e1c7721..f201b47 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java
@@ -1,8 +1,9 @@
 package org.projectfloodlight.openflow.types;
 
+import io.netty.buffer.Unpooled;
+
 import java.util.Arrays;
 
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -22,12 +23,18 @@
             {(byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 255 }
     };
 
-    String[] testStrings = {
+    String[] testColonStrings = {
             "01:02:03:04:05:06",
             "80:00:00:00:00:01",
-            "ff:ff:ff:ff:ff:ff"
+            "ff:ff:ff:ff:ff:ff",
     };
 
+    String[] testHyphenStrings = {
+             "01-02-03-04-05-06",
+             "80-00-00-00-00-01",
+             "ff-ff-ff-ff-ff-ff",
+     };
+
     long[] testInts = {
             0x00010203040506L,
             0x00800000000001L,
@@ -43,7 +50,8 @@
             "00:fff:ef:12:12:ff",
             "01:02:03:04:05;06",
             "0:1:2:3:4:5:6",
-            "01:02:03:04"
+            "01:02:03:04",
+            "01-02-03:04-05-06",
     };
 
     byte[][] invalidMacBytes = {
@@ -53,11 +61,15 @@
 
     @Test
     public void testOfString() {
+        testOfStringForArray(testColonStrings);
+        testOfStringForArray(testHyphenStrings);
+    }
+
+    private void testOfStringForArray(String [] strings) {
         for(int i=0; i < testAddresses.length; i++ ) {
-            MacAddress ip = MacAddress.of(testStrings[i]);
+            MacAddress ip = MacAddress.of(strings[i]);
             assertEquals(testInts[i], ip.getLong());
             assertArrayEquals(testAddresses[i], ip.getBytes());
-            assertEquals(testStrings[i], ip.toString());
         }
     }
 
@@ -67,17 +79,17 @@
             MacAddress ip = MacAddress.of(testAddresses[i]);
             assertEquals("error checking long representation of "+Arrays.toString(testAddresses[i]) + "(should be "+Long.toHexString(testInts[i]) +")", testInts[i],  ip.getLong());
             assertArrayEquals(testAddresses[i], ip.getBytes());
-            assertEquals(testStrings[i], ip.toString());
+            assertEquals(testColonStrings[i], ip.toString());
         }
     }
 
     @Test
     public void testReadFrom() throws OFParseError {
         for(int i=0; i < testAddresses.length; i++ ) {
-            MacAddress ip = MacAddress.read6Bytes(ChannelBuffers.copiedBuffer(testAddresses[i]));
+            MacAddress ip = MacAddress.read6Bytes(Unpooled.copiedBuffer(testAddresses[i]));
             assertEquals(testInts[i], ip.getLong());
             assertArrayEquals(testAddresses[i], ip.getBytes());
-            assertEquals(testStrings[i], ip.toString());
+            assertEquals(testColonStrings[i], ip.toString());
         }
     }
 
@@ -156,14 +168,72 @@
     }
 
     @Test
+
+    public void testForIPv4MulticastAddress() {
+        IPv4Address ip = IPv4Address.of("224.1.1.1");
+        MacAddress mac = MacAddress.forIPv4MulticastAddress(ip);
+        MacAddress expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("224.129.1.1");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("225.1.1.1");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("239.129.1.1");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("224.1.2.3");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:02:03");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("239.129.2.3");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:02:03");
+        assertTrue(mac.equals(expectedMac));
+    }
+
     public void testOfDatapathid() {
         MacAddress mac = MacAddress.of(DatapathId.NONE);
         assertThat(mac, is(MacAddress.NONE));
 
-        for (String s : testStrings) {
+        for (String s : testColonStrings) {
             DatapathId dpid = DatapathId.of("00:00:" + s);
             mac = MacAddress.of(dpid);
             assertThat(mac, is(MacAddress.of(s)));
         }
     }
+
+    @Test
+    public void forIPv6MulticastAddr() {
+        IPv6Address ip = IPv6Address.of("ff02::1:ff00:0");
+        MacAddress mac = MacAddress.forIPv6MulticastAddr(ip);
+        MacAddress expectedMac = MacAddress.of("33:33:ff:00:00:00");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv6Address.of("ff02::1:ff01:0203");
+        mac = MacAddress.forIPv6MulticastAddr(ip);
+        expectedMac = MacAddress.of("33:33:ff:01:02:03");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv6Address.of("ff02::1:0102:0304");
+        mac = MacAddress.forIPv6MulticastAddr(ip);
+        expectedMac = MacAddress.of("33:33:01:02:03:04");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv6Address.of("2001::1:0102:0304");
+        try {
+            mac = MacAddress.forIPv6MulticastAddr(ip);
+        } catch(IllegalArgumentException e) {
+                // ok
+        }
+    }
 }
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java
index 9a5a4dc..6d6c545 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java
@@ -2,10 +2,10 @@
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffer;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.protocol.OFFactories;
 import org.projectfloodlight.openflow.protocol.OFFlowAdd;
@@ -60,7 +60,7 @@
         .setPriority(6000)
         .build();
 
-        ChannelBuffer bb = ChannelBuffers.dynamicBuffer();
+        ByteBuf bb = Unpooled.buffer();
         flowAdd.writeTo(bb);
         byte[] flowAddBytes = new byte[bb.readableBytes()];
         bb.readBytes(flowAddBytes);
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java
index 81d9d7f..56dc070 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java
@@ -8,12 +8,12 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 
 import java.text.MessageFormat;
 
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffer;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -36,12 +36,12 @@
 
     @Test
     public void testReadBytes() {
-        ChannelBuffer empty = ChannelBuffers.wrappedBuffer(new byte[16]);
+        ByteBuf empty = Unpooled.wrappedBuffer(new byte[16]);
         U128 uEmpty = U128.read16Bytes(empty);
         assertThat(uEmpty.getMsb(), equalTo(0L));
         assertThat(uEmpty.getLsb(), equalTo(0L));
 
-        ChannelBuffer value = ChannelBuffers.wrappedBuffer(
+        ByteBuf value = Unpooled.wrappedBuffer(
                 new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88,
                         (byte) 0x99, (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd,
                         (byte) 0xee, (byte) 0xff, 0x11 });
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/VxlanNITest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/VxlanNITest.java
new file mode 100644
index 0000000..818dd07
--- /dev/null
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/VxlanNITest.java
@@ -0,0 +1,50 @@
+package org.projectfloodlight.openflow.types;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+
+
+public class VxlanNITest {
+
+    @Test
+    public void testValidMaxVni() {
+        VxlanNI.ofVni(0x00ffffff);
+    }
+
+    @Test
+    public void testValidMinVni() {
+        VxlanNI.ofVni(0x0000001);
+    }
+
+    @Test
+    public void testVniEquals() {
+        assertEquals((int)VxlanNI.ofVni(0x01).getVni(), 0x01);
+        assertEquals((int)VxlanNI.ofVni(0x00ffFFff).getVni(), 0x00ffFFff);
+    }
+
+    @Test
+    public void testVniObjects() {
+        VxlanNI o = VxlanNI.ofVni(0x00ffFFff);
+        VxlanNI m = VxlanNI.ofVni(0x00ffFFff);
+        assertEquals(o.compareTo(m), 0);
+        assertEquals(o.getVni(), m.getVni());
+        assertFalse(!o.equals(m));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidVni1() {
+        VxlanNI.ofVni(0xFFffFFff);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidVni2() {
+        VxlanNI.ofVni(0x0FffFFff);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidVni3() {
+        VxlanNI.ofVni(0x01FffFFff);
+    }
+}
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java
index 360cb5a..ca5df98 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java
@@ -17,14 +17,21 @@
 
 package org.projectfloodlight.openflow.util;
 
+import static org.hamcrest.Matchers.equalTo;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import java.util.Random;
 
 import org.junit.Test;
 
+import com.google.common.collect.ImmutableList;
+
 /**
  * Does hexstring conversion work?
  *
  * @author Rob Sherwood (rob.sherwood@stanford.edu)
+ * @author Andreas Wundsam <andreas.wundsam@bigswitch.com>
  */
 public class HexStringTest {
 
@@ -41,7 +48,7 @@
         String dpidStr = "3e:1f:01:fc:72:8c:63:31";
         long valid = 0x3e1f01fc728c6331L;
         long testLong = HexString.toLong(dpidStr);
-        assertEquals(valid, testLong);
+        assertEquals("was: " + Long.toHexString(testLong), valid, testLong);
     }
 
     @Test
@@ -49,7 +56,7 @@
         String dpidStr = "1f:1:fc:72:3:f:31";
         long valid = 0x1f01fc72030f31L;
         long testLong = HexString.toLong(dpidStr);
-        assertEquals(valid, testLong);
+        assertEquals("was: " + Long.toHexString(testLong), valid, testLong);
     }
 
     @Test
@@ -76,13 +83,17 @@
     }
 
     @Test(expected=NumberFormatException.class)
+    public void testToLongErrorColonAtEnd() {
+        HexString.toLong("03:01:");
+    }
+
+    @Test(expected=NumberFormatException.class)
     public void testToLongErrorInvalidHexDigit() {
         HexString.toLong("ss:01");
     }
 
-    @Test(expected=NumberFormatException.class)
     public void testToLongErrorEmptyString() {
-        HexString.toLong("");
+        assertThat(HexString.toLong(""), equalTo(0L));
     }
 
 
@@ -94,10 +105,138 @@
         assertEquals(valid, testString);
     }
 
-    @Test(expected=NumberFormatException.class)
-    public void testFromHexStringError() {
-        String invalidStr = "00:00:00:00:00:00:ffff";
-        HexString.fromHexString(invalidStr);
+    @Test
+    public void testToStringBytes2() {
+        byte[] dpid = { 1, 2, 3, 4 };
+        String valid = "01:02:03:04";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
     }
+
+    @Test
+    public void testToStringBytes3() {
+        byte[] dpid = { (byte) 0xff };
+        String valid = "ff";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToStringEmpty() {
+        byte[] dpid = { };
+        String valid = "";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToStringLong() {
+        byte[] dpid = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+        String valid = "01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToZero() {
+        byte[] dpid = { 0, 0, 0, 0};
+        String valid = "00:00:00:00";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToStringFromLong() {
+        assertThat(HexString.toHexString(0x0L), equalTo("00:00:00:00:00:00:00:00"));
+        assertThat(HexString.toHexString(0x00_00_00_00_00_00_00_01L), equalTo("00:00:00:00:00:00:00:01"));
+        assertThat(HexString.toHexString(0x01_02_03_04_05_06_07_08L), equalTo("01:02:03:04:05:06:07:08"));
+        assertThat(HexString.toHexString(0x00_00_ff_fe_fd_fc_fb_fa_f9_f8L), equalTo("ff:fe:fd:fc:fb:fa:f9:f8"));
+        assertThat(HexString.toHexString(0x80_70_60_50_40_30_20_10L), equalTo("80:70:60:50:40:30:20:10"));
+    }
+
+    @Test
+    public void testToStringFromLongPad6() {
+        assertThat(HexString.toHexString(0x0L, 6), equalTo("00:00:00:00:00:00"));
+        assertThat(HexString.toHexString(0x00_00_00_00_00_00_00_01L, 6), equalTo("00:00:00:00:00:01"));
+        assertThat(HexString.toHexString(0x00_00_01_02_03_04_05_06L, 6), equalTo("01:02:03:04:05:06"));
+        assertThat(HexString.toHexString(0x00_00_ff_fe_fd_fc_fb_faL, 6), equalTo("ff:fe:fd:fc:fb:fa"));
+        // when supplying a value longer than 6, it is displayed completely
+        assertThat(HexString.toHexString(0x80_70_60_50_40_30_20_10L, 6), equalTo("80:70:60:50:40:30:20:10"));
+    }
+
+    @Test
+    public void testToBytes() {
+        assertThat(HexString.toBytes(""), equalTo(new byte[]{}));
+        assertThat(HexString.toBytes("1"), equalTo(new byte[]{0x01}));
+        assertThat(HexString.toBytes("f"), equalTo(new byte[]{0x0f}));
+        assertThat(HexString.toBytes("10"), equalTo(new byte[]{(byte) 0x10}));
+        assertThat(HexString.toBytes("80"), equalTo(new byte[]{(byte) 0x80}));
+        assertThat(HexString.toBytes("ff"), equalTo(new byte[]{(byte) 0xff}));
+        assertThat(HexString.toBytes("0:0"), equalTo(new byte[]{(byte) 0x00, 0x00}));
+        assertThat(HexString.toBytes("00:00"), equalTo(new byte[]{(byte) 0x00, 0x00}));
+        assertThat(HexString.toBytes("0:1"), equalTo(new byte[]{(byte) 0x00, 0x01}));
+        assertThat(HexString.toBytes("00:1"), equalTo(new byte[]{(byte) 0x00, 0x01}));
+        assertThat(HexString.toBytes("0:01"), equalTo(new byte[]{(byte) 0x00, 0x01}));
+        assertThat(HexString.toBytes("1:0"), equalTo(new byte[]{(byte) 0x01, 0x00}));
+        assertThat(HexString.toBytes("01:00"), equalTo(new byte[]{(byte) 0x01, 0x00}));
+        assertThat(HexString.toBytes("01:02:03:04"), equalTo(new byte[]{(byte) 0x01, 0x02, 03, 04}));
+        assertThat(HexString.toBytes("ff:fe:03:04"), equalTo(new byte[]{(byte) 0xff, (byte) 0xfe, 03, 04}));
+        assertThat(HexString.toBytes("ff:fe:3:4"), equalTo(new byte[]{(byte) 0xff, (byte) 0xfe, 03, 04}));
+        assertThat(HexString.toBytes("01:02:03:04:05:06"), equalTo(new byte[]{0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }));
+        assertThat(HexString.toBytes("ff:1:fe:2:fd"),
+                equalTo(new byte[]{(byte) 0xff, 0x01, (byte) 0xfe, 0x02, (byte) 0xfd}));
+
+    }
+    @Test
+    public void testToBytesRandom() {
+        Random r = new Random();
+        for(int length: ImmutableList.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 15, 16, 32, 63, 64, 128, 255, 256, 511, 512, 1023, 1024)) {
+            StringBuilder build = new StringBuilder();
+            byte[] bytes = new byte[length];
+            for(int i=0; i<length; i++) {
+                byte b = (byte) r.nextInt(256);
+                build.append(String.format("%02x", b));
+                if(i < length-1) {
+                    build.append(":");
+                }
+                bytes[i] = b;
+            }
+            assertThat("For length "+ length + ", ",
+                    HexString.toBytes(build.toString()),
+                    equalTo(bytes));
+        }
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testToBytesError() {
+        String invalidStr = "00:00:00:00:00:00:ffff";
+        HexString.toBytes(invalidStr);
+    }
+
+
+    @Test(expected=NumberFormatException.class)
+    public void testToBytesError2() {
+        String invalidStr = ":01:02:03";
+        HexString.toBytes(invalidStr);
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testToBytesError3() {
+        String invalidStr = "01::02:03";
+        HexString.toBytes(invalidStr);
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testBoBytesError4() {
+        String invalidStr = "01:02:03:";
+        HexString.toBytes(invalidStr);
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testtoBytesError5() {
+        String invalidStr = "01:0X";
+        HexString.toBytes(invalidStr);
+    }
+
 }
 
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/OFBundleAddTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/OFBundleAddTest.java
new file mode 100644
index 0000000..48a80c4
--- /dev/null
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/OFBundleAddTest.java
@@ -0,0 +1,74 @@
+package org.projectfloodlight.protocol;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.projectfloodlight.openflow.protocol.OFBundleAddMsg;
+import org.projectfloodlight.openflow.protocol.OFFactories;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.OFFlowAdd;
+import org.projectfloodlight.openflow.protocol.OFVersion;
+import org.projectfloodlight.openflow.types.BundleId;
+
+/** Custom tests that validate that BundleAdd messages inherit the XID from their
+ *  contained message, as per OF Spec 1.4.0:
+ *  <p>
+ *  7.3.9.6 Adding messages to a bundle
+ *  <p>
+ *     Message added in a bundle should have a unique xid to help matching errors to messages,
+ *     and the xid of the bundle add message must be the same.
+ *  </p>
+ *
+ * @author Andreas Wundsam <andreas.wundsam@bigswitch.com>
+ */
+public class OFBundleAddTest {
+    private final OFFactory factory = OFFactories.getFactory(OFVersion.OF_14);
+    private OFFlowAdd flowAdd;
+
+    @Before
+    public void setup() {
+        flowAdd = factory.buildFlowAdd().build();
+
+    }
+
+    @Test
+    public void testBundleAddBuilder() {
+        OFBundleAddMsg bundleAdd = createBundleAdd();
+        assertThat(bundleAdd.getXid(), equalTo(flowAdd.getXid()));
+    }
+
+    private OFBundleAddMsg createBundleAdd() {
+        return factory.buildBundleAddMsg()
+                .setBundleId(BundleId.of(1))
+                .setData(flowAdd)
+                .build();
+    }
+
+    @Test
+    public void testBundleAddBuilderWithParent() {
+        OFBundleAddMsg bundleAdd = createBundleAdd();
+
+        // validate BuilderWithParent
+        OFBundleAddMsg builtFromOtherMessage = bundleAdd.createBuilder()
+           .build();
+
+        assertThat(builtFromOtherMessage.getXid(), equalTo(builtFromOtherMessage.getData().getXid()));
+    }
+
+    @Test
+    public void testBundleAddBuilderWithParentOverwrite() {
+        OFFlowAdd flowAdd2 = factory.buildFlowAdd().setXid(1234L).build();
+
+        // BuilderWithParent, overwrite with new message
+        OFBundleAddMsg bundleAdd = createBundleAdd();
+
+        OFBundleAddMsg builtFromOtherMessage = bundleAdd.createBuilder()
+           .setData(flowAdd2)
+           .build();
+
+        assertThat(builtFromOtherMessage.getXid(), equalTo(flowAdd2.getXid()));
+    }
+
+}
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/match/OFMatchPrerequisitesTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/match/OFMatchPrerequisitesTest.java
new file mode 100644
index 0000000..89cd536
--- /dev/null
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/match/OFMatchPrerequisitesTest.java
@@ -0,0 +1,86 @@
+package org.projectfloodlight.protocol.match;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertThat;
+import static org.projectfloodlight.openflow.protocol.match.MatchField.ETH_TYPE;
+import static org.projectfloodlight.openflow.protocol.match.MatchField.IPV4_SRC;
+
+import java.util.Arrays;
+
+import org.hamcrest.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.projectfloodlight.openflow.protocol.OFFactories;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.OFVersion;
+import org.projectfloodlight.openflow.protocol.match.Match;
+import org.projectfloodlight.openflow.protocol.match.MatchField;
+import org.projectfloodlight.openflow.types.EthType;
+import org.projectfloodlight.openflow.types.IPv4Address;
+
+@RunWith(Parameterized.class)
+public class OFMatchPrerequisitesTest {
+    private final OFFactory factory;
+
+    @Parameters(name="{index}.ChannelHandlerVersion={0}")
+    public static Iterable<Object[]> data() {
+        return Arrays.asList(new Object[][] {
+                {OFVersion.OF_10},
+                {OFVersion.OF_13},
+                {OFVersion.OF_14}
+        });
+    }
+
+    public OFMatchPrerequisitesTest(OFVersion version) {
+        factory = OFFactories.getFactory(version);
+    }
+
+    @Test
+    public void testPreRequisitesNotMet() {
+        Match match = factory.buildMatch()
+           .setExact(ETH_TYPE, EthType.IPv6)
+           .setExact(IPV4_SRC, IPv4Address.of("1.2.3.4"))
+           .build();
+
+        assertThat(match.get(ETH_TYPE), equalTo(EthType.IPv6));
+        assertThat(match.isExact(ETH_TYPE), equalTo(true));
+        assertThat(match.isPartiallyMasked(ETH_TYPE), equalTo(false));
+        assertThat(match.isFullyWildcarded(ETH_TYPE), equalTo(false));
+
+        assertThat(match.get(IPV4_SRC), nullValue());
+        assertThat(match.isExact(IPV4_SRC), equalTo(false));
+        assertThat(match.isPartiallyMasked(IPV4_SRC), equalTo(false));
+        assertThat(match.isFullyWildcarded(IPV4_SRC), equalTo(true));
+
+        Iterable<MatchField<?>> matchFields = match.getMatchFields();
+        assertThat(matchFields, Matchers.<MatchField<?>>iterableWithSize(1));
+        assertThat(matchFields, Matchers.<MatchField<?>>contains(MatchField.ETH_TYPE));
+    }
+
+    @Test
+    public void testPreRequisitesMet() {
+        Match match = factory.buildMatch()
+           .setExact(ETH_TYPE, EthType.IPv4)
+           .setExact(IPV4_SRC, IPv4Address.of("1.2.3.4"))
+           .build();
+
+        assertThat(match.get(ETH_TYPE), equalTo(EthType.IPv4));
+        assertThat(match.isExact(ETH_TYPE), equalTo(true));
+        assertThat(match.isPartiallyMasked(ETH_TYPE), equalTo(false));
+        assertThat(match.isFullyWildcarded(ETH_TYPE), equalTo(false));
+
+        assertThat(match.get(IPV4_SRC), equalTo(IPv4Address.of("1.2.3.4")));
+        assertThat(match.isExact(IPV4_SRC), equalTo(true));
+        assertThat(match.isPartiallyMasked(IPV4_SRC), equalTo(false));
+        assertThat(match.isFullyWildcarded(IPV4_SRC), equalTo(false));
+
+        Iterable<MatchField<?>> matchFields = match.getMatchFields();
+        assertThat(matchFields, Matchers.<MatchField<?>>iterableWithSize(2));
+        assertThat(matchFields, Matchers.<MatchField<?>>contains(MatchField.ETH_TYPE, MatchField.IPV4_SRC));
+    }
+
+
+}