public async Task ToAsyncEnumerable_Observable_Cancel_InFlight()
{
var xs = new MyObservable <int>(obs =>
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
for (var i = 0; !cts.IsCancellationRequested; i++)
{
await Task.Delay(10);
obs.OnNext(i);
}
});
return(new MyDisposable(cts.Cancel));
}).ToAsyncEnumerable();
using var c = new CancellationTokenSource();
await using var e = xs.GetAsyncEnumerator(c.Token);
var task = e.MoveNextAsync();
c.Cancel();
await AssertThrowsAsync <TaskCanceledException>(task.AsTask());
}
public async Task ToAsyncEnumerable_Observable6_Async()
{
using var stop = new ManualResetEvent(false);
var xs = new MyObservable <int>(obs =>
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
for (var i = 0; !cts.IsCancellationRequested; i++)
{
await Task.Yield();
obs.OnNext(i);
}
stop.Set();
});
return(new MyDisposable(cts.Cancel));
}).ToAsyncEnumerable();
var e = xs.GetAsyncEnumerator();
for (var i = 0; i < 10_000; i++)
{
await HasNextAsync(e, i);
}
await e.DisposeAsync();
stop.WaitOne();
}
public virtual IObservable <string> ObserveContinuous(GetChangesRequest request, CancellationToken cancellationToken)
{
var httpRequest = ContinuousHttpRequestFactory.Create(request);
var ob = new MyObservable <string>();
Task.Factory.StartNew(async() =>
{
using (var httpResponse = await SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ForAwait())
{
var response = await ContinuousChangesResponseFactory.CreateAsync(httpResponse).ForAwait();
if (response.IsSuccess)
{
using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait())
{
using (var reader = new StreamReader(content, MyCouchRuntime.DefaultEncoding))
{
while (!cancellationToken.IsCancellationRequested && !reader.EndOfStream)
{
//cancellationToken.ThrowIfCancellationRequested();
if (!cancellationToken.IsCancellationRequested)
{
ob.Notify(reader.ReadLine());
}
}
ob.Complete();
}
}
}
}
}, cancellationToken).ForAwait();
return(ob);
}
public void IObservable_Subscribe()
{
// Arrange
var observable = new MyObservable();
var observer = new MyObserver();
// Act
observable.Subscribe(observer);
// Assert
}
void Awake()
{
observable = new MyObservable();
Paused = false;
castle = GameObject.FindGameObjectWithTag("Castle").GetComponent <Castle>();
spawner = GameObject.FindGameObjectWithTag("Spawner").GetComponent <Spawner>();
cam = GameObject.FindGameObjectWithTag("MainCamera");
}
void Awake()
{
Instance = this;
PointerOverObjectChanged = new MyObservable();
mainMenuContext = transform.Find("MainMenu").gameObject;
highscoresContext = transform.Find("Highscores").gameObject;
instructionsContext = transform.Find("Instructions").gameObject;
hud = transform.Find("HUD").gameObject;
buildingTowerContext = hud.transform.Find("FourTowers").gameObject;
selectedTowerContext = hud.transform.Find("SelectedTower").gameObject;
gameOverContext = transform.Find("GameOverScreen").gameObject;
gameOverName = gameOverContext.transform.Find("GameOverNameInputField").GetComponent <InputField>();
GameOverScoreText = gameOverContext.transform.Find("GameOverScoreText").GetComponent <Text>();
pauseMenuContext = transform.Find("PauseMenu").gameObject;
ScoreText = hud.transform.Find("ScorePanel").Find("ScoreText").GetComponent <Text>();
GoldText = hud.transform.Find("LivesAndGoldPanel").Find("GoldNum").GetComponent <Text>();
LivesText = hud.transform.Find("LivesAndGoldPanel").Find("LivesNum").GetComponent <Text>();
detailsPanel = hud.transform.Find("DetailsPanel").gameObject;
towerDetailsPanel = detailsPanel.transform.Find("TowerDetailsPanel").gameObject;
critterDetailsPanel = detailsPanel.transform.Find("CritterDetailsPanel").gameObject;
iconMap = new Dictionary <string, Sprite>();
for (int i = 0; i < iconKeys.Length; i++)
{
iconMap[iconKeys[i]] = iconVals[i];
}
}
public void AutoDetachObserver_ImplementISafeObserver()
{
var myObserver = Observer.Create <int>(i =>
{
i.Dump();
if (i == 1)
{
throw new Exception("triggered by observer");
}
}, ex => ex.Message.ToString(), () => "completed".Dump());
var observer = new AutoDetachObserver <int>(myObserver);
observer.SetResource(Disposable.Create(() => "obsrever exception i will clearnup by IDisposable Resource".Dump()));
var observable = new MyObservable();
observable.Subscribe(observer);
}
public void Update(MyObservable <Character> observed)
{
Character character = (Character)observed;
if (character.CurrentHP <= 0)
{
if (character == Character)
{
state = BattleStates.LOSE;
}
else
{
if (Opponents.Where(i => i.CurrentHP > 0).ToList().Count == 0)
{
state = BattleStates.WIN;
}
}
}
}
public async Task ToAsyncEnumerable_Observable_Zip()
{
using var stop = new ManualResetEvent(false);
var subCount = 0;
var xs = new MyObservable <int>(obs =>
{
subCount++;
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
for (var i = 0; !cts.IsCancellationRequested; i++)
{
await Task.Delay(10);
obs.OnNext(i);
}
stop.Set();
});
return(new MyDisposable(cts.Cancel));
}).ToAsyncEnumerable();
var e = xs.Zip(xs, (l, r) => l == r).GetAsyncEnumerator();
for (var i = 0; i < 10; i++)
{
await HasNextAsync(e, true);
}
await e.DisposeAsync();
stop.WaitOne();
Assert.Equal(2, subCount);
}
public void ToAsyncEnumerable4()
{
var ex = new Exception("Bang!");
var subscribed = false;
var xs = new MyObservable <int>(obs =>
{
subscribed = true;
obs.OnError(ex);
return(new MyDisposable(() => { }));
}).ToAsyncEnumerable();
Assert.False(subscribed);
var e = xs.GetEnumerator();
Assert.True(subscribed);
AssertThrows <Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
}
public async Task ToAsyncEnumerable_Observable_Throw()
{
var ex = new Exception("Bang!");
var subscribed = false;
var xs = new MyObservable <int>(obs =>
{
subscribed = true;
obs.OnError(ex);
return(new MyDisposable(() => { }));
}).ToAsyncEnumerable();
Assert.False(subscribed);
var e = xs.GetAsyncEnumerator();
// NB: Breaking change to align with lazy nature of async iterators.
// Assert.True(subscribed);
await AssertThrowsAsync(e.MoveNextAsync(), ex);
}
public void ToAsyncEnumerable3()
{
var subscribed = false;
var xs = new MyObservable <int>(obs =>
{
subscribed = true;
obs.OnNext(42);
obs.OnCompleted();
return(new MyDisposable(() => { }));
}).ToAsyncEnumerable();
Assert.False(subscribed);
var e = xs.GetEnumerator();
Assert.True(subscribed);
HasNext(e, 42);
NoNext(e);
}
public async Task ToAsyncEnumerable_Observable_Return()
{
var subscribed = false;
var xs = new MyObservable <int>(obs =>
{
subscribed = true;
obs.OnNext(42);
obs.OnCompleted();
return(new MyDisposable(() => { }));
}).ToAsyncEnumerable();
Assert.False(subscribed);
var e = xs.GetAsyncEnumerator();
// NB: Breaking change to align with lazy nature of async iterators.
// Assert.True(subscribed);
await HasNextAsync(e, 42);
await NoNextAsync(e);
}
public void UnitObserveable_ctor()
{
var ob = new MyObservable();
}
void Awake()
{
observable = new MyObservable();
cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();
}
void Awake()
{
observable = new MyObservable();
}
protected virtual void Awake()
{
KillPending = false;
observable = new MyObservable();
}
