public IEnumerator TestTask()
{
var request = new AudioRequest(TestConstants.RemoteMp3Url, false);
ITask <AudioClip> task = request;
Assert.AreEqual(request, task);
Assert.IsFalse(task.DidRun);
Assert.IsFalse(task.IsFinished);
// Receive via callback
AudioClip clip = null;
TaskListener <AudioClip> listener = new TaskListener <AudioClip>();
listener.OnFinished += (value) => clip = value;
// Request
task.StartTask(listener);
Assert.IsFalse(task.IsFinished);
Assert.IsFalse(request.IsFinished);
// Wait till finish
while (!task.IsFinished)
{
Debug.Log("Progress: " + request.Progress);
yield return(null);
}
Assert.IsTrue(task.DidRun);
Assert.IsTrue(task.IsFinished);
Assert.IsTrue(request.IsFinished);
Assert.IsNotNull(request.Response);
Assert.IsNotNull(clip);
Assert.AreEqual(clip, request.Response.AudioData);
Assert.AreEqual(listener.Value, clip);
}
public void InvokeSoftDispose()
{
IsPlaying = false;
IsPaused = false;
int playTime = GetPlayTime();
// Stop listening to app pause event.
Game.OnAppPause -= OnAppPaused;
Game.OnAppFocus -= OnAppFocused;
// Record score if not replay mode.
if (!CurrentParameter.IsReplay)
{
var listener = new TaskListener <IRecord>();
listener.OnFinished += (record) =>
{
ScoreProcessor = null;
GameGui.HideGame(() => OnSoftDispose?.Invoke());
};
Model?.RecordScore(ScoreProcessor, playTime, listener);
}
else
{
GameGui.HideGame(() => OnSoftDispose?.Invoke());
}
}
public void TestWithNoFinishedTasks()
{
var tasks = new List <ManualTask>()
{
new ManualTask((t) => {}),
new ManualTask((t) => {}),
new ManualTask((t) => {})
};
var task = new MultiTask(tasks);
var listener = new TaskListener();
task.StartTask(listener);
Assert.AreEqual(listener, task.Listener);
Assert.AreEqual(3, task.Tasks.Count);
Assert.IsFalse(task.IsFinished);
Assert.IsTrue(task.DidRun);
Assert.AreEqual(0f, listener.TotalProgress, Delta);
Assert.IsFalse(listener.IsFinished);
tasks.ForEach(t => t.SetFinished());
Assert.IsTrue(task.IsFinished);
Assert.AreEqual(1f, listener.TotalProgress, Delta);
Assert.IsTrue(listener.IsFinished);
}
public override void RenderStatusById(TaskListener <List <RenderStatusResults> > taskListener,
IList <string> testIds, IList <string> renderIds)
{
List <RenderStatusResults> results = new List <RenderStatusResults>();
foreach (string renderId in renderIds)
{
List <VGRegion> selectorRegions = new List <VGRegion>();
JToken request = renderRequestsById_[renderId];
JToken selectors = request["selectorsToFindRegionsFor"];
if (selectors != null && selectors is JArray selectorsArr)
{
IWebDriver driver = driverProvider_.ProvideDriver();
foreach (JObject selectorToken in selectorsArr)
{
string selector = selectorToken["selector"].Value <string>();
IWebElement elem = driver.FindElement(By.XPath(selector));
Rectangle r = EyesSeleniumUtils.GetElementBounds(elem);
selectorRegions.Add(new VGRegion()
{
X = r.X, Y = r.Y, Width = r.Width, Height = r.Height
});
}
}
RenderStatusResults result = new RenderStatusResults()
{
RenderId = renderId,
Status = RenderStatus.Rendered,
ImageLocation = "http://image.some.url.com/" + renderId,
SelectorRegions = selectorRegions.ToArray()
};
results.Add(result);
}
taskListener.OnComplete(results);
}
public void TestStart()
{
var task = new ManualTask((t) => {});
var listener = new TaskListener();
task.StartTask(listener);
Assert.IsFalse(listener.IsFinished);
Assert.AreEqual(0f, listener.Progress, Delta);
Assert.IsTrue(task.DidRun);
Assert.IsFalse(task.IsRevoked.Value);
Assert.IsFalse(task.IsFinished);
Assert.AreEqual(listener, task.Listener);
task.SetProgress(0.25f);
Assert.IsFalse(listener.IsFinished);
Assert.AreEqual(0.25f, listener.Progress, Delta);
Assert.IsTrue(task.DidRun);
Assert.IsFalse(task.IsRevoked.Value);
Assert.IsFalse(task.IsFinished);
Assert.AreEqual(listener, task.Listener);
task.SetFinished();
Assert.IsTrue(listener.IsFinished);
Assert.AreEqual(1f, listener.Progress, Delta);
Assert.IsTrue(task.DidRun);
Assert.IsFalse(task.IsRevoked.Value);
Assert.IsTrue(task.IsFinished);
Assert.AreEqual(listener, task.Listener);
}
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 IEnumerator TestStream()
{
// Current limitation:
// There is no way to check whether the loaded audio is truly a streaming audio or not.
var request = new AudioRequest(TestConstants.RemoteMp3Url, true);
var listener = new TaskListener <IWebRequest>();
request.Request(listener);
while (!request.IsFinished)
{
Debug.Log("Progress: " + listener.Progress);
yield return(null);
}
Assert.IsNotNull(request.Response);
var clip = request.Response.AudioData;
Assert.IsNotNull(clip);
Debug.Log($"Content: {request.Response.ContentLength}, response: {request.Response.BytesLoaded}");
Assert.LessOrEqual((double)request.Response.BytesLoaded, (double)request.Response.ContentLength);
}
public void TestAutoFinish()
{
var listener = new TaskListener();
Assert.IsFalse(listener.IsAutoFinish);
Assert.IsFalse(listener.IsFinished);
listener.SetFinished();
Assert.IsTrue(listener.IsFinished);
listener = new TaskListener();
listener.IsAutoFinish = true;
Assert.IsFalse(listener.IsFinished);
Assert.IsTrue(listener.IsAutoFinish);
listener.SetFinished();
Assert.IsTrue(listener.IsFinished);
listener = new TaskListener();
var sub = listener.CreateSubListener();
sub.SetFinished();
Assert.IsFalse(listener.IsFinished);
var sub2 = listener.CreateSubListener();
var sub3 = listener.CreateSubListener();
listener.IsAutoFinish = true;
Assert.IsFalse(listener.IsFinished);
sub2.SetFinished();
Assert.IsFalse(listener.IsFinished);
sub3.SetFinished();
Assert.IsTrue(listener.IsFinished);
}
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);
}
public IEnumerator TestTimeout()
{
var request = new WebRequest(TestConstants.RemoteMp3Url, timeout: 2);
var listener = new TaskListener <IWebRequest>();
request.Request(listener);
while (!request.IsFinished)
{
yield return(null);
}
Debug.Log("Stopped at progress: " + listener.Progress);
Debug.Log("Error message: " + request.Response.ErrorMessage);
Assert.IsNotNull(request.Response);
if (request.Response.IsSuccess)
{
Assert.IsNull(request.Response.ErrorMessage);
Debug.Log("Result was true.");
}
else
{
Assert.IsNotNull(request.Response.ErrorMessage);
Debug.Log("Result was false");
}
}
private short RegisterMRListenerDescriptor(TaskListener listener)
{
if (listener == null)
{
return(0);
}
short returnValue = 0;
lock (SyncMapReduce)
{
ResourcePool pool = _mapReduceListenerPool;
ResourcePool poolID = _mapReduceListenerIDPool;
if (pool.GetResource(listener) == null)
{
returnValue = ++MAPREDUCELISTENER;
pool.AddResource(listener, returnValue);
poolID.AddResource(returnValue, listener);
}
else
{
short val = (short)pool.GetResource(listener);
if (val >= 0)
{
pool.AddResource(listener, returnValue);
poolID.AddResource(returnValue, listener);
returnValue = val;
}
}
}
return(returnValue);
}
internal void FireMapReduceCallback(string taskId, int taskstatus, string taskFailureReason, short callbackId)
{
TaskCompletionStatus status = TaskCompletionStatus.Success;
switch (taskstatus)
{
case 0:
status = TaskCompletionStatus.Success;
break;
case 1:
status = TaskCompletionStatus.Failure;
break;
case 2:
status = TaskCompletionStatus.Cancelled;
break;
}
TaskResult resp = new TaskResult(status, taskId, callbackId, taskFailureReason);
if (_mapReduceListenerIDPool != null)
{
ResourcePool poole = _mapReduceListenerIDPool;
TaskListener callback = (TaskListener)poole.GetResource(callbackId);
if (callback != null)
{
callback.Invoke(resp);
}
}
}
public IEnumerator TestTask()
{
var request = new TextureRequest(TestConstants.RemoteImageUrl, false);
ITask <Texture2D> promise = request;
Assert.AreEqual(request, promise);
// Receive via callback
Texture2D texture = null;
var listener = new TaskListener <Texture2D>();
listener.OnFinished += (value) => texture = value;
// Request
promise.StartTask(listener);
Assert.IsFalse(promise.IsFinished);
Assert.IsFalse(request.IsFinished);
// Wait till finish
while (!promise.IsFinished)
{
Debug.Log("Progress: " + request.Progress);
yield return(null);
}
Assert.IsTrue(promise.IsFinished);
Assert.IsTrue(request.IsFinished);
Assert.IsNotNull(request.Response);
Assert.IsNotNull(texture);
Assert.AreEqual(listener.Value, request.Response.TextureData);
Assert.AreEqual(listener.Value, texture);
}
public Task Reload(TaskListener listener = null)
{
return(Task.Run(async() =>
{
if (listener != null)
{
listener.HasOwnProgress = false;
}
// Wait for store reloading.
await store.Reload(listener?.CreateSubListener());
// Run on the main thread
UnityThread.DispatchUnattended(() =>
{
// Refill the mapset list
allMapsets.Clear();
allMapsets.AddRange(store.Mapsets);
// TODO: Process for a case where the previously selected map no longer exists.
// Fill the displayed mapsets list using last search term.
Search(lastSearch);
// Finished
listener?.SetFinished();
return null;
});
}));
}
public void TestGenericStart()
{
var task = new ManualTask <int>();
var listener = new TaskListener <int>();
task.StartTask(listener);
Assert.IsTrue(listener.IsFinished);
Assert.AreEqual(1f, listener.Progress, Delta);
Assert.IsTrue(task.DidRun);
Assert.IsFalse(task.IsRevoked.Value);
Assert.IsTrue(task.IsFinished);
Assert.AreEqual(listener, task.Listener);
Assert.AreEqual(default(int), listener.Value);
task = new ManualTask <int>((t) => t.SetFinished(100));
listener = new TaskListener <int>();
task.StartTask(listener);
Assert.IsTrue(listener.IsFinished);
Assert.AreEqual(1f, listener.Progress, Delta);
Assert.IsTrue(task.DidRun);
Assert.IsFalse(task.IsRevoked.Value);
Assert.IsTrue(task.IsFinished);
Assert.AreEqual(listener, task.Listener);
Assert.AreEqual(100, listener.Value);
}
public override Task Reload(TaskListener listener = null)
{
return(Task.Run(async() =>
{
// Perform internal reloading routine.
await base.Reload(listener?.CreateSubListener());
// Retrieve processor count.
// Load all mapsets from the storage.
var rawMapsets = GetAll().ToList();
var threadedLoader = new ThreadedLoader <Mapset, Mapset>(ProcessMapsetLoad);
var results = await threadedLoader.StartLoad(
8,
rawMapsets,
listener: listener?.CreateSubListener <Mapset[]>()
);
// Add results to the mapsets list.
lock (mapsets)
{
mapsets.Clear();
for (int i = 0; i < results.Length; i++)
{
if (results[i] != null)
{
mapsets.Add(results[i]);
}
}
}
listener?.SetFinished();
}));
}
protected override void StartSessionInternal(TaskListener <RunningSession> taskListener, SessionStartInfo sessionStartInfo)
{
Logger.Log(TraceLevel.Info, Stage.Open, StageType.Called, new { sessionStartInfo });
RunningSession newSession = null;
bool continueInvocation = true;
bool callBase = false;
if (continueInvocation)
{
newSession = new RunningSession()
{
isNewSession_ = false, SessionId = Guid.NewGuid().ToString()
};
SessionIds.Add(newSession.SessionId);
Sessions.Add(newSession.SessionId, newSession);
SessionsStartInfo.Add(newSession.SessionId, sessionStartInfo);
}
if (callBase)
{
base.StartSessionInternal(taskListener, sessionStartInfo);
}
else
{
EnsureHttpClient_();
taskListener.OnComplete(newSession);
}
}
protected override void EndSessionInternal(TaskListener <TestResults> taskListener, SessionStopInfo sessionStopInfo)
{
Logger.Log("ending session: {0}", sessionStopInfo.RunningSession.SessionId);
TestResults testResults = new TestResults();
AfterEndSession?.Invoke(sessionStopInfo.RunningSession, sessionStopInfo.Aborted, sessionStopInfo.UpdateBaseline);
taskListener.OnComplete(testResults);
}
public override void collectionItemAdded(object item)
{
BackgroundAction action = item as BackgroundAction;
TaskListener listener = new TaskListener(_controller, action);
_actionListener.Add(action, listener);
_controller.Invoke(new AddTaskAction(_controller, action));
}
public Task Reload(TaskListener listener = null)
{
return(Task.Run(() =>
{
base.Reload();
listener?.SetFinished();
}));
}
public virtual Task Reload(TaskListener listener = null)
{
return(Task.Run(() =>
{
InitModules(true);
LoadOrphanedData(listener?.CreateSubListener());
listener.SetFinished();
}));
}
public IEnumerator TestTaskRevoke()
{
var request = new WebRequest(TestConstants.RemoteMp3Url);
ITask task = request;
Assert.IsNotNull(task);
// Register callback
bool onFinishedCalled = false;
var listener = new TaskListener();
listener.OnFinished += () => onFinishedCalled = true;
Assert.IsFalse(onFinishedCalled);
// Start request
task.StartTask(listener);
// Wait till certain progress level
while (request.Progress < 0.4f)
{
Debug.Log("Progress: " + request.Progress);
yield return(null);
}
Assert.IsFalse(request.IsFinished);
Assert.IsFalse(task.IsFinished);
// Revoke the request.
task.RevokeTask(true);
Assert.IsFalse(request.IsFinished);
Assert.IsFalse(task.IsFinished);
// See if any progress is changing even after revoke.
float lastProgress = request.Progress;
float limit = 3;
while (true)
{
limit -= Time.deltaTime;
if (request.Progress != lastProgress)
{
Debug.Log("New progress detected! " + request.Progress);
Assert.Fail("There mustn't be any progressing going on!");
}
if (limit <= 0)
{
break;
}
yield return(null);
}
Assert.IsNull(request.Response);
Assert.IsFalse(request.IsFinished);
Assert.IsFalse(task.IsFinished);
Assert.IsFalse(onFinishedCalled);
}
public RequestPollingTaskListener(HttpRestClient restClient, Uri pollingUrl,
TaskListener <HttpResponseMessage> listener, Logger logger = null)
{
restClient_ = restClient;
logger_ = logger;
pollingUrl_ = pollingUrl;
listener_ = listener;
OnComplete = OnComplete_;
OnFail = OnFail_;
}
public Task Reload(TaskListener listener = null)
{
return(Task.Run(() =>
{
dependencies.Inject(offlineUser);
userStore.Reload();
listener?.SetFinished();
}));
}
/// <summary>
/// Stops listening to record retrieval task's completion.
/// </summary>
private void StopRecordRetrieval()
{
if (recordsListener != null)
{
recordsListener.OnFinished -= OnRecordsRetrieved;
recordsListener = null;
isRetrievingRecords.Value = false;
}
}
private IEnumerator InitStore(DummyStore store, int expectedCount = 0)
{
var listener = new TaskListener();
store.Reload(listener).Wait();
yield return(null);
Assert.AreEqual(1f, listener.Progress, 0.00001f);
Assert.AreEqual(expectedCount, store.Count);
}
/// <summary>
/// Returns an enumerator which awaits until the specified progress has finished.
/// </summary>
public IEnumerator AwaitProgress(TaskListener listener)
{
bool isFinished = false;
listener.OnFinished += () => isFinished = true;
while (!isFinished)
{
yield return(null);
}
}
/// <summary>
/// Starts loading the user data.
/// </summary>
private void LoadUserData()
{
SetState("Loading user data");
TaskListener listener = new TaskListener();
listener.OnProgress += SetProgress;
listener.OnFinished += LoadRecordData;
UserManager.Reload(listener);
}
/// <summary>
/// Starts loading the record data.
/// </summary>
private void LoadRecordData()
{
SetState("Loading record data");
TaskListener listener = new TaskListener();
listener.OnProgress += SetProgress;
listener.OnFinished += FinalizeLoad;
RecordStore.Reload(listener);
}
