public void WillScavenge()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.NotRemovable, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.High, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.Normal, null);
CacheItem item4 = new CacheItem("key4", "value4", CacheItemPriority.Low, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
AddCacheItem("key4", item4);
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 1;
view.GetCacheManagerSettings().CacheManagers["test"].NumberToRemoveWhenScavenging = 2;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
scavenger.DoScavenging();
Assert.AreEqual("key4key3", scavengedKeys);
}
public void CanScavengeInBackground()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 2;
view.GetCacheManagerSettings().CacheManagers["test"].NumberToRemoveWhenScavenging = 1;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
BackgroundScheduler scheduler = new BackgroundScheduler(null, scavenger);
scheduler.Start();
Thread.Sleep(500);
scheduler.StartScavenging();
Thread.Sleep(250);
scheduler.Stop();
Thread.Sleep(250);
Assert.AreEqual("key1", scavengedKeys);
}
public void CanScavengeInBackground()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 2;
view.GetCacheManagerSettings().CacheManagers["test"].NumberToRemoveWhenScavenging = 1;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
BackgroundScheduler scheduler = new BackgroundScheduler(null, scavenger);
scheduler.Start();
Thread.Sleep(500);
scheduler.StartScavenging();
Thread.Sleep(250);
scheduler.Stop();
Thread.Sleep(250);
Assert.AreEqual("key1", scavengedKeys);
}
public void CanScavengeInBackground()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy(2);
ScavengerTask scavenger = new ScavengerTask(1, scavengingPolicy, this, instrumentationProvider);
BackgroundScheduler scheduler = new BackgroundScheduler(null, scavenger, instrumentationProvider);
scheduler.Start();
Thread.Sleep(500);
scheduler.StartScavenging();
Thread.Sleep(250);
scheduler.Stop();
Thread.Sleep(250);
Assert.AreEqual("key1", scavengedKeys);
}
public void WillRemoveMultipleEligibleForScavenging()
{
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 2;
view.GetCacheManagerSettings().CacheManagers["test"].NumberToRemoveWhenScavenging = 3;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
CacheItem itemToRemove = new CacheItem("key1", "value", CacheItemPriority.High, null);
CacheItem itemToRemain = new CacheItem("key2", "value", CacheItemPriority.Low, null);
CacheItem itemToRemoveAlso = new CacheItem("key3", "value", CacheItemPriority.Normal, null);
itemToRemove.MakeEligibleForScavenging();
itemToRemain.MakeEligibleForScavenging();
itemToRemoveAlso.MakeEligibleForScavenging();
AddCacheItem("key1", itemToRemove);
AddCacheItem("key2", itemToRemain);
AddCacheItem("key3", itemToRemoveAlso);
scavenger.DoScavenging();
Assert.AreEqual("key2key3key1", scavengedKeys);
}
public void WillNotRemoveItemIfNotEligibleForScavenging()
{
ScavengerTask scavenger = new ScavengerTask(0, 1, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key", "value", CacheItemPriority.Low, null);
itemToRemove.MakeNotEligibleForScavenging();
AddCacheItem("key", itemToRemove);
scavenger.DoScavenging();
Assert.AreEqual("", scavengedKeys);
}
public void WillNotRemoveItemIfNotEligibleForScavenging()
{
ScavengerTask scavenger = new ScavengerTask(0, 1, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key", "value", CacheItemPriority.Low, null);
itemToRemove.MakeNotEligibleForScavenging();
AddCacheItem("key", itemToRemove);
scavenger.DoScavenging();
Assert.AreEqual("", scavengedKeys);
}
public void WillRemoveSingleItemFromCache()
{
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy(0);
ScavengerTask scavenger = new ScavengerTask(1, scavengingPolicy, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key", "value", CacheItemPriority.Low, null);
itemToRemove.MakeEligibleForScavenging();
AddCacheItem("key", itemToRemove);
scavenger.DoScavenging();
Assert.AreEqual("key", scavengedKeys);
}
public void WillRemoveSingleItemFromCache()
{
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy(0);
ScavengerTask scavenger = new ScavengerTask(1, scavengingPolicy, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key", "value", CacheItemPriority.Low, null);
itemToRemove.MakeEligibleForScavenging();
AddCacheItem("key", itemToRemove);
scavenger.DoScavenging();
Assert.AreEqual("key", scavengedKeys);
}
public void WillScavengeNoItemsIfNumberOfItemsToScavengeIsZero()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
ScavengerTask scavenger = new ScavengerTask(0, 2, this, instrumentationProvider);
scavenger.DoScavenging();
Assert.AreEqual("", scavengedKeys);
}
public void WillScavenge()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.NotRemovable, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.High, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.Normal, null);
CacheItem item4 = new CacheItem("key4", "value4", CacheItemPriority.Low, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
AddCacheItem("key4", item4);
ScavengerTask scavenger = new ScavengerTask(2, 1, this, instrumentationProvider);
scavenger.DoScavenging();
Assert.AreEqual("key4key3", scavengedKeys);
}
public void WillRemoveSingleItemFromCache()
{
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 0;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
CacheItem itemToRemove = new CacheItem("key", "value", CacheItemPriority.Low, null);
itemToRemove.MakeEligibleForScavenging();
AddCacheItem("key", itemToRemove);
scavenger.DoScavenging();
Assert.AreEqual("key", scavengedKeys);
}
public void WillNotScheduleNewScavengeTaskIfOneIsAlreadyScheduled()
{
inMemoryCacheRequestSemaphore = new EventWaitHandle(false, EventResetMode.ManualReset);
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.Normal, null);
CacheItem item4 = new CacheItem("key4", "value4", CacheItemPriority.Normal, null);
CacheItem item5 = new CacheItem("key5", "value5", CacheItemPriority.High, null);
CacheItem item6 = new CacheItem("key6", "value6", CacheItemPriority.High, null);
CacheItem item7 = new CacheItem("key7", "value7", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
ScavengerTask scavenger = new ScavengerTask(2, 3, this, instrumentationProvider);
BackgroundScheduler scheduler = new BackgroundScheduler(null, scavenger, instrumentationProvider);
AddCacheItem("key4", item4);
// this new scavenge request will be scheduled, it's the first one
scheduler.StartScavenging();
// the scavenge request scheduled above would be processed here and will be blocked by the event
Thread.Sleep(500);
AddCacheItem("key5", item5);
// this new scavenge request will be scheduled, because the previously scheduled one will have started
scheduler.StartScavenging();
Thread.Sleep(250);
AddCacheItem("key6", item6);
// this new scavenge request will be ignored
scheduler.StartScavenging();
Thread.Sleep(250);
AddCacheItem("key7", item7);
// this new scavenge request will be ignored
scheduler.StartScavenging();
Thread.Sleep(250);
bool value = inMemoryCacheRequestSemaphore.Set();
Thread.Sleep(250);
// 3 cache requests should be issued: one for "key4" for one element and two for the remaining elements
// since at most 2 elements are removed per scavenge
Assert.AreEqual(3, inMemoryCacheRequests);
}
public void WillRemoveMultipleEligibleForScavenging()
{
ScavengerTask scavenger = new ScavengerTask(3, 2, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key1", "value", CacheItemPriority.High, null);
CacheItem itemToRemain = new CacheItem("key2", "value", CacheItemPriority.Low, null);
CacheItem itemToRemoveAlso = new CacheItem("key3", "value", CacheItemPriority.Normal, null);
itemToRemove.MakeEligibleForScavenging();
itemToRemain.MakeEligibleForScavenging();
itemToRemoveAlso.MakeEligibleForScavenging();
AddCacheItem("key1", itemToRemove);
AddCacheItem("key2", itemToRemain);
AddCacheItem("key3", itemToRemoveAlso);
scavenger.DoScavenging();
Assert.AreEqual("key2key3key1", scavengedKeys);
}
public void WillStopRemovingAtLimitForScavenging()
{
ScavengerTask scavenger = new ScavengerTask(2, 2, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key1", "value", CacheItemPriority.High, null);
CacheItem itemToRemain = new CacheItem("key2", "value", CacheItemPriority.Low, null);
CacheItem itemToRemoveAlso = new CacheItem("key3", "value", CacheItemPriority.Normal, null);
itemToRemove.MakeEligibleForScavenging();
itemToRemain.MakeEligibleForScavenging();
itemToRemoveAlso.MakeEligibleForScavenging();
AddCacheItem("key1", itemToRemove);
AddCacheItem("key2", itemToRemain);
AddCacheItem("key3", itemToRemoveAlso);
scavenger.DoScavenging();
Assert.AreEqual("key2key3", scavengedKeys);
}
public void WillRemoveMultipleEligibleForScavenging()
{
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy(2);
ScavengerTask scavenger = new ScavengerTask(3, scavengingPolicy, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key1", "value", CacheItemPriority.High, null);
CacheItem itemToRemain = new CacheItem("key2", "value", CacheItemPriority.Low, null);
CacheItem itemToRemoveAlso = new CacheItem("key3", "value", CacheItemPriority.Normal, null);
itemToRemove.MakeEligibleForScavenging();
itemToRemain.MakeEligibleForScavenging();
itemToRemoveAlso.MakeEligibleForScavenging();
AddCacheItem("key1", itemToRemove);
AddCacheItem("key2", itemToRemain);
AddCacheItem("key3", itemToRemoveAlso);
scavenger.DoScavenging();
Assert.AreEqual("key2key3key1", scavengedKeys);
}
public CacheManager BuildCacheManager(
string cacheManagerName,
IBackingStore backingStore,
int maximumElementsInCacheBeforeScavenging,
int numberToRemoveWhenScavenging,
int expirationPollFrequencyInSeconds,
CachingInstrumentationProvider instrumentationProvider)
{
CacheCapacityScavengingPolicy scavengingPolicy =
new CacheCapacityScavengingPolicy(maximumElementsInCacheBeforeScavenging);
Cache cache = new Cache(backingStore, scavengingPolicy, instrumentationProvider);
ExpirationPollTimer timer = new ExpirationPollTimer();
ExpirationTask expirationTask = CreateExpirationTask(cache, instrumentationProvider);
ScavengerTask scavengerTask = new ScavengerTask(numberToRemoveWhenScavenging, scavengingPolicy, cache, instrumentationProvider);
BackgroundScheduler scheduler = new BackgroundScheduler(expirationTask, scavengerTask, instrumentationProvider);
cache.Initialize(scheduler);
scheduler.Start();
timer.StartPolling(new TimerCallback(scheduler.ExpirationTimeoutExpired), expirationPollFrequencyInSeconds * 1000);
return(new CacheManager(cache, scheduler, timer));
}
public void RemovalFailureDuringCacheScavengingDoesFireEvents()
{
ICacheOperations cacheOperations = new FailingOnRemovalCacheOperations();
CacheItem item = new CacheItem(key1, new object(), CacheItemPriority.Low, null);
cacheOperations.CurrentCacheState.Add(key1, item);
cacheOperations.CurrentCacheState.Add("differentKey", item);
ScavengerTask scavenging = new ScavengerTask(1, new CacheCapacityScavengingPolicy(1), cacheOperations, instrumentationProvider);
scavenging.DoScavenging();
// two events for each of the items failing to be scavenged, and one for the announcement
// that scavenging is finished with 0 items scavenged.
Assert.AreEqual(3, instrumentationListener.eventArgs.Count);
IList <CacheScavengedEventArgs> scavenges = FilterEventArgs <CacheScavengedEventArgs>(instrumentationListener.eventArgs);
IList <CacheFailureEventArgs> failures = FilterEventArgs <CacheFailureEventArgs>(instrumentationListener.eventArgs);
Assert.AreEqual(1, scavenges.Count);
Assert.AreEqual(2, failures.Count);
}
public void CacheScavengeDoesFireEvents()
{
ICacheOperations cacheOperations = new MockCacheOperations();
CacheItem item1 = new CacheItem(key1, new object(), CacheItemPriority.Low, null);
cacheOperations.CurrentCacheState.Add(key1, item1);
CacheItem item2 = new CacheItem(key2, new object(), CacheItemPriority.Low, null);
cacheOperations.CurrentCacheState.Add(key2, item2);
CacheItem item3 = new CacheItem(key3, new object(), CacheItemPriority.NotRemovable, null);
cacheOperations.CurrentCacheState.Add(key3, item3);
ScavengerTask scavenging = new ScavengerTask(2, new CacheCapacityScavengingPolicy(2), cacheOperations, instrumentationProvider);
scavenging.DoScavenging();
Assert.AreEqual(1, instrumentationListener.eventArgs.Count);
IList <CacheScavengedEventArgs> scavenges = FilterEventArgs <CacheScavengedEventArgs>(instrumentationListener.eventArgs);
Assert.AreEqual(1, scavenges.Count);
Assert.AreEqual(2L, scavenges[0].ItemsScavenged);
}
public void CanScavengeInBackground()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy(2);
ScavengerTask scavenger = new ScavengerTask(1, scavengingPolicy, this, instrumentationProvider);
BackgroundScheduler scheduler = new BackgroundScheduler(null, scavenger, instrumentationProvider);
scheduler.Start();
Thread.Sleep(500);
scheduler.StartScavenging();
Thread.Sleep(250);
scheduler.Stop();
Thread.Sleep(250);
Assert.AreEqual("key1", scavengedKeys);
}
public void WillRemoveSingleItemFromCache()
{
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 0;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
CacheItem itemToRemove = new CacheItem("key", "value", CacheItemPriority.Low, null);
itemToRemove.MakeEligibleForScavenging();
AddCacheItem("key", itemToRemove);
scavenger.DoScavenging();
Assert.AreEqual("key", scavengedKeys);
}
public void WillScavenge()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.NotRemovable, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.High, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.Normal, null);
CacheItem item4 = new CacheItem("key4", "value4", CacheItemPriority.Low, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
AddCacheItem("key4", item4);
ScavengerTask scavenger = new ScavengerTask(2, 1, this, instrumentationProvider);
scavenger.DoScavenging();
Assert.AreEqual("key4key3", scavengedKeys);
}
public void WillStopRemovingAtLimitForScavenging()
{
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy(2);
ScavengerTask scavenger = new ScavengerTask(2, scavengingPolicy, this, instrumentationProvider);
CacheItem itemToRemove = new CacheItem("key1", "value", CacheItemPriority.High, null);
CacheItem itemToRemain = new CacheItem("key2", "value", CacheItemPriority.Low, null);
CacheItem itemToRemoveAlso = new CacheItem("key3", "value", CacheItemPriority.Normal, null);
itemToRemove.MakeEligibleForScavenging();
itemToRemain.MakeEligibleForScavenging();
itemToRemoveAlso.MakeEligibleForScavenging();
AddCacheItem("key1", itemToRemove);
AddCacheItem("key2", itemToRemain);
AddCacheItem("key3", itemToRemoveAlso);
scavenger.DoScavenging();
Assert.AreEqual("key2key3", scavengedKeys);
}
public void WillNotScheduleNewScavengeTaskIfOneIsAlreadyScheduled()
{
inMemoryCacheRequestSemaphore = new EventWaitHandle(false, EventResetMode.ManualReset);
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.Normal, null);
CacheItem item4 = new CacheItem("key4", "value4", CacheItemPriority.Normal, null);
CacheItem item5 = new CacheItem("key5", "value5", CacheItemPriority.High, null);
CacheItem item6 = new CacheItem("key6", "value6", CacheItemPriority.High, null);
CacheItem item7 = new CacheItem("key7", "value7", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
ScavengerTask scavenger = new ScavengerTask(2, 3, this, instrumentationProvider);
BackgroundScheduler scheduler = new BackgroundScheduler(null, scavenger, instrumentationProvider);
AddCacheItem("key4", item4);
// this new scavenge request will be scheduled, it's the first one
scheduler.StartScavenging();
// the scavenge request scheduled above would be processed here and will be blocked by the event
Thread.Sleep(500);
AddCacheItem("key5", item5);
// this new scavenge request will be scheduled, because the previously scheduled one will have started
scheduler.StartScavenging();
Thread.Sleep(250);
AddCacheItem("key6", item6);
// this new scavenge request will be ignored
scheduler.StartScavenging();
Thread.Sleep(250);
AddCacheItem("key7", item7);
// this new scavenge request will be ignored
scheduler.StartScavenging();
Thread.Sleep(250);
bool value = inMemoryCacheRequestSemaphore.Set();
Thread.Sleep(250);
// 3 cache requests should be issued: one for "key4" for one element and two for the remaining elements
// since at most 2 elements are removed per scavenge
Assert.AreEqual(3, inMemoryCacheRequests);
}
public void WillScavengeNoItemsIfNumberOfItemsToScavengeIsZero()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.Low, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.Normal, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.High, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
ScavengerTask scavenger = new ScavengerTask(0, 2, this, instrumentationProvider);
scavenger.DoScavenging();
Assert.AreEqual("", scavengedKeys);
}
public void WillScavenge()
{
CacheItem item1 = new CacheItem("key1", "value1", CacheItemPriority.NotRemovable, null);
CacheItem item2 = new CacheItem("key2", "value2", CacheItemPriority.High, null);
CacheItem item3 = new CacheItem("key3", "value3", CacheItemPriority.Normal, null);
CacheItem item4 = new CacheItem("key4", "value4", CacheItemPriority.Low, null);
AddCacheItem("key1", item1);
AddCacheItem("key2", item2);
AddCacheItem("key3", item3);
AddCacheItem("key4", item4);
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 1;
view.GetCacheManagerSettings().CacheManagers["test"].NumberToRemoveWhenScavenging = 2;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
scavenger.DoScavenging();
Assert.AreEqual("key4key3", scavengedKeys);
}
public void WillNotDieIfNotEnoughItemsToScavenge()
{
TestConfigurationContext context = new TestConfigurationContext();
CachingConfigurationView view = new CachingConfigurationView(context);
view.GetCacheManagerSettings().CacheManagers["test"].MaximumElementsInCacheBeforeScavenging = 2;
view.GetCacheManagerSettings().CacheManagers["test"].NumberToRemoveWhenScavenging = 4;
CacheCapacityScavengingPolicy scavengingPolicy = new CacheCapacityScavengingPolicy("test", view);
ScavengerTask scavenger = new ScavengerTask("test", view, scavengingPolicy, this);
CacheItem itemToRemove = new CacheItem("key1", "value", CacheItemPriority.High, null);
CacheItem itemToRemain = new CacheItem("key2", "value", CacheItemPriority.Low, null);
CacheItem itemToRemoveAlso = new CacheItem("key3", "value", CacheItemPriority.Normal, null);
itemToRemove.MakeEligibleForScavenging();
itemToRemain.MakeEligibleForScavenging();
itemToRemoveAlso.MakeEligibleForScavenging();
AddCacheItem("key1", itemToRemove);
AddCacheItem("key2", itemToRemain);
AddCacheItem("key3", itemToRemoveAlso);
scavenger.DoScavenging();
Assert.AreEqual("key2key3key1", scavengedKeys);
}
/// <param name="expirationTask">Задание для экспиратора</param>
/// <param name="scavengerTask">Задание для сборщика</param>
/// <param name="instrumentationProvider"></param>
public BackgroundScheduler(ExpirationTask expirationTask, ScavengerTask scavengerTask, ICachingInstrumentationProvider instrumentationProvider)
{
this.expirationTask = expirationTask;
this.scavengerTask = scavengerTask;
this.instrumentationProvider = instrumentationProvider;
}
