summaryrefslogtreecommitdiffstats
path: root/vpp-common/vpp-translate-utils/src/test/java
diff options
context:
space:
mode:
Diffstat (limited to 'vpp-common/vpp-translate-utils/src/test/java')
-rw-r--r--vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/cache/DumpCacheManagerTest.java143
-rw-r--r--vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/SubinterfaceUtilsTest.java32
-rw-r--r--vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java137
3 files changed, 312 insertions, 0 deletions
diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/cache/DumpCacheManagerTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/cache/DumpCacheManagerTest.java
new file mode 100644
index 000000000..5b9391305
--- /dev/null
+++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/cache/DumpCacheManagerTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.translate.v3po.util.cache;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.v3po.util.cache.exceptions.check.i.DumpEmptyException;
+import io.fd.honeycomb.translate.v3po.util.cache.exceptions.execution.DumpExecutionFailedException;
+import io.fd.honeycomb.v3po.translate.ModificationCache;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.openvpp.jvpp.dto.IpDetails;
+import org.openvpp.jvpp.dto.IpDetailsReplyDump;
+
+public class DumpCacheManagerTest {
+
+ private static final String KEY = "cacheKey";
+
+ @Mock
+ private EntityDumpExecutor<IpDetailsReplyDump, Void> executor;
+
+ private DumpCacheManager<IpDetailsReplyDump, Void> managerPositive;
+ private DumpCacheManager<IpDetailsReplyDump, Void> managerPositiveWithPostProcessing;
+ private DumpCacheManager<IpDetailsReplyDump, Void> managerNegative;
+ private ModificationCache cache;
+
+ @Before
+ public void init() {
+ MockitoAnnotations.initMocks(this);
+ managerPositive =
+ new DumpCacheManager.DumpCacheManagerBuilder<IpDetailsReplyDump, Void>()
+ .withExecutor(executor)
+ .withNonEmptyPredicate(createPositivePredicate())
+ .build();
+
+ managerPositiveWithPostProcessing = new DumpCacheManager.DumpCacheManagerBuilder<IpDetailsReplyDump, Void>()
+ .withExecutor(executor)
+ .withNonEmptyPredicate(createPositivePredicate())
+ .withPostProcessingFunction(createPostProcessor())
+ .build();
+
+ managerNegative =
+ new DumpCacheManager.DumpCacheManagerBuilder<IpDetailsReplyDump, Void>()
+ .withExecutor(executor)
+ .withNonEmptyPredicate(createNegativePredicate())
+ .build();
+
+ cache = new ModificationCache();
+ }
+
+ /**
+ * This test verify full dump-caching cycle
+ */
+ @Test
+ public void testCaching() throws DumpExecutionFailedException {
+
+
+ Optional<IpDetailsReplyDump> stage1Optional = managerNegative.getDump(KEY, cache);
+
+ //this is first call so instance should be from executor
+ assertEquals(false, stage1Optional.isPresent());
+ assertEquals(false, cache.containsKey(KEY));
+
+ //rebind executor with other data
+ IpDetailsReplyDump stage2LoadedDump = new IpDetailsReplyDump();
+ when(executor.executeDump()).thenReturn(stage2LoadedDump);
+
+ Optional<IpDetailsReplyDump> stage2Optional = managerPositive.getDump(KEY, cache);
+
+ assertEquals(true, stage2Optional.isPresent());
+ assertEquals(stage2LoadedDump, stage2Optional.get());
+
+ //rebind executor with other data
+ IpDetailsReplyDump stage3LoadedDump = new IpDetailsReplyDump();
+ when(executor.executeDump()).thenReturn(stage3LoadedDump);
+
+ Optional<IpDetailsReplyDump> stage3Optional = managerPositive.getDump(KEY, cache);
+ assertEquals(true, stage3Optional.isPresent());
+ //check if it returns instance cached from previous stage
+ assertEquals(stage2LoadedDump, stage3Optional.get());
+ }
+
+ @Test
+ public void testPostprocessing() throws DumpExecutionFailedException {
+ IpDetailsReplyDump dump = new IpDetailsReplyDump();
+ IpDetails details = new IpDetails();
+ details.swIfIndex = 2;
+ dump.ipDetails.add(details);
+
+ when(executor.executeDump()).thenReturn(dump);
+
+ Optional<IpDetailsReplyDump> optionalDump = managerPositiveWithPostProcessing.getDump(KEY, cache);
+
+ assertEquals(true, optionalDump.isPresent());
+ assertEquals(1, optionalDump.get().ipDetails.size());
+ assertEquals(7, optionalDump.get().ipDetails.get(0).swIfIndex);
+ }
+
+ private EntityDumpNonEmptyCheck<IpDetailsReplyDump> createNegativePredicate() {
+ return data -> {
+ throw new DumpEmptyException("Empty dump", new IllegalArgumentException());
+ };
+ }
+
+ private EntityDumpNonEmptyCheck<IpDetailsReplyDump> createPositivePredicate() {
+ return data -> {
+ //DO NOTHING
+ };
+ }
+
+ private EntityDumpPostProcessingFunction<IpDetailsReplyDump> createPostProcessor() {
+ return ipDetailsReplyDump -> {
+ IpDetailsReplyDump modified = new IpDetailsReplyDump();
+
+ for (IpDetails detail : ipDetailsReplyDump.ipDetails) {
+ IpDetails modifiedDetail = new IpDetails();
+ modifiedDetail.swIfIndex = detail.swIfIndex + 5;
+
+ modified.ipDetails.add(modifiedDetail);
+ }
+
+ return modified;
+ };
+ }
+} \ No newline at end of file
diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/SubinterfaceUtilsTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/SubinterfaceUtilsTest.java
new file mode 100644
index 000000000..a61dfea90
--- /dev/null
+++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/SubinterfaceUtilsTest.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.v3po.translate.v3po.util;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class SubinterfaceUtilsTest {
+
+ @Test
+ public void testGetSubInterfaceName() throws Exception {
+ final String superIfName = "GigabitEthernet0/9/0";
+ final int subIfaceId = 123;
+ final String expectedSubIfaceName = "GigabitEthernet0/9/0.123";
+ assertEquals(expectedSubIfaceName, SubInterfaceUtils.getSubInterfaceName(superIfName, subIfaceId));
+ }
+} \ No newline at end of file
diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java
new file mode 100644
index 000000000..334887430
--- /dev/null
+++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java
@@ -0,0 +1,137 @@
+package io.fd.honeycomb.v3po.translate.v3po.util;
+
+import static io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils.reverseBytes;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.dto.JVppReply;
+
+public class TranslateUtilsTest {
+
+ private static class AnDataObject implements DataObject {
+ @Override
+ public Class<? extends DataContainer> getImplementedInterface() {
+ return null;
+ }
+ }
+
+ @Test
+ public void testGetReplyForWriteTimeout() throws Exception {
+ final Future<JVppReply<?>> future = mock(Future.class);
+ when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class);
+ final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class);
+ try {
+ TranslateUtils.getReplyForWrite(future, replyType);
+ } catch (WriteTimeoutException e) {
+ assertTrue(e.getCause() instanceof TimeoutException);
+ assertEquals(replyType, e.getFailedId());
+ return;
+ }
+ fail("WriteTimeoutException was expected");
+ }
+
+ @Test
+ public void testGetReplyForReadTimeout() throws Exception {
+ final Future<JVppReply<?>> future = mock(Future.class);
+ final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class);
+ when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class);
+ try {
+ TranslateUtils.getReplyForRead(future, replyType);
+ } catch (ReadTimeoutException e) {
+ assertTrue(e.getCause() instanceof TimeoutException);
+ assertEquals(replyType, e.getFailedId());
+ return;
+ }
+ fail("ReadTimeoutException was expected");
+ }
+
+ @Test
+ public void testIpv4NoZone() throws Exception {
+ final Ipv4AddressNoZone ipv4Addr = new Ipv4AddressNoZone("192.168.1.1");
+ byte[] bytes = TranslateUtils.ipv4AddressNoZoneToArray(ipv4Addr);
+ assertEquals((byte)192, bytes[0]);
+ // Simulating the magic of VPP
+ bytes = reverseBytes(bytes);
+ final Ipv4AddressNoZone ipv4AddressNoZone = TranslateUtils.arrayToIpv4AddressNoZone(bytes);
+ assertEquals(ipv4Addr, ipv4AddressNoZone);
+ }
+
+ @Test
+ public void testToString() {
+ final byte[] expected = "test".getBytes();
+ final byte[] cString = new byte[expected.length + 10];
+ System.arraycopy(expected, 0, cString, 0, expected.length);
+ final String jString = TranslateUtils.toString(cString);
+ assertArrayEquals(expected, jString.getBytes());
+ }
+
+ @Test
+ public void testParseMac() throws Exception {
+ byte[] bytes = TranslateUtils.parseMac("00:fF:7f:15:5e:A9");
+ assertMac(bytes);
+ }
+
+ private void assertMac(final byte[] bytes) {
+ assertEquals(6, bytes.length);
+ assertEquals((byte) 0, bytes[0]);
+ assertEquals((byte) 255, bytes[1]);
+ assertEquals((byte) 127, bytes[2]);
+ assertEquals((byte) 21, bytes[3]);
+ assertEquals((byte) 94, bytes[4]);
+ assertEquals((byte) 169, bytes[5]);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testParseMacLonger() throws Exception {
+ byte[] bytes = TranslateUtils.parseMac("00:fF:7f:15:5e:A9:88:77");
+ assertMac(bytes);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testParseMacShorter() throws Exception {
+ TranslateUtils.parseMac("00:fF:7f");
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testParseRandomString() throws Exception {
+ TranslateUtils.parseMac("random{}}@$*&*!");
+ }
+
+ @Test(expected = NumberFormatException.class)
+ public void testParseMacNumberFormatEx() throws Exception {
+ TranslateUtils.parseMac("00:XX:7f:15:5e:77\"");
+ }
+
+ @Test
+ public void testBooleanToByte() {
+ assertEquals(0, TranslateUtils.booleanToByte(null));
+ assertEquals(0, TranslateUtils.booleanToByte(false));
+ assertEquals(1, TranslateUtils.booleanToByte(true));
+ }
+
+ @Test
+ public void testByteToBoolean() {
+ assertEquals(Boolean.FALSE, TranslateUtils.byteToBoolean((byte) 0));
+ assertEquals(Boolean.TRUE, TranslateUtils.byteToBoolean((byte) 1));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testByteToBooleanFailed() {
+ TranslateUtils.byteToBoolean((byte) 123);
+ }
+
+} \ No newline at end of file