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