public void Pausing_With_Parallel_Block_Read_In_Progress_Should_Work()
        {
            ThreadPool.QueueUserWorkItem(cb =>
            {
                Thread.Sleep(200);
                try
                {
                    PauseAndVerifyStatusIsPaused();
                }
                catch (Exception e)
                {
                    Assert.Fail(e.Message);
                }
            });

            ThreadPool.QueueUserWorkItem(cb =>
            {
                try
                {
                    Downloads.ReadBlock(Token.TransferId, 1);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    Assert.Fail("Got an exception while reading block.");
                }
            });

            Thread.Sleep(3000);
        }
        public void If_File_Size_Is_Not_Multitude_Of_Block_Size_Then_Last_Block_Should_Be_Smaller_Then_Others()
        {
            var maxSize = Downloads.MaxBlockSize ?? 2048;

            //upload a file that consists of a total of 5.5 (6) blocks
            File.WriteAllBytes(Context.DownloadFile0Template.FullName, new byte[maxSize * 5 + maxSize / 2]);
            Context.DownloadFile0Template.Refresh();
            SourceFile = Context.DownloadFolder.AddFile(Context.DownloadFile0Template.FullName, "multiple.bin", false);

            Downloads.CancelTransfer(Token.TransferId, AbortReason.ClientAbort);
            Token = Downloads.RequestDownloadToken(SourceFileInfo.FullName, false, maxSize);

            Assert.AreEqual(maxSize, Token.DownloadBlockSize);
            Assert.AreEqual(6, Token.TotalBlockCount);


            List <BufferedDataBlock> blockList = new List <BufferedDataBlock>();

            int blockNumber = 0;

            while (true)
            {
                BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, blockNumber++);
                blockList.Add(block);
                if (block.IsLastBlock)
                {
                    break;
                }
            }

            Assert.AreEqual(6, blockList.Count);
            Assert.AreEqual(maxSize / 2, blockList[5].BlockLength);
        }
        public void Request_Should_Throw_Expiration_Exception()
        {
            //expire and wait for the scheduler to readjust
            SystemTime.Now = () => Token.ExpirationTime.Value.AddSeconds(1);
            Thread.CurrentThread.Join(500);

            Downloads.ReadBlock(Token.TransferId, 0);
        }
        public void Requesting_First_Block_Multiple_Times_Should_Work()
        {
            var block1 = Downloads.ReadBlock(Token.TransferId, 0);
            var block2 = Downloads.ReadBlock(Token.TransferId, 0);

            Assert.AreEqual(block1.BlockNumber, block2.BlockNumber);
            Assert.AreEqual(block1.BlockLength, block2.BlockLength);
            Assert.AreNotEqual(0, block1.Data.Length);
            CollectionAssert.AreEqual(block1.Data, block2.Data);
        }
        public void Pausing_Should_Be_Possible_After_Having_Read_Last_Block()
        {
            CompleteReading();
            PauseAndVerifyStatusIsPaused();

            //read last block again
            var copy = Downloads.ReadBlock(Token.TransferId, recentBlock.BlockNumber);

            CollectionAssert.AreEqual(recentBlock.Data, copy.Data);
        }
        public void Resuming_Reading_Should_Switch_Status_Back_To_Running()
        {
            Downloads.ReadBlock(Token.TransferId, 0);
            PauseAndVerifyStatusIsPaused();

            //read next block
            Downloads.ReadBlock(Token.TransferId, 1);
            var status = Downloads.GetTransferStatus(Token.TransferId);

            Assert.AreEqual(TransferStatus.Running, status);
        }
        private void CompleteReading()
        {
            while (recentBlock == null || recentBlock.IsLastBlock == false)
            {
                long nextBlock = recentBlock == null ? 0 : recentBlock.BlockNumber + 1;
                var  block     = Downloads.ReadBlock(Token.TransferId, nextBlock);
                ReceiveBlock(block);
            }

            //make sure we have an exact copy
            FileAssert.AreEqual(Context.DownloadFile0Template.FullName, TargetFilePath);
        }
        public void Requesting_Random_Block_Numbers_Should_Work()
        {
            for (int i = 0; i < 10; i++)
            {
                Downloads.ReadBlock(Token.TransferId, i);
            }

            var block20     = Downloads.ReadBlock(Token.TransferId, 20);
            var block4      = Downloads.ReadBlock(Token.TransferId, 4);
            var block20Copy = Downloads.ReadBlock(Token.TransferId, 20);

            Assert.AreEqual(block20.Data, block20Copy.Data);
        }
        public void Number_Of_Available_Blocks_Should_Match_Token()
        {
            long blockNumber = 0;

            //request data using block numbers according to token info
            for (int i = 0; i < Token.TotalBlockCount; i++)
            {
                BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, blockNumber++);
                ReceiveBlock(block);
            }

            //make sure we got all the data
            FileAssert.AreEqual(Context.DownloadFile0Template.FullName, TargetFilePath);
        }
예제 #10
0
        public void Requesting_Block_Size_With_Specified_Value_Should_Be_Allowed_If_Service_Does_Not_Have_Limit()
        {
            if (Downloads.MaxBlockSize.HasValue)
            {
                Assert.Inconclusive("Download service has a maximum block size - did not run test.");
            }

            var blockSize = 2048;

            Token = Downloads.RequestDownloadToken(SourceFileInfo.FullName, false, blockSize);
            Assert.AreEqual(blockSize, Token.DownloadBlockSize);

            BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, 0);

            Assert.AreEqual(blockSize, block.BlockLength);
            Assert.AreEqual(blockSize, block.Data.Length);
        }
예제 #11
0
        public void Requesting_Token_With_Block_Size_Below_Maximum_Should_Return_Small_Blocks()
        {
            if (!Downloads.MaxBlockSize.HasValue)
            {
                Assert.Inconclusive("Download service does not provide maximum block size");
            }

            var blockSize = Downloads.MaxBlockSize.Value / 2;

            Token = Downloads.RequestDownloadToken(SourceFileInfo.FullName, false, blockSize);
            Assert.AreEqual(blockSize, Token.DownloadBlockSize);

            BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, 0);

            Assert.AreEqual(blockSize, block.BlockLength);
            Assert.AreEqual(blockSize, block.Data.Length);
        }
        public void Requesting_New_Block_Should_Fail_Once_The_Token_Expired()
        {
            try
            {
                Downloads.ReadBlock(Token.TransferId, 0);
            }
            catch
            {
                Assert.Fail("Reading first block should have worked.");
            }

            //expire and wait for the scheduler to readjust
            SystemTime.Now = () => Token.ExpirationTime.Value.AddSeconds(1);
            Thread.CurrentThread.Join(500);

            Downloads.ReadBlock(Token.TransferId, 1);
        }
예제 #13
0
        public void Requesting_Token_With_Block_Size_Above_Max_Size_Should_Fall_Back_To_Maxium()
        {
            if (!Downloads.MaxBlockSize.HasValue)
            {
                Assert.Inconclusive("Download service does not provide maximum block size");
            }

            var expectedSize = Downloads.MaxBlockSize.Value;
            var blockSize    = expectedSize + 10000;

            Token = Downloads.RequestDownloadToken(SourceFileInfo.FullName, false, blockSize);
            Assert.AreEqual(expectedSize, Token.DownloadBlockSize);

            BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, 0);

            Assert.AreEqual(expectedSize, block.BlockLength);
            Assert.AreEqual(expectedSize, block.Data.Length);
        }
        public void Reading_Blocks_Should_Deliver_All_Data()
        {
            long blockNumber = 0;

            //read blocks until last block is indicated
            while (true)
            {
                BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, blockNumber++);
                ReceiveBlock(block);

                if (block.IsLastBlock)
                {
                    break;
                }
            }

            //make sure we got all the data
            FileAssert.AreEqual(Context.DownloadFile0Template.FullName, TargetFilePath);
        }
        public void All_But_Last_Block_Should_Indicate_There_Is_More_Data()
        {
            List <BufferedDataBlock> blockList = new List <BufferedDataBlock>();

            int blockNumber = 0;

            while (true)
            {
                BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, blockNumber++);
                blockList.Add(block);
                if (block.IsLastBlock)
                {
                    break;
                }
            }

            Assert.Greater(blockList.Count, 1);
            Assert.IsTrue(blockList.Last().IsLastBlock);
            blockList.RemoveAt(blockList.Count - 1);
            blockList.ForEach(b => Assert.IsFalse(b.IsLastBlock));
        }
        public void Requesting_Last_Block_Multiple_Times_Should_Work()
        {
            long blockNumber = 0;
            BufferedDataBlock block;

            while (true)
            {
                block = Downloads.ReadBlock(Token.TransferId, blockNumber++);
                if (block.IsLastBlock)
                {
                    break;
                }
            }

            Assert.IsTrue(block.IsLastBlock);

            BufferedDataBlock copy = Downloads.ReadBlock(Token.TransferId, block.BlockNumber);

            Assert.AreEqual(block.BlockNumber, copy.BlockNumber);
            CollectionAssert.AreEqual(block.Data, copy.Data);
        }
        public void Service_Should_Always_Return_Same_Data()
        {
            List <BufferedDataBlock> blockList = new List <BufferedDataBlock>();

            long blockNumber = 0;

            while (true)
            {
                BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, blockNumber++);
                blockList.Add(block);
                if (block.IsLastBlock)
                {
                    break;
                }
            }

            for (int i = 0; i < blockList.Count; i++)
            {
                BufferedDataBlock block = blockList[i];
                BufferedDataBlock copy  = Downloads.ReadBlock(Token.TransferId, i);

                Assert.AreEqual(block.BlockLength, copy.BlockLength);
                Assert.AreEqual(block.BlockNumber, copy.BlockNumber);
                CollectionAssert.AreEqual(block.Data, copy.Data);
                Assert.AreEqual(block.Offset, copy.Offset);
            }

            //the same in the other direction
            for (int i = blockList.Count - 1; i >= 0; i--)
            {
                BufferedDataBlock block = blockList[i];
                BufferedDataBlock copy  = Downloads.ReadBlock(Token.TransferId, i);

                Assert.AreEqual(block.BlockLength, copy.BlockLength);
                Assert.AreEqual(block.BlockNumber, copy.BlockNumber);
                CollectionAssert.AreEqual(block.Data, copy.Data);
                Assert.AreEqual(block.Offset, copy.Offset);
            }
        }
        public void Received_Blocks_Should_Indicate_Offset_Within_Resource()
        {
            long blockNumber = 0;

            var timestamp = DateTimeOffset.Now.AddMinutes(5);

            SystemTime.Now = () => timestamp;
            while (true)
            {
                BufferedDataBlock block = Downloads.ReadBlock(Token.TransferId, blockNumber++);
                if (block.BlockNumber != 0)
                {
                    Assert.AreEqual(new FileInfo(TargetFilePath).Length, block.Offset);
                }

                ReceiveBlock(block);
                if (block.IsLastBlock)
                {
                    break;
                }
            }
        }
 public void Random_Block_Access_Should_Be_Possible()
 {
     Downloads.ReadBlock(Token.TransferId, 5);
     Downloads.ReadBlock(Token.TransferId, 7);
     Downloads.ReadBlock(Token.TransferId, 4);
 }
 public void Pausing_Should_Be_Possible_After_Having_Started_Downloading()
 {
     Downloads.ReadBlock(Token.TransferId, 0);
     PauseAndVerifyStatusIsPaused();
     CompleteReading();
 }
 public void Status_Should_Have_Been_Adjusted_After_Reading_First_Block()
 {
     Assert.AreEqual(TransferStatus.Starting, Downloads.GetTransferStatus(Token.TransferId));
     Downloads.ReadBlock(Token.TransferId, 0);
     Assert.AreEqual(TransferStatus.Running, Downloads.GetTransferStatus(Token.TransferId));
 }
 public void Submitting_Block_Number_Above_Total_Blocks_Should_Fail()
 {
     Downloads.ReadBlock(Token.TransferId, Token.TotalBlockCount);
 }
 public void Submitting_Negative_Block_Number_Should_Fail()
 {
     Downloads.ReadBlock(Token.TransferId, -1);
 }