public void TestProgress() { var listener = new TaskListener(); float progress = 0f; listener.OnProgress += (p) => progress = p; Assert.AreEqual(0f, listener.Progress, Delta); Assert.AreEqual(0f, listener.TotalProgress, Delta); Assert.AreEqual(0f, progress, Delta); listener.SetProgress(-1f); Assert.AreEqual(0f, listener.Progress, Delta); Assert.AreEqual(0f, listener.TotalProgress, Delta); Assert.AreEqual(0f, progress, Delta); listener.SetProgress(0.5f); Assert.AreEqual(0.5f, listener.Progress, Delta); Assert.AreEqual(0.5f, listener.TotalProgress, Delta); Assert.AreEqual(0.5f, progress, Delta); listener.SetProgress(1.1f); Assert.AreEqual(1f, listener.Progress, Delta); Assert.AreEqual(1f, listener.TotalProgress, Delta); Assert.AreEqual(1f, progress, Delta); }
public void TestHasOwnProgress() { var listener = new TaskListener(); Assert.IsTrue(listener.HasOwnProgress); listener.SetProgress(0.5f); Assert.AreEqual(0.5f, listener.Progress, Delta); Assert.AreEqual(0.5f, listener.TotalProgress, Delta); var subListener = listener.CreateSubListener(); Assert.AreEqual(0.5f, listener.Progress, Delta); Assert.AreEqual(0f, subListener.Progress, Delta); Assert.AreEqual(0.25f, listener.TotalProgress, Delta); listener.HasOwnProgress = false; Assert.IsFalse(listener.HasOwnProgress); Assert.AreEqual(0.5f, listener.Progress, Delta); Assert.AreEqual(0f, subListener.Progress, Delta); Assert.AreEqual(0f, listener.TotalProgress, Delta); listener.SetProgress(1f); subListener.SetProgress(0.25f); Assert.AreEqual(1f, listener.Progress, Delta); Assert.AreEqual(0.25f, subListener.Progress, Delta); Assert.AreEqual(0.25f, listener.TotalProgress, Delta); }
public void TestTotalProgress() { var listener = new TaskListener(); float progress = 0f; listener.OnProgress += (p) => progress = p; listener.SetProgress(0.4f); Assert.AreEqual(0.4f, listener.TotalProgress, Delta); Assert.AreEqual(0.4f, progress, Delta); Assert.AreEqual(0.4f, listener.Progress, Delta); var sub = listener.CreateSubListener(); float subProgress = 0f; sub.OnProgress += (p) => subProgress = p; Assert.AreEqual(0.2f, listener.TotalProgress, Delta); Assert.AreEqual(0.2f, progress, Delta); Assert.AreEqual(0.4f, listener.Progress, Delta); Assert.AreEqual(0f, subProgress, Delta); Assert.AreEqual(0f, sub.Progress, Delta); sub.SetProgress(1f); Assert.AreEqual(0.7f, listener.TotalProgress, Delta); Assert.AreEqual(0.7f, progress, Delta); Assert.AreEqual(0.4f, listener.Progress, Delta); Assert.AreEqual(1f, subProgress, Delta); Assert.AreEqual(1f, sub.Progress, Delta); }
/// <summary> /// Tries loading all orphaned data which exist in the directory storage but somehow not indexed in the database. /// </summary> private void LoadOrphanedData(TaskListener listener = null) { var directoryList = new List <DirectoryInfo>(storage.GetAll()); for (int i = 0; i < directoryList.Count; i++) { var dir = directoryList[i]; // Report on the progress. listener?.SetProgress((float)i / directoryList.Count); // Find an entry in the database with matching directory name against index Id. using (var result = database.Query().Where(inx => inx["Id"].ToString().Equals(dir.Name)).GetResult()) { // If already exists, just continue. if (result.Count > 0) { continue; } // Else, we must adopt this result. var data = ParseData(dir); // If this is not a valid data, delete the directory. if (data == null) { storage.Delete(dir.Name); continue; } // Calculate hashcode data.CalculateHash(); // Allocate a new id for data. PostProcessData(data, Guid.NewGuid()); // Move the old directory to new directory name. dir.MoveTo(Path.Combine(dir.Parent.FullName, data.Id.ToString())); // Register this data as a new entry. database.Edit().Write(data).Commit(); OnNewData?.Invoke(data); Logger.LogInfo($"DirectoryBackedStore.LoadOrphanedData - Successfully adopted orphaned data at: {dir.FullName}"); } } listener?.SetFinished(); }
public void TestFinishedState() { var listener = new TaskListener <string>(); listener.SetValue("lolz"); listener.SetFinished(); Assert.AreEqual("lolz", listener.Value); Assert.IsTrue(listener.IsFinished); Assert.AreEqual(1f, listener.TotalProgress, Delta); listener.SetProgress(0.5f); listener.SetValue("a"); Assert.AreEqual("lolz", listener.Value); Assert.IsTrue(listener.IsFinished); Assert.AreEqual(1f, listener.TotalProgress, Delta); }
public IEnumerator TestEventOnOtherThread() { UnityThread.Initialize(); var listener = new TaskListener(); int mainThread = Thread.CurrentThread.ManagedThreadId; int finishedThreadFlag = 0; // 0 = idle, 1 = main, 2 = other int progressThreadFlag = 0; listener.OnFinished += () => { finishedThreadFlag = ( Thread.CurrentThread.ManagedThreadId == mainThread ? 1 : -1 ); }; listener.OnProgress += (p) => { progressThreadFlag = ( Thread.CurrentThread.ManagedThreadId == mainThread ? 1 : -1 ); }; Assert.AreEqual(0, finishedThreadFlag); Assert.AreEqual(0, progressThreadFlag); bool taskRan = false; listener.CallEventOnMainThread.Value = false; Task.Run(() => { listener.SetProgress(1f); listener.SetFinished(); taskRan = true; }); while (!taskRan) { yield return(null); } Assert.AreEqual(-1, finishedThreadFlag); Assert.AreEqual(-1, progressThreadFlag); }
public Task <TOutput[]> StartLoad(int taskCount, List <TInput> inputs, TOutput[] outputs = null, TaskListener <TOutput[]> listener = null) { if (taskCount < 1) { throw new Exception("Task count must be 1 or greater."); } if (inputs == null) { throw new ArgumentNullException(nameof(inputs)); } if (outputs != null && outputs.Length < inputs.Count) { throw new ArgumentException("The outputs array length is less than the input count."); } return(Task.Run <TOutput[]>(() => { taskCount = Math.Min(taskCount, inputs.Count); if (outputs == null) { outputs = new TOutput[inputs.Count]; } object inputLocker = new object(); object finishLocker = new object(); int curInputIndex = 0; int finishedCount = 0; int loadStartTime = DateTime.UtcNow.Millisecond; for (int i = 0; i < taskCount; i++) { Task.Run(() => { while (true) { // Retrieve the index of next input to process. int inx = -1; lock (inputLocker) { inx = curInputIndex++; } if (inx >= inputs.Count) { break; } outputs[inx] = loadHandler.Invoke(inputs[inx]); lock (finishLocker) { listener?.SetProgress((float)(finishedCount + 1) / inputs.Count); finishedCount++; } } }); } while (true) { Thread.Sleep(CompletionCheckInterval); if (Timeout.HasValue) { int elapsed = DateTime.UtcNow.Millisecond - loadStartTime; if (elapsed > Timeout.Value) { throw new TimeoutException("The loading process has taken longer than expected."); } } if (finishedCount >= inputs.Count) { break; } } listener?.SetFinished(outputs); return outputs; })); }
public Task <DirectoryInfo> Uncompress(DirectoryInfo destination, TaskListener <DirectoryInfo> listener = null) { return(Task.Run(() => { if (destination == null) { Logger.LogError($"ZipCompressed.Uncompress - destination is null!"); return null; } if (!Source.Exists) { return null; } try { using (var fs = new FileStream(Source.FullName, FileMode.Open, FileAccess.Read, FileShare.Read)) { // Find total size of the zip first. float totalSize = GetUncompressedSize(); // Start unzipping. using (var zis = new ZipInputStream(fs)) { string destPath = destination.FullName; ZipEntry entry; byte[] buffer = new byte[4096]; float curSize = 0; int curInterval = ProgressInterval; while ((entry = zis.GetNextEntry()) != null) { string path = Path.Combine(destPath, entry.Name); if (entry.IsDirectory) { Directory.CreateDirectory(path); } else { // Create missing subdirectories. Directory.CreateDirectory(Path.GetDirectoryName(path)); // Start write for this entry. using (FileStream writer = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Write)) { int length; while ((length = zis.Read(buffer, 0, buffer.Length)) > 0) { writer.Write(buffer, 0, length); // Track progress and report. curSize += length; curInterval--; if (curInterval <= 0) { curInterval = ProgressInterval; listener?.SetProgress(curSize / totalSize); } } writer.Flush(); } } } } } listener?.SetFinished(destination); return destination; } catch (Exception e) { Logger.LogError($"ZipCompressed.Uncompress - Error: {e}"); return null; } })); }