Jonathan Hart | 23701d1 | 2014-04-03 10:45:48 -0700 | [diff] [blame] | 1 | package net.onrc.onos.core.util; |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 2 | |
| 3 | import static org.junit.Assert.assertEquals; |
| 4 | import static org.junit.Assert.assertTrue; |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 5 | |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 6 | import net.floodlightcontroller.util.MACAddress; |
| 7 | |
| 8 | import org.junit.Before; |
| 9 | import org.junit.Test; |
| 10 | |
| 11 | public class FlowEntryTest { |
| 12 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 13 | FlowEntry entry; |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 14 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 15 | FlowId flowId = new FlowId(0x1234); |
| 16 | FlowEntryId flowEntryId = new FlowEntryId(0x5678); |
| 17 | int idleTimeout = 5; |
| 18 | int hardTimeout = 10; |
| 19 | int priority = 15; |
| 20 | FlowEntryMatch match; |
| 21 | FlowEntryActions actions; |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 22 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 23 | Dpid dpid = new Dpid(0xCAFE); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 24 | |
Yuta HIGUCHI | fb56450 | 2014-06-16 21:29:00 -0700 | [diff] [blame] | 25 | PortNumber inport = new PortNumber((short) 1); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 26 | byte[] byte1 = {1, 2, 3, 4, 5, 6}; |
| 27 | byte[] byte2 = {6, 5, 4, 3, 2, 1}; |
| 28 | MACAddress mac1 = new MACAddress(byte1); |
| 29 | MACAddress mac2 = new MACAddress(byte2); |
| 30 | Short ether = Short.valueOf((short) 2); |
| 31 | Short vlanid = Short.valueOf((short) 3); |
| 32 | Byte vlanprio = Byte.valueOf((byte) 4); |
| 33 | IPv4Net ip1 = new IPv4Net("127.0.0.1/32"); |
| 34 | IPv4Net ip2 = new IPv4Net(new IPv4("127.0.0.2"), (short) 32); |
| 35 | IPv4 ipaddr1 = new IPv4("127.0.0.3"); |
| 36 | IPv4 ipaddr2 = new IPv4("127.0.0.4"); |
| 37 | Byte ipproto = Byte.valueOf((byte) 5); |
| 38 | Byte ipToS = Byte.valueOf((byte) 6); |
| 39 | Short tport1 = Short.valueOf((short) 7); |
| 40 | Short tport2 = Short.valueOf((short) 8); |
Yuta HIGUCHI | fb56450 | 2014-06-16 21:29:00 -0700 | [diff] [blame] | 41 | PortNumber outport = new PortNumber((short) 9); |
| 42 | PortNumber queueport = new PortNumber((short) 10); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 43 | int queueId = 11; |
Pavlin Radoslavov | 5139c0b | 2013-12-09 18:04:53 -0800 | [diff] [blame] | 44 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 45 | FlowEntryErrorState errorState = new FlowEntryErrorState((short) 12, (short) 13); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 46 | |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 47 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 48 | @Before |
| 49 | public void setUp() throws Exception { |
| 50 | entry = new FlowEntry(); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 51 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 52 | flowId = new FlowId("0x1234"); |
| 53 | entry.setFlowId(flowId); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 54 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 55 | flowEntryId = new FlowEntryId("0x5678"); |
| 56 | entry.setFlowEntryId(flowEntryId); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 57 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 58 | entry.setIdleTimeout(5); |
| 59 | entry.setHardTimeout(10); |
| 60 | entry.setPriority(15); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 61 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 62 | dpid = new Dpid("CA:FE"); |
| 63 | entry.setDpid(dpid); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 64 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 65 | entry.setInPort(inport); |
| 66 | entry.setOutPort(outport); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 67 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 68 | match = new FlowEntryMatch(); |
| 69 | match.enableInPort(inport); |
| 70 | match.enableSrcMac(mac1); |
| 71 | match.enableDstMac(mac2); |
| 72 | match.enableEthernetFrameType(ether); |
| 73 | match.enableVlanId(vlanid); |
| 74 | match.enableVlanPriority(vlanprio); |
| 75 | match.enableSrcIPv4Net(ip1); |
| 76 | match.enableDstIPv4Net(ip2); |
| 77 | match.enableIpProto(ipproto); |
| 78 | match.enableIpToS(ipToS); |
| 79 | match.enableSrcTcpUdpPort(tport1); |
| 80 | match.enableDstTcpUdpPort(tport2); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 81 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 82 | entry.setFlowEntryMatch(match); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 83 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 84 | FlowEntryAction action = null; |
| 85 | actions = entry.flowEntryActions(); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 86 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 87 | action = new FlowEntryAction(); |
| 88 | action.setActionOutput(outport); |
| 89 | actions.addAction(action); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 90 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 91 | action = new FlowEntryAction(); |
| 92 | action.setActionOutputToController((short) 0); |
| 93 | actions.addAction(action); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 94 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 95 | action = new FlowEntryAction(); |
| 96 | action.setActionSetVlanId(vlanid); |
| 97 | actions.addAction(action); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 98 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 99 | action = new FlowEntryAction(); |
| 100 | action.setActionSetVlanPriority(vlanprio); |
| 101 | actions.addAction(action); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 102 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 103 | action = new FlowEntryAction(); |
| 104 | action.setActionStripVlan(true); |
| 105 | actions.addAction(action); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 106 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 107 | action = new FlowEntryAction(); |
| 108 | action.setActionSetEthernetSrcAddr(mac1); |
| 109 | actions.addAction(action); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 110 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 111 | action = new FlowEntryAction(); |
| 112 | action.setActionSetEthernetDstAddr(mac2); |
| 113 | actions.addAction(action); |
Pavlin Radoslavov | 062c72d | 2013-10-30 12:42:15 -0700 | [diff] [blame] | 114 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 115 | action = new FlowEntryAction(); |
| 116 | action.setActionSetIPv4SrcAddr(ipaddr1); |
| 117 | actions.addAction(action); |
Pavlin Radoslavov | 062c72d | 2013-10-30 12:42:15 -0700 | [diff] [blame] | 118 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 119 | action = new FlowEntryAction(); |
| 120 | action.setActionSetIPv4DstAddr(ipaddr2); |
| 121 | actions.addAction(action); |
Pavlin Radoslavov | 062c72d | 2013-10-30 12:42:15 -0700 | [diff] [blame] | 122 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 123 | action = new FlowEntryAction(); |
| 124 | action.setActionSetIpToS(ipToS); |
| 125 | actions.addAction(action); |
Pavlin Radoslavov | 062c72d | 2013-10-30 12:42:15 -0700 | [diff] [blame] | 126 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 127 | action = new FlowEntryAction(); |
| 128 | action.setActionSetTcpUdpSrcPort(tport1); |
| 129 | actions.addAction(action); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 130 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 131 | action = new FlowEntryAction(); |
| 132 | action.setActionSetTcpUdpDstPort(tport2); |
| 133 | actions.addAction(action); |
Pavlin Radoslavov | b1309e8 | 2013-10-30 12:18:28 -0700 | [diff] [blame] | 134 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 135 | action = new FlowEntryAction(); |
| 136 | action.setActionEnqueue(queueport, queueId); |
| 137 | actions.addAction(action); |
Pavlin Radoslavov | b1309e8 | 2013-10-30 12:18:28 -0700 | [diff] [blame] | 138 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 139 | entry.setFlowEntryUserState(FlowEntryUserState.FE_USER_ADD); |
| 140 | entry.setFlowEntrySwitchState(FlowEntrySwitchState.FE_SWITCH_UPDATED); |
| 141 | entry.setFlowEntryErrorState(errorState); |
Pavlin Radoslavov | b1309e8 | 2013-10-30 12:18:28 -0700 | [diff] [blame] | 142 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 143 | } |
Pavlin Radoslavov | b1309e8 | 2013-10-30 12:18:28 -0700 | [diff] [blame] | 144 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 145 | @Test |
| 146 | public void testFlowEntry() { |
| 147 | FlowEntry e = new FlowEntry(); |
Pavlin Radoslavov | 5139c0b | 2013-12-09 18:04:53 -0800 | [diff] [blame] | 148 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 149 | assertTrue(e.flowEntryActions().isEmpty()); |
| 150 | assertEquals("flowEntryUserState", FlowEntryUserState.FE_USER_UNKNOWN, e.flowEntryUserState()); |
| 151 | assertEquals("flowEntrySwitchState", FlowEntrySwitchState.FE_SWITCH_UNKNOWN, e.flowEntrySwitchState()); |
| 152 | } |
Pavlin Radoslavov | 5139c0b | 2013-12-09 18:04:53 -0800 | [diff] [blame] | 153 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 154 | @Test |
| 155 | public void testFlowId() { |
| 156 | assertEquals("flowId", flowId, entry.flowId()); |
| 157 | } |
Pavlin Radoslavov | afbf103 | 2014-02-04 10:37:52 -0800 | [diff] [blame] | 158 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 159 | @Test |
| 160 | public void testIsValidFlowId() { |
| 161 | FlowEntry e = new FlowEntry(); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 162 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 163 | // Test a Flow Entry with empty Flow ID |
| 164 | assertEquals("isValidFlowId", false, e.isValidFlowId()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 165 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 166 | // Test a Flow Entry with invalid Flow ID |
| 167 | e.setFlowId(new FlowId()); |
| 168 | assertEquals("isValidFlowId", false, e.isValidFlowId()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 169 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 170 | // Test a Flow Entry with valid Flow ID |
| 171 | e.setFlowId(new FlowId(0x1)); |
| 172 | assertEquals("isValidFlowId", true, e.isValidFlowId()); |
| 173 | assertEquals("isValidFlowId", true, entry.isValidFlowId()); |
| 174 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 175 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 176 | @Test |
| 177 | public void testFlowEntryId() { |
| 178 | assertEquals("flowEntryId", flowEntryId, entry.flowEntryId()); |
| 179 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 180 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 181 | @Test |
| 182 | public void testIsValidFlowEntryId() { |
| 183 | FlowEntry e = new FlowEntry(); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 184 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 185 | // Test a Flow Entry with empty Flow Entry ID |
| 186 | assertEquals("isValidFlowEntryId", false, e.isValidFlowEntryId()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 187 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 188 | // Test a Flow Entry with invalid Flow Entry ID |
| 189 | e.setFlowEntryId(new FlowEntryId()); |
| 190 | assertEquals("isValidFlowEntryId", false, e.isValidFlowEntryId()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 191 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 192 | // Test a Flow Entry with valid Flow Entry ID |
| 193 | e.setFlowEntryId(new FlowEntryId(0x1)); |
| 194 | assertEquals("isValidFlowEntryId", true, e.isValidFlowEntryId()); |
| 195 | assertEquals("isValidFlowEntryId", true, entry.isValidFlowEntryId()); |
| 196 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 197 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 198 | @Test |
| 199 | public void testIdleTimeout() { |
| 200 | assertEquals("idleTimeout", idleTimeout, entry.idleTimeout()); |
| 201 | } |
| 202 | |
| 203 | @Test |
| 204 | public void testHardTimeout() { |
| 205 | assertEquals("hardTimeout", hardTimeout, entry.hardTimeout()); |
| 206 | } |
| 207 | |
| 208 | @Test |
| 209 | public void testPriority() { |
| 210 | assertEquals("priority", priority, entry.priority()); |
| 211 | } |
| 212 | |
| 213 | @Test |
| 214 | public void testFlowEntryMatch() { |
| 215 | assertEquals("flowEntryMatch", match, entry.flowEntryMatch()); |
| 216 | } |
| 217 | |
| 218 | @Test |
| 219 | public void testFlowEntryActions() { |
| 220 | assertEquals("flowEntryActions", actions, entry.flowEntryActions()); |
| 221 | } |
| 222 | |
| 223 | @Test |
| 224 | public void testSetFlowEntryActions() { |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 225 | FlowEntryActions acts = new FlowEntryActions(); |
| 226 | entry.setFlowEntryActions(acts); |
| 227 | assertEquals("flowEntryActions", acts, entry.flowEntryActions()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 228 | } |
| 229 | |
| 230 | @Test |
| 231 | public void testDpid() { |
| 232 | assertEquals("dpid", dpid, entry.dpid()); |
| 233 | } |
| 234 | |
| 235 | @Test |
| 236 | public void testInPort() { |
| 237 | assertEquals("inPort", inport, entry.inPort()); |
| 238 | } |
| 239 | |
| 240 | @Test |
| 241 | public void testOutPort() { |
| 242 | assertEquals("outPort", outport, entry.outPort()); |
| 243 | } |
| 244 | |
| 245 | @Test |
| 246 | public void testFlowEntryUserState() { |
| 247 | assertEquals("flowEntryUserState", FlowEntryUserState.FE_USER_ADD, entry.flowEntryUserState()); |
| 248 | } |
| 249 | |
| 250 | @Test |
| 251 | public void testFlowEntrySwitchState() { |
| 252 | assertEquals("flowEntrySwitchState", FlowEntrySwitchState.FE_SWITCH_UPDATED, entry.flowEntrySwitchState()); |
| 253 | } |
| 254 | |
| 255 | @Test |
| 256 | public void testFlowEntryErrorState() { |
| 257 | assertEquals("flowEntryErrorState", errorState, entry.flowEntryErrorState()); |
| 258 | } |
| 259 | |
| 260 | @Test |
| 261 | public void testToString() { |
| 262 | FlowEntry def = new FlowEntry(); |
Yuta HIGUCHI | 91a8f50 | 2014-06-17 10:15:29 -0700 | [diff] [blame] | 263 | assertEquals("toString", |
| 264 | "[ idleTimeout=0 hardTimeout=0 priority=32768" |
| 265 | + " flowEntryActions=[] flowEntryUserState=FE_USER_UNKNOWN" |
| 266 | + " flowEntrySwitchState=FE_SWITCH_UNKNOWN]", |
| 267 | def.toString()); |
| 268 | |
| 269 | assertEquals("toString", |
| 270 | "[flowEntryId=0x5678 flowId=0x1234 idleTimeout=5 hardTimeout=10" |
| 271 | + " priority=15" |
| 272 | + " flowEntryMatch=" |
| 273 | + "[inPort=1 srcMac=01:02:03:04:05:06 dstMac=06:05:04:03:02:01" |
| 274 | + " ethernetFrameType=2 vlanId=3 vlanPriority=4" |
| 275 | + " srcIPv4Net=127.0.0.1/32 dstIPv4Net=127.0.0.2/32" |
| 276 | + " ipProto=5 ipToS=6 srcTcpUdpPort=7 dstTcpUdpPort=8" |
| 277 | + "]" |
| 278 | + " flowEntryActions=[" |
| 279 | + "[type=ACTION_OUTPUT action=[port=9 maxLen=0]];" |
| 280 | // PORT_CONTROLLER((short) 0xfffd) = 65533 (-3) |
Yuta HIGUCHI | 9da3a6e | 2014-06-10 22:11:58 -0700 | [diff] [blame] | 281 | + "[type=ACTION_OUTPUT action=[port=65533 maxLen=0]];" |
Yuta HIGUCHI | 91a8f50 | 2014-06-17 10:15:29 -0700 | [diff] [blame] | 282 | + "[type=ACTION_SET_VLAN_VID action=[vlanId=3]];" |
| 283 | + "[type=ACTION_SET_VLAN_PCP action=[vlanPriority=4]];" |
| 284 | + "[type=ACTION_STRIP_VLAN action=[stripVlan=true]];" |
| 285 | + "[type=ACTION_SET_DL_SRC action=[addr=01:02:03:04:05:06]];" |
| 286 | + "[type=ACTION_SET_DL_DST action=[addr=06:05:04:03:02:01]];" |
| 287 | + "[type=ACTION_SET_NW_SRC action=[addr=127.0.0.3]];" |
| 288 | + "[type=ACTION_SET_NW_DST action=[addr=127.0.0.4]];" |
| 289 | + "[type=ACTION_SET_NW_TOS action=[ipToS=6]];" |
| 290 | + "[type=ACTION_SET_TP_SRC action=[port=7]];" |
| 291 | + "[type=ACTION_SET_TP_DST action=[port=8]];" |
| 292 | + "[type=ACTION_ENQUEUE action=[port=10 queueId=11]];]" |
| 293 | + " dpid=00:00:00:00:00:00:ca:fe inPort=1 outPort=9" |
| 294 | + " flowEntryUserState=FE_USER_ADD" |
| 295 | + " flowEntrySwitchState=FE_SWITCH_UPDATED" |
| 296 | + " flowEntryErrorState=[type=12 code=13]]", |
| 297 | entry.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 298 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 299 | |
| 300 | } |