@Override public boolean isDestroyed() { return this.regionEntry.isDestroyedOrRemoved(); }
private void givenExistingEntryWithTokenAndVersionTag(Token token) { if (token == Token.REMOVED_PHASE2) { when(regionMap.getEntry(event)).thenReturn(existingRegionEntry).thenReturn(null); when(regionMap.putEntryIfAbsent(KEY, newRegionEntry)).thenReturn(null); when(existingRegionEntry.isRemovedPhase2()).thenReturn(true); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(true); when(existingRegionEntry.isInvalidOrRemoved()).thenReturn(true); when(existingRegionEntry.isDestroyedOrRemovedButNotTombstone()).thenReturn(true); } else { throw new IllegalArgumentException("unexpected token: " + token); } givenEventWithVersionTag(); }
@Override protected boolean entryExists(RegionEntry regionEntry) { return regionEntry != null && !regionEntry.isDestroyedOrRemoved(); }
/** * Returns the tasks region entry if it "checks" out. The check is to see if the region entry * still exists. * * @throws EntryNotFoundException if the task no longer has a region entry or if the region entry * it has is removed. */ protected RegionEntry getCheckedRegionEntry() throws EntryNotFoundException { RegionEntry result = this.re; if (re == null || re.isDestroyedOrRemoved()) { throw new EntryNotFoundException("expiration task no longer has access to region entry"); } return result; }
private boolean checkCreatePreconditions() { if (isIfNew()) { if (!getRegionEntry().isDestroyedOrRemoved()) { return false; } } return true; }
/** * Returns the entry's RegionEntry if it "checks" out. The check is to see if the region entry * still exists. * * @throws EntryNotFoundException if the RegionEntry has been removed. */ private RegionEntry getCheckedRegionEntry() throws EntryNotFoundException { if (this.regionEntry.isDestroyedOrRemoved()) { throw new EntryNotFoundException( "Entry for key " + this.regionEntry.getKey() + " no longer exists"); } return this.regionEntry; }
@Override public RegionEntry getEntry(Object key) { RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isDestroyedOrRemoved()).thenReturn(true); return regionEntry; }
private void givenExistingRemovedRegionEntry() { givenExistingRegionEntry(); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(true); }
private void givenNotDestroyedOrRemoved() { when(existingRegionEntry.isRemoved()).thenReturn(false); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(false); }
private void givenOldRemovedRegionEntry() { givenOldRegionEntry(); when(oldRegionEntry.isDestroyedOrRemoved()).thenReturn(true); }
/** * Test Method: Fetch a value from the local cache * * @param key The kye * @return the value associated with that key * @see LocalRegion#get(Object, Object, boolean, EntryEventImpl) */ public Object localCacheGet(Object key) { RegionEntry re = getRegionMap().getEntry(key); if (re == null || re.isDestroyedOrRemoved()) { return null; } else { return re.getValue(this); // OFFHEAP: spin until we can copy into a heap cd? } }
@Test public void entryExistsWithRemovedEntryReturnsFalse() { createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isDestroyedOrRemoved()).thenReturn(true); boolean result = instance.entryExists(regionEntry); assertThat(result).isFalse(); }
private void givenExistingTombstone(boolean miss) { givenExistingEntry(); when(existingRegionEntry.isTombstone()).thenReturn(true); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(true); when(existingRegionEntry.isInvalidOrRemoved()).thenReturn(true); when(existingRegionEntry.getValue()).thenReturn(Token.TOMBSTONE); }
@Test public void updateRecoveredEntry_givenExistingDestroyedOrRemovedAndSettingToTombstone_neverCallsUpdateSizeOnRemove() { RecoveredEntry recoveredEntry = mock(RecoveredEntry.class); RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isTombstone()).thenReturn(false).thenReturn(true); when(regionEntry.isDestroyedOrRemoved()).thenReturn(true); when(regionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, null, null, regionEntry); arm.updateRecoveredEntry(KEY, recoveredEntry); verify(arm._getOwner(), never()).updateSizeOnRemove(any(), anyInt()); }
@Test public void txApplyDestroy_givenExistingDestroyedOrRemovedEntry_neverCallsUpdateSizeOnRemove() { RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isTombstone()).thenReturn(false); when(regionEntry.isDestroyedOrRemoved()).thenReturn(true); when(regionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); TXId txId = mock(TXId.class); when(txId.getMemberId()).thenReturn(mock(InternalDistributedMember.class)); TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, null, null, regionEntry); arm.txApplyDestroy(KEY, txId, null, false, false, null, null, null, new ArrayList<>(), null, null, false, null, null, 0); verify(arm._getOwner(), never()).updateSizeOnRemove(any(), anyInt()); }
@Test public void remoteUpdateWithOnlyExistingOnRemovedEntryFails() { when(transactionId.getMemberId()).thenReturn(remoteId); when(internalRegion.isAllEvents()).thenReturn(true); when(internalRegion.isInitialized()).thenReturn(true); Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(existingEntry.isDestroyedOrRemoved()).thenReturn(false).thenReturn(true); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isNull(); }
@Test public void eventOperationMadeCreate_ifCacheWriteNeededAndInitializedAndNotReplaceOnClientAndEntryRemoved() { givenPutNeedsToDoCacheWrite(); when(internalRegion.isInitialized()).thenReturn(true); givenReplaceOnPeer(); when(createdRegionEntry.isDestroyedOrRemoved()).thenReturn(true); doPut(); verify(event, times(1)).makeCreate(); verify(event, never()).makeUpdate(); }
@Test public void eventOperationMadeUpdate_ifCacheWriteNeededAndInitializedAndNotReplaceOnClientAndEntryExists() { givenPutNeedsToDoCacheWrite(); when(internalRegion.isInitialized()).thenReturn(true); givenReplaceOnPeer(); when(createdRegionEntry.isDestroyedOrRemoved()).thenReturn(false); doPut(); verify(event, never()).makeCreate(); verify(event, times(1)).makeUpdate(); }
protected boolean nonTXContainsKey(KeyInfo keyInfo) { boolean contains = getRegionMap().containsKey(keyInfo.getKey()); if (contains && this.imageState.isClient()) { // fix for bug #40871 - concurrent RI causes containsKey for destroyed entry // to return true RegionEntry regionEntry = this.entries.getEntry(keyInfo.getKey()); if (regionEntry == null || regionEntry.isDestroyedOrRemoved()) { contains = false; } } return contains; }
private boolean destroyEntry(RegionEntry re, EntryEventImpl event, boolean inTokenMode, boolean cacheWrite, @Released Object expectedOldValue, boolean forceDestroy, boolean removeRecoveredEntry) throws CacheWriterException, TimeoutException, EntryNotFoundException, RegionClearedException { focusedRegionMap.processVersionTag(re, event); final int oldSize = internalRegion.calculateRegionEntryValueSize(re); final boolean wasRemoved = re.isDestroyedOrRemoved(); boolean retVal = re.destroy(event.getRegion(), event, inTokenMode, cacheWrite, expectedOldValue, forceDestroy, removeRecoveredEntry); if (retVal) { EntryLogger.logDestroy(event); if (!wasRemoved) { internalRegion.updateSizeOnRemove(event.getKey(), oldSize); } } return retVal; }