public override void Setup()
{
base.Setup();
var commands = new[]
{
new CommandDescriptor("IdentityRunnable", String.Empty, Enumerable.Empty<ArgumentDescriptor>(), new[] {"IdentityRunnable"}),
new CommandDescriptor("IncrementRunnable", String.Empty, new[]
{
new ArgumentDescriptor
{
ArgumentType = typeof (Double),
ArgumentName = "value",
DefaultValue = 0,
IsOptional = false,
Position = 0
}
}, new[] {"IncrementRunnable", "increment", "inc"})
};
var runnableFactory = new DefaultRunnableFactory(new[] {typeof (IdentityRunnable), typeof (IncrementRunnable)});
var repository = new MemoryDescriptorRepository(commandDescriptors: commands);
var commandCallResolver = new DefaultCommandCallResolver(repository, runnableFactory);
var selectorManager = new DefaultSelectorFactory();
var nodeSelectorResolver = new DefaultSelectorResolver(selectorManager, repository);
var runnableManager = new DefaultRunnableManager();
var executor = new StandardExecutor(runnableManager);
// initialize compiler and control flow factory
ControlFlowFactory = new DefaultControlFlowFactory(commandCallResolver, nodeSelectorResolver, executor);
Compiler = new CodeQueryCompiler();
}
public void ShouldReturnDefinedCombinatorDescriptors_AfterCallingIt()
{
// Given in setup
var combinators = new[]
{
new CombinatorDescriptor("test-combinator", "test", typeof (Object))
};
var underTest = new MemoryDescriptorRepository(combinatorDescriptors: combinators);
// When
var result = underTest.GetCombinatorDescriptors();
// Then
Assert.That(result, Is.EquivalentTo(new[]
{
new CombinatorDescriptor("test-combinator", "test", typeof (Object))
}));
}
public void ShouldReturnDefinedSelectorDescriptors_AfterCallingIt()
{
// Given
var selectors = new[]
{
new SelectorDescriptor("test-selector", "test-selector", typeof (Object))
};
var underTest = new MemoryDescriptorRepository(selectorDescriptors: selectors);
// When
var result = underTest.GetSelectorDescriptors();
// Then
Assert.That(result, Is.EquivalentTo(new[]
{
new SelectorDescriptor("test-selector", "test-selector", typeof (Object)),
}));
}
public void ShouldReturnDefinedModifierSelectorDescriptors_AfterCallingIt()
{
// Given in setup
var modifierDescriptors = new[]
{
new ModifierDescriptor("test-modifier", "test-modifier", Enumerable.Empty<String>(), typeof (Object),
false),
};
var underTest = new MemoryDescriptorRepository(modifierDescriptors: modifierDescriptors);
// When
var result = underTest.GetModifierDescriptors();
// Then
Assert.That(result, Is.EquivalentTo(new[]
{
new ModifierDescriptor("test-modifier", "test-modifier", Enumerable.Empty<String>(), typeof (Object),
false)
}));
}
public void ShouldReturnDefinedCommandDescriptors_AfterCallingIt()
{
// Given
var commandDescriptors = new[]
{
new CommandDescriptor(
commandNames: new[] {"test"},
arguments: Enumerable.Empty<ArgumentDescriptor>(),
description: "test description",
name: "test-command")
};
var underTest = new MemoryDescriptorRepository(commandDescriptors: commandDescriptors);
// When
var result = underTest.GetCommandDescriptors();
// Then
Assert.That(result, Is.EquivalentTo(new[]
{
new CommandDescriptor(
commandNames: new[] {"test"},
arguments: Enumerable.Empty<ArgumentDescriptor>(),
description: "test description",
name: "test-command")
}));
}
