mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/serializer/MapRequestSerializationTest.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.implementation.serializer;
  10
  11 import static org.junit.Assert.assertArrayEquals;
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertTrue;
  15
  16 import java.nio.ByteBuffer;
  17 import java.util.ArrayList;
  18
  19 import org.junit.Test;
  20 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
  21 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
  22 import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainerBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.NoBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.MapReply;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.MapReplyBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
  39
  40 public class MapRequestSerializationTest extends BaseTestCase {
  41
  42     @Test
  43     public void prefix__NoPrefix() throws Exception {
  44         MapRequestBuilder mrBuilder = new MapRequestBuilder();
  45         mrBuilder.setEidRecord(new ArrayList<EidRecord>());
  46         mrBuilder.getEidRecord().add(
  47                 new EidRecordBuilder().setLispAddressContainer(
  48                         new LispAddressContainerBuilder().setAddress(
  49                                 new NoBuilder().setNoAddress(
  50                                         new NoAddressBuilder().setAfi((short) 0)
  51                                         .build()).build()).build()).build());
  52
  53
  54         assertEquals(AddressFamilyNumberEnum.NO_ADDRESS.getIanaCode(),
  55                 LispAFIConvertor.toAFI(mrBuilder.getEidRecord().get(0).getLispAddressContainer()).getAfi().shortValue());
  56     }
  57
  58     @Test
  59     public void deserialize__FlagsInFirstByte() throws Exception {
  60         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 00 00 01 3d 8d "
  61         //
  62                 + "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 " //
  63                 + "00 01 01 02 03 04"));
  64         assertFalse(mr.isAuthoritative());
  65         assertTrue(mr.isMapDataPresent());
  66         assertTrue(mr.isProbe());
  67         assertFalse(mr.isSmr());
  68
  69         mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("19 00 00 01 3d 8d "
  70         //
  71                 + "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 " //
  72                 + "00 01 01 02 03 04"));
  73         assertTrue(mr.isAuthoritative());
  74         assertFalse(mr.isMapDataPresent());
  75         assertFalse(mr.isProbe());
  76         assertTrue(mr.isSmr());
  77
  78         mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("1C 00 00 01 3d 8d "
  79         //
  80                 + "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 " //
  81                 + "00 01 01 02 03 04"));
  82         assertTrue(mr.isAuthoritative());
  83         assertTrue(mr.isMapDataPresent());
  84         assertFalse(mr.isProbe());
  85         assertFalse(mr.isSmr());
  86     }
  87
  88     @Test
  89     public void deserialize__LispMobMapRequestWithReply() throws Exception {
  90         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("14 00 00 01 3e f7 " //
  91                 + "7f 5b 41 7c 77 3c 00 01 01 01 01 01 00 01 c0 a8 " //
  92                 + "38 66 00 20 00 01 01 02 03 04 00 00 00 0a 01 20 " //
  93                 + "10 00 00 00 00 01 01 01 01 01 01 64 ff 00 00 05 " //
  94                 + "00 01 c0 a8 38 66"));
  95         assertEquals("1.1.1.1", ((Ipv4) mr.getSourceEid().getLispAddressContainer().getAddress()).getIpv4Address().getIpv4Address().getValue());
  96         assertEquals("1.2.3.4", ((Ipv4) mr.getEidRecord().get(0).getLispAddressContainer().getAddress()).getIpv4Address().getIpv4Address().getValue());
  97
  98     }
  99
 100     @Test
 101     public void serialize__EmptyMapRequest() throws Exception {
 102
 103         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 104         ByteBuffer expected = hexToByteBuffer("10 00 00 00 00 00 " //
 105                 + "00 00 00 00 00 00 00 00");
 106         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 107     }
 108
 109     @Test
 110     public void serialize__FlagsInFirstByte() throws Exception {
 111
 112         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 113         mrBuilder.setAuthoritative(true);
 114         mrBuilder.setProbe(true);
 115         ByteBuffer expected = hexToByteBuffer("1A 00 00 00 00 00 " //
 116                 + "00 00 00 00 00 00 00 00");
 117         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 118         mrBuilder = new MapRequestBuilder();
 119         mrBuilder.setSmr(true);
 120         mrBuilder.setMapDataPresent(true);
 121         expected = hexToByteBuffer("15 00 00 00 00 00 " //
 122                 + "00 00 00 00 00 00 00 00");
 123         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 124         mrBuilder.setAuthoritative(true);
 125         mrBuilder.setProbe(true);
 126         expected = hexToByteBuffer("1F 00 00 00 00 00 " //
 127                 + "00 00 00 00 00 00 00 00");
 128         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 129     }
 130
 131     @Test
 132     public void serialize__FlagsInSecondByte() throws Exception {
 133         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 134         mrBuilder.setPitr(true);
 135         mrBuilder.setSmrInvoked(true);
 136         ByteBuffer expected = hexToByteBuffer("10 C0 00 00 00 00 " //
 137                 + "00 00 00 00 00 00 00 00");
 138         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 139         mrBuilder.setPitr(false);
 140         expected = hexToByteBuffer("10 40 00 00 00 00 " //
 141                 + "00 00 00 00 00 00 00 00");
 142         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 143
 144     }
 145
 146     @Test
 147     public void deserialize__FlagsInSecondByte() throws Exception {
 148         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 80 00 01 3d 8d "
 149         //
 150                 + "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 " //
 151                 + "00 01 01 02 03 04"));
 152         assertTrue(mr.isPitr());
 153         assertFalse(mr.isSmrInvoked());
 154
 155         mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("19 40 00 01 3d 8d "
 156         //
 157                 + "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 " //
 158                 + "00 01 01 02 03 04"));
 159         assertFalse(mr.isPitr());
 160         assertTrue(mr.isSmrInvoked());
 161     }
 162
 163     @Test
 164     public void deserialize__SingleEidRecord() throws Exception {
 165         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 80 00 "
 166         //
 167                 + "01 " // single record
 168                 + "3d 8d 2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a " //
 169                 + "00 20 00 01 01 02 03 04"));
 170
 171         assertEquals(1, mr.getEidRecord().size());
 172         EidRecord eid = mr.getEidRecord().get(0);
 173         assertEquals(0x20, eid.getMask().byteValue());
 174         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")), eid.getLispAddressContainer());
 175     }
 176
 177     @Test
 178     public void deserialize__ContainsMapReply() throws Exception {
 179         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 80 00 " //
 180                 + "01 " // single record
 181                 + "3d 8d 2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a " //
 182                 + "00 20 00 01 01 02 03 04 "// end of map request
 183                 + "00 00 " //
 184                 + "00 02 01 20 00 00 00 00 " //
 185                 + "00 01 01 02 03 04 01 02 " //
 186                 + "03 04 00 06 00 01 0a 0a " //
 187                 + "0a 0a"
 188
 189         ));
 190
 191         assertEquals(1, mr.getEidRecord().size());
 192         EidRecord eid = mr.getEidRecord().get(0);
 193         assertEquals(0x20, eid.getMask().byteValue());
 194         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")), eid.getLispAddressContainer());
 195         MapReply mapReply = mr.getMapReply();
 196         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(("1.2.3.4"))), mapReply.getLispAddressContainer());
 197         assertEquals(false, mapReply.isAuthoritative());
 198         assertEquals(Action.NoAction, mapReply.getAction());
 199         assertEquals(0, mapReply.getMapVersion().shortValue());
 200         assertEquals(32, mapReply.getMaskLength().shortValue());
 201         assertEquals(2, mapReply.getRecordTtl().byteValue());
 202         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(("10.10.10.10"))), mapReply.getLocatorRecord().get(0)
 203                 .getLispAddressContainer());
 204         assertEquals(1, mapReply.getLocatorRecord().get(0).getPriority().byteValue());
 205         assertEquals(2, mapReply.getLocatorRecord().get(0).getWeight().byteValue());
 206         assertEquals(3, mapReply.getLocatorRecord().get(0).getMulticastPriority().byteValue());
 207         assertEquals(4, mapReply.getLocatorRecord().get(0).getMulticastWeight().byteValue());
 208         assertEquals(true, mapReply.getLocatorRecord().get(0).isLocalLocator());
 209         assertEquals(true, mapReply.getLocatorRecord().get(0).isRlocProbed());
 210         assertEquals(false, mapReply.getLocatorRecord().get(0).isRouted());
 211     }
 212
 213     @Test
 214     public void serialize__SingleEidRecord() throws Exception {
 215         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 216         mrBuilder.setEidRecord(new ArrayList<EidRecord>());
 217         mrBuilder.getEidRecord().add(
 218                 new EidRecordBuilder().setMask((short) 32)
 219                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 220         ByteBuffer expected = hexToByteBuffer("10 00 00 01 00 00 " //
 221                 + "00 00 00 00 00 00 00 00 00 20 00 01 01 02 03 04");
 222         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 223     }
 224
 225     @Test
 226     public void deserialize__MultipleEidRecord() throws Exception {
 227         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 80 00 "
 228         //
 229                 + "02 " // 2 records
 230                 + "3d 8d 2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a " //
 231                 + "00 20 00 01 01 02 03 04 " //
 232                 + "00 80 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05"));
 233
 234         assertEquals(2, mr.getEidRecord().size());
 235
 236         EidRecord eid = mr.getEidRecord().get(0);
 237         assertEquals(0x0020, eid.getMask().shortValue());
 238         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")), eid.getLispAddressContainer());
 239
 240         eid = mr.getEidRecord().get(1);
 241         assertEquals(0x0080, eid.getMask().shortValue());
 242         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:5")), eid.getLispAddressContainer());
 243     }
 244
 245     @Test
 246     public void serialize__MultipleEidRecord() throws Exception {
 247         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 248         mrBuilder.setEidRecord(new ArrayList<EidRecord>());
 249         mrBuilder.getEidRecord().add(
 250                 new EidRecordBuilder().setMask((short) 32)
 251                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 252         mrBuilder.getEidRecord().add(
 253                 new EidRecordBuilder().setMask((short) 0)
 254                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build());
 255         ByteBuffer expected = hexToByteBuffer("10 00 00 02 00 00 " //
 256                 + "00 00 00 00 00 00 00 00 00 20 00 01 01 02 03 04 00 00 00 01 04 03 02 01");
 257         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 258     }
 259
 260     @Test
 261     public void deserialize__SingleItrRloc() throws Exception {
 262         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("10 00 "
 263         //
 264                 + "00 " // This means 1 ITR-RLOC
 265                 + "01 3d 8d 2a cd 39 c8 d6 08 00 00 " //
 266                 + "00 01 c0 a8 88 0a " // IPv4 (ITR-RLOC #1 of 1)
 267                 + "00 20 00 01 01 02 03 04"));
 268
 269         assertEquals(1, mr.getItrRloc().size());
 270         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("192.168.136.10")), mr.getItrRloc().get(0)
 271                 .getLispAddressContainer());
 272     }
 273
 274     @Test
 275     public void serialize__SingleItrRloc() throws Exception {
 276         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 277         mrBuilder.setItrRloc(new ArrayList<ItrRloc>());
 278         mrBuilder.getItrRloc().add(
 279                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 280         ByteBuffer expected = hexToByteBuffer("10 00 00 00 00 00 " //
 281                 + "00 00 00 00 00 00 00 00 00 01 01 02 03 04");
 282         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 283     }
 284
 285     @Test
 286     public void serialize__MultipleItrRloc() throws Exception {
 287         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 288         mrBuilder.setItrRloc(new ArrayList<ItrRloc>());
 289         mrBuilder.getItrRloc().add(
 290                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 291         mrBuilder.getItrRloc().add(
 292                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build());
 293         ByteBuffer expected = hexToByteBuffer("10 00 01 00 00 00 " //
 294                 + "00 00 00 00 00 00 00 00 00 01 01 02 03 04 00 01 04 03 02 01");
 295         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 296     }
 297
 298     @Test
 299     public void deserialize__MultipleItrRlocs() throws Exception {
 300         MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("10 00 "
 301         //
 302                 + "02 " // This means 3 ITR - RLOCs
 303                 + "01 3d 8d 2a cd 39 c8 d6 08 00 00 " //
 304                 + "00 01 c0 a8 88 0a " // IPv4 (ITR-RLOC #1 of 3)
 305                 // IPv6 (ITR-RLOC #2 of 3)
 306                 + "00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 " //
 307                 + "00 01 11 22 34 56 " // IPv4 (ITR-RLOC #3 of 3)
 308                 + "00 20 00 01 01 02 03 04"));
 309
 310         assertEquals(3, mr.getItrRloc().size());
 311         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("192.168.136.10")), mr.getItrRloc().get(0)
 312                 .getLispAddressContainer());
 313         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")), mr.getItrRloc().get(1)
 314                 .getLispAddressContainer());
 315         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("17.34.52.86")), mr.getItrRloc().get(2).getLispAddressContainer());
 316     }
 317
 318     @Test
 319     public void serialize__All() throws Exception {
 320         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 321         mrBuilder.setProbe(true);
 322         mrBuilder.setPitr(true);
 323         mrBuilder.setNonce((long) 13);
 324         mrBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
 325                 LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.0.1"))).build());
 326         mrBuilder.setItrRloc(new ArrayList<ItrRloc>());
 327         mrBuilder.getItrRloc().add(
 328                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 329         mrBuilder.getItrRloc().add(
 330                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8")))
 331                         .build());
 332         mrBuilder.setEidRecord(new ArrayList<EidRecord>());
 333         mrBuilder.getEidRecord().add(
 334                 new EidRecordBuilder().setMask((short) 32)
 335                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 336         ByteBuffer expected = hexToByteBuffer("12 80 01 01 00 00 " //
 337                 + "00 00 00 00 00 0D 00 01 0a 00 00 01 00 01 01 02 03 04 00 02 00 01 00 02 00 03 00 04 00 05 00 06 00 07 00 08 00 20 00 01 01 02 03 04");
 338         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mrBuilder.build()).array());
 339     }
 340
 341     @Test
 342     public void serialize__AllWithMapReply() throws Exception {
 343         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 344         mapRequestBuilder.setProbe(true);
 345         mapRequestBuilder.setMapDataPresent(true);
 346         mapRequestBuilder.setPitr(true);
 347         mapRequestBuilder.setNonce((long) 13);
 348         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
 349                 LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.0.1"))).build());
 350         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
 351         mapRequestBuilder.getItrRloc().add(
 352                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 353         mapRequestBuilder.getItrRloc().add(
 354                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8")))
 355                         .build());
 356         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
 357         mapRequestBuilder.getEidRecord().add(
 358                 new EidRecordBuilder().setMask((short) 32)
 359                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build());
 360         MapReplyBuilder mapreplyBuilder = new MapReplyBuilder();
 361
 362         mapreplyBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.1")));
 363         mapreplyBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
 364
 365         LocatorRecordBuilder locatorBuilder = new LocatorRecordBuilder();
 366         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.2")));
 367         mapreplyBuilder.getLocatorRecord().add(locatorBuilder.build());
 368         mapRequestBuilder.setMapReply(mapreplyBuilder.build());
 369
 370         ByteBuffer expected = hexToByteBuffer("16 80 01 01 00 00 " //
 371                 + "00 00 00 00 00 0D 00 01 0a 00 00 01 00 01 01 02 03 04 00 02 00 01 00 02 00 03 00 04 00 05 00 06 00 07 00 08 00 20 00 01 01 02 03 04 "// map
 372                                                                                                                                                         // request
 373                 + "00 00 00 00 01 00 00 00 00 00 00 01 00 00 00 01 00 00 00 00 00 00 00 01 00 00 00 02");
 374         assertArrayEquals(expected.array(), MapRequestSerializer.getInstance().serialize(mapRequestBuilder.build()).array());
 375     }
 376
 377 }