This is an automated email from the ASF dual-hosted git repository.
eshu11 pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/develop by this push:
new 3cf75b6 GEODE-6212: Add unit test coverage for ValueComparisonHelper
(#3082)
3cf75b6 is described below
commit 3cf75b6e057320ae5b9338dc6433afb168151b6c
Author: pivotal-eshu <[email protected]>
AuthorDate: Thu Jan 17 17:51:50 2019 -0800
GEODE-6212: Add unit test coverage for ValueComparisonHelper (#3082)
* fixed an error in the helper class when adding test coverage.
---
.../internal/cache/ValueComparisonHelper.java | 4 +-
.../internal/cache/ValueComparisonHelperTest.java | 605 +++++++++++++++++++++
2 files changed, 607 insertions(+), 2 deletions(-)
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/ValueComparisonHelper.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/ValueComparisonHelper.java
index 4f9c63e..285e8e5 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/ValueComparisonHelper.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/ValueComparisonHelper.java
@@ -49,7 +49,7 @@ public class ValueComparisonHelper {
}
}
- private static boolean basicEquals(Object v1, Object v2) {
+ static boolean basicEquals(Object v1, Object v2) {
if (v2 != null) {
if (v2.getClass().isArray()) {
// fix for 52093
@@ -213,7 +213,7 @@ public class ValueComparisonHelper {
byte[] ba2;
if (obj instanceof CachedDeserializable) {
CachedDeserializable cdObj = (CachedDeserializable) obj;
- if (!cdObj.isSerialized()) {
+ if (cdObj.isSerialized()) {
return false;
}
ba2 = (byte[]) cdObj.getDeserializedForReading();
diff --git
a/geode-core/src/test/java/org/apache/geode/internal/cache/ValueComparisonHelperTest.java
b/geode-core/src/test/java/org/apache/geode/internal/cache/ValueComparisonHelperTest.java
new file mode 100644
index 0000000..830ff7f
--- /dev/null
+++
b/geode-core/src/test/java/org/apache/geode/internal/cache/ValueComparisonHelperTest.java
@@ -0,0 +1,605 @@
+/*
+ * 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();
+ }
+
+ @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();
+ }
+
+ @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();
+ }
+
+ @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();
+ }
+
+}
