public void SingleShotTimer_Elapsed_CanRestartTimer()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
if (actionCount == 0)
{
timer.Restart();
}
++actionCount;
};
timer.AutoReset = false;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(2, actionCount, "Timer did not honor Restart when called from Elapsed");
}
public void PeriodicTimer_Elapsed_CanCancelTimer()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
++actionCount;
timer.Cancel();
};
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(1, actionCount, "Timer did not honor Cancel when called from Elapsed");
}
public void PeriodicTimer_Elapsed_CanCancelTimer()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
++actionCount;
timer.Cancel();
};
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(1, actionCount, "Timer did not honor Cancel when called from Elapsed");
}
public void PeriodicTimer_Elapsed_IsEnabled()
{
bool enabled = false;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
enabled = timer.Enabled;
timer.Cancel();
};
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.IsTrue(enabled, "Periodic Timer should be enabled when called from Elapsed");
}
public void PeriodicTimer_Elapsed_CanChangeInterval()
{
TimeSpan interval = default(TimeSpan);
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
timer.Interval = TimeSpan.FromMilliseconds(1);
interval = timer.Interval;
timer.Cancel();
};
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(TimeSpan.FromMilliseconds(1), interval, "Interval should be honored when called from Elapsed");
}
public void PeriodicTimer_Elapsed_CanChangeToSingleShot()
{
bool autoReset = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
timer.SetSingleShot(timer.Interval);
autoReset = timer.AutoReset;
timer.Cancel();
};
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.IsFalse(autoReset, "Periodic Timer should be able to change to Single-shot within Elapsed");
}
public void PeriodicTimer_Elapsed_CanChangeInterval()
{
TimeSpan interval = default(TimeSpan);
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
timer.Interval = TimeSpan.FromMilliseconds(1);
interval = timer.Interval;
timer.Cancel();
};
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(TimeSpan.FromMilliseconds(1), interval, "Interval should be honored when called from Elapsed");
}
public void Timer_SetNegativeInterval_IsRejected()
{
Exception ex = null;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
try
{
using (Timer timer = new Timer())
{
timer.Interval = TimeSpan.FromMilliseconds(-1);
}
}
catch (Exception error)
{
ex = error;
}
});
}
Assert.IsNotNull(ex, "Timer.Interval should reject negative intervals");
}
public void Timer_SetTooBigInterval_IsRejected()
{
Exception ex = null;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
try
{
using (Timer timer = new Timer())
{
timer.Interval = TimeSpan.FromMilliseconds(((double)int.MaxValue) + 1);
}
}
catch (Exception error)
{
ex = error;
}
});
}
Assert.IsNotNull(ex, "Timer.Interval should reject intervals larger than int.MaxValue");
}
public void SyncAction_QueuedBeforeStart_ThrowsThreadStateException()
{
using (ActionThread thread = new ActionThread())
{
thread.DoSynchronously(() => { });
}
}
public void SyncAction_QueuedAfterJoin_ThrowsThreadStateException()
{
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.Join();
thread.DoSynchronously(() => { });
}
}
public void SyncAction_QueuedAfterStart_IsExecutedByThread()
{
int threadId = Thread.CurrentThread.ManagedThreadId;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() => { threadId = Thread.CurrentThread.ManagedThreadId; });
Assert.AreEqual(thread.ManagedThreadId, threadId, "ActionThread ran in wrong thread context");
}
}
static void Main()
{
ActionThread actionThread = new ActionThread();
// Set IsBackground so that this thread won't prevent the program from exiting
actionThread.IsBackground = true;
actionThread.Start();
// Wait 100 ms for the ActionThread to sleep for 1 minute
bool done = actionThread.DoSynchronously(() => Thread.Sleep(TimeSpan.FromMinutes(1)), TimeSpan.FromMilliseconds(100));
Console.WriteLine("ActionThread completed action synchronously: " + done);
}
public void SingleShotTimer_Elapsed_InvokesElapsedExactlyOnce()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () => { ++actionCount; };
timer.AutoReset = false;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(1, actionCount, "Timer did not run Elapsed exactly once");
}
public void PeriodicTimer_Elapsed_InvokesElapsedMoreThanOnce()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () => { ++actionCount; };
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.IsTrue(actionCount > 1, "Timer did not run Elapsed more than once");
}
static void Main()
{
using (ActionThread actionThread = new ActionThread())
{
actionThread.Start();
Console.WriteLine("Console thread ID: " + Thread.CurrentThread.ManagedThreadId);
// Any delegates passed to ActionThread.DoSynchronously are run by that ActionThread (synchronously)
int actionThreadID = 0;
actionThread.DoSynchronously(() => actionThreadID = Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("ActionThread thread ID: " + actionThreadID);
}
}
public void Timer_AfterConstruction_IsDisabled()
{
bool enabled = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
enabled = timer.Enabled;
}
});
}
Assert.IsFalse(enabled, "Timer.Enabled should initially be false");
}
static void Main(string[] args)
{
nito.Start();
nito.DoSynchronously(() =>
{
timer = new Nito.Async.Timer();
timer.AutoReset = false;
timer.Elapsed += timer_Elapsed;
Session.OnAudioDataArrived += Session_OnAudioDataArrived;
Session.OnAudioStreamComplete += Session_OnAudioStreamComplete;
Session.OnNotifyMainThread += Session_OnNotifyMainThread;
try
{
Session.appkey = System.IO.File.ReadAllBytes(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "spotify_appkey.key"));
}
catch { }
bool gui = (args == null || args.Length == 0);
Log.gui = gui;
if (Session.appkey == null || Session.appkey.Length == 0)
{
Log.Error("Error: Can't find app key file spotify_appkey.key!");
}
else
{
lame.LameInit();
if (gui)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
frm = new Form1(Session.Login());
}
else
{
DoConsole(args);
}
}
});
if (Log.gui)
{
Application.Run(frm);
}
}
public void Timer_AfterSetSingleShot_IsEnabled()
{
bool enabled = false;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(50));
enabled = timer.Enabled;
}
});
}
Assert.IsTrue(enabled, "Timer.Enabled should be true");
}
public void TimerType_AfterSetSingleShot_IsSingleShot()
{
bool autoReset = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(50));
autoReset = timer.AutoReset;
}
});
}
Assert.IsFalse(autoReset, "Timer should be single-shot");
}
public void TimerInterval_AfterSetSingleShot_IsSetToArgument()
{
TimeSpan interval = default(TimeSpan);
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(50));
interval = timer.Interval;
}
});
}
Assert.AreEqual(TimeSpan.FromMilliseconds(50), interval, "Timer should have its Interval set");
}
public void TimerType_AfterSetPeriodic_IsPeriodic()
{
bool autoReset = false;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetPeriodic(TimeSpan.FromMilliseconds(50));
autoReset = timer.AutoReset;
}
});
}
Assert.IsTrue(autoReset, "Timer should be periodic");
}
public void Action_BeginInvokeThroughThreadPoolGSO_RunsOnAThreadPoolThread()
{
using (ActionThread thread = new ActionThread())
{
thread.Start();
bool threadPoolThreadIsThreadPoolThread = false;
thread.DoSynchronously(() =>
{
using (ScopedSynchronizationContext x = new ScopedSynchronizationContext(new SynchronizationContext()))
{
GenericSynchronizingObject test = new GenericSynchronizingObject();
IAsyncResult result = test.BeginInvoke((MethodInvoker)(() => { threadPoolThreadIsThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread; }), null);
test.EndInvoke(result);
}
});
Assert.IsTrue(threadPoolThreadIsThreadPoolThread, "ThreadPool thread is not a thread pool thread");
}
}
public void Timer_ElapsedAfterDisposed_DoesNotInvokeElapsed()
{
bool sawAction = false;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.Elapsed += () => { sawAction = true; };
timer.SetSingleShot(TimeSpan.FromMilliseconds(0));
Thread.Sleep(10);
}
});
}
Assert.IsFalse(sawAction, "Disposed timer invoked Elapsed");
}
public void Timer_Running_CanChangeInterval()
{
TimeSpan interval = default(TimeSpan);
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(0));
timer.Interval = TimeSpan.FromMilliseconds(1);
interval = timer.Interval;
}
});
}
Assert.AreEqual(TimeSpan.FromMilliseconds(1), interval, "Interval should be settable while the timer is running");
}
public void Timer_AfterCancel_IsDisabled()
{
bool enabled = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetPeriodic(TimeSpan.FromMilliseconds(50));
timer.Cancel();
enabled = timer.Enabled;
}
});
}
Assert.IsFalse(enabled, "Timer.Enabled should be false");
}
public void Action_BeginInvokeThroughThreadPoolGSO_Runs()
{
using (ActionThread thread = new ActionThread())
{
thread.Start();
bool sawAction = false;
thread.DoSynchronously(() =>
{
using (ScopedSynchronizationContext x = new ScopedSynchronizationContext(new SynchronizationContext()))
{
GenericSynchronizingObject test = new GenericSynchronizingObject();
IAsyncResult result = test.BeginInvoke((MethodInvoker)(() => { sawAction = true; }), null);
test.EndInvoke(result);
}
});
Assert.IsTrue(sawAction, "BeginInvoke did not execute action.");
}
}
public void Action_BeginInvokeThroughThreadPoolGSO_Runs()
{
using (ActionThread thread = new ActionThread())
{
thread.Start();
bool sawAction = false;
thread.DoSynchronously(() =>
{
using (ScopedSynchronizationContext x = new ScopedSynchronizationContext(new SynchronizationContext()))
{
GenericSynchronizingObject test = new GenericSynchronizingObject();
IAsyncResult result = test.BeginInvoke((MethodInvoker)(() => { sawAction = true; }), null);
test.EndInvoke(result);
}
});
Assert.IsTrue(sawAction, "BeginInvoke did not execute action.");
}
}
public void Action_BeginInvokeThroughThreadPoolGSO_RunsOnAThreadPoolThread()
{
using (ActionThread thread = new ActionThread())
{
thread.Start();
bool threadPoolThreadIsThreadPoolThread = false;
thread.DoSynchronously(() =>
{
using (ScopedSynchronizationContext x = new ScopedSynchronizationContext(new SynchronizationContext()))
{
GenericSynchronizingObject test = new GenericSynchronizingObject();
IAsyncResult result = test.BeginInvoke((MethodInvoker)(() => { threadPoolThreadIsThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread; }), null);
test.EndInvoke(result);
}
});
Assert.IsTrue(threadPoolThreadIsThreadPoolThread, "ThreadPool thread is not a thread pool thread");
}
}
public void Timer_AfterCancel_IsDisabled()
{
bool enabled = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetPeriodic(TimeSpan.FromMilliseconds(50));
timer.Cancel();
enabled = timer.Enabled;
}
});
}
Assert.IsFalse(enabled, "Timer.Enabled should be false");
}
public void SyncAction_QueuedAfterStart_IsExecutedByThread()
{
int threadId = Thread.CurrentThread.ManagedThreadId;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() => { threadId = Thread.CurrentThread.ManagedThreadId; });
Assert.AreEqual(thread.ManagedThreadId, threadId, "ActionThread ran in wrong thread context");
}
}
public void SingleShotTimer_Elapsed_IsDisabled()
{
bool enabled = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
enabled = timer.Enabled;
};
timer.AutoReset = false;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.IsFalse(enabled, "Single-shot Timer should be disabled when called from Elapsed");
}
public void Timer_Running_CanChangeInterval()
{
TimeSpan interval = default(TimeSpan);
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(0));
timer.Interval = TimeSpan.FromMilliseconds(1);
interval = timer.Interval;
}
});
}
Assert.AreEqual(TimeSpan.FromMilliseconds(1), interval, "Interval should be settable while the timer is running");
}
public void TimerInterval_AfterSetSingleShot_IsSetToArgument()
{
TimeSpan interval = default(TimeSpan);
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(50));
interval = timer.Interval;
}
});
}
Assert.AreEqual(TimeSpan.FromMilliseconds(50), interval, "Timer should have its Interval set");
}
public void TimerType_AfterSetPeriodic_IsPeriodic()
{
bool autoReset = false;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetPeriodic(TimeSpan.FromMilliseconds(50));
autoReset = timer.AutoReset;
}
});
}
Assert.IsTrue(autoReset, "Timer should be periodic");
}
public void TimerType_AfterSetSingleShot_IsSingleShot()
{
bool autoReset = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(50));
autoReset = timer.AutoReset;
}
});
}
Assert.IsFalse(autoReset, "Timer should be single-shot");
}
public void Timer_AfterSetSingleShot_IsEnabled()
{
bool enabled = false;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.SetSingleShot(TimeSpan.FromMilliseconds(50));
enabled = timer.Enabled;
}
});
}
Assert.IsTrue(enabled, "Timer.Enabled should be true");
}
public void Timer_ElapsedAfterDisposed_DoesNotInvokeElapsed()
{
bool sawAction = false;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
timer.Elapsed += () => { sawAction = true; };
timer.SetSingleShot(TimeSpan.FromMilliseconds(0));
Thread.Sleep(10);
}
});
}
Assert.IsFalse(sawAction, "Disposed timer invoked Elapsed");
}
public void SingleShotTimer_Elapsed_InvokesElapsedExactlyOnce()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () => { ++actionCount; };
timer.AutoReset = false;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(1, actionCount, "Timer did not run Elapsed exactly once");
}
public void SyncAction_QueuedAfterJoin_ThrowsThreadStateException()
{
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.Join();
thread.DoSynchronously(() => { });
}
}
public void SingleShotTimer_Elapsed_CanRestartTimer()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
if (actionCount == 0)
{
timer.Restart();
}
++actionCount;
};
timer.AutoReset = false;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.AreEqual(2, actionCount, "Timer did not honor Restart when called from Elapsed");
}
public void SyncAction_QueuedBeforeStart_ThrowsThreadStateException()
{
using (ActionThread thread = new ActionThread())
{
thread.DoSynchronously(() => { });
}
}
public void PeriodicTimer_Elapsed_InvokesElapsedMoreThanOnce()
{
int actionCount = 0;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () => { ++actionCount; };
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.IsTrue(actionCount > 1, "Timer did not run Elapsed more than once");
}
public void PeriodicTimer_Elapsed_CanChangeToSingleShot()
{
bool autoReset = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
Timer timer = null;
thread.DoSynchronously(() =>
{
timer = new Timer();
timer.Elapsed += () =>
{
timer.SetSingleShot(timer.Interval);
autoReset = timer.AutoReset;
timer.Cancel();
};
timer.AutoReset = true;
timer.Interval = TimeSpan.FromMilliseconds(0);
timer.Enabled = true;
});
Thread.Sleep(10);
thread.DoSynchronously(() => timer.Dispose());
}
Assert.IsFalse(autoReset, "Periodic Timer should be able to change to Single-shot within Elapsed");
}
public void Timer_AfterConstruction_IsDisabled()
{
bool enabled = true;
using (ActionThread thread = new ActionThread())
{
thread.Start();
thread.DoSynchronously(() =>
{
using (Timer timer = new Timer())
{
enabled = timer.Enabled;
}
});
}
Assert.IsFalse(enabled, "Timer.Enabled should initially be false");
}