import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
+import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.match.Match;
-import org.opendaylight.controller.sal.match.MatchField;
-import org.opendaylight.controller.sal.match.MatchType;
+import org.opendaylight.controller.sal.core.Property;
+import org.opendaylight.controller.sal.core.Tables;
+import org.opendaylight.controller.sal.core.Tier;
import org.opendaylight.controller.sal.utils.EtherTypes;
import org.opendaylight.controller.sal.utils.IPProtocols;
import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
public class MatchTest {
@Test
public void testMatchCreation() {
- Node node = NodeCreator.createOFNode(7l);
+ Node node = NodeCreator.createOFNode(7L);
NodeConnector port = NodeConnectorCreator.createOFNodeConnector((short) 6, node);
MatchField field = new MatchField(MatchType.IN_PORT, port);
public void testMatchSetGet() {
Match x = new Match();
short val = 2346;
- NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector(val, NodeCreator.createOFNode(1l));
+ NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector(val, NodeCreator.createOFNode(1L));
x.setField(MatchType.IN_PORT, inPort);
Assert.assertTrue(((NodeConnector) x.getField(MatchType.IN_PORT).getValue()).equals(inPort));
Assert.assertTrue((Short) ((NodeConnector) x.getField(MatchType.IN_PORT).getValue()).getID() == val);
Assert.assertTrue(o.equals(proto));
}
+ @Test
+ public void testSetTpSrc() {
+ // Minimum value validation.
+ Match match = new Match();
+ short tp_src = 0;
+ match.setField(MatchType.TP_SRC, tp_src);
+
+ Object o = match.getField(MatchType.TP_SRC).getValue();
+ Assert.assertTrue(o.equals(tp_src));
+
+ // Maximum value validation.
+ match = new Match();
+ tp_src = (short) 0xffff;
+ match.setField(MatchType.TP_SRC, tp_src);
+
+ o = match.getField(MatchType.TP_SRC).getValue();
+ Assert.assertTrue(o.equals(tp_src));
+ }
+
+ @Test
+ public void testSetTpDst() {
+ // Minimum value validation.
+ Match match = new Match();
+ short tp_dst = 0;
+ match.setField(MatchType.TP_DST, tp_dst);
+
+ Object o = match.getField(MatchType.TP_DST).getValue();
+ Assert.assertTrue(o.equals(tp_dst));
+
+ // Maximum value validation.
+ match = new Match();
+ tp_dst = (short) 0xffff;
+ match.setField(MatchType.TP_DST, tp_dst);
+
+ o = match.getField(MatchType.TP_DST).getValue();
+ Assert.assertTrue(o.equals(tp_dst));
+ }
+
@Test
public void testMatchMask() {
Match x = new Match();
- NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector((short) 6, NodeCreator.createOFNode(3l));
+ NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector((short) 6, NodeCreator.createOFNode(3L));
x.setField(MatchType.IN_PORT, inPort);
x.setField(MatchType.DL_VLAN, (short) 28, (short) 0xfff);
Assert.assertFalse(x.getMatches() == 0);
public void testMatchBitMask() {
byte mac[] = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 22, (byte) 12 };
byte mask[] = { (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0 };
- NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector((short) 4095, NodeCreator.createOFNode(7l));
+ NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector((short) 4095, NodeCreator.createOFNode(7L));
MatchField x = new MatchField(MatchType.IN_PORT, inPort);
Assert.assertTrue((x.getMask()) == null);
@Test
public void testNullMask() {
byte mac[] = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 22, (byte) 12 };
- NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector((short) 2000, NodeCreator.createOFNode(7l));
+ NodeConnector inPort = NodeConnectorCreator.createOFNodeConnector((short) 2000, NodeCreator.createOFNode(7L));
MatchField x = new MatchField(MatchType.IN_PORT, inPort);
Assert.assertTrue(x.getBitMask() == 0);
@Test
public void testEquality() throws Exception {
- Node node = NodeCreator.createOFNode(7l);
+ Node node = NodeCreator.createOFNode(7L);
NodeConnector port = NodeConnectorCreator.createOFNodeConnector((short) 24, node);
NodeConnector port2 = NodeConnectorCreator.createOFNodeConnector((short) 24, node);
byte srcMac[] = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9a, (byte) 0xbc };
Assert.assertTrue(match1.equals(match2));
}
+ @Test
+ public void testHashCodeWithReverseMatch() throws Exception {
+ InetAddress srcIP1 = InetAddress.getByName("1.1.1.1");
+ InetAddress ipMask1 = InetAddress.getByName("255.255.255.255");
+ InetAddress srcIP2 = InetAddress.getByName("2.2.2.2");
+ InetAddress ipMask2 = InetAddress.getByName("255.255.255.255");
+ MatchField field1 = new MatchField(MatchType.NW_SRC, srcIP1, ipMask1);
+ MatchField field2 = new MatchField(MatchType.NW_DST, srcIP2, ipMask2);
+ Match match1 = new Match();
+ match1.setField(field1);
+ match1.setField(field2);
+ Match match2 = match1.reverse();
+ Assert.assertFalse(match1.hashCode() == match2.hashCode());
+ }
+
@Test
public void testHashCode() throws Exception {
byte srcMac1[] = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9a, (byte) 0xbc };
@Test
public void testCloning() throws Exception {
- Node node = NodeCreator.createOFNode(7l);
+ Node node = NodeCreator.createOFNode(7L);
NodeConnector port = NodeConnectorCreator.createOFNodeConnector((short) 24, node);
byte srcMac[] = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9a, (byte) 0xbc };
byte dstMac[] = { (byte) 0x1a, (byte) 0x2b, (byte) 0x3c, (byte) 0x4d, (byte) 0x5e, (byte) 0x6f };
@Test
public void testFlip() throws Exception {
- Node node = NodeCreator.createOFNode(7l);
+ Node node = NodeCreator.createOFNode(7L);
NodeConnector port = NodeConnectorCreator.createOFNodeConnector((short) 24, node);
byte srcMac[] = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9a, (byte) 0xbc };
byte dstMac[] = { (byte) 0x1a, (byte) 0x2b, (byte) 0x3c, (byte) 0x4d, (byte) 0x5e, (byte) 0x6f };
Assert.assertTrue(field.getValue().equals(new Short(vlan)));
Assert.assertTrue(field.isValid());
}
+
+ @Test
+ public void testIntersection() throws UnknownHostException {
+ Short ethType = Short.valueOf((short)0x800);
+ InetAddress ip1 = InetAddress.getByName("1.1.1.1");
+ InetAddress ip2 = InetAddress.getByName("1.1.1.0");
+ InetAddress ipm2 = InetAddress.getByName("255.255.255.0");
+ InetAddress ip3 = InetAddress.getByName("1.3.0.0");
+ InetAddress ipm3 = InetAddress.getByName("255.255.0.0");
+ InetAddress ip4 = InetAddress.getByName("1.3.4.4");
+ InetAddress ipm4 = InetAddress.getByName("255.255.255.0");
+
+ Match m1 = new Match();
+ m1.setField(MatchType.DL_TYPE, ethType);
+ m1.setField(MatchType.NW_SRC, ip1);
+
+ Match m2 = new Match();
+ m2.setField(MatchType.DL_TYPE, ethType);
+ m2.setField(MatchType.NW_SRC, ip2, ipm2);
+
+ Match m3 = new Match();
+ m3.setField(MatchType.DL_TYPE, ethType);
+ m3.setField(MatchType.NW_SRC, ip3, ipm3);
+ m3.setField(MatchType.NW_PROTO, IPProtocols.TCP.byteValue());
+
+ Match m3r = m3.reverse();
+ Assert.assertTrue(m3.intersetcs(m3r));
+
+ Assert.assertTrue(m1.intersetcs(m2));
+ Assert.assertTrue(m2.intersetcs(m1));
+ Assert.assertFalse(m1.intersetcs(m3));
+ Assert.assertTrue(m1.intersetcs(m3r));
+ Assert.assertFalse(m3.intersetcs(m1));
+ Assert.assertTrue(m3.intersetcs(m1.reverse()));
+ Assert.assertFalse(m2.intersetcs(m3));
+ Assert.assertFalse(m3.intersetcs(m2));
+ Assert.assertTrue(m2.intersetcs(m3r));
+
+
+ Match i = m1.getIntersection(m2);
+ Assert.assertTrue(((Short)i.getField(MatchType.DL_TYPE).getValue()).equals(ethType));
+ // Verify intersection of IP addresses is correct
+ Assert.assertTrue(((InetAddress)i.getField(MatchType.NW_SRC).getValue()).equals(ip1));
+ Assert.assertNull(i.getField(MatchType.NW_SRC).getMask());
+
+ // Empty set
+ i = m2.getIntersection(m3);
+ Assert.assertNull(i);
+
+ Match m4 = new Match();
+ m4.setField(MatchType.DL_TYPE, ethType);
+ m4.setField(MatchType.NW_PROTO, IPProtocols.TCP.byteValue());
+ m3.setField(MatchType.NW_SRC, ip4, ipm4);
+ Assert.assertTrue(m4.intersetcs(m3));
+
+ // Verify intersection of IP and IP mask addresses is correct
+ Match ii = m3.getIntersection(m4);
+ Assert.assertTrue(((InetAddress)ii.getField(MatchType.NW_SRC).getValue()).equals(ip4));
+ Assert.assertTrue(((InetAddress)ii.getField(MatchType.NW_SRC).getMask()).equals(ipm4));
+
+ Match m5 = new Match();
+ m5.setField(MatchType.DL_TYPE, ethType);
+ m3.setField(MatchType.NW_SRC, ip3, ipm3);
+ m5.setField(MatchType.NW_PROTO, IPProtocols.UDP.byteValue());
+ Assert.assertFalse(m5.intersetcs(m3));
+ Assert.assertFalse(m5.intersetcs(m4));
+ Assert.assertTrue(m5.intersetcs(m5));
+ Assert.assertFalse(m3.intersetcs(m5));
+ Assert.assertFalse(m4.intersetcs(m5));
+
+
+ Match i2 = m4.getIntersection(m3);
+ Assert.assertFalse(i2.getMatches() == 0);
+ Assert.assertFalse(i2.getMatchesList().isEmpty());
+ Assert.assertTrue(((InetAddress)i2.getField(MatchType.NW_SRC).getValue()).equals(ip3));
+ Assert.assertTrue(((InetAddress)i2.getField(MatchType.NW_SRC).getMask()).equals(ipm3));
+ Assert.assertTrue(((Byte)i2.getField(MatchType.NW_PROTO).getValue()).equals(IPProtocols.TCP.byteValue()));
+
+ byte src[] = {(byte)0, (byte)0xab,(byte)0xbc,(byte)0xcd,(byte)0xde,(byte)0xef};
+ byte dst[] = {(byte)0x10, (byte)0x11,(byte)0x12,(byte)0x13,(byte)0x14,(byte)0x15};
+ Short srcPort = (short)1024;
+ Short dstPort = (short)80;
+
+ // Check identity
+ Match m6 = new Match();
+ m6.setField(MatchType.DL_SRC, src);
+ m6.setField(MatchType.DL_DST, dst);
+ m6.setField(MatchType.NW_SRC, ip2, ipm2);
+ m6.setField(MatchType.NW_DST, ip3, ipm3);
+ m6.setField(MatchType.NW_PROTO, IPProtocols.UDP.byteValue());
+ m6.setField(MatchType.TP_SRC, srcPort);
+ m6.setField(MatchType.TP_DST, dstPort);
+ Assert.assertTrue(m6.intersetcs(m6));
+ Assert.assertTrue(m6.getIntersection(m6).equals(m6));
+
+ // Empty match, represents the universal set (all packets)
+ Match u = new Match();
+ Assert.assertTrue(m6.getIntersection(u).equals(m6));
+ Assert.assertTrue(u.getIntersection(m6).equals(m6));
+
+ // No intersection with null match, empty set
+ Assert.assertNull(m6.getIntersection(null));
+ }
+
+ @Test
+ public void testMetadata() {
+ Property tier1 = new Tier(1);
+ Property tier2 = new Tier(2);
+ Property table1 = new Tables((byte)0x7f);
+ Match m1 = new Match();
+ List<Property> resprops = null;
+ resprops = m1.getMetadatas();
+ // This should be null
+ Assert.assertTrue(resprops.isEmpty());
+ m1.setMetadata("tier1", tier1);
+ m1.setMetadata("tier2", tier2);
+ m1.setMetadata("table1", table1);
+ resprops = m1.getMetadatas();
+ // Check for the number of elements in it
+ Assert.assertTrue(resprops.size() == 3);
+ // Check if the elements are in it
+ Assert.assertTrue(resprops.contains(tier1));
+ Assert.assertTrue(resprops.contains(tier2));
+ Assert.assertTrue(resprops.contains(table1));
+ // Check for single elements retrieve
+ Assert.assertTrue(m1.getMetadata("tier1").equals(tier1));
+ Assert.assertTrue(m1.getMetadata("tier2").equals(tier2));
+ Assert.assertTrue(m1.getMetadata("table1").equals(table1));
+ // Now remove an element and make sure the remaining are
+ // correct
+ m1.removeMetadata("tier1");
+
+ resprops = m1.getMetadatas();
+ // Check for the number of elements in it
+ Assert.assertTrue(resprops.size() == 2);
+ // Check if the elements are in it
+ Assert.assertFalse(resprops.contains(tier1));
+ Assert.assertTrue(resprops.contains(tier2));
+ Assert.assertTrue(resprops.contains(table1));
+ // Check for single elements retrieve
+ Assert.assertTrue(m1.getMetadata("table1").equals(table1));
+ Assert.assertTrue(m1.getMetadata("tier2").equals(tier2));
+ Assert.assertNull(m1.getMetadata("tier1"));
+
+ // Check for an element never existed
+ Assert.assertNull(m1.getMetadata("table100"));
+
+ // Remove them all
+ m1.removeMetadata("tier2");
+ m1.removeMetadata("table1");
+
+ // Remove also a non-existent one
+ m1.removeMetadata("table100");
+
+ resprops = m1.getMetadatas();
+ // Check there are no elements left
+ Assert.assertTrue(resprops.size() == 0);
+
+ // Now check for exception on setting null values
+ try {
+ m1.setMetadata("foo", null);
+ // The line below should never be reached
+ Assert.assertTrue(false);
+ } catch (NullPointerException nue) {
+ // NPE should be raised for null value
+ Assert.assertTrue(true);
+ }
+
+ // Now check on using null key
+ try {
+ m1.setMetadata(null, table1);
+ // The line below should never be reached
+ Assert.assertTrue(false);
+ } catch (NullPointerException nue) {
+ // NPE should be raised for null value
+ Assert.assertTrue(true);
+ }
+
+ // Now check on using null key and null value
+ try {
+ m1.setMetadata(null, null);
+ // The line below should never be reached
+ Assert.assertTrue(false);
+ } catch (NullPointerException nue) {
+ // NPE should be raised for null value
+ Assert.assertTrue(true);
+ }
+ }
}