gerrit.opnfv Code Review - onosfw.git/blob

   1 /*
   2  * Copyright 2014-2015 Open Networking Laboratory
   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 package org.onosproject.pcepio.protocol;
  17
  18 import org.jboss.netty.buffer.ChannelBuffer;
  19 import org.jboss.netty.buffer.ChannelBuffers;
  20 import org.junit.Test;
  21 import org.onosproject.pcepio.exceptions.PcepParseException;
  22
  23 import static org.hamcrest.MatcherAssert.assertThat;
  24 import static org.hamcrest.Matchers.instanceOf;
  25 import static org.hamcrest.Matchers.is;
  26
  27 public class PcepLabelUpdateMsgTest {
  28
  29     /**
  30      * This test case checks for
  31      * <pce-label-download> SRP, LSP, LABEL Object.
  32      * in PcepLabelUpdate message.
  33      */
  34     @Test
  35     public void labelUpdateMessageTest1() throws PcepParseException {
  36
  37         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x24, // common header
  38                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
  39                 0x00, 0x00, 0x00, 0x00,
  40                 0x00, 0x00, 0x00, 0x10,
  41                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
  42                 0x00, 0x01, 0x00, 0x00,
  43                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
  44                 0x00, 0x00, 0x00, 0x00,
  45                 0x00, 0x00, 0x00, 0x66};
  46
  47         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
  48         buffer.writeBytes(labelUpdate);
  49
  50         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
  51         PcepMessage message = null;
  52
  53         message = reader.readFrom(buffer);
  54
  55         byte[] testLabelUpdateMsg = {0};
  56         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
  57
  58
  59         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
  60         message.writeTo(buf);
  61
  62         int readLen = buf.writerIndex();
  63         testLabelUpdateMsg = new byte[readLen];
  64         buf.readBytes(testLabelUpdateMsg, 0, readLen);
  65
  66         assertThat(testLabelUpdateMsg, is(labelUpdate));
  67     }
  68
  69     /**
  70      * This test case checks for
  71      * <pce-label-download> SRP, LSP, LABEL Object, LABEL Object.
  72      * in PcepLabelUpdate message.
  73      */
  74     @Test
  75     public void labelUpdateMessageTest2() throws PcepParseException {
  76
  77         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x30, // common header
  78                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
  79                 0x00, 0x00, 0x00, 0x00,
  80                 0x00, 0x00, 0x00, 0x10,
  81                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
  82                 0x00, 0x01, 0x00, 0x00,
  83                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
  84                 0x00, 0x00, 0x00, 0x00,
  85                 0x00, 0x00, 0x00, 0x66,
  86                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
  87                 0x00, 0x00, 0x00, 0x00,
  88                 0x00, 0x00, 0x00, 0x77};
  89
  90         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
  91         buffer.writeBytes(labelUpdate);
  92
  93         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
  94         PcepMessage message = null;
  95
  96         message = reader.readFrom(buffer);
  97
  98         byte[] testLabelUpdateMsg = {0};
  99         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
 100         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
 101         message.writeTo(buf);
 102
 103         int readLen = buf.writerIndex();
 104         testLabelUpdateMsg = new byte[readLen];
 105         buf.readBytes(testLabelUpdateMsg, 0, readLen);
 106
 107         assertThat(testLabelUpdateMsg, is(labelUpdate));
 108     }
 109
 110     /**
 111      * This test case checks for
 112      * <pce-label-map> SRP, LABEL, FEC Object.
 113      * in PcepLabelUpdate message.
 114      */
 115     @Test
 116     public void labelUpdateMessageTest3() throws PcepParseException {
 117
 118         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x24, // common header
 119                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 120                 0x00, 0x00, 0x00, 0x00,
 121                 0x00, 0x00, 0x00, 0x10,
 122                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 123                 0x00, 0x00, 0x00, 0x00,
 124                 0x00, 0x00, 0x00, 0x66,
 125                 0x24, 0x10, 0x00, 0x08, // FEC Object Header
 126                 0x0A, 0x0A, 0x0B, 0x0B};
 127
 128         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
 129         buffer.writeBytes(labelUpdate);
 130
 131         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
 132         PcepMessage message = null;
 133
 134         message = reader.readFrom(buffer);
 135
 136         byte[] testLabelUpdateMsg = {0};
 137         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
 138         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
 139         message.writeTo(buf);
 140
 141         int readLen = buf.writerIndex();
 142         testLabelUpdateMsg = new byte[readLen];
 143         buf.readBytes(testLabelUpdateMsg, 0, readLen);
 144
 145         assertThat(testLabelUpdateMsg, is(labelUpdate));
 146     }
 147
 148     /**
 149      * This test case checks for
 150      * <pce-label-download> SRP, LSP, LABEL, LABEL, <pce-label-download> SRP, LSP, LABEL
 151      * in PcepLabelUpdate message.
 152      */
 153     @Test
 154     public void labelUpdateMessageTest4() throws PcepParseException {
 155
 156         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header
 157                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 158                 0x00, 0x00, 0x00, 0x00,
 159                 0x00, 0x00, 0x00, 0x10,
 160                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
 161                 0x00, 0x01, 0x00, 0x00,
 162                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 163                 0x00, 0x00, 0x00, 0x00,
 164                 0x00, 0x00, 0x00, 0x66,
 165                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 166                 0x00, 0x00, 0x00, 0x00,
 167                 0x00, 0x00, 0x00, 0x77,
 168                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 169                 0x00, 0x00, 0x00, 0x00,
 170                 0x00, 0x00, 0x00, 0x11,
 171                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
 172                 0x00, 0x02, 0x00, 0x00,
 173                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 174                 0x00, 0x00, 0x00, 0x00,
 175                 0x00, 0x00, 0x00, 0x44};
 176
 177         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
 178         buffer.writeBytes(labelUpdate);
 179
 180         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
 181         PcepMessage message = null;
 182
 183         message = reader.readFrom(buffer);
 184
 185         byte[] testLabelUpdateMsg = {0};
 186         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
 187         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
 188         message.writeTo(buf);
 189
 190         int readLen = buf.writerIndex();
 191         testLabelUpdateMsg = new byte[readLen];
 192         buf.readBytes(testLabelUpdateMsg, 0, readLen);
 193
 194         assertThat(testLabelUpdateMsg, is(labelUpdate));
 195     }
 196
 197     /**
 198      * This test case checks for
 199      * <pce-label-map> SRP, LABEL, FEC, <pce-label-map> SRP, LABEL, FEC.
 200      * in PcepLabelUpdate message.
 201      */
 202     @Test
 203     public void labelUpdateMessageTest5() throws PcepParseException {
 204
 205         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x44, // common header
 206                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 207                 0x00, 0x00, 0x00, 0x00,
 208                 0x00, 0x00, 0x00, 0x10,
 209                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 210                 0x00, 0x00, 0x00, 0x01,
 211                 0x00, 0x00, 0x00, 0x66,
 212                 0x24, 0x10, 0x00, 0x08, // FEC Object Header
 213                 0x0A, 0x0A, 0x0B, 0x0B,
 214                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 215                 0x00, 0x00, 0x00, 0x00,
 216                 0x00, 0x00, 0x00, 0x11,
 217                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 218                 0x00, 0x00, 0x00, 0x00,
 219                 0x00, 0x00, 0x00, 0x66,
 220                 0x24, 0x10, 0x00, 0x08, // FEC Object Header
 221                 0x0A, 0x0A, 0x0C, 0x0C};
 222
 223         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
 224         buffer.writeBytes(labelUpdate);
 225
 226         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
 227         PcepMessage message = null;
 228
 229         message = reader.readFrom(buffer);
 230
 231         byte[] testLabelUpdateMsg = {0};
 232         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
 233         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
 234         message.writeTo(buf);
 235
 236         int readLen = buf.writerIndex();
 237         testLabelUpdateMsg = new byte[readLen];
 238         buf.readBytes(testLabelUpdateMsg, 0, readLen);
 239
 240         assertThat(testLabelUpdateMsg, is(labelUpdate));
 241     }
 242
 243     /**
 244      * This test case checks for
 245      * <pce-label-download> SRP, LSP, LABEL, LABEL, <pce-label-download> SRP, LABEL, FEC.
 246      * in PcepLabelUpdate message.
 247      */
 248     @Test
 249     public void labelUpdateMessageTest6() throws PcepParseException {
 250
 251         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header
 252                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 253                 0x00, 0x00, 0x00, 0x00,
 254                 0x00, 0x00, 0x00, 0x10,
 255                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
 256                 0x00, 0x01, 0x00, 0x00,
 257                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 258                 0x00, 0x00, 0x00, 0x00,
 259                 0x00, 0x00, 0x00, 0x66,
 260                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 261                 0x00, 0x00, 0x00, 0x00,
 262                 0x00, 0x00, 0x00, 0x77,
 263                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 264                 0x00, 0x00, 0x00, 0x00,
 265                 0x00, 0x00, 0x00, 0x12,
 266                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 267                 0x00, 0x00, 0x00, 0x00,
 268                 0x00, 0x00, 0x00, 0x66,
 269                 0x24, 0x10, 0x00, 0x08, // FEC Object Header
 270                 0x0A, 0x0A, 0x0D, 0x0D};
 271
 272         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
 273         buffer.writeBytes(labelUpdate);
 274
 275         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
 276         PcepMessage message = null;
 277
 278         message = reader.readFrom(buffer);
 279
 280         byte[] testLabelUpdateMsg = {0};
 281         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
 282         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
 283         message.writeTo(buf);
 284
 285         int readLen = buf.writerIndex();
 286         testLabelUpdateMsg = new byte[readLen];
 287         buf.readBytes(testLabelUpdateMsg, 0, readLen);
 288
 289         assertThat(testLabelUpdateMsg, is(labelUpdate));
 290     }
 291
 292     /**
 293      * This test case checks for
 294      * <pce-label-download> SRP, LABEL, FEC, <pce-label-download> SRP, LSP, LABEL, LABEL.
 295      * in PcepLabelUpdate message.
 296      */
 297     @Test
 298     public void labelUpdateMessageTest7() throws PcepParseException {
 299
 300         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header
 301                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 302                 0x00, 0x00, 0x00, 0x00,
 303                 0x00, 0x00, 0x00, 0x12,
 304                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 305                 0x00, 0x00, 0x00, 0x00,
 306                 0x00, 0x00, 0x00, 0x66,
 307                 0x24, 0x10, 0x00, 0x08, // FEC Object Header
 308                 0x0A, 0x0A, 0x0D, 0x0D,
 309                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 310                 0x00, 0x00, 0x00, 0x00,
 311                 0x00, 0x00, 0x00, 0x10,
 312                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
 313                 0x00, 0x01, 0x00, 0x00,
 314                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 315                 0x00, 0x00, 0x00, 0x00,
 316                 0x00, 0x00, 0x00, 0x66,
 317                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 318                 0x00, 0x00, 0x00, 0x00,
 319                 0x00, 0x00, 0x00, 0x77};
 320
 321         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
 322         buffer.writeBytes(labelUpdate);
 323
 324         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
 325         PcepMessage message = null;
 326
 327         message = reader.readFrom(buffer);
 328
 329         byte[] testLabelUpdateMsg = {0};
 330         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
 331         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
 332         message.writeTo(buf);
 333
 334         int readLen = buf.writerIndex();
 335         testLabelUpdateMsg = new byte[readLen];
 336         buf.readBytes(testLabelUpdateMsg, 0, readLen);
 337
 338         assertThat(testLabelUpdateMsg, is(labelUpdate));
 339     }
 340
 341     /**
 342      * This test case checks for
 343      * <pce-label-download> SRP, LABEL, FEC, <pce-label-download> SRP, LSP, LABEL, LABEL.
 344      * <pce-label-download> SRP, LSP, LABEL, LABEL.
 345      * in PcepLabelUpdate message.
 346      */
 347     @Test
 348     public void labelUpdateMessageTest8() throws PcepParseException {
 349
 350         byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x7C, // common header
 351                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 352                 0x00, 0x00, 0x00, 0x00,
 353                 0x00, 0x00, 0x00, 0x12,
 354                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 355                 0x00, 0x00, 0x00, 0x00,
 356                 0x00, 0x00, 0x00, 0x66,
 357                 0x24, 0x10, 0x00, 0x08, // FEC Object Header
 358                 0x0A, 0x0A, 0x0D, 0x0D,
 359                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 360                 0x00, 0x00, 0x00, 0x00,
 361                 0x00, 0x00, 0x00, 0x10,
 362                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
 363                 0x00, 0x01, 0x00, 0x00,
 364                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 365                 0x00, 0x00, 0x00, 0x00,
 366                 0x00, 0x00, 0x00, 0x66,
 367                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 368                 0x00, 0x00, 0x00, 0x00,
 369                 0x00, 0x00, 0x00, 0x77,
 370                 0x21, 0x10, 0x00, 0x0C, // SRP Object Header
 371                 0x00, 0x00, 0x00, 0x00,
 372                 0x00, 0x00, 0x00, 0x10,
 373                 0x20, 0x10, 0x00, 0x08, // LSP Object Header
 374                 0x00, 0x01, 0x00, 0x00,
 375                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 376                 0x00, 0x00, 0x00, 0x00,
 377                 0x00, 0x00, 0x00, 0x66,
 378                 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header
 379                 0x00, 0x00, 0x00, 0x00,
 380                 0x00, 0x00, 0x00, 0x77};
 381
 382         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
 383         buffer.writeBytes(labelUpdate);
 384
 385         PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
 386         PcepMessage message = null;
 387
 388         message = reader.readFrom(buffer);
 389
 390         byte[] testLabelUpdateMsg = {0};
 391
 392         assertThat(message, instanceOf(PcepLabelUpdateMsg.class));
 393         ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
 394         message.writeTo(buf);
 395
 396         int readLen = buf.writerIndex();
 397         testLabelUpdateMsg = new byte[readLen];
 398         buf.readBytes(testLabelUpdateMsg, 0, readLen);
 399
 400         assertThat(testLabelUpdateMsg, is(labelUpdate));
 401     }
 402 }