openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/serialization/match/OxmIpv6ExtHdrSerializerTest.java

   1 /*
   2  * Copyright (c) 2014 Pantheon Technologies s.r.o. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowjava.protocol.impl.serialization.match;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertTrue;
  13 import io.netty.buffer.ByteBuf;
  14 import io.netty.buffer.PooledByteBufAllocator;
  15
  16 import org.junit.Assert;
  17 import org.junit.Test;
  18 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
  19 import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Ipv6ExthdrFlags;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6Exthdr;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OpenflowBasicClass;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6ExthdrCaseBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.ipv6.exthdr._case.Ipv6ExthdrBuilder;
  26
  27 /**
  28  * @author michal.polkorab
  29  *
  30  */
  31 public class OxmIpv6ExtHdrSerializerTest {
  32
  33     OxmIpv6ExtHdrSerializer serializer = new OxmIpv6ExtHdrSerializer();
  34
  35     /**
  36      * Test correct serialization
  37      */
  38     @Test
  39     public void testSerializeWithoutMask() {
  40         MatchEntryBuilder builder = prepareIpv6ExtHdrMatchEntry(false,
  41                 new Ipv6ExthdrFlags(true, false, true, false, true, false, true, false, true));
  42
  43         ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer();
  44         serializer.serialize(builder.build(), buffer);
  45
  46         checkHeader(buffer, false);
  47         assertEquals("Wrong value", 358, buffer.readUnsignedShort());
  48         assertTrue("Unexpected data", buffer.readableBytes() == 0);
  49     }
  50
  51     /**
  52      * Test correct serialization
  53      */
  54     @Test
  55     public void testSerializeWithMask() {
  56         MatchEntryBuilder builder = prepareIpv6ExtHdrMatchEntry(true,
  57                 new Ipv6ExthdrFlags(false, true, false, true, false, true, false, true, false));
  58
  59         ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer();
  60         serializer.serialize(builder.build(), buffer);
  61
  62         checkHeader(buffer, true);
  63         assertEquals("Wrong value", 153, buffer.readUnsignedShort());
  64         byte[] tmp = new byte[2];
  65         buffer.readBytes(tmp);
  66         Assert.assertArrayEquals("Wrong mask", new byte[]{0, 15}, tmp);
  67         assertTrue("Unexpected data", buffer.readableBytes() == 0);
  68     }
  69
  70     /**
  71      * Test correct header serialization
  72      */
  73     @Test
  74     public void testSerializeHeaderWithoutMask() {
  75         MatchEntryBuilder builder = prepareIpv6ExtHdrHeader(false);
  76
  77         ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer();
  78         serializer.serializeHeader(builder.build(), buffer);
  79
  80         checkHeader(buffer, false);
  81         assertTrue("Unexpected data", buffer.readableBytes() == 0);
  82     }
  83
  84     /**
  85      * Test correct header serialization
  86      */
  87     @Test
  88     public void testSerializeHeaderWithMask() {
  89         MatchEntryBuilder builder = prepareIpv6ExtHdrHeader(true);
  90
  91         ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer();
  92         serializer.serializeHeader(builder.build(), buffer);
  93
  94         checkHeader(buffer, true);
  95         assertTrue("Unexpected data", buffer.readableBytes() == 0);
  96     }
  97
  98     /**
  99      * Test correct oxm-class return value
 100      */
 101     @Test
 102     public void testGetOxmClassCode() {
 103         assertEquals("Wrong oxm-class", OxmMatchConstants.OPENFLOW_BASIC_CLASS, serializer.getOxmClassCode());
 104     }
 105
 106     /**
 107      * Test correct oxm-field return value
 108      */
 109     @Test
 110     public void getOxmFieldCode() {
 111         assertEquals("Wrong oxm-class", OxmMatchConstants.IPV6_EXTHDR, serializer.getOxmFieldCode());
 112     }
 113
 114     /**
 115      * Test correct value length return value
 116      */
 117     @Test
 118     public void testGetValueLength() {
 119         assertEquals("Wrong value length", EncodeConstants.SIZE_OF_SHORT_IN_BYTES, serializer.getValueLength());
 120     }
 121
 122     private static MatchEntryBuilder prepareIpv6ExtHdrMatchEntry(boolean hasMask, Ipv6ExthdrFlags flags) {
 123         MatchEntryBuilder builder = prepareIpv6ExtHdrHeader(hasMask);
 124         Ipv6ExthdrCaseBuilder casebuilder = new Ipv6ExthdrCaseBuilder();
 125         Ipv6ExthdrBuilder valueBuilder = new Ipv6ExthdrBuilder();
 126         if (hasMask) {
 127             valueBuilder.setMask(new byte[]{0, 15});
 128         }
 129         valueBuilder.setPseudoField(flags);
 130         casebuilder.setIpv6Exthdr(valueBuilder.build());
 131         builder.setMatchEntryValue(casebuilder.build());
 132         return builder;
 133     }
 134
 135     private static MatchEntryBuilder prepareIpv6ExtHdrHeader(boolean hasMask) {
 136         MatchEntryBuilder builder = new MatchEntryBuilder();
 137         builder.setOxmClass(OpenflowBasicClass.class);
 138         builder.setOxmMatchField(Ipv6Exthdr.class);
 139         builder.setHasMask(hasMask);
 140         return builder;
 141     }
 142
 143     private static void checkHeader(ByteBuf buffer, boolean hasMask) {
 144         assertEquals("Wrong oxm-class", OxmMatchConstants.OPENFLOW_BASIC_CLASS, buffer.readUnsignedShort());
 145         short fieldAndMask = buffer.readUnsignedByte();
 146         assertEquals("Wrong oxm-field", OxmMatchConstants.IPV6_EXTHDR, fieldAndMask >>> 1);
 147         assertEquals("Wrong hasMask", hasMask, (fieldAndMask & 1) != 0);
 148         if (hasMask) {
 149             assertEquals("Wrong length", EncodeConstants.SIZE_OF_INT_IN_BYTES, buffer.readUnsignedByte());
 150         } else {
 151             assertEquals("Wrong length", EncodeConstants.SIZE_OF_SHORT_IN_BYTES, buffer.readUnsignedByte());
 152         }
 153     }
 154 }