public void GetTile_TileNotCachedAnywhere_GetTileAsynchronouslyFromTileProvider()
{
// Setup
var info = new TileInfo();
var data = new byte[0];
var mocks = new MockRepository();
var tileProvider = mocks.Stub <ITileProvider>();
tileProvider.Stub(tp => tp.GetTile(info)).Return(data);
var persistentCache = mocks.Stub <ITileCache <byte[]> >();
persistentCache.Stub(c => c.Find(info.Index)).Return(null);
persistentCache.Expect(c => c.Add(info.Index, data));
mocks.ReplayAll();
using (var fetcherIsDoneEvent = new AutoResetEvent(false))
using (var fetcher = new AsyncTileFetcher(tileProvider, 100, 200, persistentCache))
{
TileReceivedEventArgs receivedArguments = null;
var tileReceivedCounter = 0;
fetcher.TileReceived += (sender, args) =>
{
receivedArguments = args;
tileReceivedCounter++;
};
var queueEmptyCounter = 0;
fetcher.QueueEmpty += (sender, args) =>
{
queueEmptyCounter++;
fetcherIsDoneEvent.Set();
};
// Call
byte[] fetchedData = fetcher.GetTile(info);
// Assert
Assert.IsNull(fetchedData,
"Tile data hasn't been cached, so it has to be retrieved asynchronously.");
if (fetcherIsDoneEvent.WaitOne(allowedTileFetchTime))
{
Assert.AreEqual(1, tileReceivedCounter);
Assert.AreSame(data, receivedArguments.Tile);
Assert.AreSame(info, receivedArguments.TileInfo);
Assert.AreEqual(1, queueEmptyCounter);
}
else
{
Assert.Fail("TileFetcher did not respond within timelimit.");
}
}
mocks.VerifyAll();
}
public void Constructor_ValidArguments_ExpectedValues()
{
// Setup
var tileInfo = new TileInfo();
var tileData = new byte[0];
// Call
var eventArgs = new TileReceivedEventArgs(tileInfo, tileData);
// Assert
Assert.AreSame(tileInfo, eventArgs.TileInfo);
Assert.AreSame(tileData, eventArgs.Tile);
}
public void GivenTileFetcherWithoutCachedTile_WhenGettingTileFailsForFirstTime_ThenTileFetcherTriesSecondTime()
{
// Setup
var info = new TileInfo();
var data = new byte[0];
var mocks = new MockRepository();
var tileProvider = mocks.Stub <ITileProvider>();
using (mocks.Ordered())
{
var callCount = 0;
tileProvider.Stub(tp => tp.GetTile(info))
.WhenCalled(invocation =>
{
if (++callCount == 1)
{
throw new Exception("1st attempt fails.");
}
})
.Return(data);
}
var persistentCache = mocks.Stub <ITileCache <byte[]> >();
persistentCache.Stub(c => c.Find(info.Index)).Return(null);
persistentCache.Expect(c => c.Add(info.Index, data));
mocks.ReplayAll();
using (var fetcherIsDoneEvent = new AutoResetEvent(false))
using (var fetcher = new AsyncTileFetcher(tileProvider, 100, 200, persistentCache))
{
TileReceivedEventArgs receivedArguments = null;
var tileReceivedCounter = 0;
fetcher.TileReceived += (sender, args) =>
{
receivedArguments = args;
tileReceivedCounter++;
};
var queueEmptyCounter = 0;
fetcher.QueueEmpty += (sender, args) =>
{
queueEmptyCounter++;
fetcherIsDoneEvent.Set();
};
// Call
byte[] fetchedData = fetcher.GetTile(info);
// Assert
Assert.IsNull(fetchedData,
"Tile data hasn't been cached, so it has to be retrieved asynchronously.");
if (fetcherIsDoneEvent.WaitOne(allowedTileFetchTime))
{
Assert.AreEqual(1, tileReceivedCounter);
Assert.AreSame(data, receivedArguments.Tile);
Assert.AreSame(info, receivedArguments.TileInfo);
Assert.AreEqual(1, queueEmptyCounter);
}
else
{
Assert.Fail("TileFetcher did not respond within timelimit.");
}
mocks.VerifyAll();
}
}
public void GivenTileFetcherWithoutCachedTile_WhenGettingSameTimeMultipleTimes_IgnoreDuplicateRequests()
{
// Given
var info = new TileInfo();
var data = new byte[0];
using (var allRequestsDoneEvent = new ManualResetEvent(false))
{
var tileProvider = new TileProviderStub(allRequestsDoneEvent)
{
TileDataToReturn = data
};
using (var fetcherIsDoneEvent = new ManualResetEvent(false))
using (var fetcher = new AsyncTileFetcher(tileProvider, 100, 200))
{
TileReceivedEventArgs receivedArguments = null;
var tileReceivedCounter = 0;
fetcher.TileReceived += (sender, args) =>
{
receivedArguments = args;
tileReceivedCounter++;
};
var queueEmptyCounter = 0;
fetcher.QueueEmpty += (sender, args) =>
{
queueEmptyCounter++;
fetcherIsDoneEvent.Set();
};
// When
byte[] fetchedData1 = fetcher.GetTile(info);
byte[] fetchedData2 = fetcher.GetTile(info);
byte[] fetchedData3 = fetcher.GetTile(info);
byte[] fetchedData4 = fetcher.GetTile(info);
Assert.IsTrue(allRequestsDoneEvent.Set());
// Assert
if (fetcherIsDoneEvent.WaitOne(allowedTileFetchTime))
{
Assert.AreEqual(1, tileProvider.GetTileCallCount);
Assert.AreEqual(1, tileReceivedCounter);
Assert.AreSame(data, receivedArguments.Tile);
Assert.AreSame(info, receivedArguments.TileInfo);
Assert.AreEqual(1, queueEmptyCounter);
}
else
{
Assert.Fail("TileFetcher did not respond within timelimit.");
}
Assert.IsNull(fetchedData1, "Tile data hasn't been cached, so it has to be retrieved asynchronously.");
Assert.IsNull(fetchedData2, "Tile data hasn't been cached, so it has to be retrieved asynchronously.");
Assert.IsNull(fetchedData3, "Tile data hasn't been cached, so it has to be retrieved asynchronously.");
Assert.IsNull(fetchedData4, "Tile data hasn't been cached, so it has to be retrieved asynchronously.");
}
}
}
