mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRegisterSerializationTest.java

   1 /*
   2  * Copyright (c) 2014 Contextream, Inc. 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.lispflowmapping.serializer;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import java.nio.ByteBuffer;
  16 import java.util.ArrayList;
  17
  18 import junitx.framework.ArrayAssert;
  19
  20 import org.junit.Test;
  21 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
  22 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer.Length;
  23 import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
  24 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  25 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
  36
  37 public class MapRegisterSerializationTest extends BaseTestCase {
  38
  39     @Test
  40     public void serialize__Fields() throws Exception {
  41         MapRegisterBuilder mrBuilder = new MapRegisterBuilder();
  42         mrBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
  43         MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
  44         recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
  45         recordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("0.0.0.1/32"));
  46
  47         mrBuilder.getMappingRecordItem().add(
  48                 new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
  49         recordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("0.0.0.73/32"));
  50         mrBuilder.getMappingRecordItem().add(
  51                 new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
  52
  53         mrBuilder.setNonce(6161616161L);
  54         mrBuilder.setKeyId((short) 0x0001);
  55         mrBuilder.setWantMapNotify(true);
  56         mrBuilder.setProxyMapReply(true);
  57         mrBuilder.setXtrSiteIdPresent(true);
  58         byte[] authenticationData = new byte[] { (byte) 0x16, (byte) 0x98, (byte) 0x96, (byte) 0xeb, (byte) 0x88,
  59                 (byte) 0x2d, (byte) 0x4d, (byte) 0x22, (byte) 0xe5, (byte) 0x8f, (byte) 0xe6, (byte) 0x89, (byte) 0x64,
  60                 (byte) 0xb9, (byte) 0x17, (byte) 0xa4, (byte) 0xba, (byte) 0x4e, (byte) 0x8c, (byte) 0x41 };
  61         mrBuilder.setAuthenticationData(authenticationData);
  62         XtrId xtrId  = new XtrId(new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
  63                 (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
  64                 (byte) 0x00, (byte) 0x00, (byte) 0x01 });
  65         mrBuilder.setXtrId(xtrId);
  66         SiteId siteId = new SiteId(new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
  67                 (byte) 0x00, (byte) 0x00, (byte) 0x01 });
  68         mrBuilder.setSiteId(siteId);
  69
  70         ByteBuffer bb = MapRegisterSerializer.getInstance().serialize(mrBuilder.build());
  71         assertHexEquals((byte) 0x3a, bb.get()); // Type + MSByte of reserved
  72         assertEquals(1, bb.getShort()); // Rest of reserved + want map notify
  73         assertEquals(2, bb.get()); // Record Count
  74         assertEquals(6161616161L, bb.getLong()); // Nonce
  75         assertHexEquals((short) 0x0001, bb.getShort()); // Key ID
  76         assertEquals(authenticationData.length, bb.getShort());
  77
  78         byte[] actualAuthenticationData = new byte[20];
  79         bb.get(actualAuthenticationData);
  80         ArrayAssert.assertEquals(authenticationData, actualAuthenticationData);
  81
  82         bb.position(bb.position() + 12); // EID in first record
  83         assertEquals(0x1, bb.getInt());
  84
  85         bb.position(bb.position() + 12); // EID in second record
  86         assertEquals(73, bb.getInt());
  87
  88         byte[] actualXtrId  = new byte[Length.XTRID_SIZE];
  89         bb.get(actualXtrId);
  90         ArrayAssert.assertEquals(xtrId.getValue(), actualXtrId);
  91
  92         byte[] actualSiteId = new byte[Length.SITEID_SIZE];
  93         bb.get(actualSiteId);
  94         ArrayAssert.assertEquals(siteId.getValue(), actualSiteId);
  95
  96         assertEquals(bb.position(), bb.capacity());
  97     }
  98
  99     @Test
 100     public void serialize__deserialize() throws Exception {
 101         MapRegisterBuilder mrBuilder = new MapRegisterBuilder();
 102         mrBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
 103         MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
 104         recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
 105         recordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("0.0.0.1/32"));
 106
 107         mrBuilder.getMappingRecordItem().add(
 108                 new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
 109         recordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("0.0.0.73/32"));
 110         mrBuilder.getMappingRecordItem().add(
 111                 new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
 112
 113         recordBuilder.setAction(Action.NoAction);
 114         recordBuilder.setMapVersion((short) 0);
 115         recordBuilder.setMaskLength((short) 0);
 116         recordBuilder.setRecordTtl(0);
 117         mrBuilder.setNonce(6161616161L);
 118         mrBuilder.setKeyId((short) 0x0001);
 119         mrBuilder.setWantMapNotify(true);
 120         mrBuilder.setProxyMapReply(true);
 121         byte[] authenticationData = new byte[] { (byte) 0x16, (byte) 0x98, (byte) 0x96, (byte) 0xeb, (byte) 0x88,
 122                 (byte) 0x2d, (byte) 0x4d, (byte) 0x22, (byte) 0xe5, (byte) 0x8f, (byte) 0xe6, (byte) 0x89, (byte) 0x64,
 123                 (byte) 0xb9, (byte) 0x17, (byte) 0xa4, (byte) 0xba, (byte) 0x4e, (byte) 0x8c, (byte) 0x41 };
 124         mrBuilder.setAuthenticationData(authenticationData);
 125
 126         MapRegister mapRegister = mrBuilder.build();
 127         ArrayAssert.assertEquals(
 128                 MapRegisterSerializer.getInstance().serialize(mapRegister).array(),
 129                 MapRegisterSerializer.getInstance()
 130                         .serialize(MapRegisterSerializer.getInstance().deserialize(MapRegisterSerializer.getInstance()
 131                                 .serialize(mapRegister), null)).array());
 132     }
 133
 134     @Test
 135     public void serialize__NoAuthenticationData() throws Exception {
 136         MapRegisterBuilder mrBuilder = new MapRegisterBuilder();
 137         mrBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
 138         mrBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
 139                 new MappingRecordBuilder().setRecordTtl(55)
 140                         .setEid(LispAddressUtil.asIpv4PrefixEid("0.0.0.1/32")).build()).build());
 141         // mrBuilder.addEidToLocator(new EidToLocatorRecord().setPrefix(new
 142         // LispIpv4Address(1)).setRecordTtl(55));
 143
 144         ByteBuffer bb = MapRegisterSerializer.getInstance().serialize(mrBuilder.build());
 145         bb.position(bb.position() + 14); // jump to AuthenticationDataLength
 146         assertEquals(0, bb.getShort());
 147         assertEquals(55, bb.getInt());
 148
 149         mrBuilder.setAuthenticationData(null);
 150
 151         bb = MapRegisterSerializer.getInstance().serialize(mrBuilder.build());
 152         bb.position(bb.position() + 14); // jump to AuthenticationDataLength
 153         assertEquals(0, bb.getShort());
 154         assertEquals(55, bb.getInt());
 155
 156         mrBuilder.setAuthenticationData(new byte[0]);
 157
 158         bb = MapRegisterSerializer.getInstance().serialize(mrBuilder.build());
 159         bb.position(bb.position() + 14); // jump to AuthenticationDataLength
 160         assertEquals(0, bb.getShort());
 161         assertEquals(55, bb.getInt());
 162     }
 163
 164     @Test
 165     public void serialize__NoPrefixInEidToLocator() throws Exception {
 166         MapRegisterBuilder mrBuilder = new MapRegisterBuilder();
 167         mrBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
 168         mrBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
 169                 new MappingRecordBuilder().build()).build());
 170         mrBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
 171                 new MappingRecordBuilder().setEid(null).build()).build());
 172         mrBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
 173                 new MappingRecordBuilder().setEid(LispAddressUtil.getNoAddressEid()).build()).build());
 174
 175         ByteBuffer bb = MapRegisterSerializer.getInstance().serialize(mrBuilder.build());
 176         bb.position(bb.position() + 16); // jump to first record prefix AFI
 177         assertEquals(0, bb.getShort());
 178
 179         bb.position(bb.position() + 10); // jump to second record prefix AFI
 180         assertEquals(0, bb.getShort());
 181
 182         bb.position(bb.position() + 10); // jump to third record prefix AFI
 183         assertEquals(0, bb.getShort());
 184     }
 185
 186     @Test
 187     public void deserialize__AllFields() throws Exception {
 188         // LISP(Type = 3 Map-Register, P=1, M=1
 189         // Record Counter: 1
 190         // Nonce: (something)
 191         // Key ID: 0x0000
 192         // AuthDataLength: 00 Data:
 193         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 194         // No-Action
 195         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 196         // Priority/Weight: 1/100, Multicast Priority/Weight: 255/0
 197         //
 198         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
 199         //
 200                 + "00 00 00 00 00 00 00 00 00 00 00 00 " //
 201                 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 202                 + "ff 00 00 05 00 01 c0 a8 88 0a"), null);
 203
 204         assertTrue(mr.isProxyMapReply());
 205         assertTrue(mr.isWantMapNotify());
 206
 207         assertEquals(1, mr.getMappingRecordItem().size());
 208         assertEquals(0xFFBB000000000000L, mr.getNonce().longValue());
 209         assertEquals(0x0000, mr.getKeyId().shortValue());
 210         byte[] expectedAuthenticationData = {};
 211         ArrayAssert.assertEquals(expectedAuthenticationData, mr.getAuthenticationData());
 212     }
 213
 214     @Test
 215     public void deserialize__serialize() throws Exception {
 216         ByteBuffer bb = hexToByteBuffer("32 00 01 01 63 99 "
 217                 + "83 64 23 06 a8 be 00 01 00 14 b8 c2 a2 e1 dc 4a "
 218                 + "08 0c f6 01 b0 9d 70 5a d4 88 95 f8 73 dd 00 00 "
 219                 + "05 a0 01 20 10 00 00 00 40 03 00 00 02 20 00 0a "
 220                 + "00 00 00 01 00 01 c3 a8 c8 01 0a 32 ff 00 00 04 "
 221                 + "00 01 ac 10 01 02 15 1a 39 80 e3 35 e6 c4 49 a6 "
 222                 + "90 87 20 65 9a b7 00 00 00 00 00 00 00 00 ");
 223         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(bb, null);
 224
 225         assertTrue(mr.isXtrSiteIdPresent());
 226
 227         ArrayAssert.assertEquals(bb.array(), MapRegisterSerializer.getInstance().serialize(mr).array());
 228     }
 229
 230     @Test
 231     public void deserialize__MultipleRecords() throws Exception {
 232         // LISP(Type = 3 Map-Register, P=1, M=1
 233         // Record Counter: 4
 234         // EID prefixes: 153.16.254.1 -- 152.16.254.1 -- 151.16.254.1 --
 235         // 150.16.254.1
 236         // Local RLOCs: 192.168.136.10 -- 192.168.136.11 -- 192.168.136.12 --
 237         // 192.168.136.13
 238         //
 239         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 "
 240         //
 241                 + "04 " // Record count
 242                 + "FF BB 00 00 00 00 00 00 00 01 00 14 87 c1 33 cd " //
 243                 + "d1 1e bc 80 fd 3e 71 11 81 17 40 74 26 25 44 bd " //
 244                 + "00 00 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " // Record
 245                 // 1
 246                 + "ff 00 00 05 00 01 c0 a8 88 0a " // contd
 247                 + "00 00 00 0a 01 20 10 00 00 00 00 01 98 10 fe 01 01 64 " // Record
 248                 // 2
 249                 + "ff 00 00 05 00 01 c0 a8 88 0b " // contd
 250                 + "00 00 00 0a 01 20 10 00 00 00 00 01 97 10 fe 01 01 64 " // Record
 251                 // 3
 252                 + "ff 00 00 05 00 01 c0 a8 88 0c " // contd
 253                 + "00 00 00 0a 01 20 10 00 00 00 00 01 96 10 fe 01 01 64 " // Record
 254                 // 4
 255                 + "ff 00 00 05 00 01 c0 a8 88 0d " // contd
 256         ), null);
 257
 258         assertEquals(4, mr.getMappingRecordItem().size());
 259         assertEquals(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), mr.getMappingRecordItem().get(0)
 260                 .getMappingRecord().getEid());
 261         assertEquals(LispAddressUtil.asIpv4PrefixEid("151.16.254.1/32"), mr.getMappingRecordItem().get(2)
 262                 .getMappingRecord().getEid());
 263         assertEquals(LispAddressUtil.asIpv4Rloc("192.168.136.11"), mr.getMappingRecordItem().get(1)
 264                 .getMappingRecord().getLocatorRecord().get(0).getRloc());
 265         assertEquals(LispAddressUtil.asIpv4Rloc("192.168.136.13"), mr.getMappingRecordItem().get(3)
 266                 .getMappingRecord().getLocatorRecord().get(0).getRloc());
 267     }
 268
 269     @Test
 270     public void deserialize__Locators() throws Exception {
 271         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 "
 272         //
 273                 + "FF BB 00 00 00 00 00 00 00 01 00 14 f1 b8 ab f0 " //
 274                 + "66 bb 2e ef 12 70 74 46 6f 6b 8e ca bf 1e 68 40 " //
 275                 + "00 00 00 0a " //
 276                 + "03 " // Locator Count
 277                 + "20 10 00 00 00 00 01 99 10 fe 01 "
 278                 // Locator 1
 279                 + "01 64 1f 00 " // priorities + weights
 280                 + "00 05 " // Flags
 281                 + "00 01 c0 a8 88 0a " // Locator
 282                 // Locator 2
 283                 + "67 00 30 34 " // priorities + weights
 284                 + "00 02 " // Flags
 285                 + "00 01 cc aa AA 11 " // Locator
 286                 // Locator 3
 287                 + "60 11 34 A4 " // priorities + weights
 288                 + "00 03 " // Flags
 289                 + "00 01 c0 a8 88 0a " // Locator
 290         ), null);
 291
 292         assertEquals(1, mr.getMappingRecordItem().size());
 293         MappingRecordItem eidToLocator = mr.getMappingRecordItem().get(0);
 294         assertEquals(3, eidToLocator.getMappingRecord().getLocatorRecord().size());
 295         LocatorRecord loc0 = eidToLocator.getMappingRecord().getLocatorRecord().get(0);
 296         LocatorRecord loc1 = eidToLocator.getMappingRecord().getLocatorRecord().get(1);
 297         LocatorRecord loc2 = eidToLocator.getMappingRecord().getLocatorRecord().get(2);
 298         assertEquals((byte) 0x01, loc0.getPriority().byteValue());
 299         assertEquals((byte) 0x67, loc1.getPriority().byteValue());
 300         assertEquals((byte) 0x60, loc2.getPriority().byteValue());
 301
 302         assertEquals((byte) 0x64, loc0.getWeight().byteValue());
 303         assertEquals((byte) 0x00, loc1.getWeight().byteValue());
 304         assertEquals((byte) 0x11, loc2.getWeight().byteValue());
 305
 306         assertEquals((byte) 0x1F, loc0.getMulticastPriority().byteValue());
 307         assertEquals((byte) 0x30, loc1.getMulticastPriority().byteValue());
 308         assertEquals((byte) 0x34, loc2.getMulticastPriority().byteValue());
 309
 310         assertEquals((byte) 0x00, loc0.getMulticastWeight().byteValue());
 311         assertEquals((byte) 0x34, loc1.getMulticastWeight().byteValue());
 312         assertEquals((byte) 0xA4, loc2.getMulticastWeight().byteValue());
 313
 314         assertTrue(loc0.isLocalLocator());
 315         assertFalse(loc1.isLocalLocator());
 316         assertFalse(loc2.isLocalLocator());
 317
 318         assertFalse(loc0.isRlocProbed());
 319         assertTrue(loc1.isRlocProbed());
 320         assertTrue(loc2.isRlocProbed());
 321
 322         assertTrue(loc0.isRouted());
 323         assertFalse(loc1.isRouted());
 324         assertTrue(loc2.isRouted());
 325
 326         assertEquals(LispAddressUtil.asIpv4Rloc("192.168.136.10"), loc0.getRloc());
 327         assertEquals(LispAddressUtil.asIpv4Rloc("204.170.170.17"), loc1.getRloc());
 328     }
 329
 330     @Test
 331     public void deserialize__SomeEidToLocatorFiels() throws Exception {
 332         // LISP(Type = 3 Map-Register, P=1, M=1
 333         // Record Counter: 4
 334         // EID prefixes: 153.16.254.1 -- 152.16.254.1 -- 151.16.254.1 --
 335         // 150.16.254.1
 336         // Local RLOCs: 192.168.136.10 -- 192.168.136.11 -- 192.168.136.12 --
 337         // 192.168.136.13
 338         //
 339         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 "
 340         //
 341                 + "04 " // Record count
 342                 + "FF BB 00 00 00 00 00 00 00 01 00 14 b9 cd 7b 89 " //
 343                 + "65 c2 56 03 be dd 81 20 47 e5 c3 4f 56 02 e1 59 " //
 344                 + "00 00 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " // Record
 345                 // 0
 346                 + "ff 00 00 05 00 01 c0 a8 88 0a " // contd
 347                 + "00 00 00 0b 01 17 50 00 01 11 00 01 98 10 fe 01 01 64 " // Record
 348                 // 1
 349                 + "ff 00 00 05 00 01 c0 a8 88 0b " // contd
 350                 + "00 00 00 0c 01 20 00 00 02 22 00 01 97 10 fe 01 01 64 " // Record
 351                 // 2
 352                 + "ff 00 00 05 00 01 c0 a8 88 0c " // contd
 353                 + "00 00 00 0d 01 20 20 00 03 33 00 01 96 10 fe 01 01 64 " // Record
 354                 // 3
 355                 + "ff 00 00 05 00 01 c0 a8 88 0d " // contd
 356         ), null);
 357
 358         assertEquals(4, mr.getMappingRecordItem().size());
 359
 360         MappingRecord record0 = mr.getMappingRecordItem().get(0).getMappingRecord();
 361         MappingRecord record1 = mr.getMappingRecordItem().get(1).getMappingRecord();
 362         MappingRecord record2 = mr.getMappingRecordItem().get(2).getMappingRecord();
 363         MappingRecord record3 = mr.getMappingRecordItem().get(3).getMappingRecord();
 364
 365         assertEquals(10, record0.getRecordTtl().intValue());
 366         assertEquals(13, record3.getRecordTtl().intValue());
 367
 368         assertEquals(32, record0.getMaskLength().intValue());
 369         assertEquals(23, record1.getMaskLength().intValue());
 370
 371         assertEquals(Action.NoAction, record0.getAction());
 372         assertEquals(Action.SendMapRequest, record1.getAction());
 373         assertEquals(Action.NoAction, record2.getAction());
 374         assertEquals(Action.NativelyForward, record3.getAction());
 375
 376         assertTrue(record0.isAuthoritative());
 377         assertTrue(record1.isAuthoritative());
 378         assertFalse(record2.isAuthoritative());
 379         assertFalse(record3.isAuthoritative());
 380
 381         assertEquals(0x000, record0.getMapVersion().shortValue());
 382         assertEquals(0x111, record1.getMapVersion().shortValue());
 383         assertEquals(0x222, record2.getMapVersion().shortValue());
 384         assertEquals(0x333, record3.getMapVersion().shortValue());
 385     }
 386
 387     @Test
 388     public void deserialize__IllegalAction() throws Exception {
 389         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
 390         //
 391                 + "00 00 00 00 00 00 00 01 00 14 ec 47 1e 53 25 91 " //
 392                 + "2f 68 10 75 13 dd 2c e8 6e 3c ac 94 ed e4 00 00 " //
 393                 + "00 0a 01 20 F0 00 00 00 00 01 99 10 fe 01 01 64 " //
 394                 + "ff 00 00 05 00 01 c0 a8 88 0a"), null);
 395
 396         assertEquals(1, mr.getMappingRecordItem().size());
 397         assertEquals(Action.NoAction, mr.getMappingRecordItem().get(0).getMappingRecord().getAction());
 398     }
 399
 400     @Test(expected = LispSerializationException.class)
 401     public void deserialize_WrongAuthenticationLength() throws Exception {
 402         // LISP(Type = 3 Map-Register, P=1, M=1
 403         // Record Counter: 1
 404         // Nonce: (something)
 405         // Key ID: 0x0000
 406         // AuthDataLength: 20 Data:
 407         // e8:f5:0b:c5:c5:f2:b0:21:27:a8:a5:68:89:ec
 408         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 409         // No-Action
 410         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 411         // Priority/Weight: 1/100, Multicast Priority/Weight: 255/0
 412         //
 413         MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
 414         //
 415                 + "00 00 00 00 00 00 00 00 00 14 e8 f5 0b c5 c5 f2 " //
 416                 + "b0 21 27 a8 21 a5 68 89 ec 00 00 " //
 417                 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 418                 + "ff 00 00 05 00 01 c0 a8 88 0a"), null);
 419     }
 420
 421     @Test
 422     public void deserialize__SHA1() throws Exception {
 423         // LISP(Type = 3 Map-Register, P=1, M=1
 424         // Record Counter: 1
 425         // Nonce: (something)
 426         // Key ID: 0x0001
 427         // AuthDataLength: 20 Data:
 428         // b2:dd:1a:25:c0:60:b1:46:e8:dc:6d:a6:ae:2e:92:92:a6:ca:b7:9d
 429         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 430         // No-Action
 431         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 432         // Priority/Weight: 1/100, Multicast Priority/Weight: 255/0
 433         //
 434         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
 435         //
 436                 + "00 00 00 00 00 00 00 01 00 14 2c 61 b9 c9 9a 20 " //
 437                 + "ba d8 f5 40 d3 55 6f 5f 6e 5a b2 0a bf b5 00 00 " //
 438                 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 439                 + "ff 00 00 05 00 01 c0 a8 88 0a"), null);
 440
 441         assertTrue(mr.isProxyMapReply());
 442         assertTrue(mr.isWantMapNotify());
 443
 444         assertEquals(1, mr.getMappingRecordItem().size());
 445         assertEquals(0xFFBB000000000000L, mr.getNonce().longValue());
 446         assertEquals(0x0001, mr.getKeyId().shortValue());
 447         byte[] expectedAuthenticationData = { (byte) 0x2c, (byte) 0x61, (byte) 0xb9, (byte) 0xc9, (byte) 0x9a,
 448                 (byte) 0x20, (byte) 0xba, (byte) 0xd8, (byte) 0xf5, (byte) 0x40, (byte) 0xd3, (byte) 0x55, (byte) 0x6f,
 449                 (byte) 0x5f, (byte) 0x6e, (byte) 0x5a, (byte) 0xb2, (byte) 0x0a, (byte) 0xbf, (byte) 0xb5 };
 450         ArrayAssert.assertEquals(expectedAuthenticationData, mr.getAuthenticationData());
 451     }
 452
 453     @Test
 454     public void deserialize__SHA256() throws Exception {
 455         // LISP(Type = 3 Map-Register, P=1, M=1
 456         // Record Counter: 1
 457         // Nonce: (something)
 458         // Key ID: 0x0002
 459         // AuthDataLength: 32 Data:
 460         // 70 30 d4 c6 10 44 0d 83 be 4d bf fd a9 8c 57 6d 68 a5 bf 32 11 c9 7b
 461         // 58 c4 b9 9f 06 11 23 b9 38
 462         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 463         // No-Action
 464         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 465         // Priority/Weight: 1/100, Multicast Priority/Weight: 255/0
 466         //
 467         MapRegister mr = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
 468         //
 469                 + "00 00 00 00 00 00 00 02 00 20 70 30 d4 c6 10 44 0d 83 be 4d bf fd a9 8c 57 6d 68 a5 bf 32 "
 470                 //
 471                 + "11 c9 7b 58 c4 b9 9f 06 11 23 b9 38 00 00 " //
 472                 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 473                 + "ff 00 00 05 00 01 c0 a8 88 0a"), null);
 474
 475         assertTrue(mr.isProxyMapReply());
 476         assertTrue(mr.isWantMapNotify());
 477
 478         assertEquals(1, mr.getMappingRecordItem().size());
 479         assertEquals(0xFFBB000000000000L, mr.getNonce().longValue());
 480         assertEquals(0x0002, mr.getKeyId().shortValue());
 481         byte[] expectedAuthenticationData = { (byte) 0x70, (byte) 0x30, (byte) 0xd4, (byte) 0xc6, (byte) 0x10,
 482                 (byte) 0x44, (byte) 0x0d, (byte) 0x83, (byte) 0xbe, (byte) 0x4d, (byte) 0xbf, (byte) 0xfd, (byte) 0xa9,
 483                 (byte) 0x8c, (byte) 0x57, (byte) 0x6d, (byte) 0x68, (byte) 0xa5, (byte) 0xbf, (byte) 0x32, (byte) 0x11,
 484                 (byte) 0xc9, (byte) 0x7b, (byte) 0x58, (byte) 0xc4, (byte) 0xb9, (byte) 0x9f, (byte) 0x06, (byte) 0x11,
 485                 (byte) 0x23, (byte) 0xb9, (byte) 0x38 };
 486         ArrayAssert.assertEquals(expectedAuthenticationData, mr.getAuthenticationData());
 487     }
 488 }