/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You 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 org.apache.geode.internal.cache;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.Serializable;
import java.util.Arrays;

import org.junit.Test;

import org.apache.geode.internal.offheap.StoredObject;
import org.apache.geode.pdx.PdxInstance;

public class ValueComparisonHelperTest {
  private static final String STRING = "ABCD";
  private static final byte[] BYTE_ARRAY = {65, 66, 67, 68};
  private static final String STRING2 = "EFGH";
  private static final int[] INT_ARRAY = {65, 66, 67, 68};
  private static final int[] INT_ARRAY2 = new int[] {65, 66, 67, 68};
  private static final int[] INT_ARRAY3 = new int[] {65, 66, 67, 69};
  private static final boolean[] BOOLEAN_ARRAY = {true, false, false, true};
  private static final boolean[] BOOLEAN_ARRAY2 = new boolean[] {true, false, false, true};
  private static final boolean[] BOOLEAN_ARRAY3 = new boolean[] {true, false, true, true};
  private static final short[] SHORT_ARRAY = {65, 66, 67, 68};
  private static final short[] SHORT_ARRAY2 = new short[] {65, 66, 67, 68};
  private static final short[] SHORT_ARRAY3 = new short[] {65, 66, 67, 69};
  private static final float[] FLOAT_ARRAY = {65.1f, 66.0f, 67.3f, 68.9f};
  private static final float[] FLOAT_ARRAY2 = new float[] {65.1f, 66.0f, 67.3f, 68.9f};
  private static final float[] FLOAT_ARRAY3 = {65.1f, 66.0f, 67.3f, 69.9f};
  private static final String[] STRING_ARRAY = {"ABCD", "EFGH"};
  private static final String[] STRING_ARRAY2 = {STRING, STRING2};
  private static final String[] STRING_ARRAY3 = {STRING, STRING2, ""};

  @Test
  public void basicEqualsCanCompareTwoNullObjects() {
    assertThat(ValueComparisonHelper.basicEquals(null, null)).isTrue();
  }

  @Test
  public void basicEqualsCanCompareWhenOnlyFirstObjectIsNull() {
    assertThat(ValueComparisonHelper.basicEquals(null, new Object())).isFalse();
  }

  @Test
  public void basicEqualsCanCompareWhenOnlySecondObjectIsNull() {
    assertThat(ValueComparisonHelper.basicEquals(new Object(), null)).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualByteArrays() {
    assertThat(ValueComparisonHelper.basicEquals(STRING.getBytes(), BYTE_ARRAY)).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualByteArrays() {
    assertThat(ValueComparisonHelper.basicEquals(STRING.getBytes(), STRING2.getBytes())).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlyFirstObjectIsAByteArray() {
    assertThat(ValueComparisonHelper.basicEquals(BYTE_ARRAY, INT_ARRAY)).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlySecondObjectIsAByteArray() {
    assertThat(ValueComparisonHelper.basicEquals(INT_ARRAY, BYTE_ARRAY)).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualIntArrays() {
    assertThat(ValueComparisonHelper.basicEquals(INT_ARRAY, INT_ARRAY2)).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualIntArrays() {
    assertThat(ValueComparisonHelper.basicEquals(INT_ARRAY, INT_ARRAY3)).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualLongArrays() {
    assertThat(ValueComparisonHelper.basicEquals(Arrays.stream(INT_ARRAY).asLongStream().toArray(),
        Arrays.stream(INT_ARRAY2).asLongStream().toArray())).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualLongArrays() {
    assertThat(ValueComparisonHelper.basicEquals(Arrays.stream(INT_ARRAY3).asLongStream().toArray(),
        Arrays.stream(INT_ARRAY2).asLongStream().toArray())).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualBooleanArrays() {
    assertThat(ValueComparisonHelper.basicEquals(BOOLEAN_ARRAY, BOOLEAN_ARRAY2)).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualBooleanArrays() {
    assertThat(ValueComparisonHelper.basicEquals(BOOLEAN_ARRAY3, BOOLEAN_ARRAY)).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlyFirstObjectIsABooleanArray() {
    assertThat(ValueComparisonHelper.basicEquals(BOOLEAN_ARRAY, SHORT_ARRAY)).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlySecondObjectIsABooleanArray() {
    assertThat(ValueComparisonHelper.basicEquals(SHORT_ARRAY, BOOLEAN_ARRAY)).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualShortArrays() {
    assertThat(ValueComparisonHelper.basicEquals(SHORT_ARRAY, SHORT_ARRAY2)).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualShortArrays() {
    assertThat(ValueComparisonHelper.basicEquals(SHORT_ARRAY2, SHORT_ARRAY3)).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualDoubleArrays() {
    assertThat(
        ValueComparisonHelper.basicEquals(Arrays.stream(INT_ARRAY).asDoubleStream().toArray(),
            Arrays.stream(INT_ARRAY2).asDoubleStream().toArray())).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualDoubleArrays() {
    assertThat(
        ValueComparisonHelper.basicEquals(Arrays.stream(INT_ARRAY3).asDoubleStream().toArray(),
            Arrays.stream(INT_ARRAY).asDoubleStream().toArray())).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualCharArrays() throws Exception {
    assertThat(ValueComparisonHelper.basicEquals(STRING.toCharArray(),
        (new String(BYTE_ARRAY, "UTF-8")).toCharArray())).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualCharArrays() throws Exception {
    assertThat(ValueComparisonHelper.basicEquals(STRING2.toCharArray(),
        (new String(BYTE_ARRAY, "UTF-8")).toCharArray())).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlyFirstObjectIsACharArray() {
    assertThat(ValueComparisonHelper.basicEquals(STRING.toCharArray(),
        Arrays.stream(INT_ARRAY).asDoubleStream().toArray())).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlySecondObjectIsACharArray() {
    assertThat(ValueComparisonHelper
        .basicEquals(Arrays.stream(INT_ARRAY).asDoubleStream().toArray(), STRING.toCharArray()))
            .isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualFloatArrays() throws Exception {
    assertThat(ValueComparisonHelper.basicEquals(FLOAT_ARRAY, FLOAT_ARRAY2)).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualFloatArrays() throws Exception {
    assertThat(ValueComparisonHelper.basicEquals(FLOAT_ARRAY2, FLOAT_ARRAY3)).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlySecondObjectIsAFloatArray() throws Exception {
    assertThat(ValueComparisonHelper.basicEquals(STRING, FLOAT_ARRAY3)).isFalse();
  }

  @Test
  public void basicEqualsReturnsTrueWhenCompareTwoEqualStringArrays() throws Exception {
    assertThat(ValueComparisonHelper.basicEquals(STRING_ARRAY, STRING_ARRAY2)).isTrue();
  }

  @Test
  public void basicEqualsReturnsFalseWhenCompareTwoNotEqualStringArrays() throws Exception {
    assertThat(ValueComparisonHelper.basicEquals(STRING_ARRAY, STRING_ARRAY3)).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlyFirstObjectIsAStringArray() {
    assertThat(ValueComparisonHelper.basicEquals(STRING_ARRAY,
        Arrays.stream(INT_ARRAY).asLongStream().toArray())).isFalse();
  }

  @Test
  public void basicEqualsReturnsFalseWhenOnlySecondObjectIsAStringArray() {
    assertThat(ValueComparisonHelper
        .basicEquals(Arrays.stream(INT_ARRAY).asDoubleStream().toArray(), STRING_ARRAY2)).isFalse();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingNotSerializedCacheDeserializableWithPdxInstance() {
    PdxInstance pdxInstance1 = mock(PdxInstance.class);
    CachedDeserializable object = mock(CachedDeserializable.class);
    when(object.isSerialized()).thenReturn(false);

    assertThat(
        ValueComparisonHelper.checkEquals(object, pdxInstance1, false, mock(InternalCache.class)))
            .isFalse();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingPdxInstanceWithNonPdxCacheDeserializable() {
    int[] value = {0, 1, 2, 3};
    Object object = new VMCachedDeserializable(EntryEventImpl.serialize(value));
    PdxInstance pdxInstance1 = mock(PdxInstance.class);

    assertThat(
        ValueComparisonHelper.checkEquals(pdxInstance1, object, false, mock(InternalCache.class)))
            .isFalse();
  }

  @Test
  public void checkEqualsReturnsTrueWhenComparingPdxInstanceWithItsCacheDeserializable() {
    PdxInstance pdxInstance1 = mock(PdxInstance.class);
    Object object = new VMCachedDeserializable(pdxInstance1, 1);

    assertThat(
        ValueComparisonHelper.checkEquals(pdxInstance1, object, false, mock(InternalCache.class)))
            .isTrue();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingTwoNonEqualStoredObject() {
    StoredObject object1 = mock(StoredObject.class);
    StoredObject object2 = mock(StoredObject.class);

    when(object1.checkDataEquals(object2)).thenReturn(false);

    assertThat(
        ValueComparisonHelper.checkEquals(object1, object2, false, mock(InternalCache.class)))
            .isFalse();
  }

  @Test
  public void checkEqualsReturnsTrueWhenComparingTwoEqualStoredObject() {
    StoredObject object1 = mock(StoredObject.class);
    StoredObject object2 = mock(StoredObject.class);

    when(object1.checkDataEquals(object2)).thenReturn(true);

    assertThat(
        ValueComparisonHelper.checkEquals(object1, object2, false, mock(InternalCache.class)))
            .isTrue();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingStoredObjectWithByteArrayAsCacheDeserializable() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(false);
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, cachedDeserializable, false,
            mock(InternalCache.class)))
                .isFalse();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingNonSerializedStoredObjectWithCacheDeserializable() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(false);
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, cachedDeserializable, false,
            mock(InternalCache.class)))
                .isFalse();
  }

  @Test
  public void checkEqualsCanCompareStoredObjectWithCacheDeserializable() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(true);
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    byte[] serializedObj = new byte[1];
    when(cachedDeserializable.getSerializedValue()).thenReturn(serializedObj);

    ValueComparisonHelper.checkEquals(storedObject, cachedDeserializable, false,
        mock(InternalCache.class));

    verify(storedObject).checkDataEquals(serializedObj);
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingSerializedStoredObjectWithByteArray() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(true);
    byte[] object = new byte[1];

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, object, false, mock(InternalCache.class)))
            .isFalse();
  }

  @Test
  public void checkEqualsCanCompareNonSerializedStoredObjectWithByteArray() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(false);
    byte[] object = new byte[1];

    ValueComparisonHelper.checkEquals(storedObject, object, false, mock(InternalCache.class));

    verify(storedObject).checkDataEquals(object);
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingNonSerializedStoredObjectWithAnObject() {
    StoredObject storedObject = mock(StoredObject.class);
    // storeObject is a byte[]
    when(storedObject.isSerialized()).thenReturn(false);
    Object object = new Object();

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, object, false, mock(InternalCache.class)))
            .isFalse();
    verify(storedObject, never()).checkDataEquals(any(byte[].class));
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingSerializedStoredObjectWithANullObject() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(true);

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, null, false, mock(InternalCache.class)))
            .isFalse();
    verify(storedObject, never()).checkDataEquals(any(byte[].class));
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingSerializedStoredObjectWithNotAvailableToken() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(true);

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, Token.NOT_AVAILABLE, false,
            mock(InternalCache.class)))
                .isFalse();
    verify(storedObject, never()).checkDataEquals(any(byte[].class));
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingSerializedStoredObjectWithInvalidToken() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(true);

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, Token.INVALID, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, Token.LOCAL_INVALID, false,
            mock(InternalCache.class)))
                .isFalse();
    verify(storedObject, never()).checkDataEquals(any(byte[].class));
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingSerializedStoredObjectWithRemovedToken() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(true);

    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, Token.DESTROYED, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, Token.REMOVED_PHASE1, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, Token.REMOVED_PHASE2, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(storedObject, Token.TOMBSTONE, false,
            mock(InternalCache.class)))
                .isFalse();
    verify(storedObject, never()).checkDataEquals(any(byte[].class));
  }

  @Test
  public void checkEqualsCanCompareSerializedStoredObjectWithAnObject() {
    StoredObject storedObject = mock(StoredObject.class);
    when(storedObject.isSerialized()).thenReturn(true);
    Object object = mock(Serializable.class);

    ValueComparisonHelper.checkEquals(object, storedObject, false, mock(InternalCache.class));

    verify(storedObject).checkDataEquals(any(byte[].class));
  }

  @Test
  public void checkEqualsReturnsTrueWhenComparingTwoEqualNotSerializedCacheDeserializable() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(false);
    CachedDeserializable object = mock(CachedDeserializable.class);
    when(object.isSerialized()).thenReturn(false);
    when(cachedDeserializable.getDeserializedForReading()).thenReturn(BYTE_ARRAY);
    when(object.getDeserializedForReading()).thenReturn(STRING.getBytes());

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, object, false,
        mock(InternalCache.class))).isTrue();
  }

  @Test
  public void checkEqualsReturnsTrueWhenComparingNotSerializedDeserializableWithAByteArray() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(false);
    byte[] object = STRING.getBytes();
    when(cachedDeserializable.getDeserializedForReading()).thenReturn(BYTE_ARRAY);

    assertThat(ValueComparisonHelper.checkEquals(object, cachedDeserializable, false,
        mock(InternalCache.class))).isTrue();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingNotSerializedCacheDeserializableWithAnObject() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(false);
    Object object = new Object();

    assertThat(ValueComparisonHelper.checkEquals(object, cachedDeserializable, false,
        mock(InternalCache.class))).isFalse();
  }

  @Test
  public void checkEqualsCanCompareNotSerializedCacheDeserializableWithSerializedOne() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(false);
    CachedDeserializable object = mock(CachedDeserializable.class);
    when(object.isSerialized()).thenReturn(true);

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, object, false,
        mock(InternalCache.class))).isFalse();
  }

  @Test
  public void checkEqualsCanCompareCacheDeserializableIfIsCompressedOffheap() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(BYTE_ARRAY);
    CachedDeserializable object = mock(CachedDeserializable.class);
    when(object.getSerializedValue()).thenReturn(STRING.getBytes());

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, object, true,
        mock(InternalCache.class))).isTrue();
  }

  @Test
  public void checkEqualsCanCompareCacheDeserializableWithAnObjectIfIsCompressedOffheap() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(EntryEventImpl.serialize(STRING));

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, STRING, true,
        mock(InternalCache.class))).isTrue();
  }

  @Test
  public void checkEqualsCanCompareCacheDeserializable() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(BYTE_ARRAY);
    when(cachedDeserializable.getDeserializedForReading()).thenReturn(STRING);
    CachedDeserializable object = mock(CachedDeserializable.class);
    when(object.getDeserializedForReading()).thenReturn(STRING);

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, object, false,
        mock(InternalCache.class))).isTrue();
    verify(cachedDeserializable).getDeserializedForReading();
    verify(object).getDeserializedForReading();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingCacheDeserializableWithANullObject() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(BYTE_ARRAY);

    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, null, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, null, true,
            mock(InternalCache.class)))
                .isFalse();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingCacheDeserializableWithNotAvailableToken() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(BYTE_ARRAY);

    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.NOT_AVAILABLE, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.NOT_AVAILABLE, true,
            mock(InternalCache.class)))
                .isFalse();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingCacheDeserializableWithInvalidToken() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(BYTE_ARRAY);

    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.INVALID, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.LOCAL_INVALID, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.INVALID, true,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.LOCAL_INVALID, true,
            mock(InternalCache.class)))
                .isFalse();
  }

  @Test
  public void checkEqualsReturnsFalseWhenComparingCacheDeserializableWithRemovedToken() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(BYTE_ARRAY);

    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.DESTROYED, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.REMOVED_PHASE1, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.REMOVED_PHASE2, false,
            mock(InternalCache.class)))
                .isFalse();
    assertThat(
        ValueComparisonHelper.checkEquals(cachedDeserializable, Token.TOMBSTONE, false,
            mock(InternalCache.class)))
                .isFalse();
  }

  @Test
  public void checkEqualsCanCompareCacheDeserializableWithAnObject() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(BYTE_ARRAY);
    when(cachedDeserializable.getDeserializedForReading()).thenReturn(STRING);

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, STRING, false,
        mock(InternalCache.class))).isTrue();
  }

  @Test
  public void checkEqualsCanCompareObjectAsValueCacheDeserializableWithCacheDeserializable() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(STRING);
    CachedDeserializable object = mock(CachedDeserializable.class);
    when(object.getDeserializedForReading()).thenReturn(STRING);

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, object, false,
        mock(InternalCache.class))).isTrue();
  }

  @Test
  public void checkEqualsCanCompareObjectAsValueCacheDeserializableWithAnObject() {
    CachedDeserializable cachedDeserializable = mock(CachedDeserializable.class);
    when(cachedDeserializable.isSerialized()).thenReturn(true);
    when(cachedDeserializable.getValue()).thenReturn(STRING);

    assertThat(ValueComparisonHelper.checkEquals(cachedDeserializable, STRING, false,
        mock(InternalCache.class))).isTrue();
  }

  @Test
  public void checkEqualsCanCompareTwoObjects() {
    assertThat(ValueComparisonHelper.checkEquals(BOOLEAN_ARRAY, BOOLEAN_ARRAY2, false,
        mock(InternalCache.class))).isTrue();
  }

}