diff --git a/tests/FuncUtils.py b/tests/FuncUtils.py
index f090d20..9f5278d 100644
--- a/tests/FuncUtils.py
+++ b/tests/FuncUtils.py
@@ -40,7 +40,7 @@
     match = parse.packet_to_flow_match(pkt_exactflow)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
     match.in_port = of_ports[0]
-    #match.nw_src = 1
+    #match.ipv4_src = 1
     match.wildcards=0
     match_send_flowadd(self, match, priority, of_ports[1])
     return (pkt_exactflow,match)
@@ -53,7 +53,7 @@
     match = parse.packet_to_flow_match(pkt_exactflow)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
     match.in_port = of_ports[0]
-    #match.nw_src = 1
+    #match.ipv4_src = 1
     match.wildcards=0
     match_send_flowadd(self, match, priority, of_ports[2])
     return (pkt_exactflow,match)         
@@ -67,7 +67,7 @@
     match1 = parse.packet_to_flow_match(pkt_wildcardsrc)
     self.assertTrue(match1 is not None, "Could not generate flow match from pkt")
     match1.in_port = of_ports[0]
-    #match1.nw_src = 1
+    #match1.ipv4_src = 1
     match1.wildcards = ofp.OFPFW_DL_SRC
     match_send_flowadd(self, match1, priority, of_ports[1])
     return (pkt_wildcardsrc,match1)
@@ -76,7 +76,7 @@
     #Generate Match_Ethernet_SrC_Address flow
 
     #Create a simple tcp packet and generate match on ethernet src address flow
-    pkt_MatchSrc = simple_eth_packet(dl_src='00:01:01:01:01:01')
+    pkt_MatchSrc = simple_eth_packet(eth_src='00:01:01:01:01:01')
     match = parse.packet_to_flow_match(pkt_MatchSrc)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
     match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_SRC
@@ -87,7 +87,7 @@
     #Generate Match_Ethernet_Dst_Address flow
 
     #Create a simple tcp packet and generate match on ethernet dst address flow
-    pkt_matchdst = simple_eth_packet(dl_dst='00:01:01:01:01:01')
+    pkt_matchdst = simple_eth_packet(eth_dst='00:01:01:01:01:01')
     match = parse.packet_to_flow_match(pkt_matchdst)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
 
@@ -136,7 +136,7 @@
     #Generate Match_Vlan_Id
 
     #Create a simple tcp packet and generate match on ethernet dst address flow
-    pkt_matchvlanid = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=1)
+    pkt_matchvlanid = simple_tcp_packet(dl_vlan_enable=True,vlan_vid=1)
     match = parse.packet_to_flow_match(pkt_matchvlanid)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
 
@@ -148,7 +148,7 @@
     #Generate Match_Vlan_Priority
 
     #Create a simple tcp packet and generate match on ethernet dst address flow
-    pkt_matchvlanpcp = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=1,dl_vlan_pcp=5)
+    pkt_matchvlanpcp = simple_tcp_packet(dl_vlan_enable=True,vlan_vid=1,vlan_pcp=5)
     match = parse.packet_to_flow_match(pkt_matchvlanpcp)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
 
@@ -161,7 +161,7 @@
     #Generate Match_Mul_L2 flow
 
     #Create a simple eth packet and generate match on ethernet protocol flow
-    pkt_mulL2 = simple_eth_packet(dl_type=0x88cc,dl_src='00:01:01:01:01:01',dl_dst='00:01:01:01:01:02')
+    pkt_mulL2 = simple_eth_packet(eth_type=0x88cc,eth_src='00:01:01:01:01:01',eth_dst='00:01:01:01:01:02')
     match = parse.packet_to_flow_match(pkt_mulL2)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
 
@@ -308,7 +308,7 @@
     #Generate a Match_Ethernet_Type flow
 
     #Create a simple tcp packet and generate match on ethernet type flow
-    pkt_matchtype = simple_eth_packet(dl_type=0x88cc)
+    pkt_matchtype = simple_eth_packet(eth_type=0x88cc)
     match = parse.packet_to_flow_match(pkt_matchtype)
     self.assertTrue(match is not None, "Could not generate flow match from pkt")
 
diff --git a/tests/actions.py b/tests/actions.py
index 5b9828c..68b2e1b 100644
--- a/tests/actions.py
+++ b/tests/actions.py
@@ -439,7 +439,7 @@
         len_w_vid = 104
         pkt = simple_tcp_packet(pktlen=len_wo_vid)
         exp_pkt = simple_tcp_packet(pktlen=len_w_vid, dl_vlan_enable=True, 
-                                    dl_vlan=new_vid,dl_vlan_pcp=0)
+                                    vlan_vid=new_vid,vlan_pcp=0)
         vid_act = ofp.action.set_vlan_vid()
         vid_act.vlan_vid = new_vid
 
@@ -475,8 +475,8 @@
         #Create a tagged packet with old_vid to be sent, and expected packet with new_vid
         old_vid = 2
         new_vid = 3
-        pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=old_vid)
-        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=new_vid)
+        pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=old_vid)
+        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=new_vid)
         vid_act = ofp.action.set_vlan_vid()
         vid_act.vlan_vid = new_vid
         
@@ -514,7 +514,7 @@
         vlan_pcp = 1
         pktlen = 64 if config["minsize"] < 64 else config["minsize"]
         pkt = simple_tcp_packet(pktlen=pktlen)
-        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=vlan_id,dl_vlan_pcp=vlan_pcp, pktlen=pktlen + 4)
+        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=vlan_id,vlan_pcp=vlan_pcp, pktlen=pktlen + 4)
         act = ofp.action.set_vlan_pcp()
         act.vlan_pcp = vlan_pcp
 
@@ -552,8 +552,8 @@
         vid          = 123
         old_vlan_pcp = 2
         new_vlan_pcp = 3
-        pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=vid, dl_vlan_pcp=old_vlan_pcp)
-        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=vid, dl_vlan_pcp=new_vlan_pcp)
+        pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=vid, vlan_pcp=old_vlan_pcp)
+        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=vid, vlan_pcp=new_vlan_pcp)
         vid_act = ofp.action.set_vlan_pcp()
         vid_act.vlan_pcp = new_vlan_pcp
 
@@ -587,8 +587,8 @@
             skip_message_emit(self, "modify_l2_src test skipped")
             return
 
-        #Create packet to be sent and expected packet with dl_src set to specified value
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_src'],
+        #Create packet to be sent and expected packet with eth_src set to specified value
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_src'],
                                                 check_test_params=True)
         
         #Insert flow with action -- set src address, Send packet matching the flow, Verify recieved packet is expected packet
@@ -621,8 +621,8 @@
             skip_message_emit(self, "modify_l2_dst test skipped")
             return
 
-        #Create packet to be sent and expected packet with dl_src set to specified value
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_dst'],
+        #Create packet to be sent and expected packet with eth_src set to specified value
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_dst'],
                                                 check_test_params=True)
         
         #Insert flow with action -- set dst address, Send packet matching the flow, Verify recieved packet is expected packet
@@ -654,7 +654,7 @@
             skip_message_emit(self, "modify_l3_src test")
             return
 
-        #Create packet to be sent and expected packet with nw_src set to specified value
+        #Create packet to be sent and expected packet with ipv4_src set to specified value
         (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['ip_src'],
                                                 check_test_params=True)
         
@@ -687,7 +687,7 @@
             skip_message_emit(self, "modify_l3_dst test skipped")
             return
         
-        #Create packet to be sent and expected packet with nw_dst set to specified value
+        #Create packet to be sent and expected packet with ipv4_dst set to specified value
         (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['ip_dst'],
                                                 check_test_params=True)
         
diff --git a/tests/basic.py b/tests/basic.py
index 54aea3a..b2fe483 100644
--- a/tests/basic.py
+++ b/tests/basic.py
@@ -84,7 +84,7 @@
         for of_port in config["port_map"].keys():
             for pkt, pt in [
                (simple_tcp_packet(), "simple TCP packet"),
-               (simple_tcp_packet(dl_vlan_enable=True,dl_vlan=vid,pktlen=108), 
+               (simple_tcp_packet(dl_vlan_enable=True,vlan_vid=vid,pktlen=108), 
                 "simple tagged TCP packet"),
                (simple_eth_packet(), "simple Ethernet packet"),
                (simple_eth_packet(pktlen=40), "tiny Ethernet packet")]:
@@ -133,7 +133,7 @@
 
         of_ports = config["port_map"].keys()
         d_port = of_ports[0]
-        pkt = simple_eth_packet(dl_dst='ff:ff:ff:ff:ff:ff')
+        pkt = simple_eth_packet(eth_dst='ff:ff:ff:ff:ff:ff')
 
         logging.info("BCast Leak Test, send to port %s" % d_port)
         self.dataplane.send(d_port, str(pkt))
diff --git a/tests/caps.py b/tests/caps.py
index 8d7779e..76147d7 100644
--- a/tests/caps.py
+++ b/tests/caps.py
@@ -35,7 +35,7 @@
     for port in of_ports:
         break;
     match.in_port = port
-    match.nw_src = 1
+    match.ipv4_src = 1
     request = ofp.message.flow_mod()
     count_check = 101  # fixme:  better way to determine this.
     if is_exact:
@@ -63,7 +63,7 @@
     logging.info("Check every " + str(count_check) + " inserts")
 
     while True:
-        request.match.nw_src += 1
+        request.match.ipv4_src += 1
         obj.controller.message_send(request)
         flow_count += 1
         if flow_count % count_check == 0:
diff --git a/tests/flow_matches.py b/tests/flow_matches.py
index 56fd3a7..721d68b 100644
--- a/tests/flow_matches.py
+++ b/tests/flow_matches.py
@@ -50,11 +50,11 @@
         wildcard_all(self,of_ports)
 
         #check for different  match fields and verify packet implements the action specified in the flow
-        pkt1 = simple_tcp_packet(dl_src="00:01:01:01:01:01");
+        pkt1 = simple_tcp_packet(eth_src="00:01:01:01:01:01");
         self.dataplane.send(of_ports[0], str(pkt1))
         receive_pkt_check(self.dataplane,pkt1,[yes_ports],no_ports,self)
        
-        pkt2 = simple_tcp_packet(dl_dst="00:01:01:01:01:01");    
+        pkt2 = simple_tcp_packet(eth_dst="00:01:01:01:01:01");    
         self.dataplane.send(of_ports[0], str(pkt2))
         receive_pkt_check(self.dataplane,pkt2,[yes_ports],no_ports,self)
         
@@ -113,7 +113,7 @@
         receive_pkt_check(self.dataplane,pkt,[yes_ports],no_ports,self)
 
         #Sending non matching packet , verify Packetin event gets triggered.
-        pkt2 = simple_eth_packet(dl_src='00:01:01:01:01:02');
+        pkt2 = simple_eth_packet(eth_src='00:01:01:01:01:02');
         self.dataplane.send(of_ports[0], str(pkt2))
         
         (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN,timeout=4)
@@ -152,7 +152,7 @@
         receive_pkt_check(self.dataplane,pkt,[yes_ports],no_ports,self)
         
         #Send Non-matching packet
-        pkt2 = simple_eth_packet(dl_dst='00:01:01:01:01:02');
+        pkt2 = simple_eth_packet(eth_dst='00:01:01:01:01:02');
         self.dataplane.send(of_ports[0], str(pkt2))
         
         #Verify PacketIn event gets triggered
@@ -193,7 +193,7 @@
         receive_pkt_check(self.dataplane,pkt,[yes_ports],no_ports,self)
 
         #Sending non matching packet , 
-        pkt2 = simple_eth_packet(dl_type=0x0806);
+        pkt2 = simple_eth_packet(eth_type=0x0806);
         self.dataplane.send(of_ports[0], str(pkt2))
         
         #verify Packetin event gets triggered.
@@ -271,7 +271,7 @@
         receive_pkt_check(self.dataplane,pkt,[yes_ports],no_ports,self)
         
         #Send Non-matching packet, i.e packet with different Vlan Id
-        pkt2 = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=4);
+        pkt2 = simple_tcp_packet(dl_vlan_enable=True,vlan_vid=4);
         self.dataplane.send(of_ports[0], str(pkt2))
         
         #Verify PacketIn event gets triggered
@@ -311,7 +311,7 @@
         receive_pkt_check(self.dataplane,pkt,[yes_ports],no_ports,self)
         
         #Send tagged packet with same vlan_id but different vlan priority
-        pkt2 = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=1,dl_vlan_pcp=20);
+        pkt2 = simple_tcp_packet(dl_vlan_enable=True,vlan_vid=1,vlan_pcp=20);
         self.dataplane.send(of_ports[0], str(pkt2))
 
         #Verify Packet_In event gets triggered
@@ -343,28 +343,28 @@
 
         (pkt,match) = match_mul_l2(self,of_ports)   
 
-        #Send eth packet matching the dl_type field, verify it implements the action
+        #Send eth packet matching the eth_type field, verify it implements the action
         self.dataplane.send(of_ports[0], str(pkt))
 
         #Verify packet implements the action specified in the flow
         receive_pkt_check(self.dataplane,pkt,[yes_ports],no_ports,self)
 
-        #Sending non matching packet (only dl_dst is different) , verify Packetin event gets triggered.
-        pkt2 = simple_eth_packet(dl_type=0x88cc,dl_src='00:01:01:01:01:01',dl_dst='00:01:01:02:01:01');
+        #Sending non matching packet (only eth_dst is different) , verify Packetin event gets triggered.
+        pkt2 = simple_eth_packet(eth_type=0x88cc,eth_src='00:01:01:01:01:01',eth_dst='00:01:01:02:01:01');
         self.dataplane.send(of_ports[0], str(pkt2))
         
         (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN,timeout=4)
         self.assertTrue(response is not None, "PacketIn not received for non matching packet")
 
-        #Sending non matching packet (only dl_src is different) , verify Packetin event gets triggered.
-        pkt2 = simple_eth_packet(dl_type=0x88cc,dl_src='00:01:01:01:01:02',dl_dst='00:01:01:01:01:02');
+        #Sending non matching packet (only eth_src is different) , verify Packetin event gets triggered.
+        pkt2 = simple_eth_packet(eth_type=0x88cc,eth_src='00:01:01:01:01:02',eth_dst='00:01:01:01:01:02');
         self.dataplane.send(of_ports[0], str(pkt2))
         
         (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN,timeout=4)
         self.assertTrue(response is not None, "PacketIn not received for non matching packet")
 
         #Sending non matching packet (only ether_type is different) , verify Packetin event gets triggered.
-        pkt2 = simple_eth_packet(dl_type=0x0806,dl_src='00:01:01:01:01:01',dl_dst='00:01:01:01:01:02');
+        pkt2 = simple_eth_packet(eth_type=0x0806,eth_src='00:01:01:01:01:01',eth_dst='00:01:01:01:01:02');
         self.dataplane.send(of_ports[0], str(pkt2))
         
         #Verify packet_in event gets triggered
diff --git a/tests/flow_query.py b/tests/flow_query.py
index 2d5c7b5..0784040 100644
--- a/tests/flow_query.py
+++ b/tests/flow_query.py
@@ -353,41 +353,41 @@
            and self.match.in_port != x.match.in_port:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_DST) == 0 \
-           and self.match.dl_dst != x.match.dl_dst:
+           and self.match.eth_dst != x.match.eth_dst:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_SRC) == 0 \
-           and self.match.dl_src != x.match.dl_src:
+           and self.match.eth_src != x.match.eth_src:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_VLAN) == 0 \
-           and self.match.dl_vlan != x.match.dl_vlan:
+           and self.match.vlan_vid != x.match.vlan_vid:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_VLAN_PCP) == 0 \
-           and self.match.dl_vlan_pcp != x.match.dl_vlan_pcp:
+           and self.match.vlan_pcp != x.match.vlan_pcp:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_TYPE) == 0 \
-           and self.match.dl_type != x.match.dl_type:
+           and self.match.eth_type != x.match.eth_type:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_NW_TOS) == 0 \
-           and self.match.nw_tos != x.match.nw_tos:
+           and self.match.ip_dscp != x.match.ip_dscp:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_NW_PROTO) == 0 \
-           and self.match.nw_proto != x.match.nw_proto:
+           and self.match.ip_proto != x.match.ip_proto:
             return False
         n = wildcard_get(self.match.wildcards, ofp.OFPFW_NW_SRC_MASK)
         if n < 32:
             m = ~((1 << n) - 1)
-            if (self.match.nw_src & m) != (x.match.nw_src & m):
+            if (self.match.ipv4_src & m) != (x.match.ipv4_src & m):
                 return False
         n = wildcard_get(self.match.wildcards, ofp.OFPFW_NW_DST_MASK)
         if n < 32:
             m = ~((1 << n) - 1)
-            if (self.match.nw_dst & m) != (x.match.nw_dst & m):
+            if (self.match.ipv4_dst & m) != (x.match.ipv4_dst & m):
                 return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_TP_SRC) == 0 \
-               and self.match.tp_src != x.match.tp_src:
+               and self.match.tcp_src != x.match.tcp_src:
             return False
         if wildcard_get(self.match.wildcards, ofp.OFPFW_TP_DST) == 0 \
-               and self.match.tp_dst != x.match.tp_dst:
+               and self.match.tcp_dst != x.match.tcp_dst:
             return False
         return True
 
@@ -431,37 +431,37 @@
         if wildcard_get(self.match.wildcards, ofp.OFPFW_IN_PORT) == 0:
             result = result + (", in_port=%d" % (self.match.in_port))
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_DST) == 0:
-            result = result + (", dl_dst=%s" \
-                               % (dl_addr_to_str(self.match.dl_dst)) \
+            result = result + (", eth_dst=%s" \
+                               % (dl_addr_to_str(self.match.eth_dst)) \
                                )
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_SRC) == 0:
-            result = result + (", dl_src=%s" \
-                               % (dl_addr_to_str(self.match.dl_src)) \
+            result = result + (", eth_src=%s" \
+                               % (dl_addr_to_str(self.match.eth_src)) \
                                )
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_VLAN) == 0:
-            result = result + (", dl_vlan=%d" % (self.match.dl_vlan))
+            result = result + (", vlan_vid=%d" % (self.match.vlan_vid))
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_VLAN_PCP) == 0:
-            result = result + (", dl_vlan_pcp=%d" % (self.match.dl_vlan_pcp))
+            result = result + (", vlan_pcp=%d" % (self.match.vlan_pcp))
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_TYPE) == 0:
-            result = result + (", dl_type=0x%x" % (self.match.dl_type))
+            result = result + (", eth_type=0x%x" % (self.match.eth_type))
         if wildcard_get(self.match.wildcards, ofp.OFPFW_NW_TOS) == 0:
-            result = result + (", nw_tos=0x%x" % (self.match.nw_tos))
+            result = result + (", ip_dscp=0x%x" % (self.match.ip_dscp))
         if wildcard_get(self.match.wildcards, ofp.OFPFW_NW_PROTO) == 0:
-            result = result + (", nw_proto=%d" % (self.match.nw_proto))
+            result = result + (", ip_proto=%d" % (self.match.ip_proto))
         n = wildcard_get(self.match.wildcards, ofp.OFPFW_NW_SRC_MASK)
         if n < 32:
-            result = result + (", nw_src=%s" % \
-                               (ip_addr_to_str(self.match.nw_src, 32 - n)) \
+            result = result + (", ipv4_src=%s" % \
+                               (ip_addr_to_str(self.match.ipv4_src, 32 - n)) \
                                )
         n = wildcard_get(self.match.wildcards, ofp.OFPFW_NW_DST_MASK)
         if n < 32:
-            result = result + (", nw_dst=%s" % \
-                               (ip_addr_to_str(self.match.nw_dst, 32 - n)) \
+            result = result + (", ipv4_dst=%s" % \
+                               (ip_addr_to_str(self.match.ipv4_dst, 32 - n)) \
                                )
         if wildcard_get(self.match.wildcards, ofp.OFPFW_TP_SRC) == 0:
-            result = result + (", tp_src=%d" % self.match.tp_src)
+            result = result + (", tcp_src=%d" % self.match.tcp_src)
         if wildcard_get(self.match.wildcards, ofp.OFPFW_TP_DST) == 0:
-            result = result + (", tp_dst=%d" % self.match.tp_dst)
+            result = result + (", tcp_dst=%d" % self.match.tcp_dst)
         return result
 
     def __eq__(self, x):
@@ -551,7 +551,7 @@
                 act.nw_addr = fi.rand_ip_addr()
             elif a == ofp.OFPAT_SET_NW_TOS:
                 act = ofp.action.set_nw_tos()
-                act.nw_tos = fi.rand_ip_tos()
+                act.ip_dscp = fi.rand_ip_tos()
             elif a == ofp.OFPAT_SET_TP_SRC:
                 act = ofp.action.set_tp_src()
                 act.tp_port = fi.rand_l4_port()
@@ -666,7 +666,7 @@
                 self.actions.append(act)
             elif a == ofp.OFPAT_SET_NW_TOS:
                 act = ofp.action.set_nw_tos()
-                act.nw_tos = fi.rand_ip_tos()
+                act.ip_dscp = fi.rand_ip_tos()
                 self.actions.append(act)
             elif a == ofp.OFPAT_SET_TP_SRC:
                 act = ofp.action.set_tp_src()
@@ -730,7 +730,7 @@
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.dl_dst = fi.rand_dl_addr()
+            self.match.eth_dst = fi.rand_dl_addr()
         else:
             self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                 ofp.OFPFW_DL_DST, \
@@ -742,7 +742,7 @@
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.dl_src = fi.rand_dl_addr()
+            self.match.eth_src = fi.rand_dl_addr()
         else:
             self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                 ofp.OFPFW_DL_SRC, \
@@ -754,7 +754,7 @@
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.dl_vlan = fi.rand_vlan()
+            self.match.vlan_vid = fi.rand_vlan()
         else:
             self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                 ofp.OFPFW_DL_VLAN, \
@@ -766,7 +766,7 @@
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.dl_vlan_pcp = random.randint(0, (1 << 3) - 1)
+            self.match.vlan_pcp = random.randint(0, (1 << 3) - 1)
         else:
             self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                 ofp.OFPFW_DL_VLAN_PCP, \
@@ -778,7 +778,7 @@
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.dl_type = fi.rand_ethertype()
+            self.match.eth_type = fi.rand_ethertype()
         else:
             self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                 ofp.OFPFW_DL_TYPE, \
@@ -799,11 +799,11 @@
                                             n \
                                             )
         if n < 32:
-            self.match.nw_src    = fi.rand_ip_addr() & ~((1 << n) - 1)
+            self.match.ipv4_src    = fi.rand_ip_addr() & ~((1 << n) - 1)
             # Specifying any IP address match other than all bits
             # don't care requires that Ethertype is one of {IP, ARP}
             if flip_coin():
-                self.match.dl_type   = rand_pick([0x0800, 0x0806])
+                self.match.eth_type   = rand_pick([0x0800, 0x0806])
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_DL_TYPE, \
                                                     0 \
@@ -823,11 +823,11 @@
                                             n \
                                             )
         if n < 32:
-            self.match.nw_dst    = fi.rand_ip_addr() & ~((1 << n) - 1)
+            self.match.ipv4_dst    = fi.rand_ip_addr() & ~((1 << n) - 1)
             # Specifying any IP address match other than all bits
             # don't care requires that Ethertype is one of {IP, ARP}
             if flip_coin():
-                self.match.dl_type   = rand_pick([0x0800, 0x0806])
+                self.match.eth_type   = rand_pick([0x0800, 0x0806])
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_DL_TYPE, \
                                                     0 \
@@ -838,10 +838,10 @@
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.nw_tos = fi.rand_ip_tos()
+            self.match.ip_dscp = fi.rand_ip_tos()
             # Specifying a TOS value requires that Ethertype is IP
             if flip_coin():
-                self.match.dl_type   = 0x0800
+                self.match.eth_type   = 0x0800
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_DL_TYPE, \
                                                     0 \
@@ -852,16 +852,16 @@
                                                 1 \
                                                 )
 
-        # Known issue on OVS with specifying nw_proto w/o dl_type as IP
+        # Known issue on OVS with specifying ip_proto w/o eth_type as IP
         if wildcard_get(wildcards_force, ofp.OFPFW_NW_PROTO) == 0 \
                and (wildcard_get(valid_wildcards, ofp.OFPFW_NW_PROTO) == 0 \
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.nw_proto = fi.rand_ip_proto()
+            self.match.ip_proto = fi.rand_ip_proto()
             # Specifying an IP protocol requires that Ethertype is IP
             if flip_coin():
-                self.match.dl_type   = 0x0800
+                self.match.eth_type   = 0x0800
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_DL_TYPE, \
                                                     0 \
@@ -877,23 +877,23 @@
                     or exact\
                     or flip_coin() \
                     ):
-            self.match.tp_src = fi.rand_l4_port()
+            self.match.tcp_src = fi.rand_l4_port()
             # Specifying a L4 port requires that IP protcol is
             # one of {ICMP, TCP, UDP}
             if flip_coin():
-                self.match.nw_proto = rand_pick([1, 6, 17])
+                self.match.ip_proto = rand_pick([1, 6, 17])
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_NW_PROTO, \
                                                     0 \
                                                     )
                 # Specifying a L4 port requirues that Ethertype is IP
-                self.match.dl_type   = 0x0800
+                self.match.eth_type   = 0x0800
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_DL_TYPE, \
                                                     0 \
                                                     )
-                if self.match.nw_proto == 1:
-                    self.match.tp_src = self.match.tp_src & 0xff
+                if self.match.ip_proto == 1:
+                    self.match.tcp_src = self.match.tcp_src & 0xff
         else:
             self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                 ofp.OFPFW_TP_SRC, \
@@ -905,23 +905,23 @@
                     or exact \
                     or flip_coin() \
                     ):
-            self.match.tp_dst = fi.rand_l4_port()
+            self.match.tcp_dst = fi.rand_l4_port()
             # Specifying a L4 port requires that IP protcol is
             # one of {ICMP, TCP, UDP}
             if flip_coin():
-                self.match.nw_proto = rand_pick([1, 6, 17])
+                self.match.ip_proto = rand_pick([1, 6, 17])
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_NW_PROTO, \
                                                     0 \
                                                     )
                 # Specifying a L4 port requirues that Ethertype is IP
-                self.match.dl_type   = 0x0800
+                self.match.eth_type   = 0x0800
                 self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                     ofp.OFPFW_DL_TYPE, \
                                                     0 \
                                                     )
-                if self.match.nw_proto == 1:
-                    self.match.tp_dst = self.match.tp_dst & 0xff
+                if self.match.ip_proto == 1:
+                    self.match.tcp_dst = self.match.tcp_dst & 0xff
         else:
             self.match.wildcards = wildcard_set(self.match.wildcards, \
                                                 ofp.OFPFW_TP_DST, \
@@ -947,7 +947,7 @@
 
     # Return flow cfg in canonical form
     # - There are dependencies between flow qualifiers, e.g. it only makes
-    #   sense to qualify nw_proto if dl_type is qualified to be 0x0800 (IP).
+    #   sense to qualify ip_proto if eth_type is qualified to be 0x0800 (IP).
     #   The canonical form of flow match criteria will "wildcard out"
     #   all such cases.
     def canonical(self):
@@ -960,10 +960,10 @@
                                                   )
 
         if wildcard_get(result.match.wildcards, ofp.OFPFW_DL_TYPE) != 0 \
-               or result.match.dl_type not in [0x0800, 0x0806]:
+               or result.match.eth_type not in [0x0800, 0x0806]:
             # dl_tyoe is wildcarded, or specified as something other
             # than IP or ARP
-            # => nw_src, nw_dst, nw_proto cannot be specified,
+            # => ipv4_src, ipv4_dst, ip_proto cannot be specified,
             # must be wildcarded
             result.match.wildcards = wildcard_set(result.match.wildcards, \
                                                   ofp.OFPFW_NW_SRC_MASK, \
@@ -979,9 +979,9 @@
                                                   )
 
         if wildcard_get(result.match.wildcards, ofp.OFPFW_DL_TYPE) != 0 \
-               or result.match.dl_type != 0x0800:
-            # dl_type is wildcarded, or specified as something other than IP
-            # => nw_tos, tp_src and tp_dst cannot be specified,
+               or result.match.eth_type != 0x0800:
+            # eth_type is wildcarded, or specified as something other than IP
+            # => ip_dscp, tcp_src and tcp_dst cannot be specified,
             #    must be wildcarded
             result.match.wildcards = wildcard_set(result.match.wildcards, \
                                                   ofp.OFPFW_NW_TOS, \
@@ -1009,10 +1009,10 @@
                                                   )
             
         if wildcard_get(result.match.wildcards, ofp.OFPFW_NW_PROTO) != 0 \
-               or result.match.nw_proto not in [1, 6, 17]:
-            # nw_proto is wildcarded, or specified as something other than ICMP,
+               or result.match.ip_proto not in [1, 6, 17]:
+            # ip_proto is wildcarded, or specified as something other than ICMP,
             # TCP or UDP
-            # => tp_src and tp_dst cannot be specified, must be wildcarded
+            # => tcp_src and tcp_dst cannot be specified, must be wildcarded
             result.match.wildcards = wildcard_set(result.match.wildcards, \
                                                   ofp.OFPFW_TP_SRC, \
                                                   1 \
@@ -1038,43 +1038,43 @@
                 return False            # Receiver more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_VLAN) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_DL_VLAN) == 0:
-                if self.match.dl_vlan != x.match.dl_vlan:
+                if self.match.vlan_vid != x.match.vlan_vid:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_SRC) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_DL_SRC) == 0:
-                if self.match.dl_src != x.match.dl_src:
+                if self.match.eth_src != x.match.eth_src:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_DST) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_DL_DST) == 0:
-                if self.match.dl_dst != x.match.dl_dst:
+                if self.match.eth_dst != x.match.eth_dst:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_TYPE) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_DL_TYPE) == 0:
-                if self.match.dl_type != x.match.dl_type:
+                if self.match.eth_type != x.match.eth_type:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Recevier more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_NW_PROTO) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_NW_PROTO) == 0:
-                if self.match.nw_proto != x.match.nw_proto:
+                if self.match.ip_proto != x.match.ip_proto:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_TP_SRC) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_TP_SRC) == 0:
-                if self.match.tp_src != x.match.tp_src:
+                if self.match.tcp_src != x.match.tcp_src:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_TP_DST) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_TP_DST) == 0:
-                if self.match.tp_dst != x.match.tp_dst:
+                if self.match.tcp_dst != x.match.tcp_dst:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
@@ -1084,7 +1084,7 @@
             return False                # Receiver more specific
         if (na < 32 and nb < 32):
             m = ~((1 << na) - 1) & ~((1 << nb) - 1)
-            if (self.match.nw_src & m) != (x.match.nw_src & m):
+            if (self.match.ipv4_src & m) != (x.match.ipv4_src & m):
                 return False            # Overlapping bits not equal
         na = wildcard_get(self.match.wildcards, ofp.OFPFW_NW_DST_MASK)
         nb = wildcard_get(x.match.wildcards, ofp.OFPFW_NW_DST_MASK)
@@ -1092,17 +1092,17 @@
             return False                # Receiver more specific
         if (na < 32 and nb < 32):
             m = ~((1 << na) - 1) & ~((1 << nb) - 1)
-            if (self.match.nw_dst & m) != (x.match.nw_dst & m):
+            if (self.match.ipv4_dst & m) != (x.match.ipv4_dst & m):
                 return False            # Overlapping bits not equal
         if wildcard_get(self.match.wildcards, ofp.OFPFW_DL_VLAN_PCP) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_DL_VLAN_PCP) == 0:
-                if self.match.dl_vlan_pcp != x.match.dl_vlan_pcp:
+                if self.match.vlan_pcp != x.match.vlan_pcp:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
         if wildcard_get(self.match.wildcards, ofp.OFPFW_NW_TOS) == 0:
             if wildcard_get(x.match.wildcards, ofp.OFPFW_NW_TOS) == 0:
-                if self.match.nw_tos != x.match.nw_tos:
+                if self.match.ip_dscp != x.match.ip_dscp:
                     return False        # Both specified, and not equal
             elif delf:
                 return False            # Receiver more specific
diff --git a/tests/flow_stats.py b/tests/flow_stats.py
index 9f71616..8520638 100644
--- a/tests/flow_stats.py
+++ b/tests/flow_stats.py
@@ -261,7 +261,7 @@
         pkt1 = simple_tcp_packet()
         flow_mod_msg1 = self.buildFlowModMsg(pkt1, ingress_port, egress_port1)
        
-        pkt2 = simple_tcp_packet(dl_src='0:7:7:7:7:7')
+        pkt2 = simple_tcp_packet(eth_src='0:7:7:7:7:7')
         flow_mod_msg2 = self.buildFlowModMsg(pkt2, ingress_port, egress_port2)
        
         logging.info("Inserting flow1")
@@ -372,7 +372,7 @@
         pkt1 = simple_tcp_packet()
         flow_mod_msg1 = self.buildFlowModMsg(pkt1, ingress_port, egress_port1)
        
-        pkt2 = simple_tcp_packet(dl_src='0:7:7:7:7:7')
+        pkt2 = simple_tcp_packet(eth_src='0:7:7:7:7:7')
         flow_mod_msg2 = self.buildFlowModMsg(pkt2, ingress_port, egress_port2)
        
         logging.info("Inserting flow1")
diff --git a/tests/load.py b/tests/load.py
index 76c3f45..7179914 100644
--- a/tests/load.py
+++ b/tests/load.py
@@ -211,8 +211,8 @@
         for i in range(num_flows):
             match = ofp.ofp_match()
             match.wildcards = ofp.OFPFW_ALL & ~ofp.OFPFW_DL_VLAN & ~ofp.OFPFW_DL_DST
-            match.dl_vlan = ofp.OFP_VLAN_NONE
-            match.dl_dst = [0, 1, 2, 3, i / 256, i % 256]
+            match.vlan_vid = ofp.OFP_VLAN_NONE
+            match.eth_dst = [0, 1, 2, 3, i / 256, i % 256]
             act = ofp.action.output()
             act.port = ofp.OFPP_CONTROLLER
             request = ofp.message.flow_mod()
diff --git a/tests/pktact.py b/tests/pktact.py
index bd3e79f..b43c7f6 100644
--- a/tests/pktact.py
+++ b/tests/pktact.py
@@ -924,7 +924,7 @@
 
     def runTest(self):
         vid = test_param_get('vid', default=TEST_VID_DEFAULT)
-        flow_match_test(self, config["port_map"], dl_vlan=vid)
+        flow_match_test(self, config["port_map"], vlan_vid=vid)
 
 @disabled
 class ExactMatchTaggedMany(BaseMatchCase):
@@ -934,10 +934,10 @@
 
     def runTest(self):
         for vid in range(2,100,10):
-            flow_match_test(self, config["port_map"], dl_vlan=vid, max_test=5)
+            flow_match_test(self, config["port_map"], vlan_vid=vid, max_test=5)
         for vid in range(100,4000,389):
-            flow_match_test(self, config["port_map"], dl_vlan=vid, max_test=5)
-        flow_match_test(self, config["port_map"], dl_vlan=4094, max_test=5)
+            flow_match_test(self, config["port_map"], vlan_vid=vid, max_test=5)
+        flow_match_test(self, config["port_map"], vlan_vid=4094, max_test=5)
 
 class SingleWildcardMatchPriority(BaseMatchCase):
     """
@@ -1161,11 +1161,11 @@
             wc |= required_wildcards(self)
             if wc & ofp.OFPFW_DL_VLAN:
                 # Set nonzero VLAN id to avoid sending priority-tagged packet
-                dl_vlan = vid
+                vlan_vid = vid
             else:
-                dl_vlan = -1
+                vlan_vid = -1
             flow_match_test(self, config["port_map"], wildcards=wc, 
-                            dl_vlan=dl_vlan, max_test=10)
+                            vlan_vid=vlan_vid, max_test=10)
 
 class SingleWildcardMatchTagged(BaseMatchCase):
     """
@@ -1175,7 +1175,7 @@
         vid = test_param_get('vid', default=TEST_VID_DEFAULT)
         for wc in WILDCARD_VALUES:
             wc |= required_wildcards(self)
-            flow_match_test(self, config["port_map"], wildcards=wc, dl_vlan=vid,
+            flow_match_test(self, config["port_map"], wildcards=wc, vlan_vid=vid,
                             max_test=10)
 
 class AllExceptOneWildcardMatch(BaseMatchCase):
@@ -1195,11 +1195,11 @@
             all_exp_one_wildcard |= required_wildcards(self)
             if all_exp_one_wildcard & ofp.OFPFW_DL_VLAN:
                 # Set nonzero VLAN id to avoid sending priority-tagged packet
-                dl_vlan = vid
+                vlan_vid = vid
             else:
-                dl_vlan = -1
+                vlan_vid = -1
             flow_match_test(self, config["port_map"], wildcards=all_exp_one_wildcard,
-                            dl_vlan=dl_vlan)
+                            vlan_vid=vlan_vid)
 
 class AllExceptOneWildcardMatchTagged(BaseMatchCase):
     """
@@ -1210,7 +1210,7 @@
         for all_exp_one_wildcard in NO_WILDCARD_VALUES:
             all_exp_one_wildcard |= required_wildcards(self)
             flow_match_test(self, config["port_map"], wildcards=all_exp_one_wildcard,
-                            dl_vlan=vid)
+                            vlan_vid=vid)
 
 class AllWildcardMatch(BaseMatchCase):
     """
@@ -1233,7 +1233,7 @@
     def runTest(self):
         vid = test_param_get('vid', default=TEST_VID_DEFAULT)
         flow_match_test(self, config["port_map"], wildcards=ofp.OFPFW_ALL, 
-                        dl_vlan=vid)
+                        vlan_vid=vid)
 
 @group('smoke')
 class AddVLANTag(BaseMatchCase):
@@ -1251,7 +1251,7 @@
         len_w_vid = 104
         pkt = simple_tcp_packet(pktlen=len)
         exp_pkt = simple_tcp_packet(pktlen=len_w_vid, dl_vlan_enable=True, 
-                                    dl_vlan=new_vid)
+                                    vlan_vid=new_vid)
         vid_act = ofp.action.set_vlan_vid()
         vid_act.vlan_vid = new_vid
 
@@ -1281,7 +1281,7 @@
 
     def runTest(self):
         vid = test_param_get('vid', default=TEST_VID_DEFAULT)
-        pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=vid)
+        pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=vid)
         of_ports = config["port_map"].keys()
         of_ports.sort()
         ing_port = of_ports[0]
@@ -1305,8 +1305,8 @@
             skip_message_emit(self, "Modify VLAN tag test")
             return
 
-        pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=old_vid)
-        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=new_vid)
+        pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=old_vid)
+        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=new_vid)
         vid_act = ofp.action.set_vlan_vid()
         vid_act.vlan_vid = new_vid
 
@@ -1346,9 +1346,9 @@
         len_w_vid = 104
         untagged_pkt = simple_tcp_packet(pktlen=len_untagged)
         tagged_pkt = simple_tcp_packet(pktlen=len_w_vid, 
-                                       dl_vlan_enable=True, dl_vlan=old_vid)
+                                       dl_vlan_enable=True, vlan_vid=old_vid)
         exp_pkt = simple_tcp_packet(pktlen=len_w_vid, dl_vlan_enable=True,
-                                    dl_vlan=new_vid)
+                                    vlan_vid=new_vid)
         wildcards = (required_wildcards(self) | ofp.OFPFW_DL_VLAN |
                      ofp.OFPFW_DL_VLAN_PCP)
         vid_act = ofp.action.set_vlan_vid()
@@ -1381,8 +1381,8 @@
             skip_message_emit(self, "Modify VLAN priority test")
             return
 
-        pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=vid, dl_vlan_pcp=old_vlan_pcp)
-        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=vid, dl_vlan_pcp=new_vlan_pcp)
+        pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=vid, vlan_pcp=old_vlan_pcp)
+        exp_pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=vid, vlan_pcp=new_vlan_pcp)
         vid_act = ofp.action.set_vlan_pcp()
         vid_act.vlan_pcp = new_vlan_pcp
 
@@ -1403,7 +1403,7 @@
         len_w_vid = 104
         len = 100
         pkt = simple_tcp_packet(pktlen=len_w_vid, dl_vlan_enable=True, 
-                                dl_vlan=old_vid)
+                                vlan_vid=old_vid)
         exp_pkt = simple_tcp_packet(pktlen=len)
         vid_act = ofp.action.strip_vlan()
 
@@ -1425,7 +1425,7 @@
         len_w_vid = 104
         len_untagged = 100
         pkt = simple_tcp_packet(pktlen=len_w_vid, dl_vlan_enable=True, 
-                                dl_vlan=old_vid)
+                                vlan_vid=old_vid)
         exp_pkt = simple_tcp_packet(pktlen=len_untagged)
         wildcards = (required_wildcards(self) | ofp.OFPFW_DL_VLAN |
                      ofp.OFPFW_DL_VLAN_PCP)
@@ -1441,13 +1441,13 @@
     Pass back a dictionary with default packet arguments
     """
     args = {}
-    args["dl_src"] = '00:23:45:67:89:AB'
+    args["eth_src"] = '00:23:45:67:89:AB'
 
     dl_vlan_enable=False
-    dl_vlan=-1
+    vlan_vid=-1
     if config["test-params"]["vid"]:
         dl_vlan_enable=True
-        dl_vlan = config["test-params"]["vid"]
+        vlan_vid = config["test-params"]["vid"]
 
 # Unpack operator is ** on a dictionary
 
@@ -1463,7 +1463,7 @@
             skip_message_emit(self, "ModifyL2Src test")
             return
 
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_src'],
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_src'],
                                                 check_test_params=True)
         flow_match_test(self, config["port_map"], pkt=pkt, exp_pkt=exp_pkt, 
                         action_list=acts, max_test=2)
@@ -1478,7 +1478,7 @@
             skip_message_emit(self, "ModifyL2dst test")
             return
 
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_dst'],
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_dst'],
                                                 check_test_params=True)
         flow_match_test(self, config["port_map"], pkt=pkt, exp_pkt=exp_pkt, 
                         action_list=acts, max_test=2)
@@ -1598,7 +1598,7 @@
             skip_message_emit(self, "ModifyL2dstMC test")
             return
 
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_dst'],
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_dst'],
                                                 check_test_params=True)
         flow_match_test(self, config["port_map"], pkt=pkt, exp_pkt=exp_pkt, 
                         action_list=acts, max_test=2, egr_count=-1)
@@ -1613,7 +1613,7 @@
             skip_message_emit(self, "ModifyL2dstIngress test")
             return
 
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_dst'],
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_dst'],
                                                 check_test_params=True)
         flow_match_test(self, config["port_map"], pkt=pkt, exp_pkt=exp_pkt, 
                         action_list=acts, max_test=2, egr_count=0,
@@ -1629,7 +1629,7 @@
             skip_message_emit(self, "ModifyL2dstMC test")
             return
 
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_dst'],
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_dst'],
                                                 check_test_params=True)
         flow_match_test(self, config["port_map"], pkt=pkt, exp_pkt=exp_pkt, 
                         action_list=acts, max_test=2, egr_count=-1,
@@ -1645,7 +1645,7 @@
             skip_message_emit(self, "ModifyL2SrcMC test")
             return
 
-        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['dl_src'],
+        (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=['eth_src'],
                                                 check_test_params=True)
         flow_match_test(self, config["port_map"], pkt=pkt, exp_pkt=exp_pkt, 
                         action_list=acts, max_test=2, egr_count=-1)
@@ -1661,7 +1661,7 @@
             skip_message_emit(self, "ModifyL2SrcDstMC test")
             return
 
-        mod_fields = ['dl_dst', 'dl_src']
+        mod_fields = ['eth_dst', 'eth_src']
         (pkt, exp_pkt, acts) = pkt_action_setup(self, mod_fields=mod_fields,
                                                 check_test_params=True)
         flow_match_test(self, config["port_map"], pkt=pkt, exp_pkt=exp_pkt, 
@@ -1678,7 +1678,7 @@
             skip_message_emit(self, "ModifyL2DstVIDMC test")
             return
 
-        mod_fields = ['dl_dst', 'dl_vlan']
+        mod_fields = ['eth_dst', 'vlan_vid']
         (pkt, exp_pkt, acts) = pkt_action_setup(self, 
              start_field_vals={'dl_vlan_enable':True}, mod_fields=mod_fields,
                                                 check_test_params=True)
@@ -1694,11 +1694,11 @@
         sup_acts = self.supported_actions
 
         sup_map = {
-            "dl_dst" : ofp.OFPAT_SET_DL_DST,
-            "dl_src" : ofp.OFPAT_SET_DL_SRC,
+            "eth_dst" : ofp.OFPAT_SET_DL_DST,
+            "eth_src" : ofp.OFPAT_SET_DL_SRC,
             "dl_vlan_enable" : ofp.OFPAT_SET_VLAN_VID,
-            "dl_vlan" : ofp.OFPAT_SET_VLAN_VID,
-            "dl_vlan_pcp" : ofp.OFPAT_SET_VLAN_PCP,
+            "vlan_vid" : ofp.OFPAT_SET_VLAN_VID,
+            "vlan_pcp" : ofp.OFPAT_SET_VLAN_PCP,
             "ip_src" : ofp.OFPAT_SET_NW_SRC,
             "ip_dst" : ofp.OFPAT_SET_NW_DST,
             "ip_tos" : ofp.OFPAT_SET_NW_TOS,
@@ -1910,7 +1910,7 @@
 
         delete_all_flows(self.controller)
 
-        pkt = simple_tcp_packet(dl_vlan_enable=True, dl_vlan=2)
+        pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=2)
         ingress_port = of_ports[0]
         egress_port = of_ports[1]
 
@@ -1966,26 +1966,26 @@
         wildcards = required_wildcards(self)
         # TODO in_port
         if not (wildcards & ofp.OFPFW_DL_SRC):
-            testField("dl_src", [0xff]*6)
+            testField("eth_src", [0xff]*6)
         if not (wildcards & ofp.OFPFW_DL_DST):
-            testField("dl_dst", [0xff]*6)
+            testField("eth_dst", [0xff]*6)
         if not (wildcards & ofp.OFPFW_DL_TYPE):
-            testField("dl_type", 0xffff)
+            testField("eth_type", 0xffff)
         if not (wildcards & ofp.OFPFW_DL_VLAN):
-            testField("dl_vlan", 0xfff)
-        # TODO dl_vlan_pcp
+            testField("vlan_vid", 0xfff)
+        # TODO vlan_pcp
         if not (wildcards & ofp.OFPFW_NW_SRC_ALL):
-            testField("nw_src", 0xffffffff)
+            testField("ipv4_src", 0xffffffff)
         if not (wildcards & ofp.OFPFW_NW_DST_ALL):
-            testField("nw_dst", 0xffffffff)
+            testField("ipv4_dst", 0xffffffff)
         if not (wildcards & ofp.OFPFW_NW_TOS):
-            testField("nw_tos", 0x3f)
+            testField("ip_dscp", 0x3f)
         if not (wildcards & ofp.OFPFW_NW_PROTO):
-            testField("nw_proto", 0xff)
+            testField("ip_proto", 0xff)
         if not (wildcards & ofp.OFPFW_TP_SRC):
-            testField("tp_src", 0xffff)
+            testField("tcp_src", 0xffff)
         if not (wildcards & ofp.OFPFW_TP_DST):
-            testField("tp_dst", 0xffff)
+            testField("tcp_dst", 0xffff)
 
 class DirectBadPacketBase(base_tests.SimpleDataPlane):
     """
@@ -2018,16 +2018,16 @@
         match = ofp.ofp_match()
         match.wildcards = ofp.OFPFW_ALL
         fields = {
-            'dl_dst': ofp.OFPFW_DL_DST,
-            'dl_src': ofp.OFPFW_DL_SRC,
-            'dl_type': ofp.OFPFW_DL_TYPE,
-            'dl_vlan': ofp.OFPFW_DL_VLAN,
-            'nw_src': ofp.OFPFW_NW_SRC_MASK,
-            'nw_dst': ofp.OFPFW_NW_DST_MASK,
-            'nw_tos': ofp.OFPFW_NW_TOS,
-            'nw_proto': ofp.OFPFW_NW_PROTO,
-            'tp_src': ofp.OFPFW_TP_SRC,
-            'tp_dst': ofp.OFPFW_TP_DST,
+            'eth_dst': ofp.OFPFW_DL_DST,
+            'eth_src': ofp.OFPFW_DL_SRC,
+            'eth_type': ofp.OFPFW_DL_TYPE,
+            'vlan_vid': ofp.OFPFW_DL_VLAN,
+            'ipv4_src': ofp.OFPFW_NW_SRC_MASK,
+            'ipv4_dst': ofp.OFPFW_NW_DST_MASK,
+            'ip_dscp': ofp.OFPFW_NW_TOS,
+            'ip_proto': ofp.OFPFW_NW_PROTO,
+            'tcp_src': ofp.OFPFW_TP_SRC,
+            'tcp_dst': ofp.OFPFW_TP_DST,
         }
         for key in kwargs:
             setattr(match, key, kwargs[key])
@@ -2142,8 +2142,8 @@
         pass
 
     def runTestWithProto(self, protoName = 'TCP'):
-        dl_dst='00:01:02:03:04:05'
-        dl_src='00:06:07:08:09:0a'
+        eth_dst='00:01:02:03:04:05'
+        eth_src='00:06:07:08:09:0a'
         ip_src='192.168.0.1'
         ip_dst='192.168.0.2'
         ip_tos=0
@@ -2161,7 +2161,7 @@
         else:
             raise Exception("Passed in unknown proto name")
 
-        match_pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
+        match_pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \
             scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos)/ \
             tp(sport=tcp_sport, dport=tcp_dport)
         match = packet_to_flow_match(self, match_pkt)
@@ -2178,32 +2178,32 @@
         
         # Try incomplete IP headers
         testPacket("Incomplete IP header (1 bytes)",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto))[0:1],
             self.RESULT_NOMATCH,
         )
         testPacket("Incomplete IP header (2 bytes)",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto))[0:2],
             self.RESULT_NOMATCH,
         )
         testPacket("Incomplete IP header (3 bytes)",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto))[0:3],
             self.RESULT_NOMATCH,
         )
         testPacket("Incomplete IP header (12 bytes)",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto))[0:12],
             self.RESULT_NOMATCH,
         )
         testPacket("Incomplete IP header (16 bytes)",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto))[0:16],
             self.RESULT_NOMATCH,
         )
         testPacket("Incomplete IP header (19 bytes)",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto))[0:19],
             self.RESULT_NOMATCH,
         )
@@ -2213,29 +2213,29 @@
         # we initiatlize once with a non-matching full packet and once with a 
         # matching full packet.
         testPacket("Non-Matching TCP packet, warming buffer",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto)/ \
                 tp(sport=tcp_sport, dport=tcp_dport + 1),
             self.RESULT_NOMATCH,
         )
         testPacket("Missing TCP header, buffer warmed with non-match",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto),
             self.RESULT_NOMATCH,
         )
         testPacket("Matching TCP packet, warming buffer",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto)/ \
                 tp(sport=tcp_sport, dport=tcp_dport),
             self.RESULT_MATCH,
         )
         testPacket("Missing TCP header, buffer warmed with match",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto),
             self.RESULT_NOMATCH,
         )
         testPacket("Truncated TCP header: 2 bytes",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto)/ \
                 (str(tp(sport=tcp_sport, dport=tcp_dport))[0:2]),
             self.RESULT_NOMATCH,
@@ -2265,27 +2265,27 @@
             self.RESULT_NOMATCH,
         )
         testPacket("Missing TCP header, corrupt ihl",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=0xf, proto=proto),
             self.RESULT_NOMATCH,
         )
         testPacket("Missing TCP header, corrupt total length",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto, len= 100),
             self.RESULT_NOMATCH,
         )
         testPacket("Missing TCP header, corrupt ihl and total length",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=0xf, proto=proto, len=43),
             self.RESULT_NOMATCH,
         )
         testPacket("Incomplete IP header (12 bytes), corrupt ihl and total length",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto, ihl=10, len=43))[0:12],
             self.RESULT_NOMATCH,
         )
         testPacket("Incomplete IP header (16 bytes), corrupt ihl and total length",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 str(scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto, ihl=10, len=43))[0:16],
             self.RESULT_NOMATCH,
         )
@@ -2294,7 +2294,7 @@
         # destination ports. As that is all we care about during matching, some
         # implementations may match and some may drop the packet
         testPacket("Incomplete TCP header: src/dst port present",
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, proto=proto)/ \
                 (str(tp(sport=tcp_sport, dport=tcp_dport))[0:4]),
             self.RESULT_ANY,
@@ -2303,7 +2303,7 @@
         for i in range(1):
             for length in range(40 / 4): # IPv4 options are a maximum of 40 in length
                 bytes = "".join([("%c" % random.randint(0, 255)) for x in range(length * 4)])
-                eth = scapy.Ether(dst=dl_dst, src=dl_src)
+                eth = scapy.Ether(dst=eth_dst, src=eth_src)
                 ip = scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=5 + length, proto=proto)
                 tcp = tp(sport=tcp_sport, dport=tcp_dport+1)
                 pkt = eth / ip
@@ -2314,7 +2314,7 @@
                     self.RESULT_NOMATCH
                 )
 
-                eth = scapy.Ether(dst=dl_dst, src=dl_src)
+                eth = scapy.Ether(dst=eth_dst, src=eth_src)
                 ip = scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=5 + length, proto=proto)
                 tcp = tp(sport=tcp_sport, dport=tcp_dport)
                 pkt = eth / ip
@@ -2346,8 +2346,8 @@
     Verify LLC/SNAP parsing and matching. Focus on packet corruptions 
     """
     def runTest(self):
-        dl_dst='00:01:02:03:04:05'
-        dl_src='00:06:07:08:09:0a'
+        eth_dst='00:01:02:03:04:05'
+        eth_src='00:06:07:08:09:0a'
         ip_src='192.168.0.1'
         ip_dst='192.168.0.2'
         ip_tos=0
@@ -2359,7 +2359,7 @@
         IS_NOT_SNAP_IP = 3
 
         def testPacketTcpMatch(title, llc):
-            match_pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            match_pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos)/ \
                 scapy.TCP(sport=tcp_sport, dport=tcp_dport)
             match = packet_to_flow_match(self, match_pkt)
@@ -2371,7 +2371,7 @@
             self.testPktsAgainstFlow(
                 [[
                     "TCP match - LLC frame correct length - %s" % title,
-                    scapy.Ether(dst=dl_dst, src=dl_src, type=len(llc)) / llc,
+                    scapy.Ether(dst=eth_dst, src=eth_src, type=len(llc)) / llc,
                     self.RESULT_ANY,
                 ]],
                 act, match
@@ -2382,7 +2382,7 @@
             self.testPktsAgainstFlow(
                 [[
                     "TCP match - LLC frame corrupted length - %s" % title,
-                    scapy.Ether(dst=dl_dst, src=dl_src, type=ethLen) / llc,
+                    scapy.Ether(dst=eth_dst, src=eth_src, type=ethLen) / llc,
                     self.RESULT_ANY,
                 ]],
                 act, match
@@ -2390,7 +2390,7 @@
 
         def testPacketEthSrcDstMatch(title, llc):
             # Matching based on Ethernet source and destination
-            match_pkt = scapy.Ether(dst=dl_dst, src=dl_src)
+            match_pkt = scapy.Ether(dst=eth_dst, src=eth_src)
             match = packet_to_flow_match(self, match_pkt)
             self.assertTrue(match is not None, 
                             "Could not generate flow match from pkt")
@@ -2399,7 +2399,7 @@
             self.testPktsAgainstFlow(
                 [[
                     "Eth addr match - LLC frame correct length- %s" % title,
-                    scapy.Ether(dst=dl_dst, src=dl_src, type=len(llc)) / llc,
+                    scapy.Ether(dst=eth_dst, src=eth_src, type=len(llc)) / llc,
                     self.RESULT_MATCH,
                 ]],
                 ofp.action.output(), match
@@ -2410,7 +2410,7 @@
             self.testPktsAgainstFlow(
                 [[
                     "Eth addr match - LLC frame corrupted length- %s" % title,
-                    scapy.Ether(dst=dl_dst, src=dl_src, type=ethLen) / llc,
+                    scapy.Ether(dst=eth_dst, src=eth_src, type=ethLen) / llc,
                     self.RESULT_ANY,
                 ]],
                 ofp.action.output(), match
@@ -2418,7 +2418,7 @@
             
         def testPacketEthSrcDstTypeMatch(title, llc, is_snap_ip):
             # Matching based on Ethernet source, destination and type
-            match_pkt = scapy.Ether(dst=dl_dst, src=dl_src, type=0x800)
+            match_pkt = scapy.Ether(dst=eth_dst, src=eth_src, type=0x800)
             match = packet_to_flow_match(self, match_pkt)
             self.assertTrue(match is not None, 
                             "Could not generate flow match from pkt")
@@ -2432,7 +2432,7 @@
             self.testPktsAgainstFlow(
                 [[
                     "Eth addr+type match - LLC frame correct length - %s" % title,
-                    scapy.Ether(dst=dl_dst, src=dl_src, type=len(llc)) / llc,
+                    scapy.Ether(dst=eth_dst, src=eth_src, type=len(llc)) / llc,
                     is_match,
                 ]],
                 ofp.action.output(), match
@@ -2443,7 +2443,7 @@
             self.testPktsAgainstFlow(
                 [[
                     "Eth addr+type match - LLC frame corrupted length - %s" % title,
-                    scapy.Ether(dst=dl_dst, src=dl_src, type=ethLen) / llc,
+                    scapy.Ether(dst=eth_dst, src=eth_src, type=ethLen) / llc,
                     self.RESULT_ANY,
                 ]],
                 ofp.action.output(), match
@@ -2499,8 +2499,8 @@
     Verify LLC/SNAP parsing (valid and corrupted packets) and matching
     """
     def runTest(self):
-        dl_dst='00:01:02:03:04:05'
-        dl_src='00:06:07:08:09:0a'
+        eth_dst='00:01:02:03:04:05'
+        eth_src='00:06:07:08:09:0a'
         ip_src='192.168.0.1'
         ip_dst='192.168.0.2'
         ip_tos=0
@@ -2513,7 +2513,7 @@
         IS_NOT_SNAP = 3
 
         def testPacketEthTypeIP(title, llc, is_snap):
-            match_pkt = scapy.Ether(dst=dl_dst, src=dl_src, type=0x800)
+            match_pkt = scapy.Ether(dst=eth_dst, src=eth_src, type=0x800)
             match = packet_to_flow_match(self, match_pkt)
             self.assertTrue(match is not None, 
                             "Could not generate flow match from pkt")
@@ -2525,14 +2525,14 @@
                 result = self.RESULT_MATCH
             pkts.append([
                 "Ether type 0x800 match - %s" % title,
-                scapy.Ether(dst=dl_dst, src=dl_src, type=len(llc)) / llc,
+                scapy.Ether(dst=eth_dst, src=eth_src, type=len(llc)) / llc,
                 result,
             ])
             act = ofp.action.output()
             self.testPktsAgainstFlow(pkts, act, match)
     
         def testPacketEthTypeNotEth(title, llc, is_snap):
-            match_pkt = scapy.Ether(dst = dl_dst, src = dl_src, 
+            match_pkt = scapy.Ether(dst = eth_dst, src = eth_src, 
                                     type = ofp.OFP_DL_TYPE_NOT_ETH_TYPE)
             match = packet_to_flow_match(self, match_pkt)
             self.assertTrue(match is not None, 
@@ -2545,7 +2545,7 @@
                 result = self.RESULT_NOMATCH
             pkts.append([
                 "Ether type OFP_DL_TYPE_NOT_ETH_TYPE match - %s" % title,
-                scapy.Ether(dst=dl_dst, src=dl_src, type=len(llc)) / llc,
+                scapy.Ether(dst=eth_dst, src=eth_src, type=len(llc)) / llc,
                 result,
             ])
             act = ofp.action.output()
@@ -2612,8 +2612,8 @@
         self.testArpHandling()
 
     def testArpHandling(self):
-        dl_dst='00:01:02:03:04:05'
-        dl_src='00:06:07:08:09:0a'
+        eth_dst='00:01:02:03:04:05'
+        eth_src='00:06:07:08:09:0a'
         ip_src='192.168.0.1'
         ip_dst='192.168.0.2'
         ip_src2='192.168.1.1'
@@ -2625,7 +2625,7 @@
         def testPacket(title, arp_match, arp_pkt, result):
             pkts = []
     
-            match_pkt = scapy.Ether(dst=dl_dst, src=dl_src) / arp_match
+            match_pkt = scapy.Ether(dst=eth_dst, src=eth_src) / arp_match
             match = packet_to_flow_match(self, match_pkt)
             self.assertTrue(match is not None, 
                             "Could not generate flow match from pkt")
@@ -2633,7 +2633,7 @@
             
             pkts.append([
                 title,
-                scapy.Ether(dst=dl_dst, src=dl_src) / arp_pkt,
+                scapy.Ether(dst=eth_dst, src=eth_src) / arp_pkt,
                 result,
             ])
     
@@ -2642,7 +2642,7 @@
             
         testPacket("Basic ARP",
             scapy.ARP(psrc=ip_src, pdst=ip_dst, op = 1),
-            scapy.ARP(hwdst = '00:00:00:00:00:00', hwsrc = dl_src,
+            scapy.ARP(hwdst = '00:00:00:00:00:00', hwsrc = eth_src,
                       psrc = ip_src, pdst = ip_dst, hwlen = 6, plen = 4,
                       ptype = 0x800, hwtype = 1, op = 1),
             self.RESULT_MATCH
@@ -2659,8 +2659,8 @@
     Verify VLAN parsing (valid and corrupted packets) and ARP matching
     """
     def runTest(self):
-        dl_dst='00:01:02:03:04:05'
-        dl_src='00:06:07:08:09:0a'
+        eth_dst='00:01:02:03:04:05'
+        eth_src='00:06:07:08:09:0a'
         ip_src='192.168.0.1'
         ip_dst='192.168.0.2'
         ip_src2='192.168.1.1'
@@ -2686,61 +2686,61 @@
             self.testPktsAgainstFlow(pkts, act, match)
 
         testPacket("Basic MAC matching - IPv4 payload",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src)),
-            scapy.Ether(dst=dl_dst, src=dl_src, type=0x800) / scapy.IP(),
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src)),
+            scapy.Ether(dst=eth_dst, src=eth_src, type=0x800) / scapy.IP(),
             self.RESULT_MATCH
         )
         testPacket("Basic MAC matching - VMware beacon - no payload",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src)),
-            scapy.Ether(dst=dl_dst, src=dl_src, type=0x8922),
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src)),
+            scapy.Ether(dst=eth_dst, src=eth_src, type=0x8922),
             self.RESULT_MATCH
         )
         testPacket("Basic MAC matching - VMware beacon - with payload",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src)),
-            scapy.Ether(dst=dl_dst, src=dl_src, type=0x8922)/ ("X" * 1),
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src)),
+            scapy.Ether(dst=eth_dst, src=eth_src, type=0x8922)/ ("X" * 1),
             self.RESULT_MATCH
         )
         testPacket("Basic MAC matching - IPv6 payload",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src)),
-            scapy.Ether(dst=dl_dst, src=dl_src) / scapy.IPv6(),
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src)),
+            scapy.Ether(dst=eth_dst, src=eth_src) / scapy.IPv6(),
             self.RESULT_MATCH
         )
         testPacket("Basic MAC matching with VLAN tag present",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src)),
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src)),
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.Dot1Q(prio=5, vlan=1000)/ \
                 scapy.IP(),
             self.RESULT_MATCH
         )
         testPacket("Basic MAC matching with VLAN tag present",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src),
-                             dl_type=0x800),
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src),
+                             eth_type=0x800),
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.Dot1Q(prio=5, vlan=1000)/ \
                 scapy.IP(),
             self.RESULT_MATCH
         )
         testPacket("Ether matching with VLAN tag present - No type match",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src),
-                             dl_type=0x801),
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src),
+                             eth_type=0x801),
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.Dot1Q(prio=5, vlan=1000)/ \
                 scapy.IP(),
             self.RESULT_NOMATCH
         )
         testPacket("Ether matching with VLAN tag present - No type match 0x8100",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src),
-                             dl_type=0x8100),
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src),
+                             eth_type=0x8100),
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.Dot1Q(prio=5, vlan=1000)/ \
                 scapy.IP(),
             self.RESULT_NOMATCH
         )
         testPacket("IP matching - VLAN tag",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src),
-                             dl_type=0x0800,
-                             nw_src=parse_ip(ip_src), nw_dst=parse_ip(ip_dst)),
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src),
+                             eth_type=0x0800,
+                             ipv4_src=parse_ip(ip_src), ipv4_dst=parse_ip(ip_dst)),
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.Dot1Q(prio=5, vlan=1000)/ \
                 scapy.IP(src=ip_src, dst=ip_dst),
             self.RESULT_MATCH
@@ -2756,8 +2756,8 @@
     the treatment of these cases, so broken out to be non-standard
     """
     def runTest(self):
-        dl_dst='00:01:02:03:04:05'
-        dl_src='00:06:07:08:09:0a'
+        eth_dst='00:01:02:03:04:05'
+        eth_src='00:06:07:08:09:0a'
         ip_src='192.168.0.1'
         ip_dst='192.168.0.2'
         ip_src2='192.168.1.1'
@@ -2782,18 +2782,18 @@
             act = ofp.action.output()
             self.testPktsAgainstFlow(pkts, act, match)
         testPacket("Ether matching with double VLAN tag - Wrong type match",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src),
-                             dl_type=0x800),
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src),
+                             eth_type=0x800),
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.Dot1Q(prio=5, vlan=1000)/ \
                 scapy.Dot1Q(prio=3, vlan=1005)/ \
                 scapy.IP(),
             self.RESULT_NOMATCH
         )
         testPacket("Ether matching with double VLAN tag - Type match",
-            self.createMatch(dl_dst=parse_mac(dl_dst), dl_src=parse_mac(dl_src),
-                             dl_type=0x8100),
-            scapy.Ether(dst=dl_dst, src=dl_src)/ \
+            self.createMatch(eth_dst=parse_mac(eth_dst), eth_src=parse_mac(eth_src),
+                             eth_type=0x8100),
+            scapy.Ether(dst=eth_dst, src=eth_src)/ \
                 scapy.Dot1Q(prio=5, vlan=1000)/ \
                 scapy.Dot1Q(prio=3, vlan=1005)/ \
                 scapy.IP(),
diff --git a/tests/port_stats.py b/tests/port_stats.py
index b4815c2..c4eb1a6 100644
--- a/tests/port_stats.py
+++ b/tests/port_stats.py
@@ -239,7 +239,7 @@
         pkt1 = simple_tcp_packet()
         flow_mod_msg1 = self.buildFlowModMsg(pkt1, ingress_port, egress_port1)
        
-        pkt2 = simple_tcp_packet(dl_src='0:7:7:7:7:7')
+        pkt2 = simple_tcp_packet(eth_src='0:7:7:7:7:7')
         flow_mod_msg2 = self.buildFlowModMsg(pkt2, ingress_port, egress_port2)
        
         logging.info("Inserting flow1")
@@ -315,7 +315,7 @@
         pkt1 = simple_tcp_packet()
         flow_mod_msg1 = self.buildFlowModMsg(pkt1, port0, port1)
        
-        pkt2 = simple_tcp_packet(dl_src='0:7:7:7:7:7')
+        pkt2 = simple_tcp_packet(eth_src='0:7:7:7:7:7')
         flow_mod_msg2 = self.buildFlowModMsg(pkt2, port0, port2)
        
         logging.info("Inserting flow1")