Eliminate EntityOwnershipChange

EntityOwnershipChange is only used in ownership listeners as a single
method argument. Since it is generic on GenericEntity type, users
actually need to use @SuppressFBWarnings to safely get at the entity.

Remove the DTO and inline its contents into
GenericEntityOwnershipListener.ownershipChanged() arguments.

JIRA: MDSAL-843
Change-Id: I49f8714c030ede45b073b0d5f3db5b4c4eb5d013
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/entityownership/mdsal-eos-binding-adapter/src/main/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DOMEntityOwnershipListenerAdapter.java b/entityownership/mdsal-eos-binding-adapter/src/main/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DOMEntityOwnershipListenerAdapter.java
index 9c21c94e00e4d335491ec73e3f470935d4c8b9aa..b5e2c9fdf57d18fd81c0d2f3f9210480f8fe6a2a 100644 (file)
--- a/entityownership/mdsal-eos-binding-adapter/src/main/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DOMEntityOwnershipListenerAdapter.java
+++ b/entityownership/mdsal-eos-binding-adapter/src/main/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DOMEntityOwnershipListenerAdapter.java
@@ -10,11 +10,10 @@ package org.opendaylight.mdsal.eos.binding.dom.adapter;
 import static com.google.common.base.Verify.verifyNotNull;
 import static java.util.Objects.requireNonNull;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
 import org.opendaylight.mdsal.eos.binding.api.Entity;
 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListener;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@@ -40,10 +39,9 @@ final class DOMEntityOwnershipListenerAdapter implements DOMEntityOwnershipListe
 
     @Override
     @SuppressWarnings("checkstyle:IllegalCatch")
-    @SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST_OF_RETURN_VALUE", justification = "generic getEntity()")
-    public void ownershipChanged(final EntityOwnershipChange<DOMEntity> ownershipChange) {
-        final var domEntity = ownershipChange.getEntity();
-        final var domId = domEntity.getIdentifier();
+    public void ownershipChanged(final DOMEntity entity, final EntityOwnershipStateChange change,
+            final boolean inJeopardy) {
+        final var domId = entity.getIdentifier();
         final InstanceIdentifier<?> bindingId;
         try {
             bindingId = verifyNotNull(adapterContext.currentSerializer().fromYangInstanceIdentifier(domId));
@@ -52,13 +50,12 @@ final class DOMEntityOwnershipListenerAdapter implements DOMEntityOwnershipListe
             return;
         }
 
-        final var bindingEntity = new Entity(domEntity.getType(), bindingId);
-        final var bindingChange = new EntityOwnershipChange<>(bindingEntity, ownershipChange.getState(),
-            ownershipChange.inJeopardy());
+        final var bindingEntity = new Entity(entity.getType(), bindingId);
         try {
-            bindingListener.ownershipChanged(bindingChange);
+            bindingListener.ownershipChanged(bindingEntity, change, inJeopardy);
         } catch (Exception e) {
-            LOG.error("Listener {} failed during change notification {}", bindingListener, bindingChange, e);
+            LOG.error("Listener {} failed on during {} {}change {}", bindingListener, bindingEntity,
+                inJeopardy ? "jeopardy " : "", change, e);
         }
     }
 }

diff --git a/entityownership/mdsal-eos-binding-adapter/src/test/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DefaultEntityOwnershipServiceTest.java b/entityownership/mdsal-eos-binding-adapter/src/test/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DefaultEntityOwnershipServiceTest.java
index 115901c854ec2bceb6f45af4e0c22ef32d3b8c3d..7cd39265d89432531e14cc0fc201ede9afaef81e 100644 (file)
--- a/entityownership/mdsal-eos-binding-adapter/src/test/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DefaultEntityOwnershipServiceTest.java
+++ b/entityownership/mdsal-eos-binding-adapter/src/test/java/org/opendaylight/mdsal/eos/binding/dom/adapter/DefaultEntityOwnershipServiceTest.java
@@ -7,29 +7,27 @@
  */
 package org.opendaylight.mdsal.eos.binding.dom.adapter;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
-import static org.mockito.ArgumentMatchers.any;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
 
 import java.util.Optional;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.eclipse.jdt.annotation.NonNull;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.mdsal.binding.dom.adapter.ConstantAdapterContext;
 import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
 import org.opendaylight.mdsal.eos.binding.api.Entity;
 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
-import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
@@ -42,91 +40,92 @@ import org.opendaylight.yangtools.concepts.Registration;
  *
  * @author Thomas Pantelis
  */
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class DefaultEntityOwnershipServiceTest {
-    static final Entity BINDING_ENTITY = new Entity("foo", "bar");
-    static final DOMEntity DOM_ENTITY = new DOMEntity("foo", "bar");
+@ExtendWith(MockitoExtension.class)
+class DefaultEntityOwnershipServiceTest {
+    private static final @NonNull Entity BINDING_ENTITY = new Entity("foo", "bar");
+    private static final @NonNull DOMEntity DOM_ENTITY = new DOMEntity("foo", "bar");
 
     @Mock
     private BindingDOMCodecServices mockCodecRegistry;
-
     @Mock
     private DOMEntityOwnershipService mockDOMService;
 
     private DefaultEntityOwnershipService adapter;
 
-    @Before
-    public void setup() {
-        doReturn(DOM_ENTITY.getIdentifier()).when(mockCodecRegistry).toYangInstanceIdentifier(
-                BINDING_ENTITY.getIdentifier());
-        doReturn(BINDING_ENTITY.getIdentifier()).when(mockCodecRegistry).fromYangInstanceIdentifier(
-                DOM_ENTITY.getIdentifier());
+    @BeforeEach
+    void setup() {
         adapter = new DefaultEntityOwnershipService(mockDOMService, new ConstantAdapterContext(mockCodecRegistry));
     }
 
+    private void mockToBinding() {
+        doReturn(BINDING_ENTITY.getIdentifier()).when(mockCodecRegistry).fromYangInstanceIdentifier(
+            DOM_ENTITY.getIdentifier());
+    }
+
+    private void mockToDom() {
+        doReturn(DOM_ENTITY.getIdentifier()).when(mockCodecRegistry)
+            .toYangInstanceIdentifier(BINDING_ENTITY.getIdentifier());
+    }
+
     @Test
-    public void testRegisterCandidate() throws CandidateAlreadyRegisteredException {
+    void testRegisterCandidate() throws Exception {
+        mockToDom();
         final var mockDOMReg = mock(Registration.class);
         doReturn(mockDOMReg).when(mockDOMService).registerCandidate(DOM_ENTITY);
 
         try (var reg = adapter.registerCandidate(BINDING_ENTITY)) {
-            assertNotNull("registerCandidate returned null", reg);
+            assertNotNull(reg);
         }
-        verify(mockDOMReg).close();
     }
 
     @Test
-    public void testRegisterListener() {
+    void testRegisterListener() {
+        mockToBinding();
+
         final var mockDOMReg = mock(Registration.class);
+        final var domListenerCaptor = ArgumentCaptor.forClass(DOMEntityOwnershipListener.class);
         doReturn(mockDOMReg).when(mockDOMService).registerListener(eq(DOM_ENTITY.getType()),
-                any(DOMEntityOwnershipListener.class));
+            domListenerCaptor.capture());
         final var mockListener = mock(EntityOwnershipListener.class);
 
         try (var reg = adapter.registerListener(BINDING_ENTITY.getType(), mockListener)) {
-            assertNotNull("registerListener returned null", reg);
+            assertNotNull(reg);
 
-            final var domListenerCaptor = ArgumentCaptor.forClass(DOMEntityOwnershipListener.class);
-            verify(mockDOMService).registerListener(eq(DOM_ENTITY.getType()),  domListenerCaptor.capture());
-
-            final var domOwnershipChange = new EntityOwnershipChange<>(DOM_ENTITY,
+            doNothing().when(mockListener).ownershipChanged(BINDING_ENTITY,
+                EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, true);
+            domListenerCaptor.getValue().ownershipChanged(DOM_ENTITY,
                 EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, true);
-            domListenerCaptor.getValue().ownershipChanged(domOwnershipChange);
-
-            final var ownershipChangeCaptor = ArgumentCaptor.forClass(EntityOwnershipChange.class);
-            verify(mockListener).ownershipChanged(ownershipChangeCaptor.capture());
-
-            final var change = ownershipChangeCaptor.getValue();
-            assertEquals("getEntity", BINDING_ENTITY, change.getEntity());
-            assertEquals("getState", EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, change.getState());
         }
-        verify(mockDOMReg).close();
     }
 
     @Test
-    public void testGetOwnershipState() {
+    void testGetOwnershipState() {
+        mockToDom();
+
         final var expectedState = Optional.of(EntityOwnershipState.IS_OWNER);
         doReturn(expectedState).when(mockDOMService).getOwnershipState(DOM_ENTITY);
-
-        final var actualState = adapter.getOwnershipState(BINDING_ENTITY);
-        assertSame("getOwnershipState", expectedState, actualState);
+        assertSame(expectedState, adapter.getOwnershipState(BINDING_ENTITY));
     }
 
     @Test
-    public void testIsCandidateRegistered() {
+    void testIsCandidateRegistered() {
+        mockToDom();
+
         doReturn(true).when(mockDOMService).isCandidateRegistered(DOM_ENTITY);
-        assertEquals("isCandidateRegistered", true, adapter.isCandidateRegistered(BINDING_ENTITY));
+        assertTrue(adapter.isCandidateRegistered(BINDING_ENTITY));
     }
 
     @Test
-    public void testOwnershipChangeWithException() {
+    void testOwnershipChangeWithException() {
+        mockToBinding();
+
         final var listener = mock(EntityOwnershipListener.class);
-        doThrow(IllegalStateException.class).when(listener).ownershipChanged(any());
+        doThrow(IllegalStateException.class).when(listener).ownershipChanged(BINDING_ENTITY,
+            EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, false);
 
-        final var domEntityOwnershipListenerAdapter = new DOMEntityOwnershipListenerAdapter(listener,
-                new ConstantAdapterContext(mockCodecRegistry));
-        final var domOwnershipChange = new EntityOwnershipChange<>(DOM_ENTITY,
-            EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED);
+        final var domAdapter = new DOMEntityOwnershipListenerAdapter(listener,
+            new ConstantAdapterContext(mockCodecRegistry));
 
-        domEntityOwnershipListenerAdapter.ownershipChanged(domOwnershipChange);
+        domAdapter.ownershipChanged(DOM_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, false);
     }
 }

diff --git a/entityownership/mdsal-eos-common-api/src/main/java/org/opendaylight/mdsal/eos/common/api/EntityOwnershipChange.java b/entityownership/mdsal-eos-common-api/src/main/java/org/opendaylight/mdsal/eos/common/api/EntityOwnershipChange.java
deleted file mode 100644 (file)
index 004650e..0000000
--- a/entityownership/mdsal-eos-common-api/src/main/java/org/opendaylight/mdsal/eos/common/api/EntityOwnershipChange.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2015 Brocade Communications Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.eos.common.api;
-
-import static java.util.Objects.requireNonNull;
-
-import com.google.common.base.MoreObjects;
-import org.eclipse.jdt.annotation.NonNull;
-
-/**
- * A DTO that encapsulates an ownership change for an entity.
- *
- * @param <E> the {@link GenericEntity} type
- * @author Thomas Pantelis
- */
-public final class EntityOwnershipChange<E extends GenericEntity<?>> {
-    private final @NonNull E entity;
-    private final @NonNull EntityOwnershipStateChange state;
-    private final boolean inJeopardy;
-
-    public EntityOwnershipChange(final @NonNull E entity, final @NonNull EntityOwnershipStateChange state) {
-        this(entity, state, false);
-    }
-
-    public EntityOwnershipChange(final @NonNull E entity, final @NonNull EntityOwnershipStateChange state,
-            final boolean inJeopardy) {
-        this.entity = requireNonNull(entity, "entity can't be null");
-        this.state = requireNonNull(state, "state can't be null");
-        this.inJeopardy = inJeopardy;
-    }
-
-    /**
-     * Returns the entity whose ownership status changed.
-     * @return the entity
-     */
-    public @NonNull E getEntity() {
-        return entity;
-    }
-
-    /**
-     * Returns the ownership change state.
-     * @return an EntityOwnershipStateChange enum
-     */
-    public @NonNull EntityOwnershipStateChange getState() {
-        return state;
-    }
-
-    /**
-     * Returns the current jeopardy state. When in a jeopardy state, the values from other methods may potentially
-     * be out of date.
-     *
-     * @return true if the local node is in a jeopardy state. If false, the reported information is accurate.
-     */
-    public boolean inJeopardy() {
-        return inJeopardy;
-    }
-
-    @Override
-    public String toString() {
-        return MoreObjects.toStringHelper(this)
-            .add("entity", entity)
-            .add("state", state)
-            .add("inJeopardy", inJeopardy)
-            .toString();
-    }
-}

diff --git a/entityownership/mdsal-eos-common-api/src/main/java/org/opendaylight/mdsal/eos/common/api/GenericEntityOwnershipListener.java b/entityownership/mdsal-eos-common-api/src/main/java/org/opendaylight/mdsal/eos/common/api/GenericEntityOwnershipListener.java
index 9e23de619f197b71a106a197db1c2ac667ec6fd5..70494604c01a08d39f2f6e2c2cd98c50b74af39b 100644 (file)
--- a/entityownership/mdsal-eos-common-api/src/main/java/org/opendaylight/mdsal/eos/common/api/GenericEntityOwnershipListener.java
+++ b/entityownership/mdsal-eos-common-api/src/main/java/org/opendaylight/mdsal/eos/common/api/GenericEntityOwnershipListener.java
@@ -19,7 +19,9 @@ public interface GenericEntityOwnershipListener<E extends GenericEntity<?>> {
     /**
      * A notification that is generated when the ownership status of an entity changes.
      *
-     * @param ownershipChange contains the entity and its ownership change state
+     * @param entity the entity whose ownership status changed
+     * @param change the change the entity underwent
+     * @param inJeopardy {@code true} if ownership is in jeopardy and the reported change may be inaccurate
      */
-    void ownershipChanged(@NonNull EntityOwnershipChange<E> ownershipChange);
+    void ownershipChanged(@NonNull E entity, @NonNull EntityOwnershipStateChange change, boolean inJeopardy);
 }

diff --git a/entityownership/mdsal-eos-common-api/src/test/java/org/opendaylight/mdsal/eos/common/api/GenericEntityOwnershipChangeTest.java b/entityownership/mdsal-eos-common-api/src/test/java/org/opendaylight/mdsal/eos/common/api/GenericEntityOwnershipChangeTest.java
deleted file mode 100644 (file)
index ec1cb03..0000000
--- a/entityownership/mdsal-eos-common-api/src/test/java/org/opendaylight/mdsal/eos/common/api/GenericEntityOwnershipChangeTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.eos.common.api;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.Mockito.doReturn;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-@ExtendWith(MockitoExtension.class)
-class GenericEntityOwnershipChangeTest {
-    @Mock
-    private GenericEntity<?> genericEntity;
-
-    @Test
-    void basicTest() {
-        doReturn("testEntity").when(genericEntity).toString();
-        final var genericEntityOwnershipChange = new EntityOwnershipChange<>(genericEntity,
-            EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED);
-
-        assertEquals(genericEntity, genericEntityOwnershipChange.getEntity());
-        assertEquals(EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, genericEntityOwnershipChange.getState());
-        assertFalse(genericEntityOwnershipChange.inJeopardy());
-        assertTrue(genericEntityOwnershipChange.toString().contains("testEntity"));
-    }
-}
\ No newline at end of file

diff --git a/entityownership/mdsal-eos-dom-api/src/test/java/org/opendaylight/mdsal/eos/dom/api/DOMEntityOwnershipChangeTest.java b/entityownership/mdsal-eos-dom-api/src/test/java/org/opendaylight/mdsal/eos/dom/api/DOMEntityOwnershipChangeTest.java
deleted file mode 100644 (file)
index 23e8bd7..0000000
--- a/entityownership/mdsal-eos-dom-api/src/test/java/org/opendaylight/mdsal/eos/dom/api/DOMEntityOwnershipChangeTest.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.eos.dom.api;
-
-import static org.junit.Assert.assertNotNull;
-
-import org.junit.Test;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-
-public class DOMEntityOwnershipChangeTest {
-    private static final String ENTITY_TYPE = "type";
-    private static final YangInstanceIdentifier ID = YangInstanceIdentifier.of(QName.create("", "test"));
-    private static final DOMEntity ENTITY = new DOMEntity(ENTITY_TYPE, ID);
-
-    @Test
-    public void createTest() {
-        assertNotNull(new EntityOwnershipChange<>(ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED));
-        assertNotNull(new EntityOwnershipChange<>(ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, false));
-    }
-}
\ No newline at end of file

diff --git a/entityownership/mdsal-eos-dom-simple/src/main/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipService.java b/entityownership/mdsal-eos-dom-simple/src/main/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipService.java
index f21b17112b3658105fd76bfe3ba943bcdc91541f..212c5fc3973c5f1e5a418db443ebcbf5e1e3d5d1 100644 (file)
--- a/entityownership/mdsal-eos-dom-simple/src/main/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipService.java
+++ b/entityownership/mdsal-eos-dom-simple/src/main/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipService.java
@@ -15,16 +15,15 @@ import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Table;
-import java.util.Collection;
+import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.eclipse.jdt.annotation.NonNull;
 import org.kohsuke.MetaInfServices;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
@@ -86,9 +85,9 @@ public sealed class SimpleDOMEntityOwnershipService implements DOMEntityOwnershi
 
     @Override
     public Registration registerListener(final String entityType, final DOMEntityOwnershipListener listener) {
-        final Collection<DOMEntity> owned;
+        final List<DOMEntity> owned;
         synchronized (entities) {
-            owned = ImmutableList.copyOf(entities.row(entityType).values());
+            owned = List.copyOf(entities.row(entityType).values());
             LOG.trace("{}: acquired candidates {} for new listener {}", uuid, owned, listener);
         }
 
@@ -97,7 +96,7 @@ public sealed class SimpleDOMEntityOwnershipService implements DOMEntityOwnershi
         }
 
         for (var entity : owned) {
-            notifyListener(listener, new EntityOwnershipChange<>(entity, LOCAL_OWNERSHIP_GRANTED));
+            notifyListener(listener, entity, LOCAL_OWNERSHIP_GRANTED);
         }
         LOG.debug("{}: registered listener {}", uuid, listener);
         return new AbstractRegistration() {
@@ -133,27 +132,24 @@ public sealed class SimpleDOMEntityOwnershipService implements DOMEntityOwnershi
     }
 
     @SuppressWarnings("checkstyle:illegalCatch")
-    private void notifyListener(final DOMEntityOwnershipListener listener,
-            final EntityOwnershipChange<DOMEntity> change) {
+    private void notifyListener(final DOMEntityOwnershipListener listener, final @NonNull DOMEntity entity,
+            final @NonNull EntityOwnershipStateChange change) {
         try {
             LOG.trace("{} notifying listener {} change {}", uuid, listener, change);
-            listener.ownershipChanged(change);
+            listener.ownershipChanged(entity, change, false);
         } catch (RuntimeException e) {
-            LOG.warn("{}: Listener {} change {} failed", uuid, listener, change, e);
+            LOG.warn("{}: Listener {} failed on {} change {}", uuid, listener, entity, change, e);
         }
     }
 
     private void notifyListeners(final DOMEntity entity, final EntityOwnershipStateChange state) {
-
-        final Collection<DOMEntityOwnershipListener> snap;
-
+        final List<DOMEntityOwnershipListener> snap;
         synchronized (listeners) {
-            snap = ImmutableList.copyOf(listeners.get(entity.getType()));
+            snap = List.copyOf(listeners.get(entity.getType()));
         }
 
-        final var change = new EntityOwnershipChange<>(entity, state);
         for (var listener : snap) {
-            notifyListener(listener, change);
+            notifyListener(listener, entity, state);
         }
     }
 

diff --git a/entityownership/mdsal-eos-dom-simple/src/test/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipServiceTest.java b/entityownership/mdsal-eos-dom-simple/src/test/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipServiceTest.java
index a9169be3c1e812453b8ee788f19d5b783596dcae..5678d36b55ade26a8228aa19f7878e39c4c3f328 100644 (file)
--- a/entityownership/mdsal-eos-dom-simple/src/test/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipServiceTest.java
+++ b/entityownership/mdsal-eos-dom-simple/src/test/java/org/opendaylight/mdsal/eos/dom/simple/SimpleDOMEntityOwnershipServiceTest.java
@@ -12,20 +12,15 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.verify;
 
 import java.util.Optional;
 import java.util.UUID;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.ArgumentCaptor;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
@@ -78,22 +73,12 @@ class SimpleDOMEntityOwnershipServiceTest {
         try (var barReg = service.registerListener(BAR_TYPE, barListener)) {
             // Matching type should be triggered
             final var fooListener = mock(DOMEntityOwnershipListener.class);
-            doNothing().when(fooListener).ownershipChanged(any(EntityOwnershipChange.class));
+            doNothing().when(fooListener)
+                .ownershipChanged(FOO_FOO_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, true);
             try (var fooReg = service.registerListener(FOO_TYPE, fooListener)) {
-                final var fooCaptor = ArgumentCaptor.forClass(EntityOwnershipChange.class);
-                verify(fooListener).ownershipChanged(fooCaptor.capture());
-
-                var fooChange = fooCaptor.getValue();
-                assertEquals(FOO_FOO_ENTITY, fooChange.getEntity());
-                assertEquals(EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, fooChange.getState());
-
-                reset(fooListener);
-                doNothing().when(fooListener).ownershipChanged(any(EntityOwnershipChange.class));
+                doNothing().when(fooListener)
+                    .ownershipChanged(FOO_FOO_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NO_OWNER, false);
                 entityReg.close();
-                verify(fooListener).ownershipChanged(fooCaptor.capture());
-                fooChange = fooCaptor.getValue();
-                assertEquals(FOO_FOO_ENTITY, fooChange.getEntity());
-                assertEquals(EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NO_OWNER, fooChange.getState());
             }
         }
     }

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java
index 434e7fdc0bf815a9b554be8f493fb3ecea88aaae..d9272e41c3a4a5cab8bdeb918b317f4f6f6737f1 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java
@@ -24,7 +24,7 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.common.api.GenericEntity;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipListener;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipService;
@@ -54,9 +54,9 @@ public abstract class AbstractClusterSingletonServiceProviderImpl<P extends Hier
     private static final Logger LOG = LoggerFactory.getLogger(AbstractClusterSingletonServiceProviderImpl.class);
 
     @VisibleForTesting
-    static final String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
+    static final @NonNull String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
     @VisibleForTesting
-    static final String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
+    static final @NonNull String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
 
     private final S entityOwnershipService;
     private final Map<String, ClusterSingletonServiceGroup<P, E>> serviceGroupMap = new ConcurrentHashMap<>();
@@ -218,12 +218,14 @@ public abstract class AbstractClusterSingletonServiceProviderImpl<P extends Hier
     }
 
     @Override
-    public final void ownershipChanged(final EntityOwnershipChange<E> ownershipChange) {
-        LOG.debug("Ownership change for ClusterSingletonService Provider {}", ownershipChange);
-        final String serviceIdentifier = getServiceIdentifierFromEntity(ownershipChange.getEntity());
+    public final void ownershipChanged(final E entity, final EntityOwnershipStateChange change,
+            final boolean inJeopardy) {
+        LOG.debug("Ownership change for ClusterSingletonService Provider on {} {} inJeopardy={}", entity, change,
+            inJeopardy);
+        final var serviceIdentifier = getServiceIdentifierFromEntity(entity);
         final var serviceHolder = serviceGroupMap.get(serviceIdentifier);
         if (serviceHolder != null) {
-            serviceHolder.ownershipChanged(ownershipChange);
+            serviceHolder.ownershipChanged(entity, change, inJeopardy);
         } else {
             LOG.debug("ClusterSingletonServiceGroup was not found for serviceIdentifier {}", serviceIdentifier);
         }

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java
index ef63fef7b3378cac85c4b55de75cdd47b568508a..e8769e5f38d2f49282abd07f7be1240b1d3da02c 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java
@@ -10,7 +10,7 @@ package org.opendaylight.mdsal.singleton.dom.impl;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.common.api.GenericEntity;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
@@ -63,9 +63,11 @@ abstract class ClusterSingletonServiceGroup<P extends HierarchicalIdentifier<P>,
     /**
      * Method implementation has to apply ownershipChange for all registered services.
      *
-     * @param ownershipChange change role for ClusterSingletonServiceGroup
+     * @param entity the entity whose ownership status changed
+     * @param change the change the entity underwent
+     * @param inJeopardy {@code true} if ownership is in jeopardy and the reported change may be inaccurate
      */
-    abstract void ownershipChanged(EntityOwnershipChange<E> ownershipChange);
+    abstract void ownershipChanged(E entity, EntityOwnershipStateChange change, boolean inJeopardy);
 
     /**
      * Closes this service group. All registered service providers are also closed. Please be careful

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java
index 9a91d727399969f9f449237a1a479a9467d91a12..2506051177640b24f29290b2754f8c30484a31e6 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java
@@ -35,7 +35,6 @@ import org.checkerframework.checker.lock.qual.GuardedBy;
 import org.checkerframework.checker.lock.qual.Holding;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.common.api.GenericEntity;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipListener;
@@ -116,8 +115,8 @@ final class ClusterSingletonServiceGroupImpl<P extends HierarchicalIdentifier<P>
     private final String identifier;
 
     /* Entity instances */
-    private final E serviceEntity;
-    private final E cleanupEntity;
+    private final @NonNull E serviceEntity;
+    private final @NonNull E cleanupEntity;
 
     private final Set<ClusterSingletonServiceRegistration> members = ConcurrentHashMap.newKeySet();
     // Guarded by lock
@@ -324,11 +323,9 @@ final class ClusterSingletonServiceGroupImpl<P extends HierarchicalIdentifier<P>
     }
 
     @Override
-    void ownershipChanged(final EntityOwnershipChange<E> ownershipChange) {
-        LOG.debug("Ownership change {} for ClusterSingletonServiceGroup {}", ownershipChange, identifier);
-
+    void ownershipChanged(final E entity, final EntityOwnershipStateChange change, final boolean inJeopardy) {
         synchronized (this) {
-            lockedOwnershipChanged(ownershipChange);
+            lockedOwnershipChanged(entity, change, inJeopardy);
         }
 
         if (isDirty()) {
@@ -348,16 +345,16 @@ final class ClusterSingletonServiceGroupImpl<P extends HierarchicalIdentifier<P>
      * @param ownershipChange reported change
      */
     @Holding("this")
-    private void lockedOwnershipChanged(final EntityOwnershipChange<E> ownershipChange) {
-        final E entity = ownershipChange.getEntity();
+    private void lockedOwnershipChanged(final E entity, final EntityOwnershipStateChange change,
+            final boolean inJeopardy) {
         if (serviceEntity.equals(entity)) {
-            serviceOwnershipChanged(ownershipChange.getState(), ownershipChange.inJeopardy());
+            serviceOwnershipChanged(change, inJeopardy);
             markDirty();
         } else if (cleanupEntity.equals(entity)) {
-            cleanupCandidateOwnershipChanged(ownershipChange.getState(), ownershipChange.inJeopardy());
+            cleanupCandidateOwnershipChanged(change, inJeopardy);
             markDirty();
         } else {
-            LOG.warn("Group {} received unrecognized change {}", identifier, ownershipChange);
+            LOG.warn("Group {} received unrecognized entity {}", identifier, entity);
         }
     }
 

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java
index 9d8db85b81c04299d2b8cbd1e33e6f2949d61616..d95e6ec19c5c8737f5c4c7e58addafd95d300dc5 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java
@@ -16,7 +16,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import java.util.ArrayList;
 import java.util.List;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.common.api.GenericEntity;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
 import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
@@ -68,10 +68,10 @@ final class PlaceholderGroup<P extends HierarchicalIdentifier<P>, E extends Gene
     }
 
     @Override
-    void ownershipChanged(final EntityOwnershipChange<E> ownershipChange) {
+    void ownershipChanged(final E entity, final EntityOwnershipStateChange change, final boolean inJeopardy) {
         // This really should not happen, but let's be defensive
         final var local = successor;
-        (local == null ? previous : local).ownershipChanged(ownershipChange);
+        (local == null ? previous : local).ownershipChanged(entity, change, inJeopardy);
     }
 
     @Override

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractDOMClusterServiceProviderTest.java b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractDOMClusterServiceProviderTest.java
index 0edb4d2afa1bf73c79f469e28788e6df6c018230..4e104f144abc018fbd4344579ee21eb0bcb95341 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractDOMClusterServiceProviderTest.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractDOMClusterServiceProviderTest.java
@@ -18,17 +18,20 @@ import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER;
 import static org.opendaylight.mdsal.singleton.dom.impl.AbstractClusterSingletonServiceProviderImpl.CLOSE_SERVICE_ENTITY_TYPE;
 import static org.opendaylight.mdsal.singleton.dom.impl.AbstractClusterSingletonServiceProviderImpl.SERVICE_ENTITY_TYPE;
 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import org.eclipse.jdt.annotation.NonNull;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
@@ -59,7 +62,7 @@ public abstract class AbstractDOMClusterServiceProviderTest {
     }
 
     static class TestClusterSingletonService implements ClusterSingletonService {
-        private static final ServiceGroupIdentifier SERVICE_ID = ServiceGroupIdentifier.create(SERVICE_NAME);
+        private static final @NonNull ServiceGroupIdentifier SERVICE_ID = ServiceGroupIdentifier.create(SERVICE_NAME);
 
         private TestClusterSingletonServiceState serviceState = TestClusterSingletonServiceState.INITIALIZED;
 
@@ -84,9 +87,9 @@ public abstract class AbstractDOMClusterServiceProviderTest {
         }
     }
 
-    public static final String SERVICE_NAME = "testServiceName";
-    public static final DOMEntity ENTITY = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
-    public static final DOMEntity DOUBLE_ENTITY = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
+    static final @NonNull String SERVICE_NAME = "testServiceName";
+    static final @NonNull DOMEntity ENTITY = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
+    static final @NonNull DOMEntity DOUBLE_ENTITY = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
 
     @Mock
     public DOMEntityOwnershipService mockEos;
@@ -131,53 +134,6 @@ public abstract class AbstractDOMClusterServiceProviderTest {
         return new TestClusterSingletonService();
     }
 
-    static final EntityOwnershipChange<DOMEntity> getEntityToMaster() {
-        return new EntityOwnershipChange(ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getEntityToSlave() {
-        return new EntityOwnershipChange(ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getInitEntityToSlave() {
-        return new EntityOwnershipChange(ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getInitEntityToSlaveNoMaster() {
-        return new EntityOwnershipChange<>(ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getEntityToJeopardy() {
-        return new EntityOwnershipChange<>(ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getEntityMasterJeopardy() {
-        return new EntityOwnershipChange<>(ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE,
-            true);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getDoubleEntityToMaster() {
-        return new EntityOwnershipChange<>(DOUBLE_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getInitDoubleEntityToSlave() {
-        return new EntityOwnershipChange<>(DOUBLE_ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getDoubleEntityToSlave() {
-        return new EntityOwnershipChange<>(DOUBLE_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getDoubleEntityToJeopardy() {
-        return new EntityOwnershipChange<>(DOUBLE_ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER,
-            true);
-    }
-
-    static final EntityOwnershipChange<DOMEntity> getDoubleEntityMasterJeopardy() {
-        return new EntityOwnershipChange<>(DOUBLE_ENTITY,
-            EntityOwnershipStateChange.LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE, true);
-    }
-
     /**
      * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
      */
@@ -248,7 +204,7 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
     }
@@ -264,7 +220,7 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, false);
         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
     }
@@ -280,7 +236,7 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
     }
@@ -296,9 +252,9 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
     }
 
@@ -313,10 +269,10 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
     }
 
@@ -331,7 +287,7 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
@@ -352,14 +308,14 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
                 .registerClusterSingletonService(clusterSingletonService2);
         assertNotNull(reg2);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
     }
@@ -391,12 +347,12 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
     }
 
@@ -411,14 +367,14 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
     }
 
@@ -433,10 +389,10 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEosEntityListReg, never()).close();
         verify(mockEosDoubleEntityListReg, never()).close();
@@ -455,10 +411,10 @@ public abstract class AbstractDOMClusterServiceProviderTest {
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
                 .registerClusterSingletonService(clusterSingletonService2);
@@ -523,7 +479,7 @@ public abstract class AbstractDOMClusterServiceProviderTest {
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         reg.close();
         verify(mockEosEntityListReg, never()).close();
         verify(mockEosDoubleEntityListReg, never()).close();
@@ -546,7 +502,7 @@ public abstract class AbstractDOMClusterServiceProviderTest {
         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
                 .registerClusterSingletonService(clusterSingletonService2);
         assertNotNull(reg2);
-        clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
         reg.close();
@@ -574,9 +530,9 @@ public abstract class AbstractDOMClusterServiceProviderTest {
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
         reg.close();
@@ -605,9 +561,9 @@ public abstract class AbstractDOMClusterServiceProviderTest {
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
         reg.close();
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
         verify(mockEosEntityListReg, never()).close();

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java
index d1967c21d92fd690c03051dadfe73b4c49f598c6..546b39ff108229f7c570e82474f05dcf2a4d6d48 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java
@@ -15,20 +15,24 @@ import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NO_OWNER;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER;
 import static org.opendaylight.mdsal.singleton.dom.impl.AbstractClusterSingletonServiceProviderImpl.CLOSE_SERVICE_ENTITY_TYPE;
 import static org.opendaylight.mdsal.singleton.dom.impl.AbstractClusterSingletonServiceProviderImpl.SERVICE_ENTITY_TYPE;
 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChange;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipListener;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipService;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
@@ -46,8 +50,9 @@ public class ClusterSingletonServiceGroupImplTest {
     public static final String SERVICE_IDENTIFIER = "TestServiceIdent";
     public static final ServiceGroupIdentifier SERVICE_GROUP_IDENT = ServiceGroupIdentifier.create(SERVICE_IDENTIFIER);
 
-    public static final TestEntity MAIN_ENTITY = new TestEntity(SERVICE_ENTITY_TYPE, SERVICE_IDENTIFIER);
-    public static final TestEntity CLOSE_ENTITY = new TestEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_IDENTIFIER);
+    public static final @NonNull TestEntity MAIN_ENTITY = new TestEntity(SERVICE_ENTITY_TYPE, SERVICE_IDENTIFIER);
+    public static final @NonNull TestEntity CLOSE_ENTITY =
+        new TestEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_IDENTIFIER);
 
     @Mock
     public ClusterSingletonService mockClusterSingletonService;
@@ -163,7 +168,7 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToSlave());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
     }
@@ -178,7 +183,7 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToSlaveNoMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_LOST_NO_OWNER, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
     }
@@ -193,7 +198,7 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToJeopardy());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
     }
@@ -266,7 +271,7 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToSlave());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
     }
 
@@ -280,7 +285,7 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
     }
@@ -295,10 +300,10 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService).instantiateServiceInstance();
     }
 
@@ -313,10 +318,10 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getInitDoubleEntityToSlave());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockClusterSingletonService, never()).closeServiceInstance();
     }
@@ -331,10 +336,10 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getEntityToJeopardy());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockClusterSingletonService, never()).closeServiceInstance();
     }
@@ -351,10 +356,10 @@ public class ClusterSingletonServiceGroupImplTest {
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.registerService(secondReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getEntityToJeopardy());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockClusterSingletonService, never()).closeServiceInstance();
     }
@@ -369,18 +374,18 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService).instantiateServiceInstance();
 
         // Base entity in jeopardy should not matter...
-        singletonServiceGroup.ownershipChanged(getEntityToMasterJeopardy());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, true);
         verify(mockClusterSingletonService, never()).closeServiceInstance();
 
         // ... application state is actually guarded by cleanup
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToJeopardy());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
         verify(mockClusterSingletonService).closeServiceInstance();
     }
 
@@ -394,12 +399,12 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService).instantiateServiceInstance();
-        singletonServiceGroup.ownershipChanged(getEntityToSlave());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockClusterSingletonService).closeServiceInstance();
     }
 
@@ -423,14 +428,14 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService).instantiateServiceInstance();
         assertNotNull(singletonServiceGroup.unregisterService(firstReg));
         verify(mockClusterSingletonService, never()).closeServiceInstance();
-        singletonServiceGroup.ownershipChanged(getEntityToSlaveNoMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_LOST_NO_OWNER, false);
         verify(mockClusterSingletonService).closeServiceInstance();
     }
 
@@ -445,12 +450,12 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService).instantiateServiceInstance();
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToSlave());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockClusterSingletonService).closeServiceInstance();
     }
 
@@ -466,10 +471,10 @@ public class ClusterSingletonServiceGroupImplTest {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToSlave());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToSlave());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockClusterSingletonService, never()).closeServiceInstance();
     }
 
@@ -487,10 +492,10 @@ public class ClusterSingletonServiceGroupImplTest {
         assertFalse(future.isDone());
         verify(mockClusterSingletonService).closeServiceInstance();
 
-        singletonServiceGroup.ownershipChanged(getEntityToSlave());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockCloseEntityCandReg).close();
 
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToSlave());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         assertTrue(future.isDone());
         assertNull(future.get());
     }
@@ -503,47 +508,9 @@ public class ClusterSingletonServiceGroupImplTest {
     private void initializeGroupAndStartService() throws CandidateAlreadyRegisteredException {
         initialize();
         singletonServiceGroup.registerService(firstReg);
-        singletonServiceGroup.ownershipChanged(getEntityToMaster());
+        singletonServiceGroup.ownershipChanged(MAIN_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
-        singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());
+        singletonServiceGroup.ownershipChanged(CLOSE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockClusterSingletonService).instantiateServiceInstance();
     }
-
-    private static EntityOwnershipChange<TestEntity> getEntityToMaster() {
-        return new EntityOwnershipChange<>(MAIN_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getEntityToSlave() {
-        return new EntityOwnershipChange<>(MAIN_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getEntityToSlaveNoMaster() {
-        return new EntityOwnershipChange<>(MAIN_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NO_OWNER);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getEntityToMasterJeopardy() {
-        return new EntityOwnershipChange<>(MAIN_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED, true);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getEntityToJeopardy() {
-        return new EntityOwnershipChange<>(MAIN_ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER,
-            true);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getDoubleEntityToMaster() {
-        return new EntityOwnershipChange<>(CLOSE_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getDoubleEntityToSlave() {
-        return new EntityOwnershipChange<>(CLOSE_ENTITY, EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getInitDoubleEntityToSlave() {
-        return new EntityOwnershipChange<>(CLOSE_ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED);
-    }
-
-    private static EntityOwnershipChange<TestEntity> getDoubleEntityToJeopardy() {
-        return new EntityOwnershipChange<>(CLOSE_ENTITY, EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER,
-            true);
-    }
 }

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderAsyncImplTest.java b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderAsyncImplTest.java
index 1a24bb6c51fb4ca70b099deeb80633e50232c9df..e16fefbebc1652490e011dfd8fa73934fff624db 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderAsyncImplTest.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderAsyncImplTest.java
@@ -5,13 +5,16 @@
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-
 package org.opendaylight.mdsal.singleton.dom.impl;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED;
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
@@ -78,19 +81,19 @@ public final class DOMClusterSingletonServiceProviderAsyncImplTest extends Abstr
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
         verify(mockDoubleEntityCandReg).close();
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         verify(mockEosDoubleEntityListReg, never()).close();
         verify(mockEosEntityListReg, never()).close();
@@ -108,14 +111,14 @@ public final class DOMClusterSingletonServiceProviderAsyncImplTest extends Abstr
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
         verify(mockEosDoubleEntityListReg, never()).close();
@@ -138,16 +141,16 @@ public final class DOMClusterSingletonServiceProviderAsyncImplTest extends Abstr
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityMasterJeopardy());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE, true);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityMasterJeopardy());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE, true);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
         verify(mockEosEntityListReg, never()).close();
@@ -168,9 +171,9 @@ public final class DOMClusterSingletonServiceProviderAsyncImplTest extends Abstr
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         reg.close();
         verify(mockEntityCandReg).close();
@@ -194,9 +197,9 @@ public final class DOMClusterSingletonServiceProviderAsyncImplTest extends Abstr
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         reg.close();
         verify(mockEntityCandReg).close();
@@ -220,9 +223,9 @@ public final class DOMClusterSingletonServiceProviderAsyncImplTest extends Abstr
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         reg.close();
         reg.close();

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderImplTest.java b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderImplTest.java
index 1710b41e2e8458eadf19daebd03eb6811bce6149..76779a9772b1e9f47ee9e2907811cf044ea2d961 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderImplTest.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderImplTest.java
@@ -14,6 +14,10 @@ import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED;
+import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -50,17 +54,17 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         verify(mockEosDoubleEntityListReg, never()).close();
         verify(mockEosEntityListReg, never()).close();
@@ -79,14 +83,14 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
         verify(mockEosDoubleEntityListReg, never()).close();
         verify(mockEntityCandReg, never()).close();
@@ -97,7 +101,7 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
         verify(mockEntityCandReg, atLeastOnce()).close();
         verify(mockDoubleEntityCandReg).close();
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockEntityCandReg).close();
         verify(mockEosDoubleEntityListReg, never()).close();
     }
@@ -113,14 +117,14 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
                 .registerClusterSingletonService(clusterSingletonService);
         assertNotNull(reg);
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToJeopardy());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
         verify(mockEosEntityListReg, never()).close();
         verify(mockEosDoubleEntityListReg, never()).close();
@@ -140,12 +144,12 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         reg.close();
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockEosEntityListReg, never()).close();
         verify(mockEosDoubleEntityListReg, never()).close();
         verify(mockEntityCandReg).close();
@@ -165,9 +169,9 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         reg.close();
         verify(mockEosEntityListReg, never()).close();
@@ -189,9 +193,9 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
         reg.close();
         reg.close();
@@ -200,7 +204,7 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
         verify(mockEntityCandReg).close();
         verify(mockDoubleEntityCandReg).close();
         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockEosDoubleEntityListReg, never()).close();
     }
 
@@ -215,9 +219,9 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
         assertNotNull(reg);
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
         verify(mockEos).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 
         // Close, triggers unregistration, but we will not continue with it.
@@ -234,16 +238,16 @@ public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClust
         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 
         // Drive the old incarnation to closure, resetting mocks as needed
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockEosDoubleEntityListReg, never()).close();
 
         // Reset mocks for reuse. The next change should see the previous group terminate and the next incarnation
         // to start coming up
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
         verify(mockEos, times(2)).registerCandidate(ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         verify(mockEos, times(2)).registerCandidate(DOUBLE_ENTITY);
-        clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
+        clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 
         // Check for potential service mixup