public void ClientDisconnected_ServerRaisesErrorMessage()
{
var failedOrigin = IntegrationTestsHelper
.GetOriginBuilder()
.UseSerializer(IntegrationTestsHelper.GetThrowsSerializationRuleFor <string>());
using (var tcpPair = new TcpConnectionPair <ITestContract, ITestContract, TestContractMock>
(failedOrigin, IntegrationTestsHelper.GetProxyBuilder()))
{
var awaiter = new EventAwaiter <ClientDisconnectEventArgs <ITestContract, TcpChannel> >();
tcpPair.Server.Disconnected += awaiter.EventRaised;
//provokes exception at origin-side serialization
try
{
tcpPair.ProxyContract.Ask("some string");
}
catch (RemoteSerializationException) {}
var receivedArgs = awaiter.WaitOneOrDefault(500);
//Client disconnected event is expected
Assert.IsNotNull(receivedArgs);
Assert.IsNotNull(receivedArgs.ErrorMessageOrNull);
Assert.AreEqual(ErrorType.SerializationError, receivedArgs.ErrorMessageOrNull.ErrorType);
}
}
public async Task ReactsToLiveEvents()
{
timeScope.AdvanceTime(1);
var player = ClientMock.AddPlayer("Newguy");
player.Logs.WriteEventLog("42 other players are online. You are on Exodus (765 totally in Wurm).");
var skillApi = Fixture.WurmApiManager.Characters.Get("Newguy")
.Skills;
// allow WurmApi to pick everything
await Task.Delay(1000);
timeScope.AdvanceTime(1);
var awaiter = new EventAwaiter <SkillsChangedEventArgs>();
skillApi.SkillsChanged += awaiter.GetEventHandler();
player.Logs.WriteSkillLog("Masonry", 58.754f);
awaiter.WaitInvocations(1);
awaiter.WaitUntilMatch(list => list.Any(args => args.HasSkillChanged("Masonry")));
var skill = await skillApi.TryGetCurrentSkillLevelAsync("Masonry", new ServerGroup("FREEDOM"), TimeSpan.MaxValue);
Expect(skill.Value, EqualTo(58.754f));
}
public async Task GetDeviceState_ENUM_ALL()
{
// Check NotOpened State for secondary camera.
if (IsSupportedSecondaryCamera())
{
Assert.That(Camera.GetDeviceState(CameraDevice.Front), Is.EqualTo(CameraDeviceState.NotOpened));
}
// Check NotOpened State.
Assert.That(Camera.GetDeviceState(CameraDevice.Rear), Is.EqualTo(CameraDeviceState.NotOpened));
/* Opened state cannot be tested.
* DeviceState is internally translated from NotOpened state to Working state after calling StartPreview method.
*/
using (var eventWaiter = EventAwaiter <CameraStateChangedEventArgs> .Create())
{
TestCamera.StateChanged += eventWaiter;
TestCamera.StartPreview();
await eventWaiter.IsRaisedAsync();
// Check Working State.
Assert.That(Camera.GetDeviceState(CameraDevice.Rear), Is.EqualTo(CameraDeviceState.Working));
}
}
public async Task HitGenesisBlockDuringInitializationAsync()
{
var chain = new ConcurrentChain(Network.RegTest);
foreach (var n in Enumerable.Range(0, 3))
{
await AddBlockAsync(chain);
}
using var notifier = CreateNotifier(chain);
var blockAwaiter = new EventAwaiter <Block>(
h => notifier.OnBlock += h,
h => notifier.OnBlock -= h);
var reorgAwaiter = new EventAwaiter <uint256>(
h => notifier.OnReorg += h,
h => notifier.OnReorg -= h);
await notifier.StartAsync(CancellationToken.None);
// No block notifications nor reorg notifications
await Assert.ThrowsAsync <OperationCanceledException>(() => blockAwaiter.WaitAsync(TimeSpan.FromSeconds(1)));
await Assert.ThrowsAsync <OperationCanceledException>(() => reorgAwaiter.WaitAsync(TimeSpan.FromSeconds(1)));
Assert.Equal(chain.Tip.HashBlock, notifier.BestBlockHash);
await notifier.StopAsync(CancellationToken.None);
}
public async Task HdrCaptureProgress_CHECK_EVENT()
{
if (TestCamera.Capabilities.IsHdrCaptureSupported == false)
{
Assert.Pass("HDR feature is not supported.");
}
using (var completeWaiter = EventAwaiter.Create())
using (var eventWaiter = EventAwaiter <HdrCaptureProgressEventArgs> .Create())
{
TestCamera.Settings.HdrMode = CameraHdrMode.Enable;
TestCamera.HdrCaptureProgress += eventWaiter;
TestCamera.CaptureCompleted += completeWaiter;
TestCamera.StartPreview();
TestCamera.StartCapture();
var eventArgs = await eventWaiter.GetResultAsync();
Assert.That(eventArgs.Percent, Is.GreaterThan(0), "HDR progress should be bigger than 0.");
await completeWaiter.IsRaisedAsync();
}
}
public async Task ReactsToCurrentServerChange()
{
//mocking current time to avoid test breaking precisely on midnight
using (var scope = TimeStub.CreateStubbedScope())
{
scope.OverrideNow(new DateTime(2015, 10, 06, 03, 10, 30));
var subscriber =
new Subscriber <CharacterDirectoriesChanged>(Fixture.WurmApiManager.InternalEventAggregator);
var serverChangeAwaiter = new EventAwaiter <PotentialServerChangeEventArgs>();
var playerdir = ClientMock.AddPlayer("Jack");
playerdir.SetConfigName("default");
// have to immediatelly create file, because during log monitor creation, existing file contents will not trigger events.
playerdir.Logs.CreateEventLogFile();
// have to wait until wurmapi picks up this folder
subscriber.WaitMessages(1);
var character = System.Get("Jack");
character.LogInOrCurrentServerPotentiallyChanged += serverChangeAwaiter.GetEventHandler();
Trace.WriteLine("writing first event");
playerdir.Logs.WriteEventLog("5 other players are online. You are on Exodus (50 totally in Wurm).");
serverChangeAwaiter.WaitUntilMatch(
list =>
list.Any(args => args.ServerName == new ServerName("Exodus")));
var server = await character.TryGetCurrentServerAsync();
Expect(server.ServerName, EqualTo(new ServerName("Exodus")));
Trace.WriteLine(
"writing second event");
playerdir.Logs.WriteEventLog(
"5 other players are online. You are on Deliverance (50 totally in Wurm).");
serverChangeAwaiter.WaitUntilMatch(
list =>
list.Any(args => args.ServerName == new ServerName("Deliverance")));
server = await character.TryGetCurrentServerAsync();
Expect(server.ServerName, EqualTo(new ServerName("Deliverance")));
Trace.WriteLine("writing third event");
playerdir.Logs.WriteEventLog(
"5 other players are online. You are on Deliverance (50 totally in Wurm).");
serverChangeAwaiter.WaitUntilMatch(
list =>
list.Any(args => args.ServerName == new ServerName("Deliverance")));
server = await character.TryGetCurrentServerAsync();
Expect(server.ServerName, EqualTo(new ServerName("Deliverance")));
}
}
public void Setup()
{
var batmobile = "batmobile";
configMock = ClientMock.AddConfig(batmobile);
awaiter = new EventAwaiter<EventArgs>();
System.AnyConfigChanged += awaiter.Handle;
}
/// <summary>
/// Send string to the server, end with new line and wait for a reply. if the server doesn't reply in given time, return null.
/// </summary>
/// <param name="data"></param>
/// <param name="timeout">how maximum time we need to wait for the reply</param>
public async Task <Message> SendLineAndGetReplyAsync(string data, TimeSpan timeout)
{
var eventAwaiter = new EventAwaiter <Message>(h => DataReceived += h, h => DataReceived -= h);
await SendLineAsync(data);
return(await eventAwaiter.WaitForEventRaised.TimeoutAfter(timeout));
}
public static async Task <IPreviewBeatmapLevel?> DownloadSong(string levelId, CancellationToken cancellationToken)
{
string hash = levelId.Replace("custom_level_", "");
var bm = await BeatSaverSharp.BeatSaver.Client.Hash(hash, cancellationToken);
string folderPath = GetSongDirectoryName(bm.Key, bm.Metadata.SongName, bm.Metadata.LevelAuthorName);
folderPath = Path.Combine(CustomLevelsFolder, folderPath);
if (bm == null)
{
Plugin.Log?.Warn($"Could not find song '{hash}' on Beat Saver.");
return(null);
}
byte[] beatmapBytes = await bm.DownloadZip(false, cancellationToken);
using (var ms = new MemoryStream(beatmapBytes))
{
var result = await ExtractZip(ms, folderPath);
if (folderPath != result.OutputDirectory)
{
folderPath = result.OutputDirectory ?? throw new Exception("Zip extract failed, no output directory.");
}
if (result.Exception != null)
{
throw result.Exception;
}
}
Plugin.Log.Info($"Downloaded song to '{folderPath}'");
using (var awaiter = new EventAwaiter <SongCore.Loader, Dictionary <string, CustomPreviewBeatmapLevel> >(cancellationToken))
{
try
{
SongCore.Loader.SongsLoadedEvent += awaiter.OnEvent;
SongCore.Collections.AddSong($"custom_level_{hash}", folderPath);
SongCore.Loader.Instance.RefreshSongs(false);
await awaiter.Task;
}
catch (OperationCanceledException)
{ }
catch (Exception e)
{
Plugin.Log?.Error($"Error waiting for songs to load: {e.Message}");
Plugin.Log?.Debug(e);
throw;
}
finally
{
SongCore.Loader.SongsLoadedEvent -= awaiter.OnEvent;
}
}
CustomPreviewBeatmapLevel beatmap = SongCore.Loader.GetLevelByHash(hash);
return(beatmap);
}
public void Subscribe_AllLogs()
{
EventAwaiter <LogsMonitorEventArgs> awaiter = new EventAwaiter <LogsMonitorEventArgs>();
var handler = awaiter.GetEventHandler();
System.Subscribe(TestGuyCharacterName.Capitalized, LogType.AllLogs, handler);
WriteToLogFile("_Event.2014-01-01.txt", "Logging started 2014-01-01");
WriteToLogFile("_Event.2014-01-01.txt", "[00:00:12] Horses like this one have many uses.");
WriteToLogFile("_Skills.2014-01-01.txt", "[00:03:15] Smartness increased by 24 to 48.");
WriteToLogFile("PM__Anotherguy.2014-01-01.txt", "Logging started 2014-01-01");
WriteToLogFile("PM__Anotherguy.2014-01-01.txt", "[00:00:18] <Anotherguy> Smartness is a very useful skill!");
awaiter.WaitUntilMatch(list =>
{
var match1 = list.Any(
args =>
args.CharacterName == TestGuyCharacterName &&
args.LogType == LogType.Event &&
args.WurmLogEntries.Any(
entry =>
entry.Content == "Horses like this one have many uses." &&
entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 12)));
return(match1);
});
awaiter.WaitUntilMatch(list =>
{
var match1 = list.Any(
args =>
args.CharacterName == TestGuyCharacterName &&
args.LogType == LogType.Skills &&
args.WurmLogEntries.Any(
entry =>
entry.Content == "Smartness increased by 24 to 48." &&
entry.Timestamp == new DateTime(2014, 1, 1, 0, 3, 15)));
return(match1);
});
awaiter.WaitUntilMatch(list =>
{
var isPm = list.Any(args => args.LogType == LogType.Pm);
var match1 = list.Any(
args =>
args.CharacterName == TestGuyCharacterName &&
args.LogType == LogType.Pm &&
args.PmRecipientNormalized == "ANOTHERGUY" &&
args.PmRecipientCapitalized == "Anotherguy" &&
args.WurmLogEntries.Any(
entry =>
entry.Content == "Smartness is a very useful skill!" &&
entry.Source.Contains("Anotherguy") &&
entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 18)));
return(match1);
});
System.Unsubscribe(TestGuyCharacterName.Capitalized, handler);
}
public void Setup()
{
var batmobile = "batmobile";
configMock = ClientMock.AddConfig(batmobile);
awaiter = new EventAwaiter <EventArgs>();
System.AnyConfigChanged += awaiter.Handle;
}
public void Connect()
{
_eventAwaiter = new EventAwaiter <IConnection <TOriginContractInterface, TestChannel> >();
Server.AfterConnect += _eventAwaiter.EventRaised;
Server.StartListening();
Server.TestListener.ImmitateAccept(ClientChannel);
OriginConnection = _eventAwaiter.WaitOneOrDefault(500);
Assert.IsNotNull(OriginConnection);
}
public void Connect()
{
_eventAwaiter = new EventAwaiter <IConnection <TOriginContractInterface, TcpChannel> >();
Server.AfterConnect += _eventAwaiter.EventRaised;
Server.StartListening();
ClientChannel.Connect(new IPEndPoint(IPAddress.Loopback, 12345));
OriginConnection = _eventAwaiter.WaitOneOrDefault(500);
Assert.IsNotNull(OriginConnection);
}
async Task WaitPopupClosing()
{
CancellationToken = new CancellationToken();
Popup popup = Popup;
AsyncAction = EventAwaiter.WaitEventAsync <object>(handler => popup.Closed += handler, handler => popup.Closed -= handler, () => { }).AsAsyncAction();
await AsyncAction;
popup = null;
}
public void Setup()
{
invoker = new PublicEventInvoker(new ThreadPoolMarshaller(logger), logger)
{
LoopDelayMillis = 1
};
eventAwaiter = new EventAwaiter <EventArgs>();
Foovent += eventAwaiter.Handle;
}
private static async void ShowExceptions()
{
var eventAwaiter = new EventAwaiter <FirstChanceExceptionEventArgs>();
AppDomain.CurrentDomain.FirstChanceException += eventAwaiter.EventRaised;
while (true)
{
Console.WriteLine("AppDomain exception:{0}", (await eventAwaiter).Exception.GetType());
}
}
public async Task <AMCPError> SendCommandAndGetStatusAsync(string command)
{
var eventWaiter = new EventAwaiter <AMCPEventArgs>(
h => ResponseParsed += h,
h => ResponseParsed -= h);
ServerConnection.SendString(command);
var data = await eventWaiter.WaitForEventRaised;
return(data?.Error ?? AMCPError.UndefinedError);
}
public async Task Preview_CHECK_EVENT()
{
using (var eventWaiter = EventAwaiter <CameraStateChangedEventArgs> .Create())
{
TestCamera.StateChanged += eventWaiter;
TestCamera.StartPreview();
Assert.That(await eventWaiter.IsRaisedAsync());
}
}
private static async void ShowExceptions()
{
var eventAwaiter = new EventAwaiter <FirstChanceExceptionEventArgs>();
AppDomain.CurrentDomain.FirstChanceException += eventAwaiter.EventRaised;
while (true)
{
Console.WriteLine($"AppDomain exception: {(await eventAwaiter).Exception.GetType()}");// awaiter 充当 异步方法的状态机 和 被引发事件之间的 “粘合剂”
}
}
public void SubscribePmLog_TriggerWithSingleEvent()
{
EventAwaiter <LogsMonitorEventArgs> anotherGuyAwaiter = new EventAwaiter <LogsMonitorEventArgs>();
EventAwaiter <LogsMonitorEventArgs> unrelatedGuyAwaiter = new EventAwaiter <LogsMonitorEventArgs>();
EventHandler <LogsMonitorEventArgs> anotherGuyEventHandler = anotherGuyAwaiter.GetEventHandler();
EventHandler <LogsMonitorEventArgs> unrelatedGuyEventHandler = unrelatedGuyAwaiter.GetEventHandler();
System.SubscribePm(TestGuyCharacterName.Capitalized, "Anotherguy", anotherGuyEventHandler);
System.SubscribePm(TestGuyCharacterName.Capitalized, "Unrelatedguy", unrelatedGuyEventHandler);
WriteToLogFile("PM__Anotherguy.2014-01-01.txt", "Logging started 2014-01-01");
WriteToLogFile("PM__Anotherguy.2014-01-01.txt",
"[00:00:12] <Anotherguy> Horses like this one have many uses.");
anotherGuyAwaiter.WaitInvocations(1);
anotherGuyAwaiter.WaitUntilMatch(list =>
{
var match1 = list.Any(
args =>
args.CharacterName == TestGuyCharacterName &&
args.PmRecipientNormalized == "ANOTHERGUY" &&
args.PmRecipientCapitalized == "Anotherguy" &&
args.WurmLogEntries.Any(
entry =>
entry.Content == "Horses like this one have many uses." &&
entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 12) &&
entry.Source == "Anotherguy"));
return(match1);
});
Expect(unrelatedGuyAwaiter.Invocations.Count(), EqualTo(0));
System.UnsubscribePm(TestGuyCharacterName.Capitalized, "Anotherguy", anotherGuyEventHandler);
WriteToLogFile("PM__Anotherguy.2014-01-01.txt",
"[00:00:13] <Anotherguy> Horses like this one have many uses.");
Thread.Sleep(1000);
var unexpected1 = anotherGuyAwaiter.Invocations.Any(
args =>
args.WurmLogEntries.Any(
entry =>
entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 13)));
var unexpected2 = anotherGuyAwaiter.Invocations.Any(
args =>
args.WurmLogEntries.Any(
entry =>
entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 13)));
Expect(unexpected1, False);
Expect(unexpected2, False);
}
public TcpConnectionPair(PresentationBuilder <TOriginContractInterface> originBuilder,
PresentationBuilder <TProxyContractInterface> proxyBuider, bool connect = true)
{
Server = originBuilder.CreateTcpServer(IPAddress.Loopback, 12345);
ClientChannel = new TcpChannel();
ProxyConnection = proxyBuider.UseChannel(ClientChannel).Build();
_eventAwaiter = new EventAwaiter <IConnection <TOriginContractInterface, TcpChannel> >();
Server.AfterConnect += _eventAwaiter.EventRaised;
if (connect)
{
Connect();
}
}
public void ProxySayCall_NoThreadDispatcher_OriginSayCalled(string sentMessage)
{
using (var tcpPair = new TcpConnectionPair())
{
EventAwaiter <string> callAwaiter = new EventAwaiter <string>();
tcpPair.OriginContract.SayMethodWasCalled += callAwaiter.EventRaised;
tcpPair.ProxyConnection.Contract.Say(sentMessage);
var received = callAwaiter.WaitOneOrDefault(500);
Assert.AreEqual(sentMessage, received);
}
}
public void Interrupted_CHECK_EVENT()
{
using (var eventWaiter = EventAwaiter <CameraInterruptedEventArgs> .Create())
{
try
{
TestCamera.Interrupted += eventWaiter;
}
catch (Exception ex)
{
Assert.Fail("Exception is occured. msg : " + ex.ToString());
}
}
}
public void ErrorOccurred_CHECK_EVENT()
{
using (var eventWaiter = EventAwaiter <CameraErrorOccurredEventArgs> .Create())
{
try
{
TestCamera.ErrorOccurred += (s, e) => { };
}
catch (Exception ex)
{
Assert.Fail("Exception is occured. msg : " + ex.ToString());
}
}
}
public void SubscribePmLog_TriggerWithSingleEvent()
{
EventAwaiter<LogsMonitorEventArgs> anotherGuyAwaiter = new EventAwaiter<LogsMonitorEventArgs>();
EventAwaiter<LogsMonitorEventArgs> unrelatedGuyAwaiter = new EventAwaiter<LogsMonitorEventArgs>();
EventHandler<LogsMonitorEventArgs> anotherGuyEventHandler = anotherGuyAwaiter.GetEventHandler();
EventHandler<LogsMonitorEventArgs> unrelatedGuyEventHandler = unrelatedGuyAwaiter.GetEventHandler();
System.SubscribePm(TestGuyCharacterName, new CharacterName("Anotherguy"), anotherGuyEventHandler);
System.SubscribePm(TestGuyCharacterName, new CharacterName("Unrelatedguy"), unrelatedGuyEventHandler);
WriteToLogFile("PM__Anotherguy.2014-01-01.txt", "Logging started 2014-01-01");
WriteToLogFile("PM__Anotherguy.2014-01-01.txt",
"[00:00:12] <Anotherguy> Horses like this one have many uses.");
anotherGuyAwaiter.WaitInvocations(1);
anotherGuyAwaiter.WaitUntilMatch(list =>
{
var match1 = list.Any(
args =>
args.CharacterName == TestGuyCharacterName
&& args.ConversationNameNormalized == "ANOTHERGUY"
&& args.WurmLogEntries.Any(
entry =>
entry.Content == "Horses like this one have many uses."
&& entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 12)
&& entry.Source == "Anotherguy"));
return match1;
});
Expect(unrelatedGuyAwaiter.Invocations.Count(), EqualTo(0));
System.UnsubscribePm(TestGuyCharacterName, new CharacterName("Anotherguy"), anotherGuyEventHandler);
WriteToLogFile("PM__Anotherguy.2014-01-01.txt",
"[00:00:13] <Anotherguy> Horses like this one have many uses.");
Thread.Sleep(1000);
var unexpected1 = anotherGuyAwaiter.Invocations.Any(
args =>
args.WurmLogEntries.Any(
entry =>
entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 13)));
var unexpected2 = anotherGuyAwaiter.Invocations.Any(
args =>
args.WurmLogEntries.Any(
entry =>
entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 13)));
Expect(unexpected1, False);
Expect(unexpected2, False);
}
public async Task StopPreview_CHECK_STATE()
{
using (var eventWaiter = EventAwaiter <CameraStateChangedEventArgs> .Create())
{
TestCamera.StateChanged += eventWaiter;
TestCamera.StartPreview();
await eventWaiter.IsRaisedAsync();
}
TestCamera.StopPreview();
Assert.That(TestCamera.State, Is.EqualTo(CameraState.Created));
}
public async Task DisplayReuseHint_PROPERTY_READ_WRITE()
{
using (var eventWaiter = EventAwaiter <CameraStateChangedEventArgs> .Create())
{
TestCamera.StateChanged += eventWaiter;
TestCamera.StartPreview();
await eventWaiter.IsRaisedAsync();
}
TestCamera.DisplayReuseHint = true;
Assert.IsNotNull(TestCamera.DisplayReuseHint, "display reuse hint should not be null.");
Assert.IsTrue(TestCamera.DisplayReuseHint, "display reuse hint is not same as set value.");
}
public void TriggersEventOnChanged()
{
IWurmConfig config = System.GetConfig(configMock.Name);
Expect(config.NoSkillMessageOnFavorChange, False);
var configAwaiter = new EventAwaiter <EventArgs>();
config.ConfigChanged += configAwaiter.Handle;
configMock.GameSettings.ChangeValue("skillgain_no_favor", "true");
awaiter.WaitInvocations(2, 10000);
Expect(config.NoSkillMessageOnFavorChange, True);
}
private static void CheckProtobuffEchoTransaction(int itemsSize)
{
using (var tcpPair = new TcpConnectionPair
<ISingleMessageContract <Company>,
ISingleMessageContract <Company>,
SingleMessageContract <Company> >())
{
EventAwaiter <Company> callAwaiter = new EventAwaiter <Company>();
tcpPair.OriginContract.SayCalled += callAwaiter.EventRaised;
var company = IntegrationTestsHelper.CreateCompany(itemsSize);
tcpPair.ProxyConnection.Contract.Ask(company);
var received = callAwaiter.WaitOneOrDefault(5000);
Assert.IsNotNull(received);
received.AssertIsSameTo(company);
}
}
public async Task State_GET_ENUM_ALL()
{
Assert.That(TestCamera.State, Is.EqualTo(CameraState.Created));
TestCamera.StartPreview();
Assert.That(TestCamera.State, Is.EqualTo(CameraState.Preview));
using (var eventWaiter = EventAwaiter <EventArgs> .Create())
{
TestCamera.CaptureCompleted += eventWaiter;
TestCamera.StartCapture();
Assert.That(await eventWaiter.IsRaisedAsync());
}
}
public async Task MediaPacketPreview_CHECK_EVENT()
{
if (TestCamera.Capabilities.IsMediaPacketPreviewCallbackSupported == false)
{
Assert.Pass("MediaPacketPreviewCallback feature is not supported.");
}
using (var eventWaiter = EventAwaiter <MediaPacketPreviewEventArgs> .Create())
{
TestCamera.MediaPacketPreview += eventWaiter;
TestCamera.StartPreview();
var eventArgs = await eventWaiter.GetResultAsync();
Assert.IsNotNull(eventArgs.Packet);
}
}
public async Task StartCapture_CHANGE_STATUS()
{
TestCamera.StartPreview();
using (var completeWaiter = EventAwaiter <CameraCapturingEventArgs> .Create())
using (var tokenSource = new CancellationTokenSource())
{
try
{
TestCamera.Capturing += completeWaiter;
TestCamera.StartCapture(10, 100, tokenSource.Token);
await completeWaiter.IsRaisedAsync();
}
catch (NotSupportedException)
{
if (TestCamera.Capabilities.IsContinuousCaptureSupported)
{
Assert.Fail("Continuous capture is failed.");
}
else
{
Assert.Pass("Continuous capture feature is not supported.");
}
}
catch (Exception ex)
{
Assert.Fail("Continuous capture is failed. Msg : " + ex.ToString());
}
/* TESTCODE */
using (var eventWaiter = EventAwaiter <CameraStateChangedEventArgs> .Create())
{
TestCamera.StateChanged += eventWaiter;
tokenSource.Cancel();
await eventWaiter.IsRaisedAsync();
}
Assert.That(TestCamera.State, Is.EqualTo(CameraState.Captured));
}
}
public void SubscribeAll_TriggerWithSingleEvent()
{
EventAwaiter<LogsMonitorEventArgs> allAwaiter = new EventAwaiter<LogsMonitorEventArgs>();
EventHandler<LogsMonitorEventArgs> allEventHandler = allAwaiter.GetEventHandler();
System.SubscribeAllActive(allEventHandler);
WriteToLogFile("_Event.2014-01-01.txt", "Logging started 2014-01-01");
WriteToLogFile("_Event.2014-01-01.txt", "[00:00:12] Horses like this one have many uses.");
allAwaiter.WaitInvocations(1);
allAwaiter.WaitUntilMatch(list =>
{
var match1 = list.Any(
args =>
args.CharacterName == TestGuyCharacterName
&& args.WurmLogEntries.Any(
entry =>
entry.Content == "Horses like this one have many uses."
&& entry.Timestamp == new DateTime(2014, 1, 1, 0, 0, 12)));
return match1;
});
}
public void Setup()
{
invoker = new PublicEventInvoker(new ThreadPoolMarshaller(logger), logger)
{
LoopDelayMillis = 1
};
eventAwaiter = new EventAwaiter<EventArgs>();
Foovent += eventAwaiter.Handle;
}
public void SubscribeSingleLogType_TriggerWithSingleEvent()
{
EventAwaiter<LogsMonitorEventArgs> awaiter = new EventAwaiter<LogsMonitorEventArgs>();
var handler = awaiter.GetEventHandler();
System.Subscribe(TestGuyCharacterName, LogType.Event, handler);
WriteToLogFile("_Event.2014-01-01.txt", "Logging started 2014-01-01");
WriteToLogFile("_Event.2014-01-01.txt", "[00:00:12] Horses like this one have many uses.");
awaiter.WaitInvocations(1);
awaiter.WaitUntilMatch(list =>
{
var match1 = list.Any(
args =>
args.CharacterName == TestGuyCharacterName
&& args.WurmLogEntries.Any(
entry =>
entry.Content == "Horses like this one have many uses."
&& entry.Timestamp == new DateTime(2014,1,1, 0,0,12)));
return match1;
});
System.Unsubscribe(TestGuyCharacterName, handler);
WriteToLogFile("_Event.2014-01-01.txt", "[00:00:13] Horses like this one have many uses.");
Thread.Sleep(1000);
var unexpected = awaiter.Invocations.Any(
args =>
args.WurmLogEntries.Any(
entry =>
entry.Timestamp == new DateTime(2014,1,1, 0,0,13)));
Expect(unexpected, False);
}
public void TriggersEventOnChanged()
{
IWurmConfig config = System.GetConfig(configMock.Name);
Expect(config.NoSkillMessageOnFavorChange, False);
var configAwaiter = new EventAwaiter<EventArgs>();
config.ConfigChanged += configAwaiter.Handle;
configMock.GameSettings.ChangeValue("skillgain_no_favor", "true");
awaiter.WaitInvocations(2, 10000);
Expect(config.NoSkillMessageOnFavorChange, True);
}
