public TestResult <DMLibDataInfo> RunTransferItems(List <TransferItem> items, TestExecutionOptions <DMLibDataInfo> options)
        {
            Dictionary <TransferItem, Task <TransferStatus> > allTasks = new Dictionary <TransferItem, Task <TransferStatus> >();
            var testResult = new TestResult <DMLibDataInfo>();

            testResult.TransferItems = items;

            try
            {
                foreach (TransferItem item in items)
                {
                    DMLibWrapper wrapper = GetDMLibWrapper(item.SourceType, item.DestType, DMLibTestContext.IsAsync);

                    if (item.BeforeStarted != null)
                    {
                        item.BeforeStarted();
                    }

                    try
                    {
                        if (options.LimitSpeed)
                        {
                            OperationContext.GlobalSendingRequest            += this.LimitSpeed;
                            TransferManager.Configurations.ParallelOperations = DMLibTestConstants.LimitedSpeedNC;
                        }

                        if (options.BlockSize.HasValue)
                        {
                            TransferManager.Configurations.BlockSize = options.BlockSize.Value;
                        }

                        allTasks.Add(item, wrapper.DoTransfer(item));
                    }
                    catch (Exception e)
                    {
                        testResult.AddException(e);
                    }

                    if (item.AfterStarted != null)
                    {
                        item.AfterStarted();
                    }
                }

                if (options.AfterAllItemAdded != null)
                {
                    options.AfterAllItemAdded();
                }

                try
                {
                    Task.WaitAll(allTasks.Values.ToArray(), options.TimeoutInMs);
                }
                catch (Exception e)
                {
                    AggregateException ae = e as AggregateException;
                    if (ae != null)
                    {
                        ae = ae.Flatten();
                        foreach (var innerE in ae.InnerExceptions)
                        {
                            testResult.AddException(innerE);
                        }
                    }
                    else
                    {
                        testResult.AddException(e);
                    }
                }
            }
            finally
            {
                if (options.LimitSpeed)
                {
                    OperationContext.GlobalSendingRequest            -= this.LimitSpeed;
                    TransferManager.Configurations.ParallelOperations = DMLibTestConstants.DefaultNC;
                }
                TransferManager.Configurations.BlockSize = DMLibTestConstants.DefaultBlockSize;
            }

            Parallel.ForEach(allTasks, pair =>
            {
                TransferItem transferItem  = pair.Key;
                Task <TransferStatus> task = pair.Value;

                transferItem.CloseStreamIfNecessary();

                try
                {
                    transferItem.FinalStatus = task.Result;
                }
                catch (Exception e)
                {
                    transferItem.Exception = e;
                }
            });

            if (!options.DisableDestinationFetch)
            {
                testResult.DataInfo = DestAdaptor.GetTransferDataInfo(string.Empty);
            }

            foreach (var exception in testResult.Exceptions)
            {
                Test.Info("Exception from DMLib: {0}", exception.ToString());
            }

            return(testResult);
        }