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 net.floodlightcontroller.util.MACAddress; |
Jonathan Hart | 23701d1 | 2014-04-03 10:45:48 -0700 | [diff] [blame] | 5 | import net.onrc.onos.core.util.FlowEntryAction.ActionEnqueue; |
| 6 | import net.onrc.onos.core.util.FlowEntryAction.ActionOutput; |
| 7 | import net.onrc.onos.core.util.FlowEntryAction.ActionSetEthernetAddr; |
| 8 | import net.onrc.onos.core.util.FlowEntryAction.ActionSetIPv4Addr; |
| 9 | import net.onrc.onos.core.util.FlowEntryAction.ActionSetIpToS; |
| 10 | import net.onrc.onos.core.util.FlowEntryAction.ActionSetTcpUdpPort; |
| 11 | import net.onrc.onos.core.util.FlowEntryAction.ActionSetVlanId; |
| 12 | import net.onrc.onos.core.util.FlowEntryAction.ActionSetVlanPriority; |
| 13 | import net.onrc.onos.core.util.FlowEntryAction.ActionStripVlan; |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 14 | |
| 15 | import org.junit.Test; |
Jonathan Hart | 862ea92 | 2014-07-09 14:41:04 -0700 | [diff] [blame] | 16 | import org.openflow.protocol.OFPort; |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 17 | |
| 18 | public class FlowEntryActionTest { |
| 19 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 20 | @Test |
| 21 | public void testSetActionOutputActionOutput() { |
| 22 | FlowEntryAction act = new FlowEntryAction(); |
Yuta HIGUCHI | fb56450 | 2014-06-16 21:29:00 -0700 | [diff] [blame] | 23 | ActionOutput actout = new FlowEntryAction.ActionOutput(new PortNumber((short) 42)); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 24 | act.setActionOutput(actout); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 25 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 26 | assertEquals("action output", FlowEntryAction.ActionValues.ACTION_OUTPUT, act.actionType()); |
| 27 | assertEquals("actionOutput port should be the same", actout.port(), act.actionOutput().port()); |
| 28 | assertEquals("actionOutput maxlen should be the same", actout.maxLen(), act.actionOutput().maxLen()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 29 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 30 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 31 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 32 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 33 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 34 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 35 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 36 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 37 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 38 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 39 | @Test |
| 40 | public void testSetActionOutputPort() { |
| 41 | FlowEntryAction act = new FlowEntryAction(); |
Yuta HIGUCHI | fb56450 | 2014-06-16 21:29:00 -0700 | [diff] [blame] | 42 | act.setActionOutput(new PortNumber((short) 42)); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 43 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 44 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 45 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 46 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 47 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 48 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 49 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 50 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 51 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 52 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 53 | @Test |
| 54 | public void testSetActionOutputToController() { |
| 55 | FlowEntryAction act = new FlowEntryAction(); |
| 56 | act.setActionOutputToController((short) 0); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 57 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 58 | FlowEntryAction actCopy = new FlowEntryAction(); |
Jonathan Hart | 862ea92 | 2014-07-09 14:41:04 -0700 | [diff] [blame] | 59 | actCopy.setActionOutput(new PortNumber(OFPort.OFPP_CONTROLLER.getValue())); |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 60 | |
| 61 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 62 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 63 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 64 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 65 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 66 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 67 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 68 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 69 | @Test |
| 70 | public void testSetActionSetVlanIdActionSetVlanId() { |
| 71 | FlowEntryAction act = new FlowEntryAction(); |
| 72 | ActionSetVlanId actVlan = new FlowEntryAction.ActionSetVlanId((short) 42); |
| 73 | act.setActionSetVlanId(actVlan); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 74 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 75 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_VLAN_VID, act.actionType()); |
| 76 | assertEquals("vlanid should be the same", actVlan.vlanId(), act.actionSetVlanId().vlanId()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 77 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 78 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 79 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 80 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 81 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 82 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 83 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 84 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 85 | } |
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 | @Test |
| 88 | public void testSetActionSetVlanIdShort() { |
| 89 | FlowEntryAction act = new FlowEntryAction(); |
| 90 | act.setActionSetVlanId((short) 42); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 91 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 92 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 93 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
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 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 96 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 97 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 98 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 99 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 100 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 101 | @Test |
| 102 | public void testSetActionSetVlanPriorityActionSetVlanPriority() { |
| 103 | FlowEntryAction act = new FlowEntryAction(); |
| 104 | ActionSetVlanPriority actVlan = new FlowEntryAction.ActionSetVlanPriority((byte) 42); |
| 105 | act.setActionSetVlanPriority(actVlan); |
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 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_VLAN_PCP, act.actionType()); |
Yuta HIGUCHI | 91a8f50 | 2014-06-17 10:15:29 -0700 | [diff] [blame] | 108 | assertEquals("vlan priority should be the same", actVlan.vlanPriority(), |
| 109 | act.actionSetVlanPriority().vlanPriority()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 110 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 111 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 112 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 113 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 114 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 115 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 116 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 117 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 118 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 119 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 120 | @Test |
| 121 | public void testSetActionSetVlanPriorityByte() { |
| 122 | FlowEntryAction act = new FlowEntryAction(); |
| 123 | act.setActionSetVlanPriority((byte) 42); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 124 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 125 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 126 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 127 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 128 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 129 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 130 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 131 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 132 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 133 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 134 | @Test |
| 135 | public void testSetActionStripVlanActionStripVlan() { |
| 136 | FlowEntryAction act = new FlowEntryAction(); |
| 137 | ActionStripVlan actVlan = new FlowEntryAction.ActionStripVlan(); |
| 138 | act.setActionStripVlan(actVlan); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 139 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 140 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_STRIP_VLAN, act.actionType()); |
| 141 | assertEquals("vlanid should be the same", actVlan.stripVlan(), act.actionStripVlan().stripVlan()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 142 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 143 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 144 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 145 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 146 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 147 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 148 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 149 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 150 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 151 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 152 | @Test |
| 153 | public void testSetActionStripVlanBoolean() { |
| 154 | FlowEntryAction act = new FlowEntryAction(); |
| 155 | act.setActionStripVlan(true); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 156 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 157 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 158 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 159 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 160 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 161 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 162 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 163 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 164 | } |
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 |
| 167 | public void testSetActionSetEthernetSrcAddrActionSetEthernetAddr() { |
| 168 | FlowEntryAction act = new FlowEntryAction(); |
| 169 | byte[] mac = {1, 2, 3, 4, 5, 6}; |
| 170 | ActionSetEthernetAddr setEth = new FlowEntryAction.ActionSetEthernetAddr(new MACAddress(mac)); |
| 171 | act.setActionSetEthernetSrcAddr(setEth); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 172 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 173 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_DL_SRC, act.actionType()); |
| 174 | assertEquals("addr should be the same", setEth.addr(), act.actionSetEthernetSrcAddr().addr()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 175 | |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 176 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 177 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 178 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 179 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 180 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 181 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 182 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 183 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 184 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 185 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 186 | @Test |
| 187 | public void testSetActionSetEthernetSrcAddrMACAddress() { |
| 188 | FlowEntryAction act = new FlowEntryAction(); |
| 189 | byte[] mac = {1, 2, 3, 4, 5, 6}; |
| 190 | act.setActionSetEthernetSrcAddr(new MACAddress(mac)); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 191 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 192 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 193 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 194 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 195 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 196 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 197 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 198 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 199 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 200 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 201 | @Test |
| 202 | public void testSetActionSetEthernetDstAddrActionSetEthernetAddr() { |
| 203 | FlowEntryAction act = new FlowEntryAction(); |
| 204 | byte[] mac = {1, 2, 3, 4, 5, 6}; |
| 205 | ActionSetEthernetAddr setEth = new FlowEntryAction.ActionSetEthernetAddr(new MACAddress(mac)); |
| 206 | act.setActionSetEthernetDstAddr(setEth); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 207 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 208 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_DL_DST, act.actionType()); |
| 209 | assertEquals("addr should be the same", setEth.addr(), act.actionSetEthernetDstAddr().addr()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 210 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 211 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 212 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 213 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 214 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 215 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 216 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 217 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | @Test |
| 221 | public void testSetActionSetEthernetDstAddrMACAddress() { |
| 222 | FlowEntryAction act = new FlowEntryAction(); |
| 223 | byte[] mac = {1, 2, 3, 4, 5, 6}; |
| 224 | act.setActionSetEthernetDstAddr(new MACAddress(mac)); |
| 225 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 226 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 227 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 228 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 229 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 230 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 231 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 232 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 233 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 234 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 235 | @Test |
| 236 | public void testSetActionSetIPv4SrcAddrActionSetIPv4Addr() { |
| 237 | FlowEntryAction act = new FlowEntryAction(); |
| 238 | ActionSetIPv4Addr setIp = new FlowEntryAction.ActionSetIPv4Addr(new IPv4("127.0.0.1")); |
| 239 | act.setActionSetIPv4SrcAddr(setIp); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 240 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 241 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_NW_SRC, act.actionType()); |
| 242 | assertEquals("addr should be the same", setIp.addr(), act.actionSetIPv4SrcAddr().addr()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 243 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 244 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 245 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 246 | |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 247 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 248 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 249 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 250 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 251 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 252 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 253 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 254 | @Test |
| 255 | public void testSetActionSetIPv4SrcAddrIPv4() { |
| 256 | FlowEntryAction act = new FlowEntryAction(); |
| 257 | act.setActionSetIPv4SrcAddr(new IPv4("127.0.0.1")); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 258 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 259 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 260 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 261 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 262 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 263 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 264 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 265 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 266 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 267 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 268 | @Test |
| 269 | public void testSetActionSetIPv4DstAddrActionSetIPv4Addr() { |
| 270 | FlowEntryAction act = new FlowEntryAction(); |
| 271 | ActionSetIPv4Addr setIp = new FlowEntryAction.ActionSetIPv4Addr(new IPv4("127.0.0.1")); |
| 272 | act.setActionSetIPv4DstAddr(setIp); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 273 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 274 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_NW_DST, act.actionType()); |
| 275 | assertEquals("addr should be the same", setIp.addr(), act.actionSetIPv4DstAddr().addr()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 276 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 277 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 278 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 279 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 280 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 281 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 282 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 283 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 284 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 285 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 286 | @Test |
| 287 | public void testSetActionSetIPv4DstAddrIPv4() { |
| 288 | FlowEntryAction act = new FlowEntryAction(); |
| 289 | act.setActionSetIPv4DstAddr(new IPv4("127.0.0.1")); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 290 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 291 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 292 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 293 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 294 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 295 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 296 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 297 | actCopy2.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 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 300 | @Test |
| 301 | public void testSetActionSetIpToSActionSetIpToS() { |
| 302 | FlowEntryAction act = new FlowEntryAction(); |
| 303 | ActionSetIpToS setIpTos = new FlowEntryAction.ActionSetIpToS((byte) 42); |
| 304 | act.setActionSetIpToS(setIpTos); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 305 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 306 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_NW_TOS, act.actionType()); |
| 307 | assertEquals("tos should be the same", setIpTos.ipToS(), act.actionSetIpToS().ipToS()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 308 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 309 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 310 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 311 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 312 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 313 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 314 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 315 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 316 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 317 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 318 | @Test |
| 319 | public void testSetActionSetIpToSByte() { |
| 320 | FlowEntryAction act = new FlowEntryAction(); |
| 321 | act.setActionSetIpToS((byte) 1); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 322 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 323 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 324 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 325 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 326 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 327 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 328 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 329 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 330 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 331 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 332 | @Test |
| 333 | public void testSetActionSetTcpUdpSrcPortActionSetTcpUdpPort() { |
| 334 | FlowEntryAction act = new FlowEntryAction(); |
| 335 | ActionSetTcpUdpPort setPorts = new FlowEntryAction.ActionSetTcpUdpPort((short) 42); |
| 336 | act.setActionSetTcpUdpSrcPort(setPorts); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 337 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 338 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_TP_SRC, act.actionType()); |
| 339 | assertEquals("port should be the same", setPorts.port(), act.actionSetTcpUdpSrcPort().port()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 340 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 341 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 342 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 343 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 344 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 345 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 346 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 347 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 348 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 349 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 350 | @Test |
| 351 | public void testSetActionSetTcpUdpSrcPortShort() { |
| 352 | FlowEntryAction act = new FlowEntryAction(); |
| 353 | act.setActionSetTcpUdpSrcPort((short) 1); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 354 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 355 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 356 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 357 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 358 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 359 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 360 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 361 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 362 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 363 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 364 | @Test |
| 365 | public void testSetActionSetTcpUdpDstPortActionSetTcpUdpPort() { |
| 366 | FlowEntryAction act = new FlowEntryAction(); |
| 367 | ActionSetTcpUdpPort setPorts = new FlowEntryAction.ActionSetTcpUdpPort((short) 42); |
| 368 | act.setActionSetTcpUdpDstPort(setPorts); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 369 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 370 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_SET_TP_DST, act.actionType()); |
| 371 | assertEquals("port should be the same", setPorts.port(), act.actionSetTcpUdpDstPort().port()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 372 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 373 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 374 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 375 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 376 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 377 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 378 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 379 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 380 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 381 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 382 | @Test |
| 383 | public void testSetActionSetTcpUdpDstPortShort() { |
| 384 | FlowEntryAction act = new FlowEntryAction(); |
| 385 | act.setActionSetTcpUdpDstPort((short) 1); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 386 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 387 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 388 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 389 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 390 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 391 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 392 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 393 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 394 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 395 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 396 | @Test |
| 397 | public void testSetActionEnqueueActionEnqueue() { |
| 398 | FlowEntryAction act = new FlowEntryAction(); |
Yuta HIGUCHI | fb56450 | 2014-06-16 21:29:00 -0700 | [diff] [blame] | 399 | ActionEnqueue enq = new FlowEntryAction.ActionEnqueue(new PortNumber((short) 42), 1); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 400 | act.setActionEnqueue(enq); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 401 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 402 | assertEquals("action type", FlowEntryAction.ActionValues.ACTION_ENQUEUE, act.actionType()); |
| 403 | assertEquals("port should be the same", enq.port(), act.actionEnqueue().port()); |
| 404 | assertEquals("queue id should be the same", enq.queueId(), act.actionEnqueue().queueId()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 405 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 406 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 407 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 408 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 409 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 410 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 411 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 412 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 413 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 414 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 415 | @Test |
| 416 | public void testSetActionEnqueuePortInt() { |
| 417 | FlowEntryAction act = new FlowEntryAction(); |
Yuta HIGUCHI | fb56450 | 2014-06-16 21:29:00 -0700 | [diff] [blame] | 418 | act.setActionEnqueue(new PortNumber((short) 42), 1); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 419 | |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 420 | FlowEntryAction actCopy = new FlowEntryAction(act); |
| 421 | FlowEntryAction actCopy2 = new FlowEntryAction(act.toString()); |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 422 | |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 423 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 424 | actCopy.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 425 | assertEquals("toString must match between copies", act.toString(), |
Yuta HIGUCHI | 44a0b35 | 2014-05-14 21:32:48 -0700 | [diff] [blame] | 426 | actCopy2.toString()); |
Ray Milkey | 269ffb9 | 2014-04-03 14:43:30 -0700 | [diff] [blame] | 427 | } |
HIGUCHI Yuta | d8dc9c0 | 2013-08-04 06:16:30 +0900 | [diff] [blame] | 428 | |
| 429 | } |