public void TransferInAllDirections() { List <TransferItem> allItems = AllTransferDirectionTest.GetTransformItemsForAllDirections(resume: false); // Execution var result = this.RunTransferItems(allItems, new TestExecutionOptions <DMLibDataInfo>()); // Verify all files are transfered successfully Test.Assert(result.Exceptions.Count == 0, "Verify no exception occurs."); foreach (DMLibDataType destDataType in DataTypes) { if (DMLibDataType.Stream == destDataType || DMLibDataType.URI == destDataType) { continue; } DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(destDataType); DMLibDataInfo destDataInfo = destAdaptor.GetTransferDataInfo(string.Empty); foreach (FileNode destFileNode in destDataInfo.EnumerateFileNodes()) { FileNode sourceFileNode = expectedFileNodes[destFileNode.Name]; if (IsCloudService(destDataType)) { IDictionary <string, string> metadata = new Dictionary <string, string>(); metadata.Add("aa", "bb"); sourceFileNode.ContentLanguage = "EN"; sourceFileNode.Metadata = metadata; } Test.Assert(DMLibDataHelper.Equals(sourceFileNode, destFileNode), "Verify transfer result."); } } }
private static List <TransferItem> GetTransformItemsForAllSingleTransferDirections(bool resume) { List <TransferItem> allItems = new List <TransferItem>(); foreach (DMLibTransferDirection direction in GetAllValidDirections()) { if (resume && (direction.SourceType == DMLibDataType.Stream || direction.DestType == DMLibDataType.Stream)) { continue; } string fileName = GetTransferFileName(direction); DataAdaptor <DMLibDataInfo> sourceAdaptor = GetSourceAdaptor(direction.SourceType); DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(direction.DestType); FileNode fileNode = singleObjectNodes[fileName]; TransferItem item = new TransferItem() { SourceObject = sourceAdaptor.GetTransferObject(string.Empty, fileNode), DestObject = destAdaptor.GetTransferObject(string.Empty, fileNode), SourceType = direction.SourceType, DestType = direction.DestType, CopyMethod = direction.CopyMethod, TransferContext = new SingleTransferContext() { SetAttributesCallbackAsync = AllTransferDirectionTest.SetAttributesCallbackMethodAsync } }; allItems.Add(item); } return(allItems); }
private static List <TransferItem> GetTransformItemsForAllDirTransferDirections(bool resume) { List <TransferItem> allItems = new List <TransferItem>(); foreach (DMLibTransferDirection direction in GetAllDirectoryValidDirections()) { string dirName = GetTransferDirName(direction); DataAdaptor <DMLibDataInfo> sourceAdaptor = GetSourceAdaptor(direction.SourceType); DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(direction.DestType); DirNode dirNode = directoryNodes[dirName]; dynamic options = DMLibTestBase.GetDefaultTransferDirectoryOptions(direction.SourceType, direction.DestType); options.Recursive = true; TransferItem item = new TransferItem() { SourceObject = sourceAdaptor.GetTransferObject(string.Empty, dirNode), DestObject = destAdaptor.GetTransferObject(string.Empty, dirNode), SourceType = direction.SourceType, DestType = direction.DestType, CopyMethod = direction.CopyMethod, IsDirectoryTransfer = true, Options = options, TransferContext = new DirectoryTransferContext() { SetAttributesCallbackAsync = AllTransferDirectionTest.SetAttributesCallbackMethodAsync } }; allItems.Add(item); } return(allItems); }
public static void WaitUntilFileCreated(FileNode fileNode, DataAdaptor <DMLibDataInfo> dataAdaptor, DMLibDataType dataType, int timeoutInSec = 300) { Func <bool> checkFileCreated = null; if (dataType == DMLibDataType.Local) { string filePath = dataAdaptor.GetAddress() + fileNode.GetLocalRelativePath(); checkFileCreated = () => { return(File.Exists(filePath)); }; } else if (dataType == DMLibDataType.PageBlob || dataType == DMLibDataType.AppendBlob) { CloudBlobDataAdaptor blobAdaptor = dataAdaptor as CloudBlobDataAdaptor; checkFileCreated = () => { CloudBlob cloudBlob = blobAdaptor.GetCloudBlobReference(fileNode); return(cloudBlob.Exists(options: HelperConst.DefaultBlobOptions)); }; } else if (dataType == DMLibDataType.BlockBlob) { CloudBlobDataAdaptor blobAdaptor = dataAdaptor as CloudBlobDataAdaptor; checkFileCreated = () => { CloudBlockBlob blockBlob = blobAdaptor.GetCloudBlobReference(fileNode) as CloudBlockBlob; try { return(blockBlob.DownloadBlockList(BlockListingFilter.All, options: HelperConst.DefaultBlobOptions).Any()); } catch (StorageException) { return(false); } }; } else if (dataType == DMLibDataType.CloudFile) { CloudFileDataAdaptor fileAdaptor = dataAdaptor as CloudFileDataAdaptor; checkFileCreated = () => { CloudFile cloudFile = fileAdaptor.GetCloudFileReference(fileNode); return(cloudFile.Exists(options: HelperConst.DefaultFileOptions)); }; } else { Test.Error("Unexpected data type: {0}", DMLibTestContext.SourceType); } MultiDirectionTestHelper.WaitUntil(checkFileCreated, timeoutInSec); }
public void DummyDirectoryBlobDownload() { Dictionary <string, string> metadata = new Dictionary <string, string>(); metadata.Add(Constants.DirectoryBlobMetadataKey, "true"); Test.Info("Metadata is ====================="); foreach (var keyValue in metadata) { Test.Info("name:{0} value:{1}", keyValue.Key, keyValue.Value); } DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty); FileNode dummyFolderNode = new FileNode(DMLibTestBase.FileName) { SizeInByte = 0L, Metadata = metadata }; DirNode dirNode = new DirNode(DMLibTestBase.FileName); FileNode actualFile = new FileNode(DMLibTestBase.FileName) { SizeInByte = DMLibTestBase.FileSizeInKB * 1024L, }; dirNode.AddFileNode(actualFile); sourceDataInfo.RootNode.AddFileNode(dummyFolderNode); sourceDataInfo.RootNode.AddDirNode(dirNode); DMLibDataInfo destDataInfo = new DMLibDataInfo(string.Empty); var options = new TestExecutionOptions <DMLibDataInfo>(); options.DestTransferDataInfo = destDataInfo; options.DisableDestinationFetch = true; options.IsDirectoryTransfer = true; options.TransferItemModifier = (fileNode, transferItem) => { dynamic transferOptions = DefaultTransferDirectoryOptions; transferOptions.Recursive = true; transferItem.Options = transferOptions; }; var result = this.ExecuteTestCase(sourceDataInfo, options); Test.Assert(result.Exceptions.Count == 0, "Verify no exception is thrown."); DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(DMLibDataType.Local); destDataInfo = destAdaptor.GetTransferDataInfo(destDataInfo.RootPath); sourceDataInfo.RootNode.DeleteFileNode(DMLibTestBase.FileName); Test.Assert(DMLibDataHelper.Equals(sourceDataInfo, destDataInfo), "Verify transfer result."); }
private static List <TransferItem> GetTransformItemsForAllDirections(bool resume) { List <TransferItem> allItems = new List <TransferItem>(); foreach (DMLibTransferDirection direction in GetAllValidDirections()) { if (resume && (direction.SourceType == DMLibDataType.Stream || direction.DestType == DMLibDataType.Stream)) { continue; } string fileName = GetTransferFileName(direction); DataAdaptor <DMLibDataInfo> sourceAdaptor = GetSourceAdaptor(direction.SourceType); DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(direction.DestType); FileNode fileNode = singleObjectNodes[fileName]; TransferItem item = new TransferItem() { SourceObject = sourceAdaptor.GetTransferObject(string.Empty, fileNode), DestObject = destAdaptor.GetTransferObject(string.Empty, fileNode), SourceType = direction.SourceType, DestType = direction.DestType, IsServiceCopy = direction.IsAsync, }; allItems.Add(item); } foreach (DMLibTransferDirection direction in GetAllDirectoryValidDirections()) { string dirName = GetTransferDirName(direction); DataAdaptor <DMLibDataInfo> sourceAdaptor = GetSourceAdaptor(direction.SourceType); DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(direction.DestType); DirNode dirNode = directoryNodes[dirName]; dynamic options = DMLibTestBase.GetDefaultTransferDirectoryOptions(direction.SourceType, direction.DestType); options.Recursive = true; TransferItem item = new TransferItem() { SourceObject = sourceAdaptor.GetTransferObject(string.Empty, dirNode), DestObject = destAdaptor.GetTransferObject(string.Empty, dirNode), SourceType = direction.SourceType, DestType = direction.DestType, IsServiceCopy = direction.IsAsync, IsDirectoryTransfer = true, Options = options, }; allItems.Add(item); } return(allItems); }
private static void CleanupAllDestination() { // Clean up destination foreach (DMLibDataType destDataType in DataTypes) { if (destDataType != DMLibDataType.URI) { DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(destDataType); destAdaptor.Cleanup(); destAdaptor.CreateIfNotExists(); } } }
public void TransferInAllDirections() { List <TransferItem> allItems = AllTransferDirectionTest.GetTransformItemsForAllDirections(resume: false); // Execution var result = this.RunTransferItems(allItems, new TestExecutionOptions <DMLibDataInfo>()); // Verify all files are transfered successfully Test.Assert(result.Exceptions.Count == 0, "Verify no exception occurs."); foreach (DMLibDataType destDataType in DataTypes) { DataAdaptor <DMLibDataInfo> destAdaptor = GetSourceAdaptor(destDataType); DMLibDataInfo destDataInfo = destAdaptor.GetTransferDataInfo(string.Empty); foreach (FileNode destFileNode in destDataInfo.EnumerateFileNodes()) { FileNode sourceFileNode = expectedFileNodes[destFileNode.Name]; Test.Assert(DMLibDataHelper.Equals(sourceFileNode, destFileNode), "Verify transfer result."); } } }
public static void SetCalculatedFileMD5(DMLibDataInfo dataInfo, DataAdaptor <DMLibDataInfo> destAdaptor, bool disableMD5Check = false) { foreach (FileNode fileNode in dataInfo.EnumerateFileNodes()) { if (DMLibTestBase.IsCloudBlob(DMLibTestContext.DestType)) { CloudBlobDataAdaptor cloudBlobDataAdaptor = destAdaptor as CloudBlobDataAdaptor; CloudBlob cloudBlob = cloudBlobDataAdaptor.GetCloudBlobReference(fileNode); fileNode.MD5 = CloudBlobHelper.CalculateMD5ByDownloading(cloudBlob, disableMD5Check); } else if (DMLibTestContext.DestType == DMLibDataType.CloudFile) { CloudFileDataAdaptor cloudFileDataAdaptor = destAdaptor as CloudFileDataAdaptor; CloudFile cloudFile = cloudFileDataAdaptor.GetCloudFileReference(fileNode); fileNode.MD5 = CloudFileHelper.CalculateMD5ByDownloading(cloudFile, disableMD5Check); } // No need to set md5 for local destination } }
private static void PrepareSourceData() { PrepareDirSourceData(5 * 1024 * 1024); PrepareSingleObjectSourceData(5 * 1024 * 1024); // Generate source data foreach (var pair in sourceDataInfos) { DMLibDataType sourceDataType; if (Enum.TryParse <DMLibDataType>(pair.Key, out sourceDataType)) { DataAdaptor <DMLibDataInfo> sourceAdaptor = GetSourceAdaptor(sourceDataType); sourceAdaptor.Cleanup(); sourceAdaptor.CreateIfNotExists(); sourceAdaptor.GenerateData(pair.Value); } } // Generate source data for URI source separately since it's destination related DataAdaptor <DMLibDataInfo> uriSourceAdaptor = GetSourceAdaptor(DMLibDataType.URI); uriSourceAdaptor.Cleanup(); uriSourceAdaptor.CreateIfNotExists(); DMLibTestContext.SourceType = DMLibDataType.URI; DMLibTestContext.CopyMethod = DMLibCopyMethod.ServiceSideAsyncCopy; DMLibDataType[] uriDestDataTypes = { DMLibDataType.CloudFile, DMLibDataType.BlockBlob, DMLibDataType.PageBlob, DMLibDataType.AppendBlob }; foreach (DMLibDataType uriDestDataType in uriDestDataTypes) { DMLibTestContext.DestType = uriDestDataType; string sourceDataInfoKey = GetTransferString(DMLibDataType.URI, uriDestDataType, CopyMethod.ServiceSideAsyncCopy); uriSourceAdaptor.GenerateData(sourceDataInfos[sourceDataInfoKey]); } }
private List <TransferItem> GetTransformItemsForAllDirections(Dictionary <string, FileNode> fileNodes) { List <TransferItem> allItems = new List <TransferItem>(); foreach (DMLibTransferDirection direction in GetAllValidDirections()) { string fileName = GetTransferFileName(direction); DataAdaptor <DMLibDataInfo> sourceAdaptor = GetSourceAdaptor(direction.SourceType); DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(direction.DestType); FileNode fileNode = fileNodes[fileName]; TransferItem item = new TransferItem() { SourceObject = sourceAdaptor.GetTransferObject(fileNode), DestObject = destAdaptor.GetTransferObject(fileNode), SourceType = direction.SourceType, DestType = direction.DestType, IsServiceCopy = direction.IsAsync, }; allItems.Add(item); } return(allItems); }
protected static void SetDestAdaptor(TDataType dataType, DataAdaptor <TDataInfo> adaptor) { string key = MultiDirectionTestBase <TDataInfo, TDataType> .GetLocationKey(dataType); destAdaptors[key] = adaptor; }
private void ResumeInAllDirectionsHelper(bool directoryTransfer) { List <TransferItem> allItems = directoryTransfer ? AllTransferDirectionTest.GetTransformItemsForAllDirTransferDirections(resume: true) : AllTransferDirectionTest.GetTransformItemsForAllSingleTransferDirections(true); int fileCount = expectedFileNodes.Keys.Count; // Execution and store checkpoints CancellationTokenSource tokenSource = new CancellationTokenSource(); TransferContext transferContext = null; if (directoryTransfer) { transferContext = new DirectoryTransferContext(); } else { transferContext = new SingleTransferContext(); } var progressChecker = new ProgressChecker(fileCount, 1024 * fileCount); transferContext.ProgressHandler = progressChecker.GetProgressHandler(); allItems.ForEach(item => { item.CancellationToken = tokenSource.Token; item.TransferContext = transferContext; }); var options = new TestExecutionOptions <DMLibDataInfo>(); options.DisableDestinationFetch = true; // Checkpoint names const string PartialStarted = "PartialStarted", AllStarted = "AllStarted", AllStartedAndWait = "AllStartedAndWait", BeforeCancel = "BeforeCancel", AfterCancel = "AfterCancel"; Dictionary <string, TransferCheckpoint> checkpoints = new Dictionary <string, TransferCheckpoint>(); TransferItem randomItem = allItems[random.Next(0, allItems.Count)]; randomItem.AfterStarted = () => { Test.Info("Store check point after transfer item: {0}.", randomItem.ToString()); checkpoints.Add(PartialStarted, transferContext.LastCheckpoint); }; options.AfterAllItemAdded = () => { if (!progressChecker.DataTransferred.WaitOne(30000)) { Test.Error("No progress in 30s."); } checkpoints.Add(AllStarted, transferContext.LastCheckpoint); Thread.Sleep(1000); checkpoints.Add(AllStartedAndWait, transferContext.LastCheckpoint); Thread.Sleep(1000); checkpoints.Add(BeforeCancel, transferContext.LastCheckpoint); tokenSource.Cancel(); checkpoints.Add(AfterCancel, transferContext.LastCheckpoint); }; var result = this.RunTransferItems(allItems, options); // Resume with stored checkpoints in random order var checkpointList = new List <KeyValuePair <string, TransferCheckpoint> >(); checkpointList.AddRange(checkpoints); checkpointList.Shuffle(); foreach (var pair in checkpointList) { Test.Info("===Resume with checkpoint '{0}'===", pair.Key); options = new TestExecutionOptions <DMLibDataInfo>(); options.DisableDestinationFetch = true; progressChecker.Reset(); if (directoryTransfer) { transferContext = new DirectoryTransferContext(DMLibTestHelper.RandomReloadCheckpoint(pair.Value)) { ProgressHandler = progressChecker.GetProgressHandler(), // The checkpoint can be stored when DMLib doesn't check overwrite callback yet. // So it will case an skip file error if the desination file already exists and // We don't have overwrite callback here. ShouldOverwriteCallbackAsync = DMLibInputHelper.GetDefaultOverwiteCallbackY() }; } else { transferContext = new SingleTransferContext(DMLibTestHelper.RandomReloadCheckpoint(pair.Value)) { ProgressHandler = progressChecker.GetProgressHandler(), // The checkpoint can be stored when DMLib doesn't check overwrite callback yet. // So it will case an skip file error if the desination file already exists and // We don't have overwrite callback here. ShouldOverwriteCallbackAsync = DMLibInputHelper.GetDefaultOverwiteCallbackY() }; } int expectedFailureCount = 0; transferContext.FileFailed += (resource, eventArgs) => { TransferException exception = eventArgs.Exception as TransferException; if (null != exception && exception.ErrorCode == TransferErrorCode.MismatchCopyId) { Interlocked.Increment(ref expectedFailureCount); } }; TransferEventChecker eventChecker = new TransferEventChecker(); eventChecker.Apply(transferContext); List <TransferItem> itemsToResume = allItems.Select(item => { TransferItem itemToResume = item.Clone(); itemToResume.TransferContext = transferContext; return(itemToResume); }).ToList(); result = this.RunTransferItems(itemsToResume, options); foreach (DMLibDataType destDataType in DataTypes) { if (DMLibDataType.URI == destDataType) { continue; } DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(destDataType); DMLibDataInfo destDataInfo = destAdaptor.GetTransferDataInfo(string.Empty); foreach (FileNode destFileNode in destDataInfo.EnumerateFileNodes()) { string fileName = destFileNode.Name; FileNode sourceFileNode = expectedFileNodes[fileName]; Test.Assert(DMLibDataHelper.Equals(sourceFileNode, destFileNode), "Verify transfer result."); } } if (!directoryTransfer) { Test.Assert(result.Exceptions.Count == expectedFailureCount, "Verify no error happens. Expect {0}, Actual: {1}", expectedFailureCount, result.Exceptions.Count); } else { Test.Assert(result.Exceptions.Count == 0, "Verify no exception happens. Actual: {0}", result.Exceptions.Count); Test.Assert(eventChecker.FailedFilesNumber == expectedFailureCount, "Verify no unexpected error happens. Expect {0}, Actual: {1}", expectedFailureCount, eventChecker.FailedFilesNumber); } } }
private Dictionary <string, FileNode> PrepareSourceData(long fileSizeInB) { var sourceFileNodes = new Dictionary <string, FileNode>(); var sourceDataInfos = new Dictionary <string, DMLibDataInfo>(); // Prepare source data info foreach (DMLibTransferDirection direction in GetAllValidDirections()) { string fileName = GetTransferFileName(direction); DMLibDataInfo sourceDataInfo; string sourceDataInfoKey; if (direction.SourceType != DMLibDataType.URI) { sourceDataInfoKey = direction.SourceType.ToString(); } else { sourceDataInfoKey = GetTransferFileName(direction); } if (sourceDataInfos.ContainsKey(sourceDataInfoKey)) { sourceDataInfo = sourceDataInfos[sourceDataInfoKey]; } else { sourceDataInfo = new DMLibDataInfo(string.Empty); sourceDataInfos[sourceDataInfoKey] = sourceDataInfo; } DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, fileName, fileSizeInB); FileNode sourceFileNode = sourceDataInfo.RootNode.GetFileNode(fileName); sourceFileNodes.Add(fileName, sourceFileNode); } // Generate source data foreach (var pair in sourceDataInfos) { DMLibDataType sourceDataType; if (Enum.TryParse <DMLibDataType>(pair.Key, out sourceDataType)) { DataAdaptor <DMLibDataInfo> sourceAdaptor = GetSourceAdaptor(sourceDataType); sourceAdaptor.Cleanup(); sourceAdaptor.CreateIfNotExists(); sourceAdaptor.GenerateData(pair.Value); } } // Generate source data for URI source separately since it's destination related DataAdaptor <DMLibDataInfo> uriSourceAdaptor = GetSourceAdaptor(DMLibDataType.URI); uriSourceAdaptor.Cleanup(); uriSourceAdaptor.CreateIfNotExists(); DMLibTestContext.SourceType = DMLibDataType.URI; DMLibTestContext.IsAsync = true; DMLibDataType[] uriDestDataTypes = { DMLibDataType.CloudFile, DMLibDataType.BlockBlob, DMLibDataType.PageBlob, DMLibDataType.AppendBlob }; foreach (DMLibDataType uriDestDataType in uriDestDataTypes) { DMLibTestContext.DestType = uriDestDataType; string sourceDataInfoKey = GetTransferFileName(DMLibDataType.URI, uriDestDataType, true); uriSourceAdaptor.GenerateData(sourceDataInfos[sourceDataInfoKey]); } // Clean up destination foreach (DMLibDataType destDataType in DataTypes) { if (destDataType != DMLibDataType.URI) { DataAdaptor <DMLibDataInfo> destAdaptor = GetDestAdaptor(destDataType); destAdaptor.Cleanup(); destAdaptor.CreateIfNotExists(); } } return(sourceFileNodes); }
public void ResumeInAllDirections() { long fileSizeInByte = 10 * 1024 * 1024; Dictionary <string, FileNode> sourceFileNodes = this.PrepareSourceData(fileSizeInByte); List <TransferItem> allItems = this.GetTransformItemsForAllDirections(sourceFileNodes); int fileCount = sourceFileNodes.Keys.Count; // Execution and store checkpoints CancellationTokenSource tokenSource = new CancellationTokenSource(); var transferContext = new TransferContext(); var progressChecker = new ProgressChecker(fileCount, fileSizeInByte * fileCount); transferContext.ProgressHandler = progressChecker.GetProgressHandler(); allItems.ForEach(item => { item.CancellationToken = tokenSource.Token; item.TransferContext = transferContext; }); var options = new TestExecutionOptions <DMLibDataInfo>(); options.DisableDestinationFetch = true; // Checkpoint names const string PartialStarted = "PartialStarted", AllStarted = "AllStarted", AllStartedAndWait = "AllStartedAndWait", BeforeCancel = "BeforeCancel", AfterCancel = "AfterCancel"; Dictionary <string, TransferCheckpoint> checkpoints = new Dictionary <string, TransferCheckpoint>(); TransferItem randomItem = allItems[random.Next(0, allItems.Count)]; randomItem.AfterStarted = () => { Test.Info("Store check point after transfer item: {0}.", randomItem.ToString()); checkpoints.Add(PartialStarted, transferContext.LastCheckpoint); }; options.AfterAllItemAdded = () => { progressChecker.DataTransferred.WaitOne(); checkpoints.Add(AllStarted, transferContext.LastCheckpoint); Thread.Sleep(1000); checkpoints.Add(AllStartedAndWait, transferContext.LastCheckpoint); Thread.Sleep(1000); checkpoints.Add(BeforeCancel, transferContext.LastCheckpoint); tokenSource.Cancel(); checkpoints.Add(AfterCancel, transferContext.LastCheckpoint); }; var result = this.RunTransferItems(allItems, options); // Resume with stored checkpoints in random order var checkpointList = new List <KeyValuePair <string, TransferCheckpoint> >(); checkpointList.AddRange(checkpoints); checkpointList.Shuffle(); foreach (var pair in checkpointList) { Test.Info("===Resume with checkpoint '{0}'===", pair.Key); options = new TestExecutionOptions <DMLibDataInfo>(); options.DisableDestinationFetch = true; progressChecker.Reset(); transferContext = new TransferContext(pair.Value) { ProgressHandler = progressChecker.GetProgressHandler(), // The checkpoint can be stored when DMLib doesn't check overwrite callback yet. // So it will case an skip file error if the desination file already exists and // We don't have overwrite callback here. OverwriteCallback = DMLibInputHelper.GetDefaultOverwiteCallbackY() }; List <TransferItem> itemsToResume = allItems.Select(item => { TransferItem itemToResume = item.Clone(); itemToResume.TransferContext = transferContext; return(itemToResume); }).ToList(); result = this.RunTransferItems(itemsToResume, options); int resumeFailCount = 0; foreach (DMLibDataType destDataType in DataTypes) { DataAdaptor <DMLibDataInfo> destAdaptor = GetSourceAdaptor(destDataType); DMLibDataInfo destDataInfo = destAdaptor.GetTransferDataInfo(string.Empty); foreach (FileNode destFileNode in destDataInfo.EnumerateFileNodes()) { string fileName = destFileNode.Name; if (!fileName.Contains(DMLibDataType.Stream.ToString())) { FileNode sourceFileNode = sourceFileNodes[fileName]; Test.Assert(DMLibDataHelper.Equals(sourceFileNode, destFileNode), "Verify transfer result."); } else { resumeFailCount++; } } } Test.Assert(result.Exceptions.Count == resumeFailCount, "Verify resume failure count: expected {0}, actual {1}.", resumeFailCount, result.Exceptions.Count); foreach (var resumeException in result.Exceptions) { Test.Assert(resumeException is NotSupportedException, "Verify resume exception is NotSupportedException."); } } }