src/vpp-api/java/jvpp-acl/io/fd/vpp/jvpp/acl/test/AclExpectedDumpData.java

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package io.fd.vpp.jvpp.acl.test;
  18
  19
  20 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_ADDRESS_2_AS_ARRAY;
  21 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_ADDRESS_AS_ARRAY;
  22 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_DST_ICMP_TYPE_END;
  23 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_DST_ICMP_TYPE_START;
  24 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_MAC;
  25 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_MAC_MASK;
  26 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_PREFIX;
  27 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_PREFIX_2;
  28 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_SRC_ICMP_TYPE_END;
  29 import static io.fd.vpp.jvpp.acl.test.AclTestData.FIRST_RULE_SRC_ICMP_TYPE_START;
  30 import static io.fd.vpp.jvpp.acl.test.AclTestData.ICMP_PROTOCOL;
  31 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_ADDRESS_2_AS_ARRAY;
  32 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_ADDRESS_AS_ARRAY;
  33 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_DST_PORT_RANGE_END;
  34 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_DST_PORT_RANGE_START;
  35 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_MAC;
  36 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_MAC_MASK;
  37 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_PREFIX;
  38 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_PREFIX_2;
  39 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_SRC_PORT_RANGE_END;
  40 import static io.fd.vpp.jvpp.acl.test.AclTestData.SECOND_RULE_SRC_PORT_RANGE_START;
  41 import static io.fd.vpp.jvpp.acl.test.AclTestData.UDP_PROTOCOL;
  42
  43 import io.fd.vpp.jvpp.acl.dto.AclDetails;
  44 import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails;
  45 import io.fd.vpp.jvpp.acl.dto.MacipAclDetails;
  46 import io.fd.vpp.jvpp.acl.types.AclRule;
  47 import io.fd.vpp.jvpp.acl.types.MacipAclRule;
  48 import java.util.Arrays;
  49
  50 class AclExpectedDumpData {
  51
  52     static void verifyMacIpDump(final MacipAclDetails macipAclDetails) {
  53         // asserting data create by previous call
  54         assertEquals(0, macipAclDetails.aclIndex);
  55         assertEquals(2, macipAclDetails.count);
  56
  57         final MacipAclRule currentIpv4Rule = macipAclDetails.r[0];
  58         final MacipAclRule currentIpv6Rule = macipAclDetails.r[1];
  59
  60         // Comparing one property at the time to better pointer if something is wrong
  61         //Ipv4 rule
  62         assertEquals(0, currentIpv4Rule.isIpv6);
  63         assertEquals(1, currentIpv4Rule.isPermit);
  64
  65         // cutting expected ipv4 to 4 bytes,vpp sends it as 16 always
  66         assertArrays(FIRST_RULE_ADDRESS_AS_ARRAY, Arrays.copyOfRange(currentIpv4Rule.srcIpAddr, 0, 4));
  67         assertEquals(FIRST_RULE_PREFIX, currentIpv4Rule.srcIpPrefixLen);
  68         assertArrays(FIRST_RULE_MAC, currentIpv4Rule.srcMac);
  69         assertArrays(FIRST_RULE_MAC_MASK, currentIpv4Rule.srcMacMask);
  70
  71         //Ipv6 rule
  72         assertEquals(1, currentIpv6Rule.isIpv6);
  73         assertEquals(0, currentIpv6Rule.isPermit);
  74         assertArrays(SECOND_RULE_ADDRESS_AS_ARRAY, currentIpv6Rule.srcIpAddr);
  75         assertEquals(SECOND_RULE_PREFIX, currentIpv6Rule.srcIpPrefixLen);
  76         assertArrays(SECOND_RULE_MAC, currentIpv6Rule.srcMac);
  77         assertArrays(SECOND_RULE_MAC_MASK, currentIpv6Rule.srcMacMask);
  78     }
  79
  80     static void verifyAclDump(final AclDetails aclDetails) {
  81         assertEquals(0, aclDetails.aclIndex);
  82         assertEquals(2, aclDetails.count);
  83
  84         final AclRule currentIpv4Rule = aclDetails.r[0];
  85         final AclRule currentIpv6Rule = aclDetails.r[1];
  86
  87         // Comparing one property at the time to better pointer if something is wrong
  88         //Ipv4 rule
  89         assertEquals(0, currentIpv4Rule.isIpv6);
  90         assertEquals(1, currentIpv4Rule.isPermit);
  91
  92         // cutting expected ipv4 to 4 bytes,vpp sends it as 16 always
  93         assertArrays(FIRST_RULE_ADDRESS_AS_ARRAY, Arrays.copyOfRange(currentIpv4Rule.srcIpAddr, 0, 4));
  94         assertEquals(FIRST_RULE_PREFIX, currentIpv4Rule.srcIpPrefixLen);
  95         assertArrays(FIRST_RULE_ADDRESS_2_AS_ARRAY, Arrays.copyOfRange(currentIpv4Rule.dstIpAddr, 0, 4));
  96         assertEquals(FIRST_RULE_PREFIX_2, currentIpv4Rule.dstIpPrefixLen);
  97
  98         assertEquals(ICMP_PROTOCOL, currentIpv4Rule.proto);
  99         assertEquals(FIRST_RULE_SRC_ICMP_TYPE_START, currentIpv4Rule.srcportOrIcmptypeFirst);
 100         assertEquals(FIRST_RULE_SRC_ICMP_TYPE_END, currentIpv4Rule.srcportOrIcmptypeLast);
 101         assertEquals(FIRST_RULE_DST_ICMP_TYPE_START, currentIpv4Rule.dstportOrIcmpcodeFirst);
 102         assertEquals(FIRST_RULE_DST_ICMP_TYPE_END, currentIpv4Rule.dstportOrIcmpcodeLast);
 103
 104         assertArrays(SECOND_RULE_ADDRESS_AS_ARRAY, currentIpv6Rule.srcIpAddr);
 105         assertEquals(SECOND_RULE_PREFIX, currentIpv6Rule.srcIpPrefixLen);
 106         assertArrays(SECOND_RULE_ADDRESS_2_AS_ARRAY, currentIpv6Rule.dstIpAddr);
 107         assertEquals(SECOND_RULE_PREFIX_2, currentIpv6Rule.dstIpPrefixLen);
 108
 109         assertEquals(UDP_PROTOCOL, currentIpv6Rule.proto);
 110         assertEquals(SECOND_RULE_SRC_PORT_RANGE_START, currentIpv6Rule.srcportOrIcmptypeFirst);
 111         assertEquals(SECOND_RULE_SRC_PORT_RANGE_END, currentIpv6Rule.srcportOrIcmptypeLast);
 112         assertEquals(SECOND_RULE_DST_PORT_RANGE_START, currentIpv6Rule.dstportOrIcmpcodeFirst);
 113         assertEquals(SECOND_RULE_DST_PORT_RANGE_END, currentIpv6Rule.dstportOrIcmpcodeLast);
 114     }
 115
 116     static void verifyAclInterfaceList(final AclInterfaceListDetails aclInterfaceListDetails) {
 117         assertEquals(1, aclInterfaceListDetails.count);
 118         assertEquals(1, aclInterfaceListDetails.acls[0]);
 119         assertEquals(0, aclInterfaceListDetails.nInput);
 120         assertEquals(0, aclInterfaceListDetails.swIfIndex);
 121     }
 122
 123     private static void assertArrays(final byte[] expected, final byte[] actual) {
 124         if (!Arrays.equals(expected, actual)) {
 125             throw new IllegalArgumentException(
 126                     String.format("Expected[%s]/Actual[%s]", Arrays.toString(expected), Arrays.toString(actual)));
 127         }
 128     }
 129
 130     private static void assertEquals(final int expected, final int actual) {
 131         if (expected != actual) {
 132             throw new IllegalArgumentException(String.format("Expected[%s]/Actual[%s]", expected, actual));
 133         }
 134     }
 135 }