mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/LispMappingServiceTest.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;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNull;
  12
  13 import com.google.common.collect.Lists;
  14 import java.lang.reflect.Field;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17 import org.apache.commons.lang3.tuple.ImmutablePair;
  18 import org.apache.commons.lang3.tuple.MutablePair;
  19 import org.apache.commons.lang3.tuple.Pair;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.ArgumentMatcher;
  23 import org.mockito.InjectMocks;
  24 import org.mockito.Mock;
  25 import org.mockito.Mockito;
  26 import org.mockito.junit.MockitoJUnitRunner;
  27 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
  28 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
  29 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
  30 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
  31 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
  32 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  33 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MappingKeepAlive;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.MapRegisterCacheMetadata;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.MapRegisterCacheMetadataBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddress;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddressBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequest;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequestBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.OdlLispSbService;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInput;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInputBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInputBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestInputBuilder;
  68
  69 @RunWith(MockitoJUnitRunner.class)
  70 public class LispMappingServiceTest {
  71     @Mock private static MapRegister mapRegisterMock;
  72     @Mock(name = "mapServer") private static IMapServerAsync mapServerMock;
  73     @Mock(name = "mapResolver") private static IMapResolverAsync mapResolverMock;
  74     @Mock(name = "tlsMapReply") private static ThreadLocal<MapReply> tlsMapReplyMock;
  75     @Mock(name = "tlsMapNotify") private static ThreadLocal<Pair<MapNotify, List<TransportAddress>>> tlsMapNotifyMock;
  76     @Mock(name = "tlsMapRequest") private static ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequestMock;
  77
  78     private final NotificationService notificationService = Mockito.mock(NotificationService.class);
  79     private final IMappingService mappingService = Mockito.mock(IMappingService.class);
  80     private final OdlLispSbService odlLispSbService = Mockito.mock(OdlLispSbService.class);
  81     private final ClusterSingletonServiceProvider clusterSingletonService = Mockito.mock(
  82             ClusterSingletonServiceProvider.class);
  83
  84     @InjectMocks
  85     private LispMappingService lispMappingService = new LispMappingService(
  86             notificationService, mappingService, odlLispSbService, clusterSingletonService);
  87
  88     private static final byte[] IPV4_BYTES_1 =       new byte[] {1, 2, 3, 0};
  89     private static final byte[] IPV4_BYTES_2 =       new byte[] {1, 2, 4, 0};
  90     private static final String IPV4_STRING_1 =      "1.2.3.0";
  91     private static final String IPV4_STRING_2 =      "1.2.3.1";
  92     private static final String IPV4_SOURCE_STRING = "192.168.0.1";
  93     private static final String IPV4_PREFIX_STRING = "/24";
  94     private static final long TIMESTAMP = 1L;
  95
  96     private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
  97     private static final Eid IPV4_SOURCE_EID = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING);
  98     private static final Eid IPV4_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_STRING_1);
  99     private static final Eid IPV4_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_STRING_2);
 100     private static final EidItemBuilder EID_ITEM_BUILDER = new EidItemBuilder()
 101             .setEidItemId("eid-item-id")
 102             .setEid(IPV4_PREFIX_EID_1);
 103     private static final MappingRecordItemBuilder MAPPING_RECORD_ITEM_BUILDER = new MappingRecordItemBuilder()
 104             .setMappingRecord(new MappingRecordBuilder().setEid(IPV4_PREFIX_EID_1).build());
 105
 106     private static final TransportAddress TRANSPORT_ADDRESS_1 = new TransportAddressBuilder()
 107             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
 108             .setPort(new PortNumber(9999)).build();
 109     private static final TransportAddress TRANSPORT_ADDRESS_2 = new TransportAddressBuilder()
 110             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_2)))
 111             .setPort(new PortNumber(8888)).build();
 112     private static final TransportAddress TRANSPORT_ADDRESS = new TransportAddressBuilder()
 113             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
 114             .setPort(new PortNumber(LispMessage.PORT_NUM)).build();
 115
 116     /**
 117      * Tests {@link LispMappingService#handleMapRequest} method.
 118      */
 119     @Test
 120     public void handleMapRequestTest() {
 121         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 122         final MapReply mapReply = new MapReplyBuilder().build();
 123         Mockito.when(tlsMapRequestMock.get()).thenReturn(null);
 124         Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
 125
 126         final MapReply result = lispMappingService.handleMapRequest(mapRequest);
 127
 128         Mockito.verify(tlsMapRequestMock).set(null);
 129         Mockito.verify(tlsMapRequestMock).get();
 130         Mockito.verifyNoMoreInteractions(tlsMapRequestMock);
 131         Mockito.verify(mapResolverMock).handleMapRequest(mapRequest);
 132         Mockito.verify(tlsMapReplyMock).set(Mockito.any());
 133         Mockito.verify(tlsMapReplyMock).get();
 134
 135         assertEquals(result, mapReply);
 136     }
 137
 138     /**
 139      * Tests {@link LispMappingService#handleMapRequest} method request from non-proxy xTR.
 140      */
 141     @Test
 142     public void handleMapRequestTest_NonProxy() {
 143         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 144         final Pair<MapRequest, TransportAddress> pair = getDefaultMapRequestPair();
 145         final SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder()
 146                 .setMapRequest(pair.getLeft())
 147                 .setTransportAddress(pair.getRight());
 148
 149         Mockito.when(tlsMapRequestMock.get()).thenReturn(pair);
 150
 151         assertNull(lispMappingService.handleMapRequest(mapRequest));
 152         Mockito.verify(odlLispSbService).sendMapRequest(smrib.build());
 153     }
 154
 155     /**
 156      * Tests {@link LispMappingService#handleMapRegister} method.
 157      */
 158     @Test
 159     @SuppressWarnings("unchecked")
 160     public void handleMapRegisterTest() {
 161         final Pair<MapNotify, List<TransportAddress>> pairMock = Mockito.mock(Pair.class);
 162
 163         Mockito.when(tlsMapNotifyMock.get()).thenReturn(pairMock);
 164
 165         lispMappingService.handleMapRegister(mapRegisterMock);
 166         Mockito.verify(mapServerMock).handleMapRegister(mapRegisterMock);
 167         Mockito.verify(tlsMapNotifyMock).set(Mockito.any());
 168     }
 169
 170     /**
 171      * Tests {@link LispMappingService#onAddMapping} method.
 172      */
 173     @Test
 174     public void onAddMappingTest() {
 175         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegister
 176                 mapRegister = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 177                 .mapregisternotification.MapRegister.class);
 178         final AddMapping addMapping = Mockito.mock(AddMapping.class);
 179
 180         Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
 181         Mockito.when(tlsMapNotifyMock.get()).thenReturn(getDefaultMapNotifyPair());
 182
 183         lispMappingService.onAddMapping(addMapping);
 184         Mockito.verify(odlLispSbService, Mockito.times(2)).sendMapNotify(Mockito.argThat(new TransportAddressMatch()));
 185     }
 186
 187     /**
 188      * Tests {@link LispMappingService#onAddMapping} method with no TransportAddress.
 189      */
 190     @Test
 191     public void onAddMappingTest_noTransportAddress() {
 192         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegister
 193                 mapRegister = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 194                 .mapregisternotification.MapRegister.class);
 195         final AddMapping addMapping = Mockito.mock(AddMapping.class);
 196         final MapNotify mapNotify = new MapNotifyBuilder().setKeyId((short) 1).build();
 197
 198         Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
 199         Mockito.when(tlsMapNotifyMock.get()).thenReturn(new MutablePair<>(mapNotify, null));
 200         Mockito.when(addMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
 201
 202         // result
 203         final SendMapNotifyInputBuilder smnib = new SendMapNotifyInputBuilder()
 204                 .setMapNotify(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 205                         .mapnotifymessage.MapNotifyBuilder().setKeyId((short) 1).build())
 206                 .setTransportAddress(TRANSPORT_ADDRESS);
 207
 208         lispMappingService.onAddMapping(addMapping);
 209         Mockito.verify(odlLispSbService).sendMapNotify(smnib.build());
 210     }
 211
 212     /**
 213      * Tests {@link LispMappingService#onRequestMapping} method.
 214      */
 215     @Test
 216     public void onRequestMappingTest() {
 217         final RequestMapping requestMapping = Mockito.mock(RequestMapping.class);
 218         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest
 219                 mapRequest = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 220                     .maprequestnotification.MapRequest.class);
 221         final MapReply mapReply = new MapReplyBuilder().build();
 222
 223         Mockito.when(requestMapping.getMapRequest()).thenReturn(mapRequest);
 224         Mockito.when(requestMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
 225         Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
 226
 227         // result
 228         final SendMapReplyInputBuilder smrib = new SendMapReplyInputBuilder()
 229                 .setMapReply(new MapReplyBuilder(mapReply).build())
 230                 .setTransportAddress(TRANSPORT_ADDRESS_1);
 231
 232         lispMappingService.onRequestMapping(requestMapping);
 233         Mockito.verify(odlLispSbService).sendMapReply(smrib.build());
 234     }
 235
 236     /**
 237      * Tests {@link LispMappingService#onRequestMapping} method with mapReply == null.
 238      */
 239     @Test
 240     public void onRequestMappingTest_withNullMapReply() {
 241         final RequestMapping requestMapping = Mockito.mock(RequestMapping.class);
 242         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest
 243                 mapRequest = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 244                     .maprequestnotification.MapRequest.class);
 245
 246         Mockito.when(requestMapping.getMapRequest()).thenReturn(mapRequest);
 247         Mockito.when(tlsMapReplyMock.get()).thenReturn(null);
 248
 249         lispMappingService.onRequestMapping(requestMapping);
 250         Mockito.verifyZeroInteractions(odlLispSbService);
 251     }
 252
 253     /**
 254      * Tests {@link LispMappingService#onMappingKeepAlive} method.
 255      */
 256     @Test
 257     public void onMappingKeepAliveTest() {
 258         final MappingKeepAlive mappingKeepAlive = Mockito.mock(MappingKeepAlive.class);
 259         Mockito.when(mappingKeepAlive.getMapRegisterCacheMetadata()).thenReturn(getDefaultMapRegisterCacheMetadata());
 260
 261         lispMappingService.onMappingKeepAlive(mappingKeepAlive);
 262         Mockito.verify(mappingService).refreshMappingRegistration(IPV4_EID_1, null, TIMESTAMP);
 263         Mockito.verify(mappingService).refreshMappingRegistration(IPV4_EID_2, null, TIMESTAMP);
 264     }
 265
 266     /**
 267      * Tests {@link LispMappingService#handleSMR} method.
 268      */
 269     @Test
 270     public void handleSmrTest() {
 271         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 272         final Rloc subscriber = LispAddressUtil.asIpv4Rloc(IPV4_STRING_1);
 273
 274         Mockito.when(mapRequest.getSourceEid()).thenReturn(new SourceEidBuilder().setEid(IPV4_SOURCE_EID).build());
 275         Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 276
 277         // result
 278         final SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder()
 279                 .setMapRequest(new MapRequestBuilder(mapRequest).build())
 280                 .setTransportAddress(TRANSPORT_ADDRESS);
 281
 282         lispMappingService.handleSMR(mapRequest, subscriber);
 283         Mockito.verify(odlLispSbService).sendMapRequest(smrib.build());
 284     }
 285
 286     /**
 287      * Tests {@link LispMappingService#setShouldUseSmr} method.
 288      */
 289     @Test
 290     public void setShouldUseSmrTest() {
 291         final boolean value = true;
 292
 293         lispMappingService.setShouldUseSmr(value);
 294         Mockito.verify(mapServerMock).setSubscriptionService(value);
 295         Mockito.verify(mapResolverMock).setSubscriptionService(value);
 296     }
 297
 298     /**
 299      * Tests {@link LispMappingService#handleMapNotify} method.
 300      */
 301     @Test
 302     @SuppressWarnings("unchecked")
 303     public void handleMapNotifyTest() {
 304         final MapNotify mapNotify = Mockito.mock(MapNotify.class);
 305         final List<TransportAddress> list = Mockito.mock(ArrayList.class);
 306
 307         lispMappingService.handleMapNotify(mapNotify, list);
 308         Mockito.verify(tlsMapNotifyMock).set(Mockito.any(MutablePair.class));
 309     }
 310
 311     /**
 312      * Tests {@link LispMappingService#handleNonProxyMapRequest} method.
 313      */
 314     @Test
 315     @SuppressWarnings("unchecked")
 316     public void handleNonProxyMapRequestTest() {
 317         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 318         final TransportAddress transportAddress = Mockito.mock(TransportAddress.class);
 319
 320         lispMappingService.handleNonProxyMapRequest(mapRequest, transportAddress);
 321         Mockito.verify(tlsMapRequestMock).set(Mockito.any(MutablePair.class));
 322     }
 323
 324     /**
 325      * Tests {@link LispMappingService#handleMapReply} method.
 326      */
 327     @Test
 328     public void handleMapReplyTest() {
 329         final MapReply mapReply = Mockito.mock(MapReply.class);
 330
 331         lispMappingService.handleMapReply(mapReply);
 332         Mockito.verify(tlsMapReplyMock).set(Mockito.any(MapReply.class));
 333     }
 334
 335     /**
 336      * Tests {@link LispMappingService#close} method.
 337      */
 338     @Test
 339     public void closeTest() throws Exception {
 340         lispMappingService.close();
 341
 342         assertNull(getField("mapResolver"));
 343         assertNull(getField("mapServer"));
 344     }
 345
 346     /**
 347      * Tests {@link LispMappingService} other setter and getter methods.
 348      */
 349     @Test
 350     public void otherTest() throws Exception {
 351         assertEquals(notificationService, lispMappingService.getNotificationService());
 352         assertEquals(true, lispMappingService.shouldUseSmr());
 353
 354         lispMappingService.setShouldAuthenticate(true);
 355         Mockito.verify(mapResolverMock).setShouldAuthenticate(true);
 356
 357         lispMappingService.onGotMapReply(Mockito.mock(GotMapReply.class));
 358         lispMappingService.onGotMapNotify(Mockito.mock(GotMapNotify.class));
 359         lispMappingService.onXtrRequestMapping(Mockito.mock(XtrRequestMapping.class));
 360         lispMappingService.onXtrReplyMapping(Mockito.mock(XtrReplyMapping.class));
 361     }
 362
 363     @SuppressWarnings("unchecked")
 364     private <T> T getField(String fieldName) throws NoSuchFieldException, IllegalAccessException {
 365         final Field field = LispMappingService.class.getDeclaredField(fieldName);
 366         field.setAccessible(true);
 367
 368         return (T) field.get(lispMappingService);
 369     }
 370
 371     private static Pair<MapNotify, List<TransportAddress>> getDefaultMapNotifyPair() {
 372         final MapNotify mapNotify = new MapNotifyBuilder().setKeyId((short) 1).build();
 373         return new MutablePair<>(mapNotify, Lists.newArrayList(TRANSPORT_ADDRESS_1, TRANSPORT_ADDRESS_2));
 374     }
 375
 376     private static Pair<MapRequest, TransportAddress> getDefaultMapRequestPair() {
 377         final MapRequestBuilder mapRequestBuilder = new MapRequestBuilder()
 378                 .setEidItem(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 379
 380         return new ImmutablePair<>(mapRequestBuilder.build(), TRANSPORT_ADDRESS_1);
 381     }
 382
 383     private static MapRegisterCacheMetadata getDefaultMapRegisterCacheMetadata() {
 384         final EidLispAddress eidLispAddress_1 = new EidLispAddressBuilder()
 385                 .setEidLispAddressId("id-1")
 386                 .setEid(IPV4_EID_1).build();
 387         final EidLispAddress eidLispAddress_2 = new EidLispAddressBuilder()
 388                 .setEidLispAddressId("id-2")
 389                 .setEid(IPV4_EID_2).build();
 390
 391         return new MapRegisterCacheMetadataBuilder()
 392                 .setEidLispAddress(Lists.newArrayList(eidLispAddress_1, eidLispAddress_2))
 393                 .setTimestamp(TIMESTAMP).build();
 394     }
 395
 396     class TransportAddressMatch implements ArgumentMatcher<SendMapNotifyInput> {
 397         public boolean matches(SendMapNotifyInput sendMapNotify) {
 398             final TransportAddress notifyTransportAddress = sendMapNotify.getTransportAddress();
 399             return TRANSPORT_ADDRESS_1.equals(notifyTransportAddress)
 400                     || TRANSPORT_ADDRESS_2.equals(notifyTransportAddress);
 401         }
 402     }
 403 }