public NavigatorV2(
MethodRunner runner,
Do <Presenter> startPresenter)
: base(runner, startPresenter)
{
this.locker = new object();
}
public LoggingTimer(
Do <LoggingTimer, LogEditor> log,
MethodRunner runner)
{
this.log = log;
this.runner = runner;
}
protected ThreadSafeNavigator(
MethodRunner runner,
Do <Presenter> startPresenter,
object locker)
: base(runner, startPresenter, locker)
{
}
protected NavigatorV2(
MethodRunner runner,
object locker)
: base(runner)
{
this.locker = locker;
}
protected ThreadSafeNavigator(
MethodRunner runner,
Do <Presenter> startPresenter,
ICollection <Presenter> presenters)
: base(runner, startPresenter, presenters)
{
}
public MethodInjector(
MethodRunner runner)
{
this.runner = runner;
this.methods = new List <Tuple <object, Type, string, string> >(
0x10000);
}
public void RunEntryMethod_ThrowsExceptionIfEntryClassDoesNotHaveEntryMethod()
{
// Arrange
string testEntryClassName = "testEntryClassName";
string testAssemblyName = "testAssemblyName";
string testEntryMethodName = "testEntryMethodName";
Mock <ILoggingService <MethodRunner> > mockRunnerLS = _mockRepository.Create <ILoggingService <MethodRunner> >();
mockRunnerLS.Setup(p => p.IsEnabled(LogLevel.Debug)).Returns(false);
Mock <Type> mockType = _mockRepository.Create <Type>();
AssemblyName stubAssemblyName = new AssemblyName(testAssemblyName);
Mock <Assembly> mockAssembly = _mockRepository.Create <Assembly>();
mockAssembly.Setup(a => a.GetType(testEntryClassName)).Returns(mockType.Object);
mockAssembly.Setup(a => a.GetName()).Returns(stubAssemblyName);
Mock <ITypeService> mockTypeService = _mockRepository.Create <ITypeService>();
mockTypeService.
Setup(t => t.GetMethod(mockType.Object, testEntryMethodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)).
Returns((MethodInfo)null);
MethodRunner runner = CreateLoader(mockRunnerLS.Object, typeService: mockTypeService.Object);
// Act and Assert
Exception result = Assert.Throws <Exception>(() => runner.Run(mockAssembly.Object, testEntryClassName, testEntryMethodName, null));
Assert.Equal(string.Format(Strings.Exception_ClassDoesNotHaveEntryMethod, testEntryClassName, testAssemblyName, testEntryMethodName), result.Message);
}
protected NavigatorV2(
MethodRunner runner,
Do <Presenter> startPresenter,
object locker)
: base(runner, startPresenter)
{
this.locker = locker;
}
public LicensePresenter(
LicenseUi ui,
MethodRunner runner)
: base(ui)
{
this.ui = ui;
this.runner = runner;
}
protected NavigatorV2(
MethodRunner runner,
Do <Presenter> startPresenter,
ICollection <Presenter> presenters)
: base(runner, startPresenter, presenters)
{
this.locker = new object();
}
public LogEditorPresenter(
LogEditorUi ui,
MethodRunner runner)
: base(ui)
{
this.ui = ui;
this.runner = runner;
}
public LogStatisticsPresenter(
LogStatisticsUi ui,
MethodRunner runner)
: base(ui)
{
this.ui = ui;
this.runner = runner;
}
public MainPresenter(
MainUi ui,
MethodRunner runner)
: base(ui, null)
{
this.ui = ui;
this.runner = runner;
}
protected Navigator(
MethodRunner runner,
Do <Presenter> startPresenter,
ICollection <Presenter> presenters)
{
this.runner = runner;
this.startPresenter = startPresenter;
this.presenters = presenters;
}
public Navigator(
MethodRunner runner,
Do <Presenter> startPresenter)
: this(
runner,
startPresenter,
new LinkedList <Presenter>())
{
}
public LogPresenter(
LogUi ui,
ShellUi shell,
MethodRunner runner)
: base(ui, shell)
{
this.ui = ui;
this.runner = runner;
}
public StatisticsPresenter(
StatisticsUi ui,
ShellUi shell,
MethodRunner runner)
: base(ui, shell)
{
this.ui = ui;
this.runner = runner;
}
public TimestampEditPresenter(
TimestampEditUi ui,
ShellUi shell,
MethodRunner runner)
: base(ui, shell)
{
this.ui = ui;
this.runner = runner;
}
public HomeNavPresenter(
HomeNavUi ui,
ShellUi shell,
MethodRunner runner)
: base(ui, shell)
{
this.ui = ui;
this.runner = runner;
}
/// <summary>
/// Reports that a timing method was found.
/// </summary>
/// <param name="methodRunner">The method which is being added.</param>
public void AddTimingMethod(MethodRunner methodRunner)
{
if (methodRunner.TimingAttribute.Singleton)
{
Console.WriteLine(" Info: Found timing: {0} [Singleton]", methodRunner.Method);
}
else
{
Console.WriteLine(" Info: Found timing: {0}", methodRunner.Method);
}
}
/// <summary>
/// Reports that a timing method was found.
/// </summary>
/// <param name="methodRunner">The method which is being added.</param>
public void AddTimingMethod(MethodRunner methodRunner)
{
if (methodRunner.TimingAttribute.Singleton)
{
Console.WriteLine(" Info: Found timing: {0} [Singleton]", methodRunner.Method);
}
else
{
Console.WriteLine(" Info: Found timing: {0}", methodRunner.Method);
}
}
public Navigator(
MethodRunner runner)
: this(
runner,
p =>
{
ThreadPool.QueueUserWorkItem(
o => p?.Start());
})
{
}
public void RegisterMethod(string name, MethodRunner method)
{
if (!methods.ContainsKey(name))
{
methods.Add(name, method);
}
else
{
methods[name] = method;
}
}
private Method BuildMethod(MethodConfig methodConfig)
{
var w = new SourceWriter();
MethodDef def = this;
var builder = new MethodRunner(methodConfig, w);
builder.WriteMethod();
return(new Method(methodConfig.Method.Name, methodConfig.MethodType, w.ToString()));
}
Task ISampleModelService.SaveItem(ISampleModel item) => MethodRunner.RunAsync(() =>
{
var dto = _mapper.MapFromSampleModel(item);
if (item.IsNew)
{
_provider.CreateItem(dto);
}
else
{
_provider.UpdateItem(dto);
}
});
public LoggingTimer(
MethodRunner runner)
{
this.runner = runner;
this.log = (lt, le) =>
{
le?.AddEntry(
DefaultEntryTypes.Information,
new[]
{
@"Timer " + this.Name + @" elapsed.",
@"Interval: " + lt.CurrentInterval
});
};
}
private void VerifyObjectMethod(string regionName, MethodType type, string expected)
{
var doc = GetDocument();
var config = GetDocumentConfig(doc);
var methodImpl = GetObjectMethod(doc);
var template = GetResolvedTemplate(methodImpl, config);
var region = template.Regions.First(r => r.Name == regionName);
var methodDef = region.MethodDefs.First();
var writer = new SourceWriter();
var builder = new MethodRunner(new MethodConfig(methodImpl, methodDef, type, config), writer);
builder.WriteMethod();
expected = expected.TrimStart('\r', '\n');
Assert.AreEqual(expected, writer.ToString());
}
public void RunEntryMethod_ThrowsExceptionIfAssemblyDoesNotHaveSpecifiedEntryClass()
{
// Arrange
string testEntryClassName = "testEntryClassName";
string testAssemblyName = "testAssemblyName";
Mock <ILoggingService <MethodRunner> > mockRunnerLS = _mockRepository.Create <ILoggingService <MethodRunner> >();
mockRunnerLS.Setup(p => p.IsEnabled(LogLevel.Debug)).Returns(false);
AssemblyName stubAssemblyName = new AssemblyName(testAssemblyName);
Mock <Assembly> mockAssembly = _mockRepository.Create <Assembly>();
mockAssembly.Setup(a => a.GetType(testEntryClassName)).Returns((Type)null);
mockAssembly.Setup(a => a.GetName()).Returns(stubAssemblyName);
MethodRunner runner = CreateLoader(mockRunnerLS.Object);
// Act and Assert
Exception result = Assert.Throws <Exception>(() => runner.Run(mockAssembly.Object, testEntryClassName, null, null));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.Exception_AssemblyDoesNotHaveClass, testAssemblyName, testEntryClassName), result.Message);
}
public ConfigKeyTappedHandler(
MethodRunner runner)
{
this.runner = runner;
}
public SetupHandler(
MethodRunner runner)
{
this.runner = runner;
}
/// <summary>
/// Reports that a timing method was found.
/// </summary>
/// <param name="methodRunner">The method which is being added.</param>
public void AddTimingMethod(MethodRunner methodRunner)
{
listeners.ForEach(sl => sl.AddTimingMethod(methodRunner));
}
public NewestKeyTappedHandler(
MethodRunner runner)
{
this.runner = runner;
}