public void GetFileTest()
{
// arrange
int size = 1024;
byte[] bytes = new byte[size];
string url = DummyFileHelper.GetFileUrl(size);
var dummyData = DummyData.GenerateOrderedBytes(size);
// act
var headers = ReadAndGetHeaders(url, bytes);
// assert
Assert.IsTrue(dummyData.SequenceEqual(bytes));
Assert.AreEqual(size.ToString(), headers["Content-Length"]);
Assert.AreEqual(contentType, headers["Content-Type"]);
}
private void TestStreamIntegrity(int streamSize, long maximumBytesPerSecond)
{
// arrange
byte[] data = DummyData.GenerateOrderedBytes(streamSize);
byte[] copiedData = new byte[streamSize];
using Stream stream = new ThrottledStream(new MemoryStream(), maximumBytesPerSecond);
// act
stream.Write(data, 0, data.Length);
stream.Seek(0, SeekOrigin.Begin);
stream.Read(copiedData, 0, copiedData.Length);
// assert
Assert.AreEqual(streamSize, data.Length);
Assert.AreEqual(streamSize, copiedData.Length);
Assert.IsTrue(data.SequenceEqual(copiedData));
}
public virtual void Initial()
{
var testData = DummyData.GenerateOrderedBytes(DummyFileHelper.FileSize16Kb);
_package = new DownloadPackage()
{
FileName = DummyFileHelper.SampleFile16KbName,
Address = DummyFileHelper.GetFileWithNameUrl(DummyFileHelper.SampleFile16KbName, DummyFileHelper.FileSize16Kb),
Chunks = new ChunkHub(Configuration).ChunkFile(DummyFileHelper.FileSize16Kb, 8),
TotalFileSize = DummyFileHelper.FileSize16Kb
};
foreach (var chunk in _package.Chunks)
{
chunk.Storage.WriteAsync(testData, (int)chunk.Start, (int)chunk.Length);
}
}
public void TestSetValidPositionWhenStorageChanged()
{
// arrange
var nextPosition = 512;
var chunk = new Chunk(0, 1024)
{
Position = 1,
Storage = Storage
};
// act
Storage.WriteAsync(DummyData.GenerateRandomBytes(nextPosition), 0, nextPosition);
chunk.SetValidPosition();
// assert
Assert.AreEqual(nextPosition, chunk.Position);
}
public void TestStreamWrite()
{
var size = 1024;
var bytesPerSecond = 256; // 32 B/s
var randomBytes = DummyData.GenerateRandomBytes(size);
using Stream tar = new ThrottledStream(new MemoryStream(), bytesPerSecond);
tar.Seek(0, SeekOrigin.Begin);
var start = Environment.TickCount64;
tar.Write(randomBytes, 0, randomBytes.Length);
var elapsed = Environment.TickCount64 - start;
var expectedTime = (size / bytesPerSecond) * 1000;
Assert.IsTrue(elapsed >= expectedTime);
}
public void IsDownloadCompletedWhenMemoryStorageDataIsExistTest()
{
// arrange
var size = 1024;
var chunk = new Chunk(0, size - 1)
{
Storage = new MemoryStorage(size),
Position = size - 1
};
chunk.Storage.WriteAsync(DummyData.GenerateRandomBytes(size), 0, size).Wait();
// act
bool isDownloadCompleted = chunk.IsDownloadCompleted();
// assert
Assert.IsTrue(isDownloadCompleted);
}
public virtual void Initial()
{
var testData = DummyData.GenerateOrderedBytes(DownloadTestHelper.FileSize16Kb);
Package = new DownloadPackage()
{
FileName = DownloadTestHelper.File16KbName,
Address = DownloadTestHelper.File16KbUrl,
Chunks = new ChunkHub(Configuration).ChunkFile(DownloadTestHelper.FileSize16Kb, 8),
TotalFileSize = DownloadTestHelper.FileSize16Kb
};
foreach (var chunk in Package.Chunks)
{
chunk.Storage.WriteAsync(testData, (int)chunk.Start, (int)chunk.Length);
Package.AddReceivedBytes(chunk.Length);
}
}
public void ReadStreamTimeoutExceptionTest()
{
// arrange
var streamSize = 20480;
var randomlyBytes = DummyData.GenerateRandomBytes(streamSize);
var chunk = new Chunk(0, streamSize - 1)
{
Timeout = 100
};
var chunkDownloader = new ChunkDownloader(chunk, _configuration);
using var memoryStream = new MemoryStream(randomlyBytes);
var canceledToken = new CancellationToken(true);
// act
async Task CallReadStream() => await chunkDownloader.ReadStream(new MemoryStream(), canceledToken).ConfigureAwait(false);
// assert
Assert.ThrowsExceptionAsync <OperationCanceledException>(CallReadStream);
}
private void TestStreamWriteSpeed(ThrottledStreamWrite writeMethod)
{
// arrange
var size = 1024;
var bytesPerSecond = 256; // 256 B/s
var tolerance = 50; // 50 ms
var expectedTime = (size / bytesPerSecond) * 1000; // 4000 Milliseconds
var randomBytes = DummyData.GenerateRandomBytes(size);
using Stream stream = new ThrottledStream(new MemoryStream(), bytesPerSecond);
var stopWatcher = Stopwatch.StartNew();
// act
writeMethod(stream, randomBytes, 0, randomBytes.Length);
stopWatcher.Stop();
// assert
Assert.IsTrue(stopWatcher.ElapsedMilliseconds + tolerance >= expectedTime,
$"actual duration is: {stopWatcher.ElapsedMilliseconds}ms");
}
public void TestPackageSituationAfterDispose()
{
// arrange
var sampleDataLength = 1024;
Package.TotalFileSize = sampleDataLength * 64;
Package.Chunks = new[] { new Chunk(0, Package.TotalFileSize) };
Package.Chunks[0].Storage = new MemoryStorage();
Package.Chunks[0].Storage.WriteAsync(DummyData.GenerateRandomBytes(sampleDataLength), 0, sampleDataLength);
Package.Chunks[0].SetValidPosition();
// act
Dispose();
// assert
Assert.IsNotNull(Package.Chunks);
Assert.AreEqual(sampleDataLength, Package.ReceivedBytesSize);
Assert.AreEqual(sampleDataLength * 64, Package.TotalFileSize);
Package.Clear();
}
public void TestStreamRead()
{
var size = 1024;
var bytesPerSecond = 256; // 256 B/s
var randomBytes = DummyData.GenerateRandomBytes(size);
using Stream src = new ThrottledStream(new MemoryStream(randomBytes), bytesPerSecond);
src.Seek(0, SeekOrigin.Begin);
byte[] buf = new byte[bytesPerSecond];
int read = 1;
long start = Environment.TickCount64;
while (read > 0)
{
read = src.Read(buf, 0, buf.Length);
}
long elapsed = Environment.TickCount64 - start;
var expectedTime = (size / bytesPerSecond) * 1000;
Assert.IsTrue(elapsed >= expectedTime);
}
public void TestPackageChunksDataAfterDispose()
{
// arrange
var dummyData = DummyData.GenerateOrderedBytes(1024);
Package.Chunks = new ChunkHub(Options).ChunkFile(1024 * 64, 64);
foreach (var chunk in Package.Chunks)
{
chunk.Storage.WriteAsync(dummyData, 0, 1024).Wait();
}
// act
Dispose();
// assert
Assert.IsNotNull(Package.Chunks);
foreach (var chunk in Package.Chunks)
{
Assert.IsTrue(DummyFileHelper.AreEqual(dummyData, chunk.Storage.OpenRead()));
}
Package.Clear();
}
private void MergeChunksTest(bool onTheFly)
{
// arrange
var fileSize = 10240;
var chunkCount = 8;
var counter = 0;
_configuration.OnTheFlyDownload = onTheFly;
var chunkHub = new ChunkHub(_configuration);
var mergedFilename = FileHelper.GetTempFile("");
Chunk[] chunks = chunkHub.ChunkFile(fileSize, chunkCount);
List <byte[]> chunksData = new List <byte[]>();
foreach (Chunk chunk in chunks)
{
var dummyBytes = DummyData.GenerateRandomBytes((int)chunk.Length);
chunksData.Add(dummyBytes);
chunk.Storage.WriteAsync(dummyBytes, 0, dummyBytes.Length).Wait();
}
// act
chunkHub.MergeChunks(chunks, mergedFilename).Wait();
// assert
Assert.IsTrue(File.Exists(mergedFilename));
var mergedData = File.ReadAllBytes(mergedFilename);
foreach (byte[] chunkData in chunksData)
{
foreach (var byteOfChunkData in chunkData)
{
Assert.AreEqual(byteOfChunkData, mergedData[counter++]);
}
}
}
