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;
}
}));
}
