mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, 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 package org.opendaylight.lispflowmapping.implementation.lisp;
   9
  10 import java.util.ArrayList;
  11 import java.util.List;
  12 import java.util.Set;
  13 import org.junit.Before;
  14 import org.junit.Test;
  15 import org.mockito.Mockito;
  16 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  17 import org.opendaylight.lispflowmapping.implementation.MappingService;
  18 import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
  19 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  20 import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
  21 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  22 import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list
  26         .MappingRecordItemBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordKey;
  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
  33         .MappingRecordBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container
  43         .MappingAuthkeyBuilder;
  44
  45 public class MapResolverTest {
  46
  47     private static MapResolver mapResolver;
  48     private static MappingService mapServiceMock;
  49     private static Set<SubscriberRLOC> subscriberSetMock;
  50     private static LispMappingService lispMappingServiceMock;
  51
  52     private static final String ITR_RLOC_KEY_STRING =   "itr_rloc_key";
  53     private static final String ITR_RLOC_ID_STRING =    "itr_rloc_id";
  54     private static final String IPV4_STRING_1 =         "1.2.3.0";
  55     private static final String IPV4_STRING_2 =         "1.2.4.0";
  56     private static final String IPV4_RLOC_STRING_1 =    "100.100.100.100";
  57     private static final String IPV4_SOURCE =           "127.0.0.1";
  58     private static final String IPV4_PREFIX_STRING =    "/24";
  59     private static final String IPV6_STRING =           "0:0:0:0:0:0:0:1";
  60     private static final String IPV6_PREFIX_STRING =    "/128";
  61
  62     private static final LocatorRecordKey LOCATOR_RECORD_KEY = new LocatorRecordKey("key");
  63     private static final int TTL_RLOC_TIMED_OUT = 1;
  64
  65     private static final IpAddress IPV4_ADDRESS_1 = new IpAddress(new Ipv4Address(IPV4_STRING_1));
  66     private static final IpAddress IPV4_ADDRESS_2 = new IpAddress(new Ipv4Address(IPV4_STRING_2));
  67
  68     private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
  69     private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_2 + IPV4_PREFIX_STRING);
  70     private static final Eid IPV6_PREFIX_EID = LispAddressUtil.asIpv6PrefixEid(IPV6_STRING + IPV6_PREFIX_STRING);
  71     private static final Eid SOURCE_DEST_KEY_EID = LispAddressUtil.asSrcDstEid(IPV4_SOURCE, IPV4_STRING_2, 24, 24, 0);
  72
  73     private static final Rloc RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1);
  74     private static MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
  75     private static final SubscriberRLOC SUBSCRIBER_RLOC_1 = new SubscriberRLOC(RLOC_1,
  76             LispAddressUtil.asIpv4Eid(IPV4_SOURCE));
  77
  78     @Before
  79     @SuppressWarnings("unchecked")
  80     public void init() throws Exception {
  81         mapServiceMock = Mockito.mock(MappingService.class, "mapService");
  82         subscriberSetMock = Mockito.mock(Set.class);
  83         lispMappingServiceMock = Mockito.mock(LispMappingService.class, "requestHandler");
  84         mapResolver = new MapResolver(mapServiceMock, true, ConfigIni.getInstance().getElpPolicy(),
  85                 lispMappingServiceMock);
  86         mapRequestBuilder = getDefaultMapRequestBuilder();
  87     }
  88
  89     /**
  90      * Tests {@link MapResolver#handleMapRequest} method.
  91      */
  92     @Test
  93     public void handleMapRequest__withSingleLocator() {
  94         // input mapping
  95         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
  96         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
  97         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
  98
  99         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 100                 .thenReturn(mappingRecordBuilder.build());
 101
 102         // result
 103         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 104         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 105                 .setMappingRecord(mappingRecordBuilder.build()).build());
 106
 107         mapResolver.handleMapRequest(mapRequestBuilder.build());
 108         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 109     }
 110
 111     /**
 112      * Tests {@link MapResolver#handleMapRequest} method.
 113      */
 114     @Test
 115     public void handleMapRequest__withNoMapping() {
 116         final MappingRecordBuilder mappingRecordBuilder = new MappingRecordBuilder()
 117                 .setAuthoritative(false)
 118                 .setMapVersion((short) 0)
 119                 .setEid(IPV4_PREFIX_EID_1)
 120                 .setAction(MappingRecord.Action.NativelyForward)
 121                 .setRecordTtl(TTL_RLOC_TIMED_OUT);
 122
 123
 124         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 125                 .thenReturn(null);
 126         Mockito.when(mapServiceMock.getAuthenticationKey(IPV4_PREFIX_EID_1))
 127                 .thenReturn(new MappingAuthkeyBuilder().build());
 128         Mockito.when(mapServiceMock.getWidestNegativePrefix(IPV4_PREFIX_EID_1)).thenReturn(IPV4_PREFIX_EID_1);
 129
 130         // result
 131         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 132         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 133                 .setMappingRecord(mappingRecordBuilder.build()).build());
 134
 135         mapResolver.handleMapRequest(mapRequestBuilder.build());
 136         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 137     }
 138
 139     /**
 140      * Tests {@link MapResolver#handleMapRequest} method.
 141      */
 142     @Test
 143     public void handleMapRequest__withSubscribers() {
 144         // input mapping
 145         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 146         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 147         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 148
 149         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 150                 .thenReturn(mappingRecordBuilder.build());
 151         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 152                 .thenReturn(subscriberSetMock);
 153         Mockito.when(subscriberSetMock.contains(Mockito.any(SubscriberRLOC.class))).thenReturn(false);
 154
 155         // result
 156         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 157         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 158                 .setMappingRecord(mappingRecordBuilder.build()).build());
 159
 160         mapResolver.handleMapRequest(mapRequestBuilder.build());
 161         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 162         Mockito.verify(subscriberSetMock, Mockito.never()).remove(Mockito.any(SubscriberRLOC.class));
 163     }
 164
 165     /**
 166      * Tests {@link MapResolver#handleMapRequest} method.
 167      */
 168     @Test
 169     public void handleMapRequest__withSubscribersToRemove() {
 170         // input mapping
 171         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 172         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 173         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 174
 175         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 176                 .thenReturn(mappingRecordBuilder.build());
 177         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 178                 .thenReturn(subscriberSetMock);
 179         Mockito.when(subscriberSetMock.contains(new SubscriberRLOC(
 180                 mapRequestBuilder.getItrRloc().get(0).getRloc(),
 181                 mapRequestBuilder.getSourceEid().getEid())))
 182                 .thenReturn(true);
 183
 184         // result
 185         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 186         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 187                 .setMappingRecord(mappingRecordBuilder.build()).build());
 188
 189         // check if a subscriber is re-instantiating when there already is one in the subscriber set
 190         mapResolver.handleMapRequest(mapRequestBuilder.build());
 191         Mockito.verify(subscriberSetMock).remove(SUBSCRIBER_RLOC_1);
 192         Mockito.verify(subscriberSetMock).add(SUBSCRIBER_RLOC_1);
 193         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 194         Mockito.verify(mapServiceMock).addData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1,
 195                 SubKeys.SUBSCRIBERS, subscriberSetMock);
 196
 197         // verify that itrRloc is subscribed to dst address
 198         mappingRecordBuilder.setEid(SOURCE_DEST_KEY_EID);
 199         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_2).build());
 200         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_2))
 201                 .thenReturn(mappingRecordBuilder.build());
 202
 203         mapResolver.handleMapRequest(mapRequestBuilder.build());
 204         Mockito.verify(mapServiceMock).getData(MappingOrigin.Southbound,
 205                 SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS);
 206     }
 207
 208     /**
 209      * Tests {@link MapResolver#handleMapRequest} method.
 210      */
 211     @Test
 212     public void handleMapRequest_withBothPolicy() {
 213         mapResolver = new MapResolver(mapServiceMock, true, "both", lispMappingServiceMock);
 214
 215         final List<IpAddress> ipAddressList = new ArrayList<>();
 216         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 217         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 218
 219         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 220         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 221         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 222
 223         // input mapping
 224         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 225         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 226         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 227
 228         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 229         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 230                 .build());
 231         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 232                 .build());
 233
 234         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 235                 .thenReturn(mappingRecordBuilder.build());
 236
 237         // result
 238         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 239                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).setPriority((short) 1); // priority increased by 1
 240         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 241
 242         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 243         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build()); // as ELP
 244         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 245
 246         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 247         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 248                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 249
 250         // invocation
 251         mapResolver.handleMapRequest(mapRequestBuilder.build());
 252         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 253     }
 254
 255     /**
 256      * Tests {@link MapResolver#handleMapRequest} method.
 257      */
 258     @Test
 259     public void handleMapRequest_withReplacePolicy() {
 260         mapResolver = new MapResolver(mapServiceMock, true, "replace", lispMappingServiceMock);
 261
 262         final List<IpAddress> ipAddressList = new ArrayList<>();
 263         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 264         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 265
 266         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 267         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 268         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 269
 270         // input mapping
 271         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 272         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 273         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 274
 275         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 276         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 277                 .build());
 278         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 279                 .build());
 280
 281         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 282                 .thenReturn(mappingRecordBuilder.build());
 283
 284         // result
 285         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 286                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2));
 287         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 288
 289         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 290         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 291
 292         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 293         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 294                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 295
 296         // invocation
 297         mapResolver.handleMapRequest(mapRequestBuilder.build());
 298         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 299     }
 300
 301     /**
 302      * Tests {@link MapResolver#handleMapRequest} method.
 303      */
 304     @Test
 305     public void handleMapRequest_withMultipleEids() {
 306         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV6_PREFIX_EID).build());
 307
 308         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 309         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder();
 310         locatorRecordBuilder_2.setRloc(LispAddressUtil.asIpv6Rloc(IPV6_STRING));
 311
 312         //input mapping
 313         final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder();
 314         mappingRecordBuilder_1.getLocatorRecord().add(locatorRecordBuilder_1.build());
 315         final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
 316         mappingRecordBuilder_2.getLocatorRecord().add(locatorRecordBuilder_2.build());
 317         mappingRecordBuilder_2.setEid(IPV6_PREFIX_EID);
 318
 319         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 320                 mapRequestBuilder.getEidItem().get(0).getEid())).thenReturn(mappingRecordBuilder_1.build());
 321         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 322                 mapRequestBuilder.getEidItem().get(1).getEid())).thenReturn(mappingRecordBuilder_2.build());
 323
 324         //result
 325         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 326         mapReplyBuilder.getMappingRecordItem()
 327                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_1.build()).build());
 328         mapReplyBuilder.getMappingRecordItem()
 329                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_2.build()).build());
 330
 331         mapResolver.handleMapRequest(mapRequestBuilder.build());
 332         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 333     }
 334
 335     private static List<ItrRloc> getDefaultItrRlocList() {
 336         final List<ItrRloc> itrRlocList = new ArrayList<>();
 337         final ItrRloc itrRloc = new ItrRlocBuilder()
 338                 .setKey(new ItrRlocKey(ITR_RLOC_KEY_STRING))
 339                 .setItrRlocId(ITR_RLOC_ID_STRING)
 340                 .setRloc(RLOC_1).build();
 341         itrRlocList.add(itrRloc);
 342
 343         return itrRlocList;
 344     }
 345
 346     private static MapRequestBuilder getDefaultMapRequestBuilder() {
 347         MapRequestBuilder mrBuilder = new MapRequestBuilder()
 348                 .setAuthoritative(false)
 349                 .setEidItem(new ArrayList<>())
 350                 .setItrRloc(new ArrayList<>())
 351                 .setMapDataPresent(true)
 352                 .setNonce((long) 0)
 353                 .setPitr(false)
 354                 .setProbe(false)
 355                 .setSmr(false)
 356                 .setSmrInvoked(true)
 357                 .setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(IPV4_SOURCE)).build())
 358                 .setItrRloc(getDefaultItrRlocList());
 359
 360         mrBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_1).build());
 361
 362         return mrBuilder;
 363     }
 364
 365     private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
 366         return new MappingRecordBuilder()
 367                 .setAction(MappingRecord.Action.NoAction)
 368                 .setAuthoritative(false)
 369                 .setLocatorRecord(new ArrayList<>())
 370                 .setMapVersion((short) 0)
 371                 .setRecordTtl(60)
 372                 .setEid(IPV4_PREFIX_EID_1);
 373     }
 374
 375     private static LocatorRecordBuilder getDefaultLocatorBuilder() {
 376         return new LocatorRecordBuilder()
 377                 .setLocalLocator(false)
 378                 .setMulticastPriority((short) 0)
 379                 .setMulticastWeight((short) 0)
 380                 .setPriority((short) 0)
 381                 .setRlocProbed(false)
 382                 .setRouted(true)
 383                 .setWeight((short) 0)
 384                 .setKey(LOCATOR_RECORD_KEY)
 385                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1));
 386     }
 387
 388     private static MapReplyBuilder getDefaultMapReplyBuilder() {
 389         return new MapReplyBuilder()
 390                 .setEchoNonceEnabled(false)
 391                 .setProbe(false)
 392                 .setSecurityEnabled(false)
 393                 .setNonce(mapRequestBuilder.getNonce())
 394                 .setMappingRecordItem(new ArrayList<>());
 395     }
 396 }