You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by es...@apache.org on 2019/01/16 17:50:15 UTC
[geode] branch feature/GEODE-6212 updated: GEODE-6212: Add unit
test coverage for ValueComparisonHelper
This is an automated email from the ASF dual-hosted git repository.
eshu11 pushed a commit to branch feature/GEODE-6212
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/feature/GEODE-6212 by this push:
new 9c814d1 GEODE-6212: Add unit test coverage for ValueComparisonHelper
9c814d1 is described below
commit 9c814d1bb138163ee393c83d189dd2b23c13aaae
Author: eshu <es...@pivotal.io>
AuthorDate: Wed Jan 16 09:48:02 2019 -0800
GEODE-6212: Add unit test coverage for ValueComparisonHelper
* 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..8dadfdd
--- /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 final String STRING = "ABCD";
+ private final byte[] BYTE_ARRAY = {65, 66, 67, 68};
+ private final String STRING2 = "EFGH";
+ private final int[] INT_ARRAY = {65, 66, 67, 68};
+ private final int[] INT_ARRAY2 = new int[] {65, 66, 67, 68};
+ private final int[] INT_ARRAY3 = new int[] {65, 66, 67, 69};
+ private final boolean[] BOOLEAN_ARRAY = {true, false, false, true};
+ private final boolean[] BOOLEAN_ARRAY2 = new boolean[] {true, false, false, true};
+ private final boolean[] BOOLEAN_ARRAY3 = new boolean[] {true, false, true, true};
+ private final short[] SHORT_ARRAY = {65, 66, 67, 68};
+ private final short[] SHORT_ARRAY2 = new short[] {65, 66, 67, 68};
+ private final short[] SHORT_ARRAY3 = new short[] {65, 66, 67, 69};
+ private final float[] FLOAT_ARRAY = {65.1f, 66.0f, 67.3f, 68.9f};
+ private final float[] FLOAT_ARRAY2 = new float[] {65.1f, 66.0f, 67.3f, 68.9f};
+ private final float[] FLOAT_ARRAY3 = {65.1f, 66.0f, 67.3f, 69.9f};
+ private final String[] STRING_ARRAY = {"ABCD", "EFGH"};
+ private final String[] STRING_ARRAY2 = {STRING, STRING2};
+ private 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();
+ }
+
+}