/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package androidx.lifecycle;

import static androidx.lifecycle.Lifecycle.Event.ON_CREATE;
import static androidx.lifecycle.Lifecycle.Event.ON_DESTROY;
import static androidx.lifecycle.Lifecycle.Event.ON_PAUSE;
import static androidx.lifecycle.Lifecycle.Event.ON_RESUME;
import static androidx.lifecycle.Lifecycle.Event.ON_START;
import static androidx.lifecycle.Lifecycle.Event.ON_STOP;

import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import androidx.annotation.Nullable;
import androidx.arch.core.executor.ArchTaskExecutor;
import androidx.arch.core.executor.testing.InstantTaskExecutorRule;

import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import org.mockito.Mockito;

@SuppressWarnings({"unchecked"})
@RunWith(JUnit4.class)
public class LiveDataTest {

    @Rule
    public InstantTaskExecutorRule mInstantTaskExecutorRule = new InstantTaskExecutorRule();

    private PublicLiveData<String> mLiveData;
    private MethodExec mActiveObserversChanged;

    private LifecycleOwner mOwner;
    private LifecycleRegistry mRegistry;

    private LifecycleOwner mOwner2;
    private LifecycleRegistry mRegistry2;

    private LifecycleOwner mOwner3;
    private Lifecycle mLifecycle3;
    private Observer<String> mObserver3;

    private LifecycleOwner mOwner4;
    private Lifecycle mLifecycle4;
    private Observer<String> mObserver4;

    private boolean mInObserver;

    @Before
    public void init() {
        mLiveData = new PublicLiveData<>();

        mActiveObserversChanged = mock(MethodExec.class);
        mLiveData.activeObserversChanged = mActiveObserversChanged;

        mOwner = mock(LifecycleOwner.class);
        mRegistry = new LifecycleRegistry(mOwner);
        when(mOwner.getLifecycle()).thenReturn(mRegistry);

        mOwner2 = mock(LifecycleOwner.class);
        mRegistry2 = new LifecycleRegistry(mOwner2);
        when(mOwner2.getLifecycle()).thenReturn(mRegistry2);

        mInObserver = false;
    }

    @Before
    public void initNonLifecycleRegistry() {
        mOwner3 = mock(LifecycleOwner.class);
        mLifecycle3 = mock(Lifecycle.class);
        mObserver3 = (Observer<String>) mock(Observer.class);
        when(mOwner3.getLifecycle()).thenReturn(mLifecycle3);

        mOwner4 = mock(LifecycleOwner.class);
        mLifecycle4 = mock(Lifecycle.class);
        mObserver4 = (Observer<String>) mock(Observer.class);
        when(mOwner4.getLifecycle()).thenReturn(mLifecycle4);
    }

    @After
    public void removeExecutorDelegate() {
        ArchTaskExecutor.getInstance().setDelegate(null);
    }

    @Test
    public void testObserverToggle() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mLiveData.observe(mOwner, observer);

        verify(mActiveObserversChanged, never()).onCall(anyBoolean());
        assertThat(mLiveData.hasObservers(), is(true));
        assertThat(mLiveData.hasActiveObservers(), is(false));

        mLiveData.removeObserver(observer);
        verify(mActiveObserversChanged, never()).onCall(anyBoolean());
        assertThat(mLiveData.hasObservers(), is(false));
        assertThat(mLiveData.hasActiveObservers(), is(false));
    }

    @Test
    public void testActiveObserverToggle() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mLiveData.observe(mOwner, observer);

        verify(mActiveObserversChanged, never()).onCall(anyBoolean());
        assertThat(mLiveData.hasObservers(), is(true));
        assertThat(mLiveData.hasActiveObservers(), is(false));

        mRegistry.handleLifecycleEvent(ON_START);
        verify(mActiveObserversChanged).onCall(true);
        assertThat(mLiveData.hasActiveObservers(), is(true));
        reset(mActiveObserversChanged);

        mRegistry.handleLifecycleEvent(ON_STOP);
        verify(mActiveObserversChanged).onCall(false);
        assertThat(mLiveData.hasActiveObservers(), is(false));
        assertThat(mLiveData.hasObservers(), is(true));

        reset(mActiveObserversChanged);
        mRegistry.handleLifecycleEvent(ON_START);
        verify(mActiveObserversChanged).onCall(true);
        assertThat(mLiveData.hasActiveObservers(), is(true));
        assertThat(mLiveData.hasObservers(), is(true));

        reset(mActiveObserversChanged);
        mLiveData.removeObserver(observer);
        verify(mActiveObserversChanged).onCall(false);
        assertThat(mLiveData.hasActiveObservers(), is(false));
        assertThat(mLiveData.hasObservers(), is(false));

        verifyNoMoreInteractions(mActiveObserversChanged);
    }

    @Test
    public void testReAddSameObserverTuple() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mLiveData.observe(mOwner, observer);
        mLiveData.observe(mOwner, observer);
        assertThat(mLiveData.hasObservers(), is(true));
    }

    @Test
    public void testAdd2ObserversWithSameOwnerAndRemove() {
        Observer<String> o1 = (Observer<String>) mock(Observer.class);
        Observer<String> o2 = (Observer<String>) mock(Observer.class);
        mLiveData.observe(mOwner, o1);
        mLiveData.observe(mOwner, o2);
        assertThat(mLiveData.hasObservers(), is(true));
        verify(mActiveObserversChanged, never()).onCall(anyBoolean());

        mRegistry.handleLifecycleEvent(ON_START);
        verify(mActiveObserversChanged).onCall(true);
        mLiveData.setValue("a");
        verify(o1).onChanged("a");
        verify(o2).onChanged("a");

        mLiveData.removeObservers(mOwner);

        assertThat(mLiveData.hasObservers(), is(false));
        assertThat(mRegistry.getObserverCount(), is(0));
    }

    @Test
    public void testAddSameObserverIn2LifecycleOwners() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);

        mLiveData.observe(mOwner, observer);
        Throwable throwable = null;
        try {
            mLiveData.observe(mOwner2, observer);
        } catch (Throwable t) {
            throwable = t;
        }
        assertThat(throwable, instanceOf(IllegalArgumentException.class));
        //noinspection ConstantConditions
        assertThat(throwable.getMessage(),
                is("Cannot add the same observer with different lifecycles"));
    }

    @Test
    public void testRemoveDestroyedObserver() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mLiveData.observe(mOwner, observer);
        mRegistry.handleLifecycleEvent(ON_START);
        verify(mActiveObserversChanged).onCall(true);
        assertThat(mLiveData.hasObservers(), is(true));
        assertThat(mLiveData.hasActiveObservers(), is(true));

        reset(mActiveObserversChanged);

        mRegistry.handleLifecycleEvent(ON_DESTROY);
        assertThat(mLiveData.hasObservers(), is(false));
        assertThat(mLiveData.hasActiveObservers(), is(false));
        verify(mActiveObserversChanged).onCall(false);
    }

    @Test
    public void testInactiveRegistry() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mRegistry.handleLifecycleEvent(ON_DESTROY);
        mLiveData.observe(mOwner, observer);
        assertThat(mLiveData.hasObservers(), is(false));
    }

    @Test
    public void testNotifyActiveInactive() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mRegistry.handleLifecycleEvent(ON_CREATE);
        mLiveData.observe(mOwner, observer);
        mLiveData.setValue("a");
        verify(observer, never()).onChanged(anyString());
        mRegistry.handleLifecycleEvent(ON_START);
        verify(observer).onChanged("a");

        mLiveData.setValue("b");
        verify(observer).onChanged("b");

        mRegistry.handleLifecycleEvent(ON_STOP);
        mLiveData.setValue("c");
        verify(observer, never()).onChanged("c");

        mRegistry.handleLifecycleEvent(ON_START);
        verify(observer).onChanged("c");

        reset(observer);
        mRegistry.handleLifecycleEvent(ON_STOP);
        mRegistry.handleLifecycleEvent(ON_START);
        verify(observer, never()).onChanged(anyString());
    }

    @Test
    public void testStopObservingOwner_onDestroy() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mRegistry.handleLifecycleEvent(ON_CREATE);
        mLiveData.observe(mOwner, observer);
        assertThat(mRegistry.getObserverCount(), is(1));
        mRegistry.handleLifecycleEvent(ON_DESTROY);
        assertThat(mRegistry.getObserverCount(), is(0));
    }

    @Test
    public void testStopObservingOwner_onStopObserving() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mRegistry.handleLifecycleEvent(ON_CREATE);
        mLiveData.observe(mOwner, observer);
        assertThat(mRegistry.getObserverCount(), is(1));

        mLiveData.removeObserver(observer);
        assertThat(mRegistry.getObserverCount(), is(0));
    }

    @Test
    public void testActiveChangeInCallback() {
        mRegistry.handleLifecycleEvent(ON_START);
        Observer<String> observer1 = spy(new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                mRegistry.handleLifecycleEvent(ON_STOP);
                assertThat(mLiveData.hasObservers(), is(true));
                assertThat(mLiveData.hasActiveObservers(), is(false));
            }
        });
        final Observer observer2 = mock(Observer.class);
        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner, observer2);
        mLiveData.setValue("bla");
        verify(observer1).onChanged(anyString());
        verify(observer2, Mockito.never()).onChanged(anyString());
        assertThat(mLiveData.hasObservers(), is(true));
        assertThat(mLiveData.hasActiveObservers(), is(false));
    }

    @Test
    public void testActiveChangeInCallback2() {
        Observer<String> observer1 = spy(new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                assertThat(mInObserver, is(false));
                mInObserver = true;
                mRegistry.handleLifecycleEvent(ON_START);
                assertThat(mLiveData.hasActiveObservers(), is(true));
                mInObserver = false;
            }
        });
        final Observer observer2 = spy(new FailReentranceObserver());
        mLiveData.observeForever(observer1);
        mLiveData.observe(mOwner, observer2);
        mLiveData.setValue("bla");
        verify(observer1).onChanged(anyString());
        verify(observer2).onChanged(anyString());
        assertThat(mLiveData.hasObservers(), is(true));
        assertThat(mLiveData.hasActiveObservers(), is(true));
    }

    @Test
    public void testObserverRemovalInCallback() {
        mRegistry.handleLifecycleEvent(ON_START);
        Observer<String> observer = spy(new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                assertThat(mLiveData.hasObservers(), is(true));
                mLiveData.removeObserver(this);
                assertThat(mLiveData.hasObservers(), is(false));
            }
        });
        mLiveData.observe(mOwner, observer);
        mLiveData.setValue("bla");
        verify(observer).onChanged(anyString());
        assertThat(mLiveData.hasObservers(), is(false));
    }

    @Test
    public void testObserverAdditionInCallback() {
        mRegistry.handleLifecycleEvent(ON_START);
        final Observer observer2 = spy(new FailReentranceObserver());
        Observer<String> observer1 = spy(new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                assertThat(mInObserver, is(false));
                mInObserver = true;
                mLiveData.observe(mOwner, observer2);
                assertThat(mLiveData.hasObservers(), is(true));
                assertThat(mLiveData.hasActiveObservers(), is(true));
                mInObserver = false;
            }
        });
        mLiveData.observe(mOwner, observer1);
        mLiveData.setValue("bla");
        verify(observer1).onChanged(anyString());
        verify(observer2).onChanged(anyString());
        assertThat(mLiveData.hasObservers(), is(true));
        assertThat(mLiveData.hasActiveObservers(), is(true));
    }

    @Test
    public void testObserverWithoutLifecycleOwner() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mLiveData.setValue("boring");
        mLiveData.observeForever(observer);
        verify(mActiveObserversChanged).onCall(true);
        verify(observer).onChanged("boring");
        mLiveData.setValue("tihs");
        verify(observer).onChanged("tihs");
        mLiveData.removeObserver(observer);
        verify(mActiveObserversChanged).onCall(false);
        mLiveData.setValue("boring");
        reset(observer);
        verify(observer, never()).onChanged(anyString());
    }

    @Test
    public void testSetValueDuringSetValue() {
        mRegistry.handleLifecycleEvent(ON_START);
        final Observer observer1 = spy(new Observer<String>() {
            @Override
            public void onChanged(String o) {
                assertThat(mInObserver, is(false));
                mInObserver = true;
                if (o.equals(("bla"))) {
                    mLiveData.setValue("gt");
                }
                mInObserver = false;
            }
        });
        final Observer observer2 = spy(new FailReentranceObserver());
        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner, observer2);
        mLiveData.setValue("bla");
        verify(observer1, Mockito.atMost(2)).onChanged("gt");
        verify(observer2, Mockito.atMost(2)).onChanged("gt");
    }

    @Test
    public void testRemoveDuringSetValue() {
        mRegistry.handleLifecycleEvent(ON_START);
        final Observer observer1 = spy(new Observer<String>() {
            @Override
            public void onChanged(String o) {
                mLiveData.removeObserver(this);
            }
        });
        Observer<String> observer2 = (Observer<String>) mock(Observer.class);
        mLiveData.observeForever(observer1);
        mLiveData.observe(mOwner, observer2);
        mLiveData.setValue("gt");
        verify(observer2).onChanged("gt");
    }

    @Test
    public void testDataChangeDuringStateChange() {
        mRegistry.handleLifecycleEvent(ON_START);
        mRegistry.addObserver(new LifecycleObserver() {
            @OnLifecycleEvent(ON_STOP)
            public void onStop() {
                // change data in onStop, observer should not be called!
                mLiveData.setValue("b");
            }
        });
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mLiveData.setValue("a");
        mLiveData.observe(mOwner, observer);
        verify(observer).onChanged("a");
        mRegistry.handleLifecycleEvent(ON_PAUSE);
        mRegistry.handleLifecycleEvent(ON_STOP);
        verify(observer, never()).onChanged("b");

        mRegistry.handleLifecycleEvent(ON_RESUME);
        verify(observer).onChanged("b");
    }

    @Test
    public void testNotCallInactiveWithObserveForever() {
        mRegistry.handleLifecycleEvent(ON_START);
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        Observer<String> observer2 = (Observer<String>) mock(Observer.class);
        mLiveData.observe(mOwner, observer);
        mLiveData.observeForever(observer2);
        verify(mActiveObserversChanged).onCall(true);
        reset(mActiveObserversChanged);
        mRegistry.handleLifecycleEvent(ON_STOP);
        verify(mActiveObserversChanged, never()).onCall(anyBoolean());
        mRegistry.handleLifecycleEvent(ON_START);
        verify(mActiveObserversChanged, never()).onCall(anyBoolean());
    }

    @Test
    public void testRemoveDuringAddition() {
        mRegistry.handleLifecycleEvent(ON_START);
        mLiveData.setValue("bla");
        mLiveData.observeForever(new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                mLiveData.removeObserver(this);
            }
        });
        assertThat(mLiveData.hasActiveObservers(), is(false));
        InOrder inOrder = Mockito.inOrder(mActiveObserversChanged);
        inOrder.verify(mActiveObserversChanged).onCall(true);
        inOrder.verify(mActiveObserversChanged).onCall(false);
        inOrder.verifyNoMoreInteractions();
    }

    @Test
    public void testRemoveDuringBringingUpToState() {
        mLiveData.setValue("bla");
        mLiveData.observeForever(new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                mLiveData.removeObserver(this);
            }
        });
        mRegistry.handleLifecycleEvent(ON_RESUME);
        assertThat(mLiveData.hasActiveObservers(), is(false));
        InOrder inOrder = Mockito.inOrder(mActiveObserversChanged);
        inOrder.verify(mActiveObserversChanged).onCall(true);
        inOrder.verify(mActiveObserversChanged).onCall(false);
        inOrder.verifyNoMoreInteractions();
    }

    @Test
    public void setValue_neverActive_observerOnChangedNotCalled() {
        Observer<String> observer = (Observer<String>) mock(Observer.class);
        mLiveData.observe(mOwner, observer);

        mLiveData.setValue("1");

        verify(observer, never()).onChanged(anyString());
    }

    @Test
    public void setValue_twoObserversTwoStartedOwners_onChangedCalledOnBoth() {
        Observer<String> observer1 = mock(Observer.class);
        Observer<String> observer2 = mock(Observer.class);

        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner2, observer2);

        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        mRegistry2.handleLifecycleEvent(Lifecycle.Event.ON_START);

        mLiveData.setValue("1");

        verify(observer1).onChanged("1");
        verify(observer2).onChanged("1");
    }

    @Test
    public void setValue_twoObserversOneStartedOwner_onChangedCalledOnOneCorrectObserver() {
        Observer<String> observer1 = mock(Observer.class);
        Observer<String> observer2 = mock(Observer.class);

        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner2, observer2);

        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);

        mLiveData.setValue("1");

        verify(observer1).onChanged("1");
        verify(observer2, never()).onChanged(anyString());
    }

    @Test
    public void setValue_twoObserversBothStartedAfterSetValue_onChangedCalledOnBoth() {
        Observer<String> observer1 = mock(Observer.class);
        Observer<String> observer2 = mock(Observer.class);

        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner2, observer2);

        mLiveData.setValue("1");

        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        mRegistry2.handleLifecycleEvent(Lifecycle.Event.ON_START);

        verify(observer1).onChanged("1");
        verify(observer1).onChanged("1");
    }

    @Test
    public void setValue_twoObserversOneStartedAfterSetValue_onChangedCalledOnCorrectObserver() {
        Observer<String> observer1 = mock(Observer.class);
        Observer<String> observer2 = mock(Observer.class);

        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner2, observer2);

        mLiveData.setValue("1");

        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);

        verify(observer1).onChanged("1");
        verify(observer2, never()).onChanged(anyString());
    }

    @Test
    public void setValue_twoObserversOneStarted_liveDataBecomesActive() {
        Observer<String> observer1 = mock(Observer.class);
        Observer<String> observer2 = mock(Observer.class);

        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner2, observer2);

        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);

        verify(mActiveObserversChanged).onCall(true);
    }

    @Test
    public void setValue_twoObserversOneStopped_liveDataStaysActive() {
        Observer<String> observer1 = mock(Observer.class);
        Observer<String> observer2 = mock(Observer.class);

        mLiveData.observe(mOwner, observer1);
        mLiveData.observe(mOwner2, observer2);

        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        mRegistry2.handleLifecycleEvent(Lifecycle.Event.ON_START);

        verify(mActiveObserversChanged).onCall(true);

        reset(mActiveObserversChanged);
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);

        verify(mActiveObserversChanged, never()).onCall(anyBoolean());
    }

    @Test
    public void setValue_lifecycleIsCreatedNoEvent_liveDataBecomesInactiveAndObserverNotCalled() {

        // Arrange.

        mLiveData.observe(mOwner3, mObserver3);

        GenericLifecycleObserver lifecycleObserver = getGenericLifecycleObserver(mLifecycle3);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        lifecycleObserver.onStateChanged(mOwner3, Lifecycle.Event.ON_START);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.CREATED);

        reset(mActiveObserversChanged);
        reset(mObserver3);

        // Act.

        mLiveData.setValue("1");

        // Assert.

        verify(mActiveObserversChanged).onCall(false);
        verify(mObserver3, never()).onChanged(anyString());
    }

    /*
     * Arrange: LiveData was made inactive via SetValue (because the Lifecycle it was
     * observing was in the CREATED state and no event was dispatched).
     * Act: Lifecycle enters Started state and dispatches event.
     * Assert: LiveData becomes active and dispatches new value to observer.
     */
    @Test
    public void test_liveDataInactiveViaSetValueThenLifecycleResumes() {

        // Arrange.

        mLiveData.observe(mOwner3, mObserver3);

        GenericLifecycleObserver lifecycleObserver = getGenericLifecycleObserver(mLifecycle3);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        lifecycleObserver.onStateChanged(mOwner3, Lifecycle.Event.ON_START);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.CREATED);
        mLiveData.setValue("1");

        reset(mActiveObserversChanged);
        reset(mObserver3);

        // Act.

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        lifecycleObserver.onStateChanged(mOwner3, Lifecycle.Event.ON_START);

        // Assert.

        verify(mActiveObserversChanged).onCall(true);
        verify(mObserver3).onChanged("1");
    }

    /*
     * Arrange: One of two Lifecycles enter the CREATED state without sending an event.
     * Act: Lifecycle's setValue method is called with new value.
     * Assert: LiveData stays active and new value is dispatched to Lifecycle that is still at least
     * STARTED.
     */
    @Test
    public void setValue_oneOfTwoLifecyclesAreCreatedNoEvent() {

        // Arrange.

        mLiveData.observe(mOwner3, mObserver3);
        mLiveData.observe(mOwner4, mObserver4);

        GenericLifecycleObserver lifecycleObserver3 = getGenericLifecycleObserver(mLifecycle3);
        GenericLifecycleObserver lifecycleObserver4 = getGenericLifecycleObserver(mLifecycle4);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        when(mLifecycle4.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        lifecycleObserver3.onStateChanged(mOwner3, Lifecycle.Event.ON_START);
        lifecycleObserver4.onStateChanged(mOwner4, Lifecycle.Event.ON_START);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.CREATED);

        reset(mActiveObserversChanged);
        reset(mObserver3);
        reset(mObserver4);

        // Act.

        mLiveData.setValue("1");

        // Assert.

        verify(mActiveObserversChanged, never()).onCall(anyBoolean());
        verify(mObserver3, never()).onChanged(anyString());
        verify(mObserver4).onChanged("1");
    }

    /*
     * Arrange: Two observed Lifecycles enter the CREATED state without sending an event.
     * Act: Lifecycle's setValue method is called with new value.
     * Assert: LiveData becomes inactive and nothing is dispatched to either observer.
     */
    @Test
    public void setValue_twoLifecyclesAreCreatedNoEvent() {

        // Arrange.

        mLiveData.observe(mOwner3, mObserver3);
        mLiveData.observe(mOwner4, mObserver4);

        GenericLifecycleObserver lifecycleObserver3 = getGenericLifecycleObserver(mLifecycle3);
        GenericLifecycleObserver lifecycleObserver4 = getGenericLifecycleObserver(mLifecycle4);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        when(mLifecycle4.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        lifecycleObserver3.onStateChanged(mOwner3, Lifecycle.Event.ON_START);
        lifecycleObserver4.onStateChanged(mOwner4, Lifecycle.Event.ON_START);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.CREATED);
        when(mLifecycle4.getCurrentState()).thenReturn(Lifecycle.State.CREATED);

        reset(mActiveObserversChanged);
        reset(mObserver3);
        reset(mObserver4);

        // Act.

        mLiveData.setValue("1");

        // Assert.

        verify(mActiveObserversChanged).onCall(false);
        verify(mObserver3, never()).onChanged(anyString());
        verify(mObserver3, never()).onChanged(anyString());
    }

    /*
     * Arrange: LiveData was made inactive via SetValue (because both Lifecycles it was
     * observing were in the CREATED state and no event was dispatched).
     * Act: One Lifecycle enters STARTED state and dispatches lifecycle event.
     * Assert: LiveData becomes active and dispatches new value to observer associated with started
     * Lifecycle.
     */
    @Test
    public void test_liveDataInactiveViaSetValueThenOneLifecycleResumes() {

        // Arrange.

        mLiveData.observe(mOwner3, mObserver3);
        mLiveData.observe(mOwner4, mObserver4);

        GenericLifecycleObserver lifecycleObserver3 = getGenericLifecycleObserver(mLifecycle3);
        GenericLifecycleObserver lifecycleObserver4 = getGenericLifecycleObserver(mLifecycle4);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        when(mLifecycle4.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        lifecycleObserver3.onStateChanged(mOwner3, Lifecycle.Event.ON_START);
        lifecycleObserver4.onStateChanged(mOwner4, Lifecycle.Event.ON_START);

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.CREATED);
        when(mLifecycle4.getCurrentState()).thenReturn(Lifecycle.State.CREATED);

        mLiveData.setValue("1");

        reset(mActiveObserversChanged);
        reset(mObserver3);
        reset(mObserver4);

        // Act.

        when(mLifecycle3.getCurrentState()).thenReturn(Lifecycle.State.STARTED);
        lifecycleObserver3.onStateChanged(mOwner3, Lifecycle.Event.ON_START);

        // Assert.

        verify(mActiveObserversChanged).onCall(true);
        verify(mObserver3).onChanged("1");
        verify(mObserver4, never()).onChanged(anyString());
    }

    @Test
    public void nestedForeverObserver() {
        mLiveData.setValue(".");
        mLiveData.observeForever(new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                mLiveData.observeForever(mock(Observer.class));
                mLiveData.removeObserver(this);
            }
        });
        verify(mActiveObserversChanged, only()).onCall(true);
    }

    @Test
    public void readdForeverObserver() {
        Observer observer = mock(Observer.class);
        mLiveData.observeForever(observer);
        mLiveData.observeForever(observer);
        mLiveData.removeObserver(observer);
        assertThat(mLiveData.hasObservers(), is(false));
    }

    private GenericLifecycleObserver getGenericLifecycleObserver(Lifecycle lifecycle) {
        ArgumentCaptor<GenericLifecycleObserver> captor =
                ArgumentCaptor.forClass(GenericLifecycleObserver.class);
        verify(lifecycle).addObserver(captor.capture());
        return (captor.getValue());
    }

    @SuppressWarnings("WeakerAccess")
    static class PublicLiveData<T> extends LiveData<T> {
        // cannot spy due to internal calls
        public MethodExec activeObserversChanged;

        @Override
        protected void onActive() {
            if (activeObserversChanged != null) {
                activeObserversChanged.onCall(true);
            }
        }

        @Override
        protected void onInactive() {
            if (activeObserversChanged != null) {
                activeObserversChanged.onCall(false);
            }
        }
    }

    private class FailReentranceObserver<T> implements Observer<T> {
        @Override
        public void onChanged(@Nullable T t) {
            assertThat(mInObserver, is(false));
        }
    }

    interface MethodExec {
        void onCall(boolean value);
    }
}