public void WhenComponentKeyDoesNotMatch()
{
// Arrange
string longName = nameof(longName);
string shortName = nameof(shortName);
string key = nameof(key);
DirectiveComponents components = new DirectiveComponents(key, null, null);
var mock = new Mock <DirectiveHandler>();
mock.Setup(h => h.LongName).Returns(longName);
mock.Setup(h => h.ShortName).Returns(shortName);
DirectiveHandler sut = mock.Object;
// Act
Directive directive;
bool result = sut.TryParse(components, out directive);
// Assert
Assert.AreNotEqual(longName, key);
Assert.AreNotEqual(shortName, key);
Assert.IsFalse(result);
Assert.IsNull(directive);
}
public void Test_MoveRover2(string size, string initialPosition, string directionList)
{
SurfaceHandler _surfaceHandler = new SurfaceHandler();
var surface = _surfaceHandler.CreateSurface(size);
DeployRoverHandler deploy = new DeployRoverHandler();
var rover = deploy.DeployRover(initialPosition);
Console.WriteLine("Rover Test", rover.Position.Position_X.ToString());
string directiveList = directionList;
var directives = DirectiveHandler.DirectiveList(directiveList);
foreach (var item in directives)
{
if (item == Domain.Enums.Directive.RotateRight)
{
RightDirectiveHandler.TurnRight(rover);
}
else if (item == Domain.Enums.Directive.MoveForward)
{
MoveDirectionHandler.Move(rover, surface);
}
else if (item == Domain.Enums.Directive.RotateLeft)
{
LeftDirectiveHandler.TurnLeft(rover);
}
}
Assert.Equal(5, rover.Position.Position_X);
Assert.Equal(1, rover.Position.Position_Y);
Assert.Equal(Direction.E, rover.Position.Direction);
}
public void GetStringTest_Null()
{
// Arrange
var mock = new Mock <DirectiveHandler>();
DirectiveHandler sut = mock.Object;
// Act
string result = sut.GetString(null);
}
public void GetStringTest_ShortForm()
{
// Arrange
Directive directive = new TitlesDirective(Alignment.Left);
string expectedText = $"{{titles: left}}";
DirectiveHandler sut = TitlesHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_ShortForm()
{
// Arrange
Directive directive = new PageTypeDirective(PageType.Letter);
string expectedText = $"{{pagetype: letter}}";
DirectiveHandler sut = PageTypeHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_ShortForm()
{
// Arrange
int fontSize = 9;
Directive directive = new TextSizeDirective(fontSize);
string expectedText = $"{{ts: {fontSize}}}";
DirectiveHandler sut = TextSizeHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_LongForm()
{
// Arrange
int fontSize = 9;
Directive directive = new ChordSizeDirective(fontSize);
string expectedText = $"{{chordsize: {fontSize}}}";
DirectiveHandler sut = ChordSizeHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: false);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_LongForm()
{
// Arrange
string fontFamily = "times";
Directive directive = new ChordFontDirective(fontFamily);
string expectedText = $"{{chordfont: {fontFamily}}}";
DirectiveHandler sut = ChordFontHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: false);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_LongForm()
{
// Arrange
string comment = "some comment";
Directive directive = new CommentBoxDirective(comment);
string expectedText = $"{{comment_box: {comment}}}";
DirectiveHandler sut = CommentBoxHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: false);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_LongForm()
{
// Arrange
string title = "some title";
Directive directive = new TitleDirective(title);
string expectedText = $"{{title: {title}}}";
DirectiveHandler sut = TitleHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: false);
// Assert
Assert.AreEqual(expectedText, text);
}
private static (Domain.Rover, IList <Domain.Enums.Directive> directives) AddRover()
{
Console.WriteLine("Please set the initial rover position Eg:1 2 N");
string initialPosition = Console.ReadLine();
DeployRoverHandler deploy = new DeployRoverHandler();
var rover = deploy.DeployRover(initialPosition);
Console.WriteLine("Please set the rover move list Eg:LLRMMRL");
string directiveList = Console.ReadLine();
var directives = DirectiveHandler.DirectiveList(directiveList);
return(rover, directives);
}
public void GetStringTest_ShortForm()
{
// Arrange
int number = 3;
Directive directive = new ColumnsDirective(number);
string expectedText = $"{{col: {number}}}";
DirectiveHandler sut = ColumnsHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_ShortForm()
{
// Arrange
string color = "red";
Directive directive = new ChordColourDirective(color);
string expectedText = $"{{chordcolour: {color}}}";
DirectiveHandler sut = ChordColourHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_ShortForm()
{
// Arrange
string subtitle = "some subtitle";
Directive directive = new SubtitleDirective(subtitle);
string expectedText = $"{{st: {subtitle}}}";
DirectiveHandler sut = SubtitleHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_ShortForm()
{
// Arrange
string fontFamily = "times";
Directive directive = new TextFontDirective(fontFamily);
string expectedText = $"{{tf: {fontFamily}}}";
DirectiveHandler sut = TextFontHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GetStringTest_ShortForm()
{
// Arrange
string comment = "some comment";
Directive directive = new CommentItalicDirective(comment);
string expectedText = $"{{ci: {comment}}}";
DirectiveHandler sut = CommentItalicHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void TryParseTest_LongForm_Other()
{
// Arrange
string input = $"{{pagetype: not a valid page type}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = PageTypeHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsFalse(result);
}
public void GetStringTest_ShortForm()
{
// Arrange
string chord = "X";
string definition = "some definition";
Directive directive = new DefineDirective(chord, definition);
string expectedText = $"{{define {chord}: {definition}}}";
DirectiveHandler sut = DefineHandler.Instance;
// Act
string text = sut.GetString(directive, shorten: true);
// Assert
Assert.AreEqual(expectedText, text);
}
public void TryParseTest_NaN()
{
// Arrange
string input = $"{{columns: NaN}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = ColumnsHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsFalse(result);
Assert.IsNull(directive);
}
private void DoGetSubKeyStringTest(string subkey, ComponentPresence subKeyPresence, string expectedResult)
{
// Arrange
var mock = new Mock <DirectiveHandler>();
mock.Setup(h => h.SubKey).Returns(subKeyPresence);
DirectiveHandler sut = mock.Object;
// Act
string result = sut.GetSubKeyString(subkey);
// Assert
Assert.AreEqual(expectedResult, result);
}
private void DoGetValueStringTest(string value, ComponentPresence valuePresence, string expectedResult)
{
// Arrange
var mock = new Mock <DirectiveHandler>();
mock.Setup(h => h.Value).Returns(valuePresence);
DirectiveHandler sut = mock.Object;
// Act
string result = sut.GetValueString(value);
// Assert
Assert.AreEqual(expectedResult, result);
}
private Token?head; //TODO: Make this make sense
public EAParser(Dictionary <string, IList <Raw> > raws, Log log, DirectiveHandler directiveHandler)
{
GlobalScope = new ImmutableStack <Closure>(new BaseClosure(this), ImmutableStack <Closure> .Nil);
pastOffsets = new Stack <Tuple <int, bool> >();
protectedRegions = new List <Tuple <int, int, Location> >();
this.log = log;
Raws = raws;
CurrentOffset = 0;
validOffset = true;
offsetInitialized = false;
Macros = new MacroCollection(this);
Definitions = new Dictionary <string, Definition>();
Inclusion = ImmutableStack <bool> .Nil;
this.directiveHandler = directiveHandler;
Pool = new Pool();
}
public void TryParseTest_ShortForm()
{
// Arrange
int fontSize = 9;
string input = $"{{ts: {fontSize}}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = TextSizeHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(TextSizeDirective));
Assert.AreEqual(fontSize, (directive as TextSizeDirective).FontSize);
}
public void TryParseTest_ShortForm()
{
// Arrange
string subtitle = "some subtitle";
string input = $"{{st: {subtitle}}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = SubtitleHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(SubtitleDirective));
Assert.AreEqual(subtitle, (directive as SubtitleDirective).Text);
}
public void TryParseTest_LongForm_A4()
{
// Arrange
PageType pageType = PageType.A4;
string input = $"{{pagetype: a4}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = PageTypeHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(PageTypeDirective));
Assert.AreEqual(pageType, (directive as PageTypeDirective).PageType);
}
public void TryParseTest_ShortForm()
{
// Arrange
string comment = "some comment";
string input = $"{{ci: {comment}}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = CommentItalicHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(CommentItalicDirective));
Assert.AreEqual(comment, (directive as CommentItalicDirective).Text);
}
public void TryParseTest_LongForm()
{
// Arrange
string color = "red";
string input = $"{{chordcolour: {color}}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = ChordColourHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(ChordColourDirective));
Assert.AreEqual(color, (directive as ChordColourDirective).Colour);
}
public void TryParseTest_ShortForm()
{
// Arrange
string fontFamily = "times";
string input = $"{{tf: {fontFamily}}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = TextFontHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(TextFontDirective));
Assert.AreEqual(fontFamily, (directive as TextFontDirective).FontFamily);
}
public void TryParseTest_LongForm_Center()
{
// Arrange
Alignment alignment = Alignment.Center;
string input = $"{{titles: center}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = TitlesHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(TitlesDirective));
Assert.AreEqual(alignment, (directive as TitlesDirective).Flush);
}
public void TryParseTest_ShortForm()
{
// Arrange
int number = 3;
string input = $"{{col: {number}}}";
DirectiveComponents components = DirectiveComponents.Parse(input);
DirectiveHandler sut = ColumnsHandler.Instance;
Directive directive;
// Act
bool result = sut.TryParse(components, out directive);
// Assert
Assert.IsTrue(result);
Assert.IsInstanceOfType(directive, typeof(ColumnsDirective));
Assert.AreEqual(number, (directive as ColumnsDirective).Number);
}
