@Test public void txApplyDestroyDoesCallsHandleDiskAccessException_givenOldRegionEntrySetValueThatThrowsDiskAccessException() throws Exception { givenLocalRegion(); givenConcurrencyChecks(); givenOldRegionEntry(); doThrow(DiskAccessException.class).when(oldRegionEntry).setValue(any(), any()); assertThatThrownBy(this::doTxApplyDestroy).isInstanceOf(DiskAccessException.class); verify(owner, times(1)).handleDiskAccessException(any()); }
@Test public void createThatDoesSeeClearDoesNotMakeLruCalls() throws RegionClearedException { doThrow(RegionClearedException.class).when(regionEntry).setValue(any(), any()); createInstance(Operation.CREATE, false, null, localTxEntryState); instance.put(); assertThat(instance.isClearOccurred()).isTrue(); verify(focusedRegionMap, never()).lruEntryUpdate(any()); verify(focusedRegionMap, never()).lruEntryCreate(any()); verify(focusedRegionMap, never()).incEntryCount(1); }
@Test public void remoteUpdateWithOnlyExistingSucceeds() throws Exception { 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(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(existingEntry.prepareValueForCache(any(), eq(newValue), eq(event), eq(true))) .thenReturn(newValue); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(existingEntry, times(1)).setValue(eq(internalRegion), eq(newValue)); }
@Test public void remoteUpdateWithInvalidateWithOnlyExistingSucceeds() throws Exception { 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(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(event.getRawNewValueAsHeapObject()).thenReturn(null); when(existingEntry.prepareValueForCache(any(), eq(Token.INVALID), eq(event), eq(true))) .thenReturn(Token.INVALID); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(existingEntry, times(1)).setValue(eq(internalRegion), eq(Token.INVALID)); }
@Test public void txApplyDestroyDoesCallTxApplyDestroyPart2_givenOldRegionEntryWithMakeTombstoneThrowingRegionDestroyedException() throws Exception { givenLocalRegion(); givenConcurrencyChecks(); givenOldRegionEntry(); doThrow(RegionClearedException.class).when(oldRegionEntry).setValue(any(), any()); doTxApplyDestroy(); verify(owner, times(1)).txApplyDestroyPart2(same(oldRegionEntry), eq(key), eq(inTokenMode), eq(true), eq(true)); }
@Test public void putIgnoresRegionClearedException_ifReplaceOnClientAndTombstoneAndVersionTag() throws RegionClearedException { ifOld = true; givenReplaceOnClient(); givenExistingRegionEntry(); when(existingRegionEntry.isTombstone()).thenReturn(true); when(existingRegionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); when(event.getVersionTag()).thenReturn(mock(VersionTag.class)); doThrow(RegionClearedException.class).when(existingRegionEntry).setValue(internalRegion, Token.TOMBSTONE); RegionEntry result = doPut(); assertThat(result).isNull(); verify(existingRegionEntry, times(1)).setValue(internalRegion, Token.TOMBSTONE); verify(internalRegion, times(1)).rescheduleTombstone(same(existingRegionEntry), any()); }
@Test public void remoteUpdateWithLocalInvalidateWithOnlyExistingSucceeds() throws Exception { 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(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(event.getRawNewValueAsHeapObject()).thenReturn(null); when(event.isLocalInvalid()).thenReturn(true); when(existingEntry.prepareValueForCache(any(), eq(Token.LOCAL_INVALID), eq(event), eq(true))) .thenReturn(Token.LOCAL_INVALID); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(existingEntry, times(1)).setValue(eq(internalRegion), eq(Token.LOCAL_INVALID)); }
private void verifyTxApplyInvalidate(TxTestableAbstractRegionMap arm, Object key, RegionEntry re, Token token) throws RegionClearedException { re.setValue(arm._getOwner(), token); arm.txApplyInvalidate(key, Token.INVALID, false, new TXId(mock(InternalDistributedMember.class), 1), mock(TXRmtEvent.class), false, mock(EventID.class), null, new ArrayList<EntryEventImpl>(), null, null, null, null, 1); assertEquals(re.getValueAsToken(), token); }
@Test public void putReturnsNull_ifReplaceOnClientAndTombstoneAndVersionTag() throws RegionClearedException { ifOld = true; givenReplaceOnClient(); givenExistingRegionEntry(); when(existingRegionEntry.isTombstone()).thenReturn(true); when(existingRegionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); when(event.getVersionTag()).thenReturn(mock(VersionTag.class)); RegionEntry result = doPut(); assertThat(result).isNull(); verify(existingRegionEntry, times(1)).setValue(internalRegion, Token.TOMBSTONE); verify(internalRegion, times(1)).rescheduleTombstone(same(existingRegionEntry), any()); }
@Test public void txApplyDestroyHandlesClear_givenExistingRegionEntryThatIsValidWithInTokenModeAndSetValueThrowsRegionClearedException() throws Exception { givenLocalRegion(); givenConcurrencyChecks(); givenExistingRegionEntry(); inTokenMode = true; doThrow(RegionClearedException.class).when(existingRegionEntry).setValue(same(owner), eq(Token.DESTROYED)); doTxApplyDestroy(); verify(owner, times(1)).txApplyDestroyPart2(any(), any(), anyBoolean(), eq(true), anyBoolean()); verify(regionMap, never()).lruEntryDestroy(any()); }
@Test public void txApplyDestroySetsValueToTokenDestroyed_givenOldRegionEntry() throws Exception { givenLocalRegion(); givenConcurrencyChecks(); givenOldRegionEntry(); doTxApplyDestroy(); verify(oldRegionEntry, times(1)).setValue(same(owner), eq(Token.DESTROYED)); }
@Test public void txApplyDestroyCallsSetValueWithDestroyedToken_givenFactoryRegionEntryWithoutConcurrencyChecksInTokenMode() throws RegionClearedException { givenLocalRegion(); givenFactoryRegionEntry(); givenNoConcurrencyChecks(); inTokenMode = true; doTxApplyDestroy(); verify(factoryRegionEntry, times(1)).setValue(same(owner), eq(Token.DESTROYED)); }
@Test public void txApplyDestroySetsValueToDestroyToken_givenExistingRegionEntryThatIsValidWithInTokenMode() throws Exception { givenLocalRegion(); givenConcurrencyChecks(); givenExistingRegionEntry(); inTokenMode = true; doTxApplyDestroy(); verify(existingRegionEntry, times(1)).setValue(same(owner), eq(Token.DESTROYED)); }
@Test public void txApplyDestroySetsValueToTokenDestroyed_givenOldRegionEntryAndInTokenMode() throws Exception { givenLocalRegion(); givenNoConcurrencyChecks(); givenOldRegionEntry(); inTokenMode = true; doTxApplyDestroy(); verify(oldRegionEntry, times(1)).setValue(same(owner), eq(Token.DESTROYED)); }
private void setNewValueOnRegionEntry(final Object newValue) throws RegionClearedException { final RegionEntry regionEntry = getRegionEntry(); final InternalRegion owner = getOwner(); final boolean wasTombstone = regionEntry.isTombstone(); final Object preparedValue = regionEntry.prepareValueForCache(owner, newValue, getEvent(), !isPutOpCreate()); regionEntry.setValue(owner, preparedValue); if (wasTombstone) { owner.unscheduleTombstone(regionEntry); } }
@Test public void destroyOfExistingTombstoneDoesDestroyAndReschedulesTombstone() throws RegionClearedException { givenConcurrencyChecks(true); givenExistingTombstone(); givenEventWithVersionTag(); givenOriginIsRemote(); doDestroy(); verifyDestroyReturnedTrue(); verify(owner, times(1)).checkEntryNotFound(any()); verify(owner, times(1)).recordEvent(event); verify(owner, times(1)).rescheduleTombstone(same(existingRegionEntry), any()); verify(existingRegionEntry, times(1)).setValue(owner, Token.TOMBSTONE); verifyPart2(true); verifyNoPart3(); }
private boolean checkUpdatePreconditions() { if (isIfOld()) { final EntryEventImpl event = getEvent(); final RegionEntry re = getRegionEntry(); // only update, so just do tombstone maintainence and exit if (re.isTombstone() && event.getVersionTag() != null) { // refresh the tombstone so it doesn't time out too soon getRegionMap().processVersionTag(re, event); try { re.setValue(getOwner(), Token.TOMBSTONE); } catch (RegionClearedException e) { // that's okay - when writing a tombstone into a disk, the // region has been cleared (including this tombstone) } getOwner().rescheduleTombstone(re, re.getVersionStamp().asVersionTag()); return false; } if (re.isRemoved() && !isReplaceOnClient()) { return false; } } return true; }
re.setValue(_getOwner(), Token.REMOVED_PHASE2); if (removeTombstone(re)) { _getOwner().cancelExpiryTask(re);
try { assert newRegionEntry != tombstone; newRegionEntry.setValue(internalRegion, Token.REMOVED_PHASE2); focusedRegionMap.removeEntry(event.getKey(), newRegionEntry, false); } catch (RegionClearedException e) { tombstone.setValue(internalRegion, Token.TOMBSTONE); } catch (RegionClearedException e) {
re.setValue(_getOwner(), value); // OFFHEAP no need to call