From 2811ff5e72df50ec3bb5da4210aa3d360ef386b4 Mon Sep 17 00:00:00 2001 From: saomenmen Date: Tue, 24 Nov 2015 17:27:21 +0800 Subject: [PATCH] Add renderer partical test files Change-Id: Idc53ef4c316b3941a8f1f02de5b18e16041648c5 Signed-off-by: saomenmen --- .../openflow/OpenflowRendererTest.java | 52 ++++ .../phtysicalnetwork/OFLinkListenerTest.java | 45 ++++ .../phtysicalnetwork/OFNodeListenerTest.java | 45 ++++ .../OFPacketInListenerTest.java | 47 ++++ .../PhysicalFlowUtilsTest.java | 85 ++++++ .../nemo/renderer/openflow/utils/ARPTest.java | 249 ++++++++++++++++++ 6 files changed, 523 insertions(+) create mode 100644 nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/OpenflowRendererTest.java create mode 100644 nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFLinkListenerTest.java create mode 100644 nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFNodeListenerTest.java create mode 100644 nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFPacketInListenerTest.java create mode 100644 nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/PhysicalFlowUtilsTest.java create mode 100644 nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/utils/ARPTest.java diff --git a/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/OpenflowRendererTest.java b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/OpenflowRendererTest.java new file mode 100644 index 0000000..02a5c9d --- /dev/null +++ b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/OpenflowRendererTest.java @@ -0,0 +1,52 @@ +package org.opendaylight.nemo.renderer.openflow; + +import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.ListenableFuture; +import static org.junit.Assert.*; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.sal.binding.api.NotificationProviderService; +import org.opendaylight.nemo.renderer.openflow.OpenflowRenderer; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.PhyConfigLoader; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.PhysicalNetworkAdapter; +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import static org.mockito.Mockito.*; +/** + * Created by zhangmeng on 2015/11/24. + */ +public class OpenflowRendererTest extends TestCase { + private OpenflowRenderer openflowRenderer; + private DataBroker dataBroker; + private NotificationProviderService notificationProviderService; + private PacketProcessingService packetProcessingService; + + @Before + public void setUp() throws Exception { + ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class); + CheckedFuture checkedFuture = mock(CheckedFuture.class); + + dataBroker = mock(DataBroker.class); + notificationProviderService = mock(NotificationProviderService.class); + packetProcessingService = mock(PacketProcessingService.class); + when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction); + when(readOnlyTransaction.read(any(LogicalDatastoreType.class),any(InstanceIdentifier.class))).thenReturn(checkedFuture); + + openflowRenderer = new OpenflowRenderer(dataBroker,notificationProviderService,packetProcessingService); + } + + @Test + public void testClose() throws Exception { + openflowRenderer.close(); + Assert.assertNotNull(openflowRenderer); + } +} \ No newline at end of file diff --git a/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFLinkListenerTest.java b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFLinkListenerTest.java new file mode 100644 index 0000000..1f26080 --- /dev/null +++ b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFLinkListenerTest.java @@ -0,0 +1,45 @@ +package org.opendaylight.nemo.renderer.openflow.physicalnetwork; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.OFLinkListener; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.PhysicalNetworkAdapter; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; +import java.util.Set; +/** + * Created by zhangmeng on 2015/11/19. + */ +public class OFLinkListenerTest extends OFLinkListener { + public OFLinkListenerTest(){ + super(mock(PhysicalNetworkAdapter.class)); + } + private AsyncDataChangeEvent, DataObject> asyncDataChangeEvent; + + @Before + public void setUp() throws Exception { + asyncDataChangeEvent = mock(AsyncDataChangeEvent.class); + } + + @Test + public void testOnDataChanged() throws Exception { + this.onDataChanged(null); + this.onDataChanged(asyncDataChangeEvent); + verify(asyncDataChangeEvent).getCreatedData(); + verify(asyncDataChangeEvent).getUpdatedData(); + verify(asyncDataChangeEvent).getOriginalData(); + verify(asyncDataChangeEvent).getRemovedPaths(); + Assert.assertNotNull(this); + } +} \ No newline at end of file diff --git a/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFNodeListenerTest.java b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFNodeListenerTest.java new file mode 100644 index 0000000..6ec5967 --- /dev/null +++ b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFNodeListenerTest.java @@ -0,0 +1,45 @@ +package org.opendaylight.nemo.renderer.openflow.physicalnetwork; + +import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.OFNodeListener; + +import static org.junit.Assert.*; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.PhysicalNetworkAdapter; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; +import java.util.Set; +import static org.mockito.Mockito.*; +/** + * Created by zhangmeng on 2015/11/24. + */ +public class OFNodeListenerTest extends OFNodeListener { + public OFNodeListenerTest(){ + super(mock(PhysicalNetworkAdapter.class)); + } + private AsyncDataChangeEvent , DataObject>asyncDataChangeEvent; + @Before + public void setUp() throws Exception { + asyncDataChangeEvent = mock(AsyncDataChangeEvent.class); + } + + @Test + public void testOnDataChanged() throws Exception { + this.onDataChanged(null); + this.onDataChanged(asyncDataChangeEvent); + verify(asyncDataChangeEvent).getCreatedData(); + verify(asyncDataChangeEvent).getUpdatedData(); + verify(asyncDataChangeEvent).getOriginalData(); + verify(asyncDataChangeEvent).getRemovedPaths(); + Assert.assertNotNull(this); + } +} \ No newline at end of file diff --git a/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFPacketInListenerTest.java b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFPacketInListenerTest.java new file mode 100644 index 0000000..368fff4 --- /dev/null +++ b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/OFPacketInListenerTest.java @@ -0,0 +1,47 @@ +package org.opendaylight.nemo.renderer.openflow.physicalnetwork; + +import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.liblldp.EtherTypes; +import org.opendaylight.controller.liblldp.Ethernet; +import org.opendaylight.controller.liblldp.NetUtils; +import org.opendaylight.controller.liblldp.PacketException; +import org.opendaylight.nemo.renderer.openflow.FlowUtils; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.OFPacketInListener; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef; +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener; +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; +/** + * Created by zhangmeng on 2015/11/24. + */ +public class OFPacketInListenerTest extends TestCase { + private OFPacketInListener ofPacketInListener; + private FlowUtils flowUtils; + @Before + public void setUp() throws Exception { + flowUtils = mock(FlowUtils.class); + ofPacketInListener = new OFPacketInListener(flowUtils); + + } + + @Test//to be resolve + public void testOnPacketReceived() throws Exception { +// byte bt[] = new byte[0]; +// PacketReceived packetReceived = mock(PacketReceived.class); +// when(packetReceived.getPayload()).thenReturn(bt); +// when(packetReceived.getIngress()).thenReturn(mock(NodeConnectorRef.class)); + + ofPacketInListener.onPacketReceived(null); + Assert.assertNotNull(ofPacketInListener); + + } +} \ No newline at end of file diff --git a/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/PhysicalFlowUtilsTest.java b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/PhysicalFlowUtilsTest.java new file mode 100644 index 0000000..d71e9c9 --- /dev/null +++ b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/phtysicalnetwork/PhysicalFlowUtilsTest.java @@ -0,0 +1,85 @@ +package org.opendaylight.nemo.renderer.openflow.physicalnetwork; + +import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.nemo.renderer.openflow.physicalnetwork.PhysicalFlowUtils; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri; +import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCaseBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action; +import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.OutputPortValues; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Instructions; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActions; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatch; +import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.LinkedList; +import java.util.List; +import java.util.UUID; +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +/** + * Created by zhangmeng on 2015/11/24. + */ +public class PhysicalFlowUtilsTest extends TestCase { + private DataBroker dataBroker; + private PhysicalFlowUtils physicalFlowUtils; + @Before + public void setUp() throws Exception { + dataBroker = mock(DataBroker.class); + + physicalFlowUtils = new PhysicalFlowUtils(dataBroker); + } + + @Test + public void testConfigLLDPEntry() throws Exception { + WriteTransaction writeTransaction = mock(WriteTransaction.class); + when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction); + physicalFlowUtils.configLLDPEntry("test"); + verify(dataBroker).newWriteOnlyTransaction(); + Assert.assertNotNull(physicalFlowUtils); + } + + @Test + public void testConfigArpPEntry() throws Exception { + WriteTransaction writeTransaction = mock(WriteTransaction.class); + when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction); + physicalFlowUtils.configArpPEntry("test"); + verify(dataBroker).newWriteOnlyTransaction(); + Assert.assertNotNull(physicalFlowUtils); + } +} \ No newline at end of file diff --git a/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/utils/ARPTest.java b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/utils/ARPTest.java new file mode 100644 index 0000000..16384ce --- /dev/null +++ b/nemo-renderers/openflow-renderer/src/test/java/org/opendaylight/nemo/renderer/openflow/utils/ARPTest.java @@ -0,0 +1,249 @@ +package org.opendaylight.nemo.renderer.openflow.utils; + +import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.commons.lang3.tuple.Pair; +import org.opendaylight.controller.liblldp.BitBufferHelper; +import org.opendaylight.controller.liblldp.Packet; +import org.opendaylight.nemo.renderer.openflow.utils.ARP; + +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; +import static org.mockito.Mockito.*; +/** + * Created by zhangmeng on 2015/11/24. + */ +public class ARPTest extends TestCase { + private ARP arp; + private ARP arp1; + private ARP arp2; + + @Before + public void setUp() throws Exception { + arp = new ARP(); + arp1 = new ARP(true); + arp2 = new ARP(false); + } + + + @Test + public void testHardwareType() throws Exception { + short hardwaretype = 0; + + // set + arp1.setHardwareType(hardwaretype); + arp2.setHardwareType(hardwaretype); + arp.setHardwareType(hardwaretype); + + //test get + Assert.assertEquals(0, arp.getHardwareType()); + Assert.assertEquals(0,arp1.getHardwareType()); + Assert.assertEquals(0,arp2.getHardwareType()); + + hardwaretype = 1; + + // set + arp1.setHardwareType(hardwaretype); + arp2.setHardwareType(hardwaretype); + arp.setHardwareType(hardwaretype); + + //test get + Assert.assertEquals(1, arp.getHardwareType()); + Assert.assertEquals(1,arp1.getHardwareType()); + Assert.assertEquals(1,arp2.getHardwareType()); + } + + @Test + public void testProtocolType() throws Exception { + short protocoltype = 0; + + //set + arp.setProtocolType(protocoltype); + arp1.setProtocolType(protocoltype); + arp2.setProtocolType(protocoltype); + + //test get + Assert.assertEquals(0,arp.getProtocolType()); + Assert.assertEquals(0,arp1.getProtocolType()); + Assert.assertEquals(0,arp2.getProtocolType()); + + protocoltype = 1; + + //set + arp.setProtocolType(protocoltype); + arp1.setProtocolType(protocoltype); + arp2.setProtocolType(protocoltype); + + //test get + Assert.assertEquals(1,arp.getProtocolType()); + Assert.assertEquals(1,arp1.getProtocolType()); + Assert.assertEquals(1,arp2.getProtocolType()); + } + + @Test + public void testHardwareAddressLength() throws Exception { + byte hardwareaddresslength = 0; + + //set + arp.setHardwareAddressLength(hardwareaddresslength); + arp1.setHardwareAddressLength(hardwareaddresslength); + arp2.setHardwareAddressLength(hardwareaddresslength); + + //test get + Assert.assertEquals(0,arp.getHardwareAddressLength()); + Assert.assertEquals(0,arp1.getHardwareAddressLength()); + Assert.assertEquals(0,arp2.getHardwareAddressLength()); + hardwareaddresslength = 1; + + //set + arp.setHardwareAddressLength(hardwareaddresslength); + arp1.setHardwareAddressLength(hardwareaddresslength); + arp2.setHardwareAddressLength(hardwareaddresslength); + + //test get + Assert.assertEquals(1,arp.getHardwareAddressLength()); + Assert.assertEquals(1,arp1.getHardwareAddressLength()); + Assert.assertEquals(1,arp2.getHardwareAddressLength()); + } + + @Test + public void testProtocolAddressLength() throws Exception { + byte protocoladdresslength = 0; + + //set + arp.setProtocolAddressLength(protocoladdresslength); + arp1.setProtocolAddressLength(protocoladdresslength); + arp2.setProtocolAddressLength(protocoladdresslength); + + //test get + Assert.assertEquals(0,arp.getProtocolAddressLength()); + Assert.assertEquals(0,arp1.getProtocolAddressLength()); + Assert.assertEquals(0,arp2.getProtocolAddressLength()); + protocoladdresslength = 1; + + //set + arp.setProtocolAddressLength(protocoladdresslength); + arp1.setProtocolAddressLength(protocoladdresslength); + arp2.setProtocolAddressLength(protocoladdresslength); + + //test get + Assert.assertEquals(1,arp.getProtocolAddressLength()); + Assert.assertEquals(1,arp1.getProtocolAddressLength()); + Assert.assertEquals(1,arp2.getProtocolAddressLength()); + } + + @Test + public void testOpCode() throws Exception { + short opcode = 0; + + //set + arp.setOpCode(opcode); + arp1.setOpCode(opcode); + arp2.setOpCode(opcode); + + //test get + Assert.assertEquals(0, arp.getOpCode()); + Assert.assertEquals(0, arp1.getOpCode()); + Assert.assertEquals(0,arp2.getOpCode()); + + //set + opcode = 1; + arp.setOpCode(opcode); + arp1.setOpCode(opcode); + arp2.setOpCode(opcode); + + //test get + Assert.assertEquals(1, arp.getOpCode()); + Assert.assertEquals(1, arp1.getOpCode()); + Assert.assertEquals(1,arp2.getOpCode()); + } + + @Test + public void testSenderHardwareAddress() throws Exception { + byte []senderhardwareaddrss = {0}; + + //set + arp.setSenderHardwareAddress(senderhardwareaddrss); + arp1.setSenderHardwareAddress(senderhardwareaddrss); + arp2.setSenderHardwareAddress(senderhardwareaddrss); + + //test get + Assert.assertEquals(senderhardwareaddrss, arp.getSenderHardwareAddress()); + Assert.assertEquals(senderhardwareaddrss,arp1.getSenderHardwareAddress()); + Assert.assertEquals(senderhardwareaddrss,arp2.getSenderHardwareAddress()); + } + + @Test + public void testTargetHardwareAddress() throws Exception { + byte []targethardwareaddress = {0}; + + //set + arp.setTargetHardwareAddress(targethardwareaddress); + arp1.setTargetHardwareAddress(targethardwareaddress); + arp2.setTargetHardwareAddress(targethardwareaddress); + + //test get + Assert.assertEquals(targethardwareaddress,arp.getTargetHardwareAddress()); + Assert.assertEquals(targethardwareaddress,arp1.getTargetHardwareAddress()); + Assert.assertEquals(targethardwareaddress,arp2.getTargetHardwareAddress()); + + + } + + @Test + public void testTargetProtocolAddress() throws Exception { + byte []targetpotocoladdress = {0}; + + //set + arp.setTargetProtocolAddress(targetpotocoladdress); + arp1.setTargetProtocolAddress(targetpotocoladdress); + arp2.setTargetProtocolAddress(targetpotocoladdress); + + //test get + Assert.assertEquals(targetpotocoladdress,arp.getTargetProtocolAddress()); + Assert.assertEquals(targetpotocoladdress,arp1.getTargetProtocolAddress()); + Assert.assertEquals(targetpotocoladdress,arp2.getTargetProtocolAddress()); + + } + + @Test + public void testSenderProtocolAddress() throws Exception { + byte []senderprotocoladdress = {0}; + + //set + arp.setSenderProtocolAddress(senderprotocoladdress); + arp1.setSenderProtocolAddress(senderprotocoladdress); + arp2.setSenderProtocolAddress(senderprotocoladdress); + + //test get + Assert.assertEquals(senderprotocoladdress,arp.getSenderProtocolAddress()); + Assert.assertEquals(senderprotocoladdress,arp1.getSenderProtocolAddress()); + Assert.assertEquals(senderprotocoladdress,arp2.getSenderProtocolAddress()); + + } + + @Test + public void testHashCode() throws Exception { + arp.hashCode(); + arp1.hashCode(); + arp2.hashCode(); + Assert.assertNotEquals(0, arp.hashCode()); + Assert.assertNotEquals(0,arp1.hashCode()); + Assert.assertNotEquals(0,arp2.hashCode()); + + } + + @Test + public void testEquals() throws Exception { + Assert.assertTrue(arp.equals(arp)); + Assert.assertTrue(arp.equals(arp1)); + Assert.assertTrue(arp1.equals(arp2)); + } +} \ No newline at end of file -- 2.36.6