com.gemstone.gemfire.DeltaTestImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-junit Show documentation
Show all versions of gemfire-junit Show documentation
SnappyData store based off Pivotal GemFireXD
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* 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. See accompanying
* LICENSE file.
*/
/**
*
*/
package com.gemstone.gemfire;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.Arrays;
import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
import com.gemstone.gemfire.internal.cache.lru.Sizeable;
import com.gemstone.gemfire.internal.util.Sizeof;
/**
* Sample test class which implements Delta.
*
* @since 6.1
*/
public class DeltaTestImpl implements DataSerializable, Delta {
private static final byte INT_MASK = 0x1;
private static final byte STR_MASK = 0x2;
private static final byte DOUBLE_MASK = 0x4;
private static final byte BYTE_ARR_MASK = 0x8;
private static final byte TEST_OBJ_MASK = 0x10;
private static final byte COMPLETE_MASK = 0x1F;
/*****************************************************************************
* Below fields are not part of standard Delta implementation but are used for
* testing purpose.
*/
public static final String ERRONEOUS_STRING_FOR_FROM_DELTA = "ERRONEOUS_STRING";
public static final int ERRONEOUS_INT_FOR_TO_DELTA = -101;
private static long fromDeltaInvokations;
private static long toDeltaInvokations;
private static long toDeltaFailure;
private static long fromDeltaFailure;
public static boolean NEED_TO_RESET_T0_DELTA = true;
/** *********************************************************************** */
// Actual data fields of this instance.
private int intVar = 0; // 0000 0001
private String str = ""; // 0000 0010
private Double doubleVar = new Double(0); // 0000 0100
private byte[] byteArr = new byte[1]; // 0000 1000
private TestObject1 testObj = new TestObject1(); // 0001 0000
/**
* Indicates the fields containing delta.
*/
private byte deltaBits = 0x0;
private boolean hasDelta = false;
public DeltaTestImpl() {
}
public DeltaTestImpl(int intVal, String str) {
this.intVar = intVal;
this.str = str;
}
public DeltaTestImpl(int intVal, String string, Double doubleVal,
byte[] bytes, TestObject1 testObj) {
this.intVar = intVal;
this.str = string;
this.doubleVar = doubleVal;
this.byteArr = bytes;
this.testObj = testObj;
}
public void resetDeltaStatus() {
this.deltaBits = 0x0;
this.hasDelta = false;
}
public byte[] getByteArr() {
return byteArr;
}
public void setByteArr(byte[] bytes) {
this.byteArr = bytes;
this.deltaBits |= BYTE_ARR_MASK;
this.hasDelta = true;
}
public Double getDoubleVar() {
return doubleVar;
}
public void setDoubleVar(Double doubleVar) {
this.doubleVar = doubleVar;
this.deltaBits |= DOUBLE_MASK;
this.hasDelta = true;
}
public int getIntVar() {
return intVar;
}
public void setIntVar(int intVar) {
this.intVar = intVar;
this.deltaBits |= INT_MASK;
this.hasDelta = true;
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
this.deltaBits |= STR_MASK;
this.hasDelta = true;
}
public TestObject1 getTestObj() {
return testObj;
}
public void setTestObj(TestObject1 testObj) {
this.testObj = testObj;
this.deltaBits |= TEST_OBJ_MASK;
this.hasDelta = true;
}
/*****************************************************************************
* Below methods are not part of standard Delta implementation but are used
* for testing purpose.
*/
public static void resetDeltaInvokationCounters() {
resetToDeltaCounter();
resetFromDeltaCounter();
resetFailureCounter();
}
public static void resetToDeltaCounter() {
toDeltaInvokations = 0;
}
public static void resetFromDeltaCounter() {
fromDeltaInvokations = 0;
}
public static void resetFailureCounter() {
toDeltaFailure = 0;
fromDeltaFailure = 0;
}
public static Boolean deltaFeatureUsed() {
return (toDeltaInvokations > 0) || (fromDeltaInvokations > 0);
}
public static Boolean toDeltaFeatureUsed() {
return (toDeltaInvokations > 0);
}
public static Long getFromDeltaInvokations() {
return fromDeltaInvokations;
}
public static Long getToDeltaInvokations() {
return toDeltaInvokations;
}
public static Boolean fromDeltaFeatureUsed() {
return (fromDeltaInvokations > 0);
}
public static Boolean isFromDeltaFailure() {
return (fromDeltaFailure > 0);
}
public static Boolean isToDeltaFailure() {
return (toDeltaFailure > 0);
}
public static Long getFromDeltaFailures() {
return fromDeltaFailure;
}
public static Long getToDeltaFailures() {
return toDeltaFailure;
}
protected void checkInvalidString(String str) {
if (ERRONEOUS_STRING_FOR_FROM_DELTA.equals(str)) {
fromDeltaFailure++;
throw new InvalidDeltaException("Delta could not be applied. "
+ this);
}
}
protected void checkInvalidInt(int intVal) {
if (ERRONEOUS_INT_FOR_TO_DELTA == intVal) {
toDeltaFailure++;
throw new InvalidDeltaException("Delta could not be extracted. "
+ this);
}
}
protected void checkInvalidInt2(int intVal) {}
/** ********************************************************************** */
public String toString() {
StringBuilder bytes = new StringBuilder();
if (byteArr != null) {
for (int i = 0; i < byteArr.length; i++) {
bytes.append(byteArr[i]);
}
}
return "DeltaTestImpl[hasDelta=" + this.hasDelta + ",int=" + this.intVar
+ ",double=" + this.doubleVar + ",str=" + this.str + ",bytes=("
+ bytes.toString() + "),testObj="
+ ((this.testObj != null) ? this.testObj.hashCode() : "") + "]";
}
public boolean equals(Object other) {
if (other == null || !(other instanceof DeltaTestImpl)) {
return false;
}
DeltaTestImpl delta = (DeltaTestImpl)other;
if (this.intVar == delta.intVar && this.doubleVar.equals(delta.doubleVar)
&& Arrays.equals(this.byteArr, delta.byteArr)
&& this.str.equals(delta.str)) {
return true;
}
return false;
}
/*
* (non-Javadoc)
*
* @see com.gemstone.gemfire.Delta#fromDelta(java.io.DataInput)
*/
public void fromDelta(DataInput in) throws IOException {
try {
fromDeltaInvokations++;
boolean tempHasDelta = false;
byte tempDeltaBits = this.deltaBits;
byte[] tempByteArr = this.byteArr;
int tempIntVar = this.intVar;
double tempDoubleVar = this.doubleVar;
String tempStr = this.str;
TestObject1 tempTestObj = this.testObj;
tempDeltaBits = DataSerializer.readByte(in);
if (tempDeltaBits != 0) {
tempHasDelta = true;
if ((tempDeltaBits & INT_MASK) == INT_MASK) {
tempIntVar = DataSerializer.readPrimitiveInt(in);
checkInvalidInt2(tempIntVar);
}
if ((tempDeltaBits & STR_MASK) == STR_MASK) {
tempStr = DataSerializer.readString(in);
checkInvalidString(tempStr); // Simulates exception
}
if ((tempDeltaBits & DOUBLE_MASK) == DOUBLE_MASK) {
tempDoubleVar = DataSerializer.readDouble(in);
}
if ((tempDeltaBits & BYTE_ARR_MASK) == BYTE_ARR_MASK) {
tempByteArr = DataSerializer.readByteArray(in);
}
if ((tempDeltaBits & TEST_OBJ_MASK) == TEST_OBJ_MASK) {
tempTestObj = (TestObject1)DataSerializer.readObject(in);
}
if ((deltaBits | COMPLETE_MASK) != COMPLETE_MASK) {
throw new IllegalArgumentException("Unknown field code: "
+ tempDeltaBits);
}
}
if (tempHasDelta) {
//this.hasDelta = true;
//this.deltaBits = tempDeltaBits;
this.intVar = tempIntVar;
this.str = tempStr;
this.doubleVar = tempDoubleVar;
this.byteArr = tempByteArr;
this.testObj = tempTestObj;
}
}
catch (IOException e) {
GemFireCacheImpl.getInstance().getLogger().warning(
"DeltaTestImpl.fromDelta(): " + e);
throw e;
}
catch (IllegalArgumentException iae) {
GemFireCacheImpl.getInstance().getLogger().warning(
"DeltaTestImpl.fromDelta(): " + iae);
throw new InvalidDeltaException(iae);
}
catch (ClassNotFoundException cnfe) {
GemFireCacheImpl.getInstance().getLogger().warning(
"DeltaTestImpl.fromDelta(): " + cnfe);
throw new InvalidDeltaException(cnfe);
}
}
/*
* (non-Javadoc)
*
* @see com.gemstone.gemfire.Delta#hasDelta()
*/
public boolean hasDelta() {
return this.hasDelta;
}
/*
* (non-Javadoc)
*
* @see com.gemstone.gemfire.Delta#toDelta(java.io.DataOutput)
*/
public void toDelta(DataOutput out) throws IOException {
try {
toDeltaInvokations++;
DataSerializer.writeByte(this.deltaBits, out);
if (deltaBits != 0) {
if ((deltaBits & INT_MASK) == INT_MASK) {
DataSerializer.writePrimitiveInt(this.intVar, out);
checkInvalidInt(this.intVar); // Simulates exception
}
if ((deltaBits & STR_MASK) == STR_MASK) {
DataSerializer.writeString(this.str, out);
}
if ((deltaBits & DOUBLE_MASK) == DOUBLE_MASK) {
DataSerializer.writeDouble(this.doubleVar, out);
}
if ((deltaBits & BYTE_ARR_MASK) == BYTE_ARR_MASK) {
DataSerializer.writeByteArray(this.byteArr, out);
}
if ((deltaBits & TEST_OBJ_MASK) == TEST_OBJ_MASK) {
DataSerializer.writeObject(this.testObj, out);
}
if ((deltaBits | COMPLETE_MASK) != COMPLETE_MASK) {
throw new IllegalArgumentException("Unknown field code: " + deltaBits);
}
}
}
catch (IOException ioe) {
GemFireCacheImpl.getInstance().getLogger().warning(
"DeltaTestImpl.toDelta(): " + ioe);
throw ioe;
}
catch (IllegalArgumentException iae) {
GemFireCacheImpl.getInstance().getLogger().warning(
"DeltaTestImpl.toDelta(): " + iae);
throw new InvalidDeltaException(iae);
}
finally {
if (NEED_TO_RESET_T0_DELTA) {// No need to reset if secondary needs to
// send delta again upon receiving
// forceReattemptException
this.deltaBits = 0x0;
this.hasDelta = false;
}
}
}
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
//this.deltaBits = DataSerializer.readByte(in);
this.intVar = DataSerializer.readPrimitiveInt(in);
this.str = DataSerializer.readString(in);
this.doubleVar = DataSerializer.readDouble(in);
this.byteArr = DataSerializer.readByteArray(in);
this.testObj = (TestObject1)DataSerializer.readObject(in);
//if (deltaBits != 0) {
// this.hasDelta = true;
//}
}
public void toData(DataOutput out) throws IOException {
//DataSerializer.writeByte(this.deltaBits, out);
DataSerializer.writePrimitiveInt(this.intVar, out);
DataSerializer.writeString(this.str, out);
DataSerializer.writeDouble(this.doubleVar, out);
DataSerializer.writeByteArray(this.byteArr, out);
DataSerializer.writeObject(this.testObj, out);
}
/**
* Object used for the put() operation as key and object
*
* @author gthombar
*/
static public class TestObject1 implements DataSerializable, Sizeable {
String name;
byte arr[] = new byte[1024 * 4];
int identifier;
public TestObject1() {
}
public TestObject1(String objectName, int objectIndentifier) {
this.name = objectName;
Arrays.fill(this.arr, (byte)'A');
this.identifier = objectIndentifier;
}
public int hashCode() {
return this.identifier;
}
public boolean equals(TestObject1 obj) {
return (this.name.equals(obj.name)
&& Arrays.equals(this.arr, obj.arr));
}
public void toData(DataOutput out) throws IOException {
DataSerializer.writeByteArray(this.arr, out);
DataSerializer.writeString(this.name, out);
out.writeInt(this.identifier);
}
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
this.arr = DataSerializer.readByteArray(in);
this.name = DataSerializer.readString(in);
this.identifier = in.readInt();
}
public int getSizeInBytes() {
return Sizeof.sizeof(arr) + Sizeof.sizeof(name) +
Sizeof.sizeof(identifier) + Sizeable.PER_OBJECT_OVERHEAD * 3;
}
}
}