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