X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fsal%2Fapi%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fmatch%2FMatchTest.java;h=b88ae034d9aa713c96f4ce3ef633f977d5a223b3;hp=cfa53fb7f37c052f2562ae94f5e03792cf386ebb;hb=cb2ae2cbea6632ab6e80ad3673dadb6492802fb3;hpb=cc5814b25b247f5ffe0c17ede1850e71ca06eee6 diff --git a/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/match/MatchTest.java b/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/match/MatchTest.java index cfa53fb7f3..b88ae034d9 100644 --- a/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/match/MatchTest.java +++ b/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/match/MatchTest.java @@ -16,9 +16,6 @@ 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.utils.EtherTypes; import org.opendaylight.controller.sal.utils.IPProtocols; import org.opendaylight.controller.sal.utils.NodeConnectorCreator; @@ -27,7 +24,7 @@ import org.opendaylight.controller.sal.utils.NodeCreator; 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); @@ -63,7 +60,7 @@ public class MatchTest { 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); @@ -137,10 +134,48 @@ public class MatchTest { 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); @@ -151,7 +186,7 @@ public class MatchTest { 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); @@ -167,7 +202,7 @@ public class MatchTest { @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); @@ -184,7 +219,7 @@ public class MatchTest { @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 }; @@ -302,6 +337,21 @@ public class MatchTest { 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 }; @@ -354,7 +404,7 @@ public class MatchTest { @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 }; @@ -420,7 +470,7 @@ public class MatchTest { @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 }; @@ -474,4 +524,118 @@ public class MatchTest { Assert.assertTrue(flipflip.equals(flipped)); } + + @Test + public void testVlanNone() throws Exception { + // The value 0 is used to indicate that no VLAN ID is set + short vlan = (short) 0; + MatchField field = new MatchField(MatchType.DL_VLAN, vlan); + + Assert.assertTrue(field != null); + 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)); + } }