mirror of
https://github.com/Laupetin/OpenAssetTools.git
synced 2025-06-10 14:58:10 -05:00
Remove old ZoneCodeGenerator implementation in c#
This commit is contained in:
Jan
@ -1,47 +0,0 @@
|
||||
ZoneCodeGeneratorTests = {}
|
||||
|
||||
function ZoneCodeGeneratorTests:include()
|
||||
|
||||
end
|
||||
|
||||
function ZoneCodeGeneratorTests:link()
|
||||
if References:link("ZoneCodeGeneratorTests") then
|
||||
links "ZoneCodeGeneratorTests"
|
||||
end
|
||||
end
|
||||
|
||||
function ZoneCodeGeneratorTests:use()
|
||||
|
||||
end
|
||||
|
||||
function ZoneCodeGeneratorTests:project()
|
||||
References:reset()
|
||||
local folder = TestFolder();
|
||||
|
||||
project "ZoneCodeGeneratorTests"
|
||||
targetdir(TargetDirectoryTest)
|
||||
location "%{wks.location}/test/%{prj.name}"
|
||||
kind "SharedLib"
|
||||
language "C#"
|
||||
dotnetframework "4.5"
|
||||
|
||||
files {
|
||||
path.join(folder, "ZoneCodeGeneratorTests/**.cs")
|
||||
}
|
||||
|
||||
vpaths { ["*"] = "test/ZoneCodeGeneratorTests" }
|
||||
|
||||
nuget {
|
||||
"Moq:4.13.1",
|
||||
"MSTest.TestFramework:2.0.0",
|
||||
"MSTest.TestAdapter:2.0.0"
|
||||
}
|
||||
|
||||
links {
|
||||
"System",
|
||||
"System.Core",
|
||||
"System.Data"
|
||||
}
|
||||
|
||||
ZoneCodeGenerator:link()
|
||||
end
|
||||
@ -1,25 +0,0 @@
|
||||
using System.Collections;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
|
||||
namespace ZoneCodeGeneratorTests
|
||||
{
|
||||
public static class AssertionExtensions
|
||||
{
|
||||
public static void Contains(this Assert assert, object expected, ICollection collection)
|
||||
{
|
||||
if (collection.Cast<object>().Any(item => item == expected))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
throw new AssertFailedException();
|
||||
}
|
||||
|
||||
public static void IsZero(this Assert assert, int number)
|
||||
{
|
||||
if(number != 0)
|
||||
throw new AssertFailedException();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,95 +0,0 @@
|
||||
using System;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Domain
|
||||
{
|
||||
[TestClass]
|
||||
public class NamespaceTest
|
||||
{
|
||||
[TestMethod]
|
||||
public void EnsureEmptyNamespaceResultIsCorrect()
|
||||
{
|
||||
var nameSpace = new Namespace();
|
||||
|
||||
Assert.AreEqual("", nameSpace.GetName());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSingleNamespaceElementResultIsCorrect()
|
||||
{
|
||||
var nameSpace = new Namespace();
|
||||
|
||||
nameSpace.Push("NameTheSpace");
|
||||
|
||||
Assert.AreEqual("NameTheSpace", nameSpace.GetName());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoubleNamespaceElementResultIsCorrect()
|
||||
{
|
||||
var nameSpace = new Namespace();
|
||||
|
||||
nameSpace.Push("NameTheSpace");
|
||||
nameSpace.Push("Please");
|
||||
|
||||
Assert.AreEqual("NameTheSpace::Please", nameSpace.GetName());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsurePopRemovesNamespace()
|
||||
{
|
||||
var nameSpace = new Namespace();
|
||||
|
||||
nameSpace.Push("NameTheSpace");
|
||||
nameSpace.Push("Please");
|
||||
nameSpace.Push("Not");
|
||||
|
||||
Assert.AreEqual("Not", nameSpace.Pop());
|
||||
Assert.AreEqual("NameTheSpace::Please", nameSpace.GetName());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMultipleNamespaceElementsResultIsCorrect()
|
||||
{
|
||||
var nameSpace = new Namespace();
|
||||
|
||||
nameSpace.Push("NameTheSpace");
|
||||
nameSpace.Push("Please");
|
||||
nameSpace.Push("Just");
|
||||
nameSpace.Push("Not");
|
||||
nameSpace.Push("MySpace");
|
||||
|
||||
Assert.AreEqual("NameTheSpace::Please::Just::Not::MySpace", nameSpace.GetName());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamespaceCanBePoppedToEmpty()
|
||||
{
|
||||
var nameSpace = new Namespace();
|
||||
|
||||
nameSpace.Push("NameTheSpace");
|
||||
nameSpace.Push("Please");
|
||||
|
||||
Assert.AreEqual("Please", nameSpace.Pop());
|
||||
Assert.AreEqual("NameTheSpace", nameSpace.Pop());
|
||||
|
||||
Assert.AreEqual("", nameSpace.GetName());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureUsingPopTooOftenResultsInAnError()
|
||||
{
|
||||
var nameSpace = new Namespace();
|
||||
|
||||
nameSpace.Push("NameTheSpace");
|
||||
nameSpace.Push("Please");
|
||||
|
||||
Assert.AreEqual("Please", nameSpace.Pop());
|
||||
Assert.AreEqual("NameTheSpace", nameSpace.Pop());
|
||||
Assert.ThrowsException<InvalidOperationException>(() => nameSpace.Pop());
|
||||
|
||||
Assert.AreEqual("", nameSpace.GetName());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
using System;
|
||||
using System.Reflection;
|
||||
|
||||
namespace ZoneCodeGeneratorTests
|
||||
{
|
||||
internal static class FieldInjector
|
||||
{
|
||||
public static bool InjectToField(object target, object toInject)
|
||||
{
|
||||
if(target == null || toInject == null)
|
||||
throw new ArgumentException("Params must not be null");
|
||||
|
||||
var injectType = toInject.GetType();
|
||||
var fields = target.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
|
||||
|
||||
foreach(var field in fields)
|
||||
{
|
||||
if (!field.FieldType.IsAssignableFrom(injectType)) continue;
|
||||
|
||||
field.SetValue(target, toInject);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,186 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Impl;
|
||||
using ZoneCodeGenerator.Utils;
|
||||
using ZoneCodeGeneratorTests.Parsing.Mock;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Impl
|
||||
{
|
||||
[TestClass]
|
||||
public class PreprocessorTest
|
||||
{
|
||||
private IncludingParsingStreamTest headerStreamTest;
|
||||
private IHeaderParserState headerParserState;
|
||||
|
||||
private Preprocessor preprocessor;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
headerStreamTest = new IncludingParsingStreamTest("file.h");
|
||||
headerParserState = new HeaderParserState();
|
||||
preprocessor = new Preprocessor(headerStreamTest, headerParserState);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureReturnsUnmodifiedText()
|
||||
{
|
||||
string[] stringsThatShouldNotBeModified =
|
||||
{
|
||||
"This is a normal string",
|
||||
"There is nothing to be preprocessed!",
|
||||
"0124124124 # 124124124",
|
||||
"...",
|
||||
"<?php><html>asdf</html>",
|
||||
""
|
||||
};
|
||||
|
||||
headerStreamTest.Lines.AddRange(stringsThatShouldNotBeModified);
|
||||
|
||||
foreach (var stringThatShouldNotBeModified in stringsThatShouldNotBeModified)
|
||||
{
|
||||
Assert.AreEqual(stringThatShouldNotBeModified, preprocessor.ReadLine());
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDefinesArePlacedCorrectly()
|
||||
{
|
||||
var defineStrings = new Dictionary<string, string>()
|
||||
{
|
||||
{"#define World Hell", ""},
|
||||
{"Hello World!", "Hello Hell!"},
|
||||
{"World-wide Teamwork", "Hell-wide Teamwork"},
|
||||
{"#define great pretty bad", ""},
|
||||
{"Defines are great, right?", "Defines are pretty bad, right?"},
|
||||
{"Great world", "Great world"}, // Capitalization should matter
|
||||
};
|
||||
headerStreamTest.Lines.AddRange(defineStrings.Keys);
|
||||
|
||||
foreach (var (_, expectedResult) in defineStrings)
|
||||
{
|
||||
Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDefinesCanBeOverwritten()
|
||||
{
|
||||
var defineStrings = new Dictionary<string, string>()
|
||||
{
|
||||
{"#define World Hell", ""},
|
||||
{"#define World Mars", ""},
|
||||
{"Hello World!", "Hello Mars!"}
|
||||
};
|
||||
headerStreamTest.Lines.AddRange(defineStrings.Keys);
|
||||
|
||||
foreach (var (_, expectedResult) in defineStrings)
|
||||
{
|
||||
Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureEmptyDefinesResolveToEmpty()
|
||||
{
|
||||
var defineStrings = new Dictionary<string, string>
|
||||
{
|
||||
{"#define World", ""},
|
||||
{"Hello World!", "Hello !"}
|
||||
};
|
||||
headerStreamTest.Lines.AddRange(defineStrings.Keys);
|
||||
|
||||
foreach (var (_, expectedResult) in defineStrings)
|
||||
{
|
||||
Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureUndefRemovesDefines()
|
||||
{
|
||||
var defineStrings = new Dictionary<string, string>()
|
||||
{
|
||||
{"#define World Hell", ""},
|
||||
{"Hello World!", "Hello Hell!"},
|
||||
{"#undef World", ""},
|
||||
{"Hello World 2!", "Hello World 2!"},
|
||||
{"#define Hell Jupiter", ""},
|
||||
{"#define Hell Mars", ""},
|
||||
{"#undef Hell", ""},
|
||||
{"Hell no", "Hell no"},
|
||||
};
|
||||
headerStreamTest.Lines.AddRange(defineStrings.Keys);
|
||||
|
||||
foreach (var (_, expectedResult) in defineStrings)
|
||||
{
|
||||
Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsurePackIsParsedCorrectly()
|
||||
{
|
||||
var defaultPack = headerParserState.CurrentPack;
|
||||
|
||||
var packs = new List<Tuple<string, int>>
|
||||
{
|
||||
new Tuple<string, int>("Test", defaultPack),
|
||||
new Tuple<string, int>("#pragma pack(push, 16)", 16),
|
||||
new Tuple<string, int>("Test2", 16),
|
||||
new Tuple<string, int>("#pragma pack(push, 64)", 64),
|
||||
new Tuple<string, int>("Test3", 64),
|
||||
new Tuple<string, int>("Test4", 64),
|
||||
new Tuple<string, int>("#pragma pack(pop)", 16),
|
||||
new Tuple<string, int>("Test5", 16),
|
||||
new Tuple<string, int>("#pragma pack(pop)", defaultPack),
|
||||
new Tuple<string, int>("Test6", defaultPack)
|
||||
};
|
||||
headerStreamTest.Lines.AddRange(packs.Select(tuple => tuple.Item1));
|
||||
|
||||
foreach (var (_, expectedPack) in packs)
|
||||
{
|
||||
preprocessor.ReadLine();
|
||||
|
||||
Assert.AreEqual(expectedPack, headerParserState.CurrentPack);
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureIncludeChangesFileWhenUsingQuotationMarks()
|
||||
{
|
||||
headerStreamTest.Lines.AddRange(new []
|
||||
{
|
||||
"#include \"asdf.h\"",
|
||||
"#include \"file/path/to/header.h\""
|
||||
});
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(1, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("asdf.h", headerStreamTest.LastInclude);
|
||||
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(2, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("file/path/to/header.h", headerStreamTest.LastInclude);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureIncludeChangesFileWhenUsingCarets()
|
||||
{
|
||||
headerStreamTest.Lines.AddRange(new []
|
||||
{
|
||||
"#include <asdf.h>",
|
||||
"#include <file/path/to/header.h>"
|
||||
});
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(1, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("asdf.h", headerStreamTest.LastInclude);
|
||||
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(2, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("file/path/to/header.h", headerStreamTest.LastInclude);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,161 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Blocks;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestCloseBlockTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private Mock<Block> topBlock;
|
||||
private Mock<INameAssignable> topBlockNameAssignable;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
topBlock = new Mock<Block>(parserStateMock.Object, BlockType.None);
|
||||
topBlockNameAssignable = topBlock.As<INameAssignable>();
|
||||
|
||||
parserStateMock.SetupGet(state => state.CurrentBlock).Returns(() => topBlock.Object);
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRecognizesSimpleCurlyBrackets()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"}", "struct", "test", "{"
|
||||
});
|
||||
|
||||
var test = new TestCloseBlock(false);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object, true));
|
||||
|
||||
// Be sure there was no name assigned
|
||||
topBlockNameAssignable.Verify(assignable => assignable.AssignName(It.IsAny<string>()), Times.Never());
|
||||
|
||||
// Be sure the top block was popped
|
||||
parserStateMock.Verify(state => state.PopBlock());
|
||||
|
||||
Assert.AreEqual(1, test.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRecognizesCurlyBracketsWithSemicolon()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"}", ";", "struct", "test", "{"
|
||||
});
|
||||
|
||||
var test = new TestCloseBlock(true);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
// Be sure there was no name assigned
|
||||
topBlockNameAssignable.Verify(assignable => assignable.AssignName(It.IsAny<string>()), Times.Never());
|
||||
|
||||
// Be sure the top block was popped
|
||||
parserStateMock.Verify(state => state.PopBlock());
|
||||
|
||||
Assert.AreEqual(2, test.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWithoutSemicolonIfRequired()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"}", "struct", "test", "{"
|
||||
});
|
||||
|
||||
var test = new TestCloseBlock(true);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
// Be sure there was no name assigned
|
||||
topBlockNameAssignable.Verify(assignable => assignable.AssignName(It.IsAny<string>()), Times.Never());
|
||||
|
||||
parserStateMock.Verify(state => state.PopBlock(), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAssignsName()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"}", "closing_name", ";", "struct", "test", "{"
|
||||
});
|
||||
|
||||
var test = new TestCloseBlock(true);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
topBlockNameAssignable.Verify(assignable => assignable.AssignName("closing_name"));
|
||||
topBlockNameAssignable.VerifyNoOtherCalls();
|
||||
|
||||
// Be sure the top block was popped
|
||||
parserStateMock.Verify(state => state.PopBlock());
|
||||
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsIfCannotAssignName()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"}", "closing_name", ";", "struct", "test", "{"
|
||||
});
|
||||
|
||||
// No INameAssignable interface implemented
|
||||
topBlock = new Mock<Block>(parserStateMock.Object, BlockType.None);
|
||||
|
||||
var test = new TestCloseBlock(true);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
parserStateMock.Verify(state => state.PopBlock(), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotMatchIfNoCurlyBracket()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"{", "}", "struct", "test", "{"
|
||||
});
|
||||
|
||||
var test = new TestCloseBlock(false);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
parserStateMock.Verify(state => state.PopBlock(), Times.Never());
|
||||
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,318 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Blocks;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestEnumMemberTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private Mock<BlockEnum> enumMock;
|
||||
private EnumMember addedEnumMember;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
enumMock = new Mock<BlockEnum>(parserStateMock.Object, "testenum", DataTypeBaseType.INT, false);
|
||||
addedEnumMember = null;
|
||||
|
||||
parserStateMock.SetupGet(state => state.CurrentBlock).Returns(() => enumMock.Object);
|
||||
enumMock.Setup(_enum => _enum.AddMember(It.IsAny<EnumMember>()))
|
||||
.Callback((EnumMember member) => addedEnumMember = member);
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleEnumEntry()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(2, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("asdf", addedEnumMember.Name);
|
||||
Assert.AreEqual(0L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsEntryWithSpecialCharacters()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"$ASgF123__", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(2, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("$ASgF123__", addedEnumMember.Name);
|
||||
Assert.AreEqual(0L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsWithDigitInTheBeginning()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"123var", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsEntryWithDecimalNumber()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"leet", "=", "1337", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("leet", addedEnumMember.Name);
|
||||
Assert.AreEqual(1337L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsEntryWithHexadecimalNumber()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"smoke", "=", "0x1a4", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("smoke", addedEnumMember.Name);
|
||||
Assert.AreEqual(420L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsEntryWithoutName()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsEntryWithoutNameButWithNumber()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"=", "0", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsurePicksNextNumberWhenNoneSpecified()
|
||||
{
|
||||
enumMock.Setup(_enum => _enum.GetNextEnumValue()).Returns(1337L);
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(2, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("asdf", addedEnumMember.Name);
|
||||
Assert.AreEqual(1337L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNeedsTerminator()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", "nextentry"
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNeedsTerminatorEvenWithValueSpecified()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", "=", "0", "nextentry"
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsLastEntryWithoutComma()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", "}"
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(1, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("asdf", addedEnumMember.Name);
|
||||
Assert.AreEqual(0L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsLastEntryWithoutCommaWithValueSpecified()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", "=", "1336", "}"
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("asdf", addedEnumMember.Name);
|
||||
Assert.AreEqual(1336L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsOtherEnumValues()
|
||||
{
|
||||
var previousMember = new EnumMember("prev", 1335);
|
||||
|
||||
parserStateMock.Setup(state => state.FindEnumMember("prev")).Returns(previousMember);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", "=", "prev", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("asdf", addedEnumMember.Name);
|
||||
Assert.AreEqual(1335L, addedEnumMember.Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsErrorIfPreviousEnumValueNotDeclared()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", "=", "prev", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsErrorIfTopBlockIsNotEnum()
|
||||
{
|
||||
var blockMock = new Mock<Block>(parserStateMock.Object, BlockType.None);
|
||||
parserStateMock.SetupGet(state => state.CurrentBlock).Returns(blockMock.Object);
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asdf", "=", "0", ","
|
||||
});
|
||||
|
||||
var test = new TestEnumMember();
|
||||
|
||||
Assert.ThrowsException<Exception>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,394 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Blocks;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestEnumTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private Block pushedBlock;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
|
||||
parserStateMock.Setup(state => state.PushBlock(It.IsAny<Block>()))
|
||||
.Callback((Block block) => pushedBlock = block);
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleEnumOpening()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
|
||||
if (pushedBlock is BlockEnum blockEnum)
|
||||
{
|
||||
Assert.AreEqual("test_enum", blockEnum.Name);
|
||||
Assert.IsFalse(blockEnum.IsTypedef);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, blockEnum.ParentType);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be an enum");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsEnumAsTypedef()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "enum", "test_enum", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
|
||||
if (pushedBlock is BlockEnum blockEnum)
|
||||
{
|
||||
Assert.AreEqual("test_enum", blockEnum.Name);
|
||||
Assert.IsTrue(blockEnum.IsTypedef);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, blockEnum.ParentType);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be an enum");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsEnumWithParentTypeSpecified()
|
||||
{
|
||||
parserStateMock.Setup(state => state.FindType("unsigned char")).Returns(DataTypeBaseType.UNSIGNED_CHAR);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "unsigned", "char", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(6, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
|
||||
|
||||
if (pushedBlock is BlockEnum blockEnum)
|
||||
{
|
||||
Assert.AreEqual("test_enum", blockEnum.Name);
|
||||
Assert.IsFalse(blockEnum.IsTypedef);
|
||||
Assert.AreEqual(DataTypeBaseType.UNSIGNED_CHAR, blockEnum.ParentType);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be an enum");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsEnumWithParentTypeAsTypedef()
|
||||
{
|
||||
var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>());
|
||||
var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
|
||||
parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "bla_blub", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(5, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
|
||||
|
||||
if (pushedBlock is BlockEnum blockEnum)
|
||||
{
|
||||
Assert.AreEqual("test_enum", blockEnum.Name);
|
||||
Assert.IsFalse(blockEnum.IsTypedef);
|
||||
Assert.AreEqual(DataTypeBaseType.SHORT, blockEnum.ParentType);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be an enum");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsEnumWithParentTypeAsTypedefWithNamespace()
|
||||
{
|
||||
var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>());
|
||||
var typedef = new DataTypeTypedef("std", "bla_blub", typeDeclaration);
|
||||
parserStateMock.Setup(state => state.FindType("std::bla_blub")).Returns(typedef);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "std", ":", ":", "bla_blub", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(8, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
|
||||
|
||||
if (pushedBlock is BlockEnum blockEnum)
|
||||
{
|
||||
Assert.AreEqual("test_enum", blockEnum.Name);
|
||||
Assert.IsFalse(blockEnum.IsTypedef);
|
||||
Assert.AreEqual(DataTypeBaseType.SHORT, blockEnum.ParentType);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be an enum");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsEnumWithInvalidParentType()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "non_existant", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.Verify(state => state.FindType("non_existant"), Times.Once());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsEnumWithParentTypeAsTypedefWithArray()
|
||||
{
|
||||
var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>
|
||||
{
|
||||
new ReferenceTypeArray(3)
|
||||
});
|
||||
var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
|
||||
parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "bla_blub", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsEnumWithParentTypeAsTypedefWithPointerDepth()
|
||||
{
|
||||
var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>
|
||||
{
|
||||
new ReferenceTypePointer()
|
||||
});
|
||||
var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
|
||||
parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "bla_blub", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsEnumWithParentTypeNotBaseType()
|
||||
{
|
||||
var _struct = new DataTypeStruct("", "bla_blub", 4);
|
||||
parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(_struct);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "bla_blub", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsEnumWithParentTypeTypedefNotBaseType()
|
||||
{
|
||||
var _struct = new DataTypeStruct("", "bla_blub", 4);
|
||||
var typeDeclaration = new TypeDeclaration(_struct, new List<ReferenceType>());
|
||||
var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
|
||||
parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "bla_blub", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsWhenKeywordIsWrong()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"notenum", "test_enum", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsWhenNameIsWrong()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "3name", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsWhenNoCurlyBrackets()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", "test", "test2"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsWhenDoubleColonButNoType()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsWhenDoubleColonAndTypeButNoBracket()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ":", "short", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNameIsGeneratedIfNoneExisting()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "{", "test"
|
||||
});
|
||||
|
||||
var test = new TestEnum();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(2, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
|
||||
if (pushedBlock is BlockEnum blockEnum)
|
||||
{
|
||||
Assert.IsFalse(string.IsNullOrEmpty(blockEnum.Name));
|
||||
Assert.IsFalse(blockEnum.IsTypedef);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, blockEnum.ParentType);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be an enum");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,121 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestForwardDeclTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private ForwardDeclaration addedForwardDeclaration;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
private Namespace currentNamespace;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
currentNamespace = new Namespace();
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
|
||||
parserStateMock.SetupGet(state => state.CurrentNamespace).Returns(() => currentNamespace);
|
||||
parserStateMock.Setup(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()))
|
||||
.Callback((ForwardDeclaration forwardDeclaration) => addedForwardDeclaration = forwardDeclaration);
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsForwardDeclarationForEnums()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"enum", "test_enum", ";"
|
||||
});
|
||||
|
||||
var test = new TestForwardDecl();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("", addedForwardDeclaration.Namespace);
|
||||
Assert.AreEqual("test_enum", addedForwardDeclaration.Name);
|
||||
Assert.AreEqual(DataTypeType.Enum, addedForwardDeclaration.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsForwardDeclarationForStructs()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"struct", "test_struct", ";"
|
||||
});
|
||||
|
||||
var test = new TestForwardDecl();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("", addedForwardDeclaration.Namespace);
|
||||
Assert.AreEqual("test_struct", addedForwardDeclaration.Name);
|
||||
Assert.AreEqual(DataTypeType.Struct, addedForwardDeclaration.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsForwardDeclarationForUnions()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"union", "test_union", ";"
|
||||
});
|
||||
|
||||
var test = new TestForwardDecl();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()), Times.Once());
|
||||
|
||||
Assert.AreEqual("", addedForwardDeclaration.Namespace);
|
||||
Assert.AreEqual("test_union", addedForwardDeclaration.Name);
|
||||
Assert.AreEqual(DataTypeType.Union, addedForwardDeclaration.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsForwardDeclarationForNamespaces()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"namespace", "test_union", ";"
|
||||
});
|
||||
|
||||
var test = new TestForwardDecl();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,140 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Blocks;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestNamespaceTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private Block pushedBlock;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
pushedBlock = null;
|
||||
|
||||
parserStateMock.Setup(state => state.PushBlock(It.IsAny<Block>()))
|
||||
.Callback((Block block) => pushedBlock = block);
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsNamespaceDeclaration()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"namespace", "some_namespace", "{"
|
||||
});
|
||||
|
||||
var test = new TestNamespace();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()));
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
|
||||
if (pushedBlock is BlockNamespace namespaceBlock)
|
||||
{
|
||||
Assert.AreEqual("some_namespace", namespaceBlock.Name);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be a namespace");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsNamespacesWithSpecialCharacters()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"namespace", "$omeW3irdN4m3sp4c3", "{"
|
||||
});
|
||||
|
||||
var test = new TestNamespace();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()));
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
|
||||
if (pushedBlock is BlockNamespace namespaceBlock)
|
||||
{
|
||||
Assert.AreEqual("$omeW3irdN4m3sp4c3", namespaceBlock.Name);
|
||||
}
|
||||
else
|
||||
Assert.Fail("Pushed block is supposed to be a namespace");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanOnlyHaveOneNamespaceName()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"namespace", "namespace_name", "another_namespace_name", "{"
|
||||
});
|
||||
|
||||
var test = new TestNamespace();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNeedsOpeningCurlyBrackets()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"namespace", "namespace_name", ""
|
||||
});
|
||||
|
||||
var test = new TestNamespace();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRejectsNameWithDigitAsFirstCharacter()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"namespace", "1ns", "{"
|
||||
});
|
||||
|
||||
var test = new TestNamespace();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(0, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.VerifyNoOtherCalls();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,181 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Blocks;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestStructTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private List<DataType> typesOfState;
|
||||
private Namespace currentNamespace;
|
||||
private BlockStruct pushedStruct;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
currentNamespace = new Namespace();
|
||||
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
typesOfState = new List<DataType>();
|
||||
parserStateMock.SetupGet(state => state.CurrentNamespace)
|
||||
.Returns(() => currentNamespace);
|
||||
parserStateMock.Setup(state => state.PushBlock(It.IsAny<Block>()))
|
||||
.Callback((Block block) => pushedStruct = block as BlockStruct);
|
||||
parserStateMock.Setup(state => state.FindType(It.IsAny<string>()))
|
||||
.Returns((string query) => typesOfState.FirstOrDefault(type => type.FullName.Equals(query)));
|
||||
|
||||
pushedStruct = null;
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleStructStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"struct", "{"
|
||||
});
|
||||
|
||||
var test = new TestStruct();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(2, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedStruct);
|
||||
Assert.IsFalse(pushedStruct.IsTypedef);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsNamedStructStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"struct", "test_struct", "{"
|
||||
});
|
||||
|
||||
var test = new TestStruct();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedStruct);
|
||||
Assert.IsFalse(pushedStruct.IsTypedef);
|
||||
Assert.AreEqual("test_struct", pushedStruct.Name);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanBeTypedef()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "struct", "test_struct", "{"
|
||||
});
|
||||
|
||||
var test = new TestStruct();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedStruct);
|
||||
Assert.IsTrue(pushedStruct.IsTypedef);
|
||||
Assert.AreEqual("test_struct", pushedStruct.Name);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsCustomSpecifiedAlignment()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"struct", "__declspec", "(", "align", "(", "64", ")", ")", "test_struct", "{"
|
||||
});
|
||||
|
||||
var test = new TestStruct();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(10, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedStruct);
|
||||
Assert.IsFalse(pushedStruct.IsTypedef);
|
||||
Assert.AreEqual("test_struct", pushedStruct.Name);
|
||||
Assert.AreEqual(64, pushedStruct.CustomAlignment);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanSpecifyParent()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"struct", "test_struct", ":", "test", ":", ":", "parent", "{"
|
||||
});
|
||||
|
||||
var test = new TestStruct();
|
||||
|
||||
var parent = new DataTypeStruct("test", "parent", 4);
|
||||
var parentEntry = new Variable("test_int", new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>()));
|
||||
parent.Members.Add(parentEntry);
|
||||
typesOfState.Add(parent);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(8, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedStruct);
|
||||
Assert.IsFalse(pushedStruct.IsTypedef);
|
||||
Assert.AreEqual("test_struct", pushedStruct.Name);
|
||||
Assert.AreEqual(1, pushedStruct.Variables.Count);
|
||||
Assert.AreEqual(parentEntry, pushedStruct.Variables[0]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenParentTypeCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"struct", "test_struct", ":", "test", ":", ":", "parent", "{"
|
||||
});
|
||||
|
||||
var test = new TestStruct();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenParentTypeIsNotDataTypeWithMembers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"struct", "test_struct", ":", "test", ":", ":", "parent", "{"
|
||||
});
|
||||
|
||||
var test = new TestStruct();
|
||||
|
||||
var testEnum = new DataTypeEnum("test", "parent", DataTypeBaseType.INT);
|
||||
typesOfState.Add(testEnum);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,291 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestTypedefTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private List<DataType> typesOfState;
|
||||
private Namespace currentNamespace;
|
||||
private DataTypeTypedef addedTypedef;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
currentNamespace = new Namespace();
|
||||
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
typesOfState = new List<DataType>();
|
||||
parserStateMock.SetupGet(state => state.CurrentNamespace)
|
||||
.Returns(() => currentNamespace);
|
||||
parserStateMock.Setup(state => state.AddDataType(It.IsAny<DataTypeTypedef>()))
|
||||
.Callback((DataType dataType) => addedTypedef = (DataTypeTypedef)dataType);
|
||||
parserStateMock.Setup(state => state.FindType(It.IsAny<string>()))
|
||||
.Returns((string typename) =>
|
||||
{
|
||||
return typesOfState.Concat(DataTypeBaseType.BASE_TYPES)
|
||||
.FirstOrDefault(type => type.FullName.Equals(typename));
|
||||
});
|
||||
|
||||
addedTypedef = null;
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleTypedef()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "char", "new_typedef", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("new_typedef", addedTypedef.FullName);
|
||||
Assert.AreEqual(DataTypeBaseType.CHAR, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsFalse(addedTypedef.TypeDefinition.IsConst);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesUseOfCurrentNamespace()
|
||||
{
|
||||
currentNamespace.Push("test_namespace");
|
||||
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "char", "new_typedef", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("test_namespace::new_typedef", addedTypedef.FullName);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCorrectlyHandlesTypesWithMoreThanOneToken()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "const", "unsigned", "int", "new_typedef", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(6, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("new_typedef", addedTypedef.FullName);
|
||||
Assert.AreEqual(DataTypeBaseType.UNSIGNED_INT, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsTrue(addedTypedef.TypeDefinition.IsConst);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureHandlesPointers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "int", "*", "*", "*", "asdf", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(7, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("asdf", addedTypedef.FullName);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsFalse(addedTypedef.TypeDefinition.IsConst);
|
||||
|
||||
Assert.AreEqual(3, addedTypedef.TypeDefinition.References.Count);
|
||||
foreach (var typeDefinitionReference in addedTypedef.TypeDefinition.References)
|
||||
{
|
||||
Assert.IsInstanceOfType(typeDefinitionReference, typeof(ReferenceTypePointer));
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureHandlesArrays()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "int", "asdf", "[", "3", "]", "[", "5", "]", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(10, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("asdf", addedTypedef.FullName);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsFalse(addedTypedef.TypeDefinition.IsConst);
|
||||
|
||||
Assert.AreEqual(2, addedTypedef.TypeDefinition.References.Count);
|
||||
foreach (var typeDefinitionReference in addedTypedef.TypeDefinition.References)
|
||||
{
|
||||
Assert.IsInstanceOfType(typeDefinitionReference, typeof(ReferenceTypeArray));
|
||||
}
|
||||
|
||||
Assert.AreEqual(3, ((ReferenceTypeArray) addedTypedef.TypeDefinition.References[0]).ArraySize);
|
||||
Assert.AreEqual(5, ((ReferenceTypeArray) addedTypedef.TypeDefinition.References[1]).ArraySize);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCorrectlyHandlesArrayOfPointers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "int", "*", "*", "asdf", "[", "1337", "]", "[", "0x1A4", "]", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(12, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("asdf", addedTypedef.FullName);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsFalse(addedTypedef.TypeDefinition.IsConst);
|
||||
|
||||
Assert.AreEqual(4, addedTypedef.TypeDefinition.References.Count);
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[0], typeof(ReferenceTypeArray));
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[1], typeof(ReferenceTypeArray));
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[2], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[3], typeof(ReferenceTypePointer));
|
||||
|
||||
Assert.AreEqual(1337, ((ReferenceTypeArray) addedTypedef.TypeDefinition.References[0]).ArraySize);
|
||||
Assert.AreEqual(0x1A4, ((ReferenceTypeArray) addedTypedef.TypeDefinition.References[1]).ArraySize);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCorrectlyHandlesPointerToArray()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "int", "(", "*", "*", "asdf", ")", "[", "1337", "]", "[", "0x1A4", "]", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(14, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("asdf", addedTypedef.FullName);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsFalse(addedTypedef.TypeDefinition.IsConst);
|
||||
|
||||
Assert.AreEqual(4, addedTypedef.TypeDefinition.References.Count);
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[0], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[1], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[2], typeof(ReferenceTypeArray));
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[3], typeof(ReferenceTypeArray));
|
||||
|
||||
Assert.AreEqual(1337, ((ReferenceTypeArray) addedTypedef.TypeDefinition.References[2]).ArraySize);
|
||||
Assert.AreEqual(0x1A4, ((ReferenceTypeArray) addedTypedef.TypeDefinition.References[3]).ArraySize);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureHandlesCustomSpecifiedAlignment()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "__declspec", "(", "align", "(", "16", ")", ")", "int", "*", "my_type_align_16", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(12, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("my_type_align_16", addedTypedef.FullName);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsFalse(addedTypedef.TypeDefinition.IsConst);
|
||||
Assert.AreEqual(16, addedTypedef.AlignmentOverride);
|
||||
|
||||
Assert.AreEqual(1, addedTypedef.TypeDefinition.References.Count);
|
||||
Assert.IsInstanceOfType(addedTypedef.TypeDefinition.References[0], typeof(ReferenceTypePointer));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTestFailsWhenTypeCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "some_type", "invalid_typedef", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanUseCustomTypes()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "some_type", "custom_typedef", ";"
|
||||
});
|
||||
|
||||
var test = new TestTypedef();
|
||||
|
||||
var someType = new DataTypeStruct("", "some_type", 4);
|
||||
typesOfState.Add(someType);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
parserStateMock.Verify(state => state.AddDataType(It.IsAny<DataTypeTypedef>()));
|
||||
|
||||
Assert.AreEqual("custom_typedef", addedTypedef.FullName);
|
||||
Assert.AreEqual(someType, addedTypedef.TypeDefinition.Type);
|
||||
Assert.IsFalse(addedTypedef.TypeDefinition.IsConst);
|
||||
|
||||
Assert.AreEqual(0, addedTypedef.TypeDefinition.References.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,181 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Blocks;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestUnionTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private List<DataType> typesOfState;
|
||||
private Namespace currentNamespace;
|
||||
private BlockUnion pushedUnion;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
currentNamespace = new Namespace();
|
||||
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
typesOfState = new List<DataType>();
|
||||
parserStateMock.SetupGet(state => state.CurrentNamespace)
|
||||
.Returns(() => currentNamespace);
|
||||
parserStateMock.Setup(state => state.PushBlock(It.IsAny<Block>()))
|
||||
.Callback((Block block) => pushedUnion = block as BlockUnion);
|
||||
parserStateMock.Setup(state => state.FindType(It.IsAny<string>()))
|
||||
.Returns((string query) => typesOfState.FirstOrDefault(type => type.FullName.Equals(query)));
|
||||
|
||||
pushedUnion = null;
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleUnionStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"union", "{"
|
||||
});
|
||||
|
||||
var test = new TestUnion();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(2, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedUnion);
|
||||
Assert.IsFalse(pushedUnion.IsTypedef);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsNamedUnionStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"union", "test_union", "{"
|
||||
});
|
||||
|
||||
var test = new TestUnion();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedUnion);
|
||||
Assert.IsFalse(pushedUnion.IsTypedef);
|
||||
Assert.AreEqual("test_union", pushedUnion.Name);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanBeTypedef()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"typedef", "union", "test_union", "{"
|
||||
});
|
||||
|
||||
var test = new TestUnion();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedUnion);
|
||||
Assert.IsTrue(pushedUnion.IsTypedef);
|
||||
Assert.AreEqual("test_union", pushedUnion.Name);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsCustomSpecifiedAlignment()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"union", "__declspec", "(", "align", "(", "64", ")", ")", "test_union", "{"
|
||||
});
|
||||
|
||||
var test = new TestUnion();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(10, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedUnion);
|
||||
Assert.IsFalse(pushedUnion.IsTypedef);
|
||||
Assert.AreEqual("test_union", pushedUnion.Name);
|
||||
Assert.AreEqual(64, pushedUnion.CustomAlignment);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanSpecifyParent()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"union", "test_union", ":", "test", ":", ":", "parent", "{"
|
||||
});
|
||||
|
||||
var test = new TestUnion();
|
||||
|
||||
var parent = new DataTypeUnion("test", "parent", 4);
|
||||
var parentEntry = new Variable("test_int", new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>()));
|
||||
parent.Members.Add(parentEntry);
|
||||
typesOfState.Add(parent);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(8, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(pushedUnion);
|
||||
Assert.IsFalse(pushedUnion.IsTypedef);
|
||||
Assert.AreEqual("test_union", pushedUnion.Name);
|
||||
Assert.AreEqual(1, pushedUnion.Variables.Count);
|
||||
Assert.AreEqual(parentEntry, pushedUnion.Variables[0]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenParentTypeCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"union", "test_union", ":", "test", ":", ":", "parent", "{"
|
||||
});
|
||||
|
||||
var test = new TestUnion();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenParentTypeIsNotDataTypeWithMembers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"union", "test_union", ":", "test", ":", ":", "parent", "{"
|
||||
});
|
||||
|
||||
var test = new TestUnion();
|
||||
|
||||
var testEnum = new DataTypeEnum("test", "parent", DataTypeBaseType.INT);
|
||||
typesOfState.Add(testEnum);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,443 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.C_Header;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Blocks;
|
||||
using ZoneCodeGenerator.Parsing.C_Header.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestVariableTest
|
||||
{
|
||||
private Mock<IHeaderParserState> parserStateMock;
|
||||
private List<DataType> typesOfState;
|
||||
private Namespace currentNamespace;
|
||||
private Stack<Block> blocks;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
currentNamespace = new Namespace();
|
||||
blocks = new Stack<Block>();
|
||||
|
||||
parserStateMock = new Mock<IHeaderParserState>();
|
||||
typesOfState = new List<DataType>();
|
||||
parserStateMock.SetupGet(state => state.CurrentNamespace)
|
||||
.Returns(() => currentNamespace);
|
||||
parserStateMock.SetupGet(state => state.CurrentBlock)
|
||||
.Returns(() => blocks.Peek());
|
||||
parserStateMock.Setup(state => state.FindType(It.IsAny<string>()))
|
||||
.Returns((string query) => typesOfState.Concat(DataTypeBaseType.BASE_TYPES).FirstOrDefault(type => type.FullName.Equals(query)));
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleVariableStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"int", "test", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("test", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(0, variable.VariableType.References.Count);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsCustomStructures()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"test_namespace", ":", ":", "customStruct", "hey_ho", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var customStruct = new DataTypeStruct("test_namespace", "customStruct", 4);
|
||||
typesOfState.Add(customStruct);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(6, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("hey_ho", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(0, variable.VariableType.References.Count);
|
||||
Assert.AreEqual(customStruct, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenTypeCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"test_namespace", ":", ":", "customStruct", "hey_ho", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandlePointers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"float", "*", "santa_claus", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("santa_claus", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(1, variable.VariableType.References.Count);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[0], typeof(ReferenceTypePointer));
|
||||
|
||||
Assert.AreEqual(DataTypeBaseType.FLOAT, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleMultiPointers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"float", "*", "*", "*", "*", "santa_claus", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(7, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("santa_claus", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(4, variable.VariableType.References.Count);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[0], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[1], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[2], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[3], typeof(ReferenceTypePointer));
|
||||
|
||||
Assert.AreEqual(DataTypeBaseType.FLOAT, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleArrays()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"double", "pepper", "[", "9", "]", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(6, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("pepper", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(1, variable.VariableType.References.Count);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[0], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(9, ((ReferenceTypeArray) variable.VariableType.References[0]).ArraySize);
|
||||
|
||||
Assert.AreEqual(DataTypeBaseType.DOUBLE, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleMultipleArrays()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"long", "long", "salt", "[", "4", "]", "[", "2", "]", "[", "1", "]", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(13, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("salt", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(3, variable.VariableType.References.Count);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[0], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(4, ((ReferenceTypeArray) variable.VariableType.References[0]).ArraySize);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[1], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(2, ((ReferenceTypeArray) variable.VariableType.References[1]).ArraySize);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[2], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(1, ((ReferenceTypeArray) variable.VariableType.References[2]).ArraySize);
|
||||
|
||||
Assert.AreEqual(DataTypeBaseType.LONG_LONG, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleArrayOfPointers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"unsigned", "long", "long", "*", "*", "what_a_var", "[", "6", "]", "[", "9", "]", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(13, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("what_a_var", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(4, variable.VariableType.References.Count);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[0], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(6, ((ReferenceTypeArray) variable.VariableType.References[0]).ArraySize);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[1], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(9, ((ReferenceTypeArray) variable.VariableType.References[1]).ArraySize);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[2], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[3], typeof(ReferenceTypePointer));
|
||||
|
||||
Assert.AreEqual(DataTypeBaseType.UNSIGNED_LONG_LONG, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandlePointerToArray()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"unsigned", "char", "(", "*", "*", "send_halp", ")", "[", "1", "]", "[", "3", "]", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(14, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("send_halp", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(4, variable.VariableType.References.Count);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[0], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[1], typeof(ReferenceTypePointer));
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[2], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(1, ((ReferenceTypeArray) variable.VariableType.References[2]).ArraySize);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[3], typeof(ReferenceTypeArray));
|
||||
Assert.AreEqual(3, ((ReferenceTypeArray) variable.VariableType.References[3]).ArraySize);
|
||||
|
||||
Assert.AreEqual(DataTypeBaseType.UNSIGNED_CHAR, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsConstVariables()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"const", "int", "test", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("test", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsTrue(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(0, variable.VariableType.References.Count);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsConstPointerVariables()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"const", "char", "*", "str", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(5, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("str", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsTrue(variable.VariableType.IsConst);
|
||||
Assert.IsFalse(variable.VariableType.HasCustomBitSize);
|
||||
|
||||
Assert.AreEqual(1, variable.VariableType.References.Count);
|
||||
Assert.IsInstanceOfType(variable.VariableType.References[0], typeof(ReferenceTypePointer));
|
||||
Assert.AreEqual(DataTypeBaseType.CHAR, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsCustomBitSizes()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"int", "test", ":", "3", ";"
|
||||
});
|
||||
|
||||
var block = new BlockStruct(parserStateMock.Object, "test_struct", false);
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(5, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, block.Variables.Count);
|
||||
|
||||
var variable = block.Variables[0];
|
||||
|
||||
Assert.AreEqual("test", variable.Name);
|
||||
Assert.IsNull(variable.AlignmentOverride);
|
||||
Assert.IsFalse(variable.VariableType.IsConst);
|
||||
|
||||
Assert.IsTrue(variable.VariableType.HasCustomBitSize);
|
||||
Assert.AreEqual(3, variable.VariableType.CustomBitSize);
|
||||
|
||||
Assert.AreEqual(0, variable.VariableType.References.Count);
|
||||
Assert.AreEqual(DataTypeBaseType.INT, variable.VariableType.Type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenNotInBlockThatCanHoldVariables()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"int", "test", ";"
|
||||
});
|
||||
|
||||
var block = new BlockNamespace(parserStateMock.Object, "asdf");
|
||||
blocks.Push(block);
|
||||
|
||||
var test = new TestVariable();
|
||||
|
||||
Assert.ThrowsException<Exception>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,76 +0,0 @@
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile.Impl;
|
||||
using ZoneCodeGeneratorTests.Parsing.Mock;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Impl
|
||||
{
|
||||
[TestClass]
|
||||
public class PreprocessorTest
|
||||
{
|
||||
private IncludingParsingStreamTest headerStreamTest;
|
||||
|
||||
private CommandFilePreprocessor preprocessor;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
headerStreamTest = new IncludingParsingStreamTest("file.h");
|
||||
preprocessor = new CommandFilePreprocessor(headerStreamTest);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureReturnsUnmodifiedText()
|
||||
{
|
||||
string[] stringsThatShouldNotBeModified =
|
||||
{
|
||||
"This is a normal string",
|
||||
"There is nothing to be preprocessed!",
|
||||
"0124124124 # 124124124",
|
||||
"...",
|
||||
"<?php><html>asdf</html>",
|
||||
""
|
||||
};
|
||||
|
||||
headerStreamTest.Lines.AddRange(stringsThatShouldNotBeModified);
|
||||
|
||||
foreach (var stringThatShouldNotBeModified in stringsThatShouldNotBeModified)
|
||||
{
|
||||
Assert.AreEqual(stringThatShouldNotBeModified, preprocessor.ReadLine());
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureIncludeChangesFileWhenUsingQuotationMarks()
|
||||
{
|
||||
headerStreamTest.Lines.AddRange(new[]
|
||||
{
|
||||
"include \"asdf.h\"",
|
||||
"include \"file/path/to/header.h\""
|
||||
});
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(1, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("asdf.h", headerStreamTest.LastInclude);
|
||||
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(2, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("file/path/to/header.h", headerStreamTest.LastInclude);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureIncludeChangesFileWhenUsingCarets()
|
||||
{
|
||||
headerStreamTest.Lines.AddRange(new[]
|
||||
{
|
||||
"include <asdf.h>",
|
||||
"include <file/path/to/header.h>"
|
||||
});
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(1, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("asdf.h", headerStreamTest.LastInclude);
|
||||
|
||||
preprocessor.ReadLine();
|
||||
Assert.AreEqual(2, headerStreamTest.IncludeCount);
|
||||
Assert.AreEqual("file/path/to/header.h", headerStreamTest.LastInclude);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,176 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Domain.Information;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
using ZoneCodeGenerator.Persistence;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestAssetTest
|
||||
{
|
||||
private Mock<IReadOnlyDataRepository> repositoryMock;
|
||||
private Mock<ICommandParserState> parserStateMock;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<ICommandParserState>();
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
repositoryMock = new Mock<IReadOnlyDataRepository>();
|
||||
|
||||
parserStateMock.SetupGet(state => state.Repository)
|
||||
.Returns(() => repositoryMock.Object);
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleAssetStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
|
||||
});
|
||||
|
||||
var test = new TestAsset();
|
||||
var assetStruct = new DataTypeStruct("test", "type", 4);
|
||||
var assetInformation = new StructureInformation(assetStruct);
|
||||
|
||||
var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
|
||||
var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
|
||||
assetEnum.Members.Add(assetEnumEntry);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
|
||||
.Returns(assetStruct);
|
||||
repositoryMock.Setup(repository => repository.GetInformationFor(assetStruct))
|
||||
.Returns(() => assetInformation);
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[]{assetEnum});
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(7, test.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenTypeCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
|
||||
});
|
||||
|
||||
var test = new TestAsset();
|
||||
var assetStruct = new DataTypeStruct("test", "type", 4);
|
||||
var assetInformation = new StructureInformation(assetStruct);
|
||||
|
||||
var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
|
||||
var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
|
||||
assetEnum.Members.Add(assetEnumEntry);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetInformationFor(It.IsAny<DataTypeWithMembers>()))
|
||||
.Returns(() => assetInformation);
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[]{assetEnum});
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenNoInformationForAssetCanBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
|
||||
});
|
||||
|
||||
var test = new TestAsset();
|
||||
var assetStruct = new DataTypeStruct("test", "type", 4);
|
||||
|
||||
var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
|
||||
var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
|
||||
assetEnum.Members.Add(assetEnumEntry);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
|
||||
.Returns(assetStruct);
|
||||
repositoryMock.Setup(repository => repository.GetInformationFor(assetStruct))
|
||||
.Returns(() => null);
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetEnum });
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenEnumEntryCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
|
||||
});
|
||||
|
||||
var test = new TestAsset();
|
||||
var assetStruct = new DataTypeStruct("test", "type", 4);
|
||||
var assetInformation = new StructureInformation(assetStruct);
|
||||
|
||||
var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
|
||||
var assetEnumEntry = new EnumMember("NOT_THE_RIGHT_ENTRY", 420);
|
||||
assetEnum.Members.Add(assetEnumEntry);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
|
||||
.Returns(assetStruct);
|
||||
repositoryMock.Setup(repository => repository.GetInformationFor(assetStruct))
|
||||
.Returns(() => assetInformation);
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[]{assetEnum});
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenAssetIsNotADataTypeWithMembers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
|
||||
});
|
||||
|
||||
var test = new TestAsset();
|
||||
var asset = new DataTypeEnum("test", "type", DataTypeBaseType.INT);
|
||||
var assetStruct = new DataTypeStruct("test", "type", 4);
|
||||
var assetInformation = new StructureInformation(assetStruct);
|
||||
|
||||
var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
|
||||
var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
|
||||
assetEnum.Members.Add(assetEnumEntry);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
|
||||
.Returns(asset);
|
||||
repositoryMock.Setup(repository => repository.GetInformationFor(It.IsAny<DataTypeWithMembers>()))
|
||||
.Returns(() => assetInformation);
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetEnum });
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,279 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Domain.FastFileStructure;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
using ZoneCodeGenerator.Persistence;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestBlockTest
|
||||
{
|
||||
private Mock<IReadOnlyDataRepository> repositoryMock;
|
||||
private Mock<ICommandParserState> parserStateMock;
|
||||
|
||||
private List<FastFileBlock> fastFileBlocks;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<ICommandParserState>();
|
||||
|
||||
fastFileBlocks = new List<FastFileBlock>();
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
repositoryMock = new Mock<IReadOnlyDataRepository>();
|
||||
|
||||
parserStateMock.SetupGet(state => state.Repository)
|
||||
.Returns(() => repositoryMock.Object);
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
parserStateMock.SetupGet(state => state.FastFileBlocks)
|
||||
.Returns(() => fastFileBlocks);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleTempBlockStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "temp", "SomeThing", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntry1 = new EnumMember("whatever", 1);
|
||||
var enumEntry2 = new EnumMember("SomeThing", 513);
|
||||
assetTypeEnum.Members.Add(enumEntry1);
|
||||
assetTypeEnum.Members.Add(enumEntry2);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, fastFileBlocks.Count);
|
||||
|
||||
var block = fastFileBlocks[0];
|
||||
|
||||
Assert.AreEqual("SomeThing", block.Name);
|
||||
Assert.AreEqual(513, block.Index);
|
||||
Assert.AreEqual(FastFileBlock.Type.Temp, block.BlockType);
|
||||
Assert.IsTrue(block.IsTemp);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleRuntimeBlockStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "runtime", "ASSET_TYPE_RUNTIME", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntry1 = new EnumMember("whatever", 1);
|
||||
var enumEntry2 = new EnumMember("ASSET_TYPE_RUNTIME", 11);
|
||||
assetTypeEnum.Members.Add(enumEntry1);
|
||||
assetTypeEnum.Members.Add(enumEntry2);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, fastFileBlocks.Count);
|
||||
|
||||
var block = fastFileBlocks[0];
|
||||
|
||||
Assert.AreEqual("ASSET_TYPE_RUNTIME", block.Name);
|
||||
Assert.AreEqual(11, block.Index);
|
||||
Assert.AreEqual(FastFileBlock.Type.Runtime, block.BlockType);
|
||||
Assert.IsTrue(block.IsRuntime);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleDelayBlockStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "delay", "ASSET_TYPE_DELAY", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntry1 = new EnumMember("whatever", 1);
|
||||
var enumEntry2 = new EnumMember("ASSET_TYPE_DELAY", 133);
|
||||
assetTypeEnum.Members.Add(enumEntry1);
|
||||
assetTypeEnum.Members.Add(enumEntry2);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, fastFileBlocks.Count);
|
||||
|
||||
var block = fastFileBlocks[0];
|
||||
|
||||
Assert.AreEqual("ASSET_TYPE_DELAY", block.Name);
|
||||
Assert.AreEqual(133, block.Index);
|
||||
Assert.AreEqual(FastFileBlock.Type.Delay, block.BlockType);
|
||||
Assert.IsTrue(block.IsDelay);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleNormalBlockStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "normal", "BLOCK_TYPE_LEET", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntryBlaze = new EnumMember("BLOCK_TYPE_BLAZE", 420);
|
||||
var enumEntryLeet = new EnumMember("BLOCK_TYPE_LEET", 1337);
|
||||
assetTypeEnum.Members.Add(enumEntryBlaze);
|
||||
assetTypeEnum.Members.Add(enumEntryLeet);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, fastFileBlocks.Count);
|
||||
|
||||
var block = fastFileBlocks[0];
|
||||
|
||||
Assert.AreEqual("BLOCK_TYPE_LEET", block.Name);
|
||||
Assert.AreEqual(1337, block.Index);
|
||||
Assert.AreEqual(FastFileBlock.Type.Normal, block.BlockType);
|
||||
Assert.IsTrue(block.IsNormal);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotExceptUnknownTypes()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "unknowntype", "ASSET_TYPE_WHATEVER", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntry1 = new EnumMember("whatever", 1);
|
||||
var enumEntry2 = new EnumMember("ASSET_TYPE_WHATEVER", 2);
|
||||
assetTypeEnum.Members.Add(enumEntry1);
|
||||
assetTypeEnum.Members.Add(enumEntry2);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotSetDefaultBlockWhenNotSpecified()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "normal", "ASSET_TYPE_BLOCK", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntry = new EnumMember("ASSET_TYPE_BLOCK", 5);
|
||||
assetTypeEnum.Members.Add(enumEntry);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(4, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, fastFileBlocks.Count);
|
||||
|
||||
var block = fastFileBlocks[0];
|
||||
Assert.IsFalse(block.IsDefault);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesSetDefaultBlockWhenSpecified()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "normal", "ASSET_TYPE_BLOCK", "default", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntry = new EnumMember("ASSET_TYPE_BLOCK", 5);
|
||||
assetTypeEnum.Members.Add(enumEntry);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(5, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreEqual(1, fastFileBlocks.Count);
|
||||
|
||||
var block = fastFileBlocks[0];
|
||||
Assert.IsTrue(block.IsDefault);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenEnumEntryCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"block", "normal", "ASSET_TYPE_BLOCK", ";"
|
||||
});
|
||||
|
||||
var test = new TestBlock();
|
||||
|
||||
var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
|
||||
var enumEntry1 = new EnumMember("whatever", 1);
|
||||
var enumEntry2 = new EnumMember("ASSET_TYPE_SOMETHING_ELSE", 6);
|
||||
assetTypeEnum.Members.Add(enumEntry1);
|
||||
assetTypeEnum.Members.Add(enumEntry2);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetAllEnums())
|
||||
.Returns(() => new[] { assetTypeEnum });
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,514 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Domain.Evaluation;
|
||||
using ZoneCodeGenerator.Domain.Information;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile.Impl;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
using ZoneCodeGenerator.Persistence;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestCountTest
|
||||
{
|
||||
private IDataRepository repository;
|
||||
private CommandParserState parserState;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
repository = new InMemoryDataRepository();
|
||||
parserState = new CommandParserState(repository);
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleSimpleCountStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "5", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(8, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsTrue(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(OperandStatic));
|
||||
Assert.AreEqual(5, ((OperandStatic) pointerReference.Count).Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleReferenceToSubStruct()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "papaStruct", ":", ":", "kiddo", ":", ":", "ptrEntry", "5", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var parentStruct = new DataTypeStruct("", "papaStruct", 4);
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var childEntry = new Variable("kiddo", new TypeDeclaration(testStruct, new List<ReferenceType>()));
|
||||
parentStruct.Members.Add(childEntry);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
repository.Add(parentStruct);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(11, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsTrue(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(OperandStatic));
|
||||
Assert.AreEqual(5, ((OperandStatic) pointerReference.Count).Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenStructureCannotBeFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "5", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserState, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenReferencingStructAndNotMembers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", "5", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>()));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserState, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenReferencedMemberHasNoPointerReference()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "5", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>()));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserState, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleMultipleOperations()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "1", "+", "countEntry", "*", "2", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
var countEntry = new Variable("countEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.UNSIGNED_INT, new List<ReferenceType>()));
|
||||
testStruct.Members.Add(countEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
var testStructInfo = repository.GetInformationFor(testStruct);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(12, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsFalse(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(Operation));
|
||||
|
||||
var countOperation = (Operation) pointerReference.Count;
|
||||
Assert.AreEqual(OperationType.OperationAdd, countOperation.OperationType);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand1, typeof(OperandStatic));
|
||||
Assert.AreEqual(1, ((OperandStatic) countOperation.Operand1).Value);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand2, typeof(Operation));
|
||||
var multiplicationOperation = (Operation) countOperation.Operand2;
|
||||
Assert.AreEqual(OperationType.OperationMultiply, multiplicationOperation.OperationType);
|
||||
|
||||
Assert.IsInstanceOfType(multiplicationOperation.Operand2, typeof(OperandStatic));
|
||||
Assert.AreEqual(2, ((OperandStatic) multiplicationOperation.Operand2).Value);
|
||||
|
||||
Assert.IsInstanceOfType(multiplicationOperation.Operand1, typeof(OperandDynamic));
|
||||
var ptrEntryDynamicOperand = (OperandDynamic) multiplicationOperation.Operand1;
|
||||
Assert.AreEqual(testStructInfo, ptrEntryDynamicOperand.Structure);
|
||||
Assert.AreEqual(1, ptrEntryDynamicOperand.ReferencedMemberChain.Count);
|
||||
Assert.AreEqual(countEntry, ptrEntryDynamicOperand.ReferencedMemberChain[0].Member);
|
||||
Assert.AreEqual(0, ptrEntryDynamicOperand.ArrayIndices.Count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleParenthesis()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "(", "1", "+", "countEntry", ")", "*", "2", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
var countEntry = new Variable("countEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.UNSIGNED_INT, new List<ReferenceType>()));
|
||||
testStruct.Members.Add(countEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
var testStructInfo = repository.GetInformationFor(testStruct);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(14, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsFalse(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(Operation));
|
||||
|
||||
var countOperation = (Operation) pointerReference.Count;
|
||||
Assert.AreEqual(OperationType.OperationMultiply, countOperation.OperationType);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand2, typeof(OperandStatic));
|
||||
Assert.AreEqual(2, ((OperandStatic) countOperation.Operand2).Value);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand1, typeof(Operation));
|
||||
var additionOperation = (Operation) countOperation.Operand1;
|
||||
Assert.AreEqual(OperationType.OperationAdd, additionOperation.OperationType);
|
||||
|
||||
Assert.IsInstanceOfType(additionOperation.Operand1, typeof(OperandStatic));
|
||||
Assert.AreEqual(1, ((OperandStatic) additionOperation.Operand1).Value);
|
||||
|
||||
Assert.IsInstanceOfType(additionOperation.Operand2, typeof(OperandDynamic));
|
||||
var ptrEntryDynamicOperand = (OperandDynamic) additionOperation.Operand2;
|
||||
Assert.AreEqual(testStructInfo, ptrEntryDynamicOperand.Structure);
|
||||
Assert.AreEqual(1, ptrEntryDynamicOperand.ReferencedMemberChain.Count);
|
||||
Assert.AreEqual(countEntry, ptrEntryDynamicOperand.ReferencedMemberChain[0].Member);
|
||||
Assert.AreEqual(0, ptrEntryDynamicOperand.ArrayIndices.Count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleReferencesToDifferentStructs()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "1", "+", "someOtherStruct", ":", ":",
|
||||
"countEntry", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
var someOtherStruct = new DataTypeStruct("", "someOtherStruct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
var countEntry = new Variable("countEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.UNSIGNED_INT, new List<ReferenceType>()));
|
||||
someOtherStruct.Members.Add(countEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
repository.Add(someOtherStruct);
|
||||
|
||||
var someOtherStructInfo = repository.GetInformationFor(someOtherStruct);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(13, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsFalse(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(Operation));
|
||||
|
||||
var countOperation = (Operation) pointerReference.Count;
|
||||
Assert.AreEqual(OperationType.OperationAdd, countOperation.OperationType);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand1, typeof(OperandStatic));
|
||||
Assert.AreEqual(1, ((OperandStatic) countOperation.Operand1).Value);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand2, typeof(OperandDynamic));
|
||||
var dynamicOperand = (OperandDynamic) countOperation.Operand2;
|
||||
Assert.AreEqual(someOtherStructInfo, dynamicOperand.Structure);
|
||||
Assert.AreEqual(1, dynamicOperand.ReferencedMemberChain.Count);
|
||||
Assert.AreEqual(countEntry, dynamicOperand.ReferencedMemberChain[0].Member);
|
||||
Assert.AreEqual(0, dynamicOperand.ArrayIndices.Count);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleArrayIndices()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "1", "+", "countEntry", "[", "7", "]", "[", "4",
|
||||
"]", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
var countEntry = new Variable("countEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.UNSIGNED_INT,
|
||||
new List<ReferenceType>(new[] {new ReferenceTypeArray(9), new ReferenceTypeArray(9)})));
|
||||
testStruct.Members.Add(countEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
var testStructInfo = repository.GetInformationFor(testStruct);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(16, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsFalse(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(Operation));
|
||||
|
||||
var countOperation = (Operation) pointerReference.Count;
|
||||
Assert.AreEqual(OperationType.OperationAdd, countOperation.OperationType);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand1, typeof(OperandStatic));
|
||||
Assert.AreEqual(1, ((OperandStatic) countOperation.Operand1).Value);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand2, typeof(OperandDynamic));
|
||||
var dynamicOperand = (OperandDynamic) countOperation.Operand2;
|
||||
Assert.AreEqual(testStructInfo, dynamicOperand.Structure);
|
||||
Assert.AreEqual(1, dynamicOperand.ReferencedMemberChain.Count);
|
||||
Assert.AreEqual(countEntry, dynamicOperand.ReferencedMemberChain[0].Member);
|
||||
|
||||
Assert.AreEqual(2, dynamicOperand.ArrayIndices.Count);
|
||||
Assert.IsTrue(dynamicOperand.ArrayIndices[0].IsStatic);
|
||||
Assert.AreEqual(7, dynamicOperand.ArrayIndices[0].EvaluateNumeric());
|
||||
Assert.IsTrue(dynamicOperand.ArrayIndices[1].IsStatic);
|
||||
Assert.AreEqual(4, dynamicOperand.ArrayIndices[1].EvaluateNumeric());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFailsWhenReferencingInvalidStructInDynamicOperand()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "1", "+", "someOtherStruct", ":", ":",
|
||||
"countEntry", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
var countEntry = new Variable("countEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.UNSIGNED_INT,
|
||||
new List<ReferenceType>(new[] {new ReferenceTypeArray(9), new ReferenceTypeArray(9)})));
|
||||
testStruct.Members.Add(countEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserState, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanReferenceNoMembersAsDynamicOperands()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "test_struct", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
var countEntry = new Variable("countEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.UNSIGNED_INT,
|
||||
new List<ReferenceType>(new[] {new ReferenceTypeArray(9), new ReferenceTypeArray(9)})));
|
||||
testStruct.Members.Add(countEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(8, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsFalse(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(OperandDynamic));
|
||||
Assert.AreEqual("test_struct", ((OperandDynamic)pointerReference.Count).Structure.Type.Name);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanReferenceUsingUsedStructure()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "ptrEntry", "5", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
var testStructInfo = repository.GetInformationFor(testStruct);
|
||||
parserState.DataTypeInUse = testStructInfo;
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(5, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsTrue(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(OperandStatic));
|
||||
Assert.AreEqual(5, ((OperandStatic) pointerReference.Count).Value);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanHandleReferencesToUsedStructure()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"set", "count", "test_struct", ":", ":", "ptrEntry", "1", "+", "countEntry", ";"
|
||||
});
|
||||
|
||||
var test = new TestCount();
|
||||
|
||||
var testStruct = new DataTypeStruct("", "test_struct", 4);
|
||||
var someOtherStruct = new DataTypeStruct("", "someOtherStruct", 4);
|
||||
|
||||
var pointerReference = new ReferenceTypePointer();
|
||||
var ptrEntry = new Variable("ptrEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.INT, new List<ReferenceType>(new[] {pointerReference})));
|
||||
testStruct.Members.Add(ptrEntry);
|
||||
|
||||
var countEntry = new Variable("countEntry",
|
||||
new TypeDeclaration(DataTypeBaseType.UNSIGNED_INT, new List<ReferenceType>()));
|
||||
someOtherStruct.Members.Add(countEntry);
|
||||
|
||||
repository.Add(testStruct);
|
||||
|
||||
repository.Add(someOtherStruct);
|
||||
var someOtherStructInfo = repository.GetInformationFor(someOtherStruct);
|
||||
parserState.DataTypeInUse = someOtherStructInfo;
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserState, lexerMock.Object));
|
||||
Assert.AreEqual(10, test.ConsumedTokenCount);
|
||||
|
||||
Assert.AreNotEqual(ReferenceTypePointer.DefaultCount, pointerReference.Count);
|
||||
Assert.IsFalse(pointerReference.Count.IsStatic);
|
||||
|
||||
Assert.IsInstanceOfType(pointerReference.Count, typeof(Operation));
|
||||
|
||||
var countOperation = (Operation) pointerReference.Count;
|
||||
Assert.AreEqual(OperationType.OperationAdd, countOperation.OperationType);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand1, typeof(OperandStatic));
|
||||
Assert.AreEqual(1, ((OperandStatic) countOperation.Operand1).Value);
|
||||
|
||||
Assert.IsInstanceOfType(countOperation.Operand2, typeof(OperandDynamic));
|
||||
var dynamicOperand = (OperandDynamic) countOperation.Operand2;
|
||||
Assert.AreEqual(someOtherStructInfo, dynamicOperand.Structure);
|
||||
Assert.AreEqual(1, dynamicOperand.ReferencedMemberChain.Count);
|
||||
Assert.AreEqual(countEntry, dynamicOperand.ReferencedMemberChain[0].Member);
|
||||
Assert.AreEqual(0, dynamicOperand.ArrayIndices.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,83 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
using ZoneCodeGenerator.Persistence;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestGameTest
|
||||
{
|
||||
private Mock<IReadOnlyDataRepository> repositoryMock;
|
||||
private Mock<ICommandParserState> parserStateMock;
|
||||
|
||||
private string game;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<ICommandParserState>();
|
||||
|
||||
game = "";
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
repositoryMock = new Mock<IReadOnlyDataRepository>();
|
||||
|
||||
parserStateMock.SetupGet(state => state.Repository)
|
||||
.Returns(() => repositoryMock.Object);
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
parserStateMock.SetupGet(state => state.Game)
|
||||
.Returns(() => game);
|
||||
parserStateMock.SetupSet(state => state.Game = It.IsAny<string>())
|
||||
.Callback((string s) => game = s);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleGameStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"game", "asdf", ";"
|
||||
});
|
||||
|
||||
var test = new TestGame();
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(3, test.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAcceptMultipleGameStatements()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"game", "asdf", ";"
|
||||
});
|
||||
|
||||
game = "alreadyAssignment";
|
||||
|
||||
var test = new TestGame();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,118 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Domain.FastFileStructure;
|
||||
using ZoneCodeGenerator.Domain.Information;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile;
|
||||
using ZoneCodeGenerator.Parsing.CommandFile.Tests;
|
||||
using ZoneCodeGenerator.Parsing.Testing;
|
||||
using ZoneCodeGenerator.Persistence;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
|
||||
{
|
||||
[TestClass]
|
||||
public class TestUseTest
|
||||
{
|
||||
private Mock<IReadOnlyDataRepository> repositoryMock;
|
||||
private Mock<ICommandParserState> parserStateMock;
|
||||
|
||||
private StructureInformation usedType;
|
||||
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
parserStateMock = new Mock<ICommandParserState>();
|
||||
|
||||
usedType = null;
|
||||
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
lexerMock = new Mock<ILexer>();
|
||||
repositoryMock = new Mock<IReadOnlyDataRepository>();
|
||||
|
||||
parserStateMock.SetupGet(state => state.Repository)
|
||||
.Returns(() => repositoryMock.Object);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetInformationFor(It.IsAny<DataTypeWithMembers>()))
|
||||
.Returns((DataTypeWithMembers type) => new StructureInformation(type));
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
parserStateMock.SetupGet(state => state.DataTypeInUse)
|
||||
.Returns(() => usedType);
|
||||
parserStateMock.SetupSet(state => state.DataTypeInUse = It.IsAny<StructureInformation>())
|
||||
.Callback((StructureInformation type) => usedType = type);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsSimpleUseStatement()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"use", "test", ":", ":", "type", ";"
|
||||
});
|
||||
|
||||
var test = new TestUse();
|
||||
|
||||
var assetTypeToUse = new DataTypeStruct("test", "type", 4);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
|
||||
.Returns(() => assetTypeToUse);
|
||||
|
||||
Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
Assert.AreEqual(6, test.ConsumedTokenCount);
|
||||
|
||||
Assert.IsNotNull(assetTypeToUse);
|
||||
Assert.AreEqual(usedType.Type, assetTypeToUse);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenTypeIsNotFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"use", "test", ":", ":", "type", ";"
|
||||
});
|
||||
|
||||
var test = new TestUse();
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureThrowsExceptionWhenTypeIsNotDataTypeWithMembers()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"use", "test", ":", ":", "type", ";"
|
||||
});
|
||||
|
||||
var test = new TestUse();
|
||||
|
||||
var _enum = new DataTypeEnum("test", "type", DataTypeBaseType.INT);
|
||||
var enumEntry1 = new EnumMember("ENTRY_ONE", 1);
|
||||
var enumEntry2 = new EnumMember("ENTRY_TWO", 2);
|
||||
_enum.Members.Add(enumEntry1);
|
||||
_enum.Members.Add(enumEntry2);
|
||||
|
||||
repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
|
||||
.Returns(() => _enum);
|
||||
|
||||
Assert.ThrowsException<TestFailedException>(
|
||||
() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,93 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Impl;
|
||||
using ZoneCodeGenerator.Utils;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Impl
|
||||
{
|
||||
[TestClass]
|
||||
public class CommentPreprocessorTest
|
||||
{
|
||||
private ICommentProcessor commentProcessor;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
commentProcessor = new CommentProcessor();
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureReturnsUnmodifiedText()
|
||||
{
|
||||
string[] stringsThatShouldNotBeModified =
|
||||
{
|
||||
"This is a normal string",
|
||||
"There is nothing to be preprocessed!",
|
||||
"0124124124 # 124124124",
|
||||
"...",
|
||||
"<?php><html>asdf</html>",
|
||||
""
|
||||
};
|
||||
|
||||
foreach (var stringThatShouldNotBeModified in stringsThatShouldNotBeModified)
|
||||
{
|
||||
Assert.AreEqual(stringThatShouldNotBeModified, commentProcessor.RemoveComments(stringThatShouldNotBeModified));
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesRemoveLineComments()
|
||||
{
|
||||
var commentStrings = new Dictionary<string, string>()
|
||||
{
|
||||
{"// This is a comment at the beginning of the line", ""},
|
||||
{"Text in front of a comment // Comment", "Text in front of a comment"},
|
||||
{"/ / Not a comment", "/ / Not a comment"},
|
||||
{"asdf /// Triple slash is a comment", "asdf"},
|
||||
{"b2h3 /////////////// In fact after the first two slashes it should always be considered a comment", "b2h3"},
|
||||
};
|
||||
|
||||
foreach (var (input, expectedResult) in commentStrings)
|
||||
{
|
||||
Assert.AreEqual(expectedResult, commentProcessor.RemoveComments(input));
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesRemoveBlockComments()
|
||||
{
|
||||
var commentStrings = new Dictionary<string, string>()
|
||||
{
|
||||
{"/* This is a block comment */", ""},
|
||||
{"Text in front of a comment /** Comment ***/", "Text in front of a comment"},
|
||||
{"/ * Not a comment */", "/ * Not a comment */"},
|
||||
{"Text in front of comment /* Comment */ Text after the comment", "Text in front of comment Text after the comment"},
|
||||
{"Hello/*Hell*/World", "HelloWorld"},
|
||||
};
|
||||
|
||||
foreach (var (input, expectedResult) in commentStrings)
|
||||
{
|
||||
Assert.AreEqual(expectedResult, commentProcessor.RemoveComments(input));
|
||||
}
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureBlockCommentsWorkOverMultipleLines()
|
||||
{
|
||||
var commentStrings = new Dictionary<string, string>()
|
||||
{
|
||||
{"The start of the comment /* Is now", "The start of the comment"},
|
||||
{"Nothing to be seen here", ""},
|
||||
{"* / /* Still nothing", ""},
|
||||
{"The comment ends */ now", " now"},
|
||||
{"This line should not cause any issues", "This line should not cause any issues"},
|
||||
};
|
||||
|
||||
foreach (var (input, expectedResult) in commentStrings)
|
||||
{
|
||||
Assert.AreEqual(expectedResult, commentProcessor.RemoveComments(input));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,357 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using ZoneCodeGenerator.Parsing.Impl;
|
||||
using ZoneCodeGeneratorTests.Parsing.Mock;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Impl
|
||||
{
|
||||
[TestClass]
|
||||
public class LexerTest
|
||||
{
|
||||
private IncludingParsingStreamTest headerStream;
|
||||
private Lexer lexer;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
headerStream = new IncludingParsingStreamTest("file.h");
|
||||
lexer = new Lexer(headerStream);
|
||||
}
|
||||
|
||||
private void AssertTokenOutput(params string[] expectedTokens)
|
||||
{
|
||||
foreach (var token in expectedTokens)
|
||||
Assert.AreEqual(token, lexer.NextToken());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanSplitWords()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
AssertTokenOutput("Some", "random", "tokens", "right", "here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureCanSplitSpecialCharactersFromWords()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"word1;word2; word3 ; word4 ;word5",
|
||||
"word1:word2: word3 : word4 :word5",
|
||||
"word1{word2{ word3 { word4 {word5",
|
||||
"word1}word2} word3 } word4 }word5",
|
||||
"word1,word2, word3 , word4 ,word5",
|
||||
"word1.word2. word3 . word4 .word5",
|
||||
"word1=word2= word3 = word4 =word5",
|
||||
"word1(word2( word3 ( word4 (word5",
|
||||
"word1)word2) word3 ) word4 )word5",
|
||||
"word1*word2* word3 * word4 *word5",
|
||||
"word1[word2[ word3 [ word4 [word5",
|
||||
"word1]word2] word3 ] word4 ]word5",
|
||||
"word1<word2< word3 < word4 <word5",
|
||||
"word1>word2> word3 > word4 >word5",
|
||||
"word1#word2# word3 # word4 #word5",
|
||||
"word1&word2& word3 & word4 &word5",
|
||||
"word1%word2% word3 % word4 %word5",
|
||||
"word1\"word2\" word3 \" word4 \"word5",
|
||||
"word1?word2? word3 ? word4 ?word5",
|
||||
"word1!word2! word3 ! word4 !word5",
|
||||
"word1+word2+ word3 + word4 +word5",
|
||||
"word1-word2- word3 - word4 -word5",
|
||||
"word1/word2/ word3 / word4 /word5",
|
||||
"word1\\word2\\ word3 \\ word4 \\word5",
|
||||
"word1|word2| word3 | word4 |word5",
|
||||
});
|
||||
|
||||
AssertTokenOutput("word1", ";", "word2", ";", "word3", ";", "word4", ";", "word5");
|
||||
AssertTokenOutput("word1", ":", "word2", ":", "word3", ":", "word4", ":", "word5");
|
||||
AssertTokenOutput("word1", "{", "word2", "{", "word3", "{", "word4", "{", "word5");
|
||||
AssertTokenOutput("word1", "}", "word2", "}", "word3", "}", "word4", "}", "word5");
|
||||
AssertTokenOutput("word1", ",", "word2", ",", "word3", ",", "word4", ",", "word5");
|
||||
AssertTokenOutput("word1", ".", "word2", ".", "word3", ".", "word4", ".", "word5");
|
||||
AssertTokenOutput("word1", "=", "word2", "=", "word3", "=", "word4", "=", "word5");
|
||||
AssertTokenOutput("word1", "(", "word2", "(", "word3", "(", "word4", "(", "word5");
|
||||
AssertTokenOutput("word1", ")", "word2", ")", "word3", ")", "word4", ")", "word5");
|
||||
AssertTokenOutput("word1", "*", "word2", "*", "word3", "*", "word4", "*", "word5");
|
||||
AssertTokenOutput("word1", "[", "word2", "[", "word3", "[", "word4", "[", "word5");
|
||||
AssertTokenOutput("word1", "]", "word2", "]", "word3", "]", "word4", "]", "word5");
|
||||
AssertTokenOutput("word1", "<", "word2", "<", "word3", "<", "word4", "<", "word5");
|
||||
AssertTokenOutput("word1", ">", "word2", ">", "word3", ">", "word4", ">", "word5");
|
||||
AssertTokenOutput("word1", "#", "word2", "#", "word3", "#", "word4", "#", "word5");
|
||||
AssertTokenOutput("word1", "&", "word2", "&", "word3", "&", "word4", "&", "word5");
|
||||
AssertTokenOutput("word1", "%", "word2", "%", "word3", "%", "word4", "%", "word5");
|
||||
AssertTokenOutput("word1", "\"", "word2", "\"", "word3", "\"", "word4", "\"", "word5");
|
||||
AssertTokenOutput("word1", "?", "word2", "?", "word3", "?", "word4", "?", "word5");
|
||||
AssertTokenOutput("word1", "!", "word2", "!", "word3", "!", "word4", "!", "word5");
|
||||
AssertTokenOutput("word1", "+", "word2", "+", "word3", "+", "word4", "+", "word5");
|
||||
AssertTokenOutput("word1", "-", "word2", "-", "word3", "-", "word4", "-", "word5");
|
||||
AssertTokenOutput("word1", "/", "word2", "/", "word3", "/", "word4", "/", "word5");
|
||||
AssertTokenOutput("word1", "\\", "word2", "\\", "word3", "\\", "word4", "\\", "word5");
|
||||
AssertTokenOutput("word1", "|", "word2", "|", "word3", "|", "word4", "|", "word5");
|
||||
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsurePeekingDoesNotConsumeTokens()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
Assert.AreEqual("Some", lexer.PeekToken());
|
||||
Assert.AreEqual("tokens", lexer.PeekToken(2));
|
||||
Assert.AreEqual("here", lexer.PeekToken(4));
|
||||
Assert.AreEqual("right", lexer.PeekToken(3));
|
||||
|
||||
|
||||
Assert.AreEqual("Some", lexer.NextToken());
|
||||
Assert.AreEqual("right", lexer.PeekToken(2));
|
||||
|
||||
AssertTokenOutput("random", "tokens", "right");
|
||||
|
||||
Assert.AreEqual("here", lexer.PeekToken());
|
||||
Assert.AreEqual("here", lexer.PeekToken());
|
||||
Assert.AreEqual("here", lexer.PeekToken());
|
||||
|
||||
Assert.AreEqual("here", lexer.NextToken());
|
||||
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsurePeekingOutOfBoundsDoesNotCauseIssues()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
Assert.AreEqual("", lexer.PeekToken(1337));
|
||||
Assert.AreEqual("", lexer.PeekToken(5));
|
||||
Assert.AreEqual("", lexer.PeekToken(-2));
|
||||
|
||||
AssertTokenOutput("Some", "random", "tokens", "right", "here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
|
||||
Assert.AreEqual("", lexer.PeekToken());
|
||||
Assert.AreEqual("", lexer.PeekToken(2));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureGettingNextTokenAfterStreamEndDoesNotCauseIssues()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
AssertTokenOutput("Some", "random", "tokens", "right", "here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
|
||||
Assert.AreEqual("", lexer.NextToken());
|
||||
Assert.AreEqual("", lexer.NextToken());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSkippingTokensWorksCorrectly()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
AssertTokenOutput("Some", "random");
|
||||
Assert.IsFalse(lexer.IsEndOfStream);
|
||||
|
||||
lexer.SkipTokens(2);
|
||||
|
||||
AssertTokenOutput("here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSkippingNoTokensWorksCorrectly()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
AssertTokenOutput("Some", "random");
|
||||
Assert.IsFalse(lexer.IsEndOfStream);
|
||||
|
||||
lexer.SkipTokens(0);
|
||||
|
||||
AssertTokenOutput("tokens", "right", "here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSkippingOutOfBoundsDoesNotCauseIssues()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
AssertTokenOutput("Some", "random");
|
||||
Assert.IsFalse(lexer.IsEndOfStream);
|
||||
|
||||
lexer.SkipTokens(-5);
|
||||
|
||||
AssertTokenOutput("tokens", "right");
|
||||
|
||||
lexer.SkipTokens(1337);
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
AssertTokenOutput("");
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSkippingAfterStreamEndDoesNotCauseIssues()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some random tokens",
|
||||
"right here"
|
||||
});
|
||||
|
||||
AssertTokenOutput("Some", "random", "tokens", "right", "here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
|
||||
lexer.SkipTokens(1);
|
||||
lexer.SkipTokens(2);
|
||||
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTheFilenameOfTheTokenIsCorrect()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some",
|
||||
"random",
|
||||
"tokens",
|
||||
"right",
|
||||
"here"
|
||||
});
|
||||
|
||||
Assert.AreEqual("file.h", lexer.CurrentFile);
|
||||
AssertTokenOutput("Some");
|
||||
Assert.AreEqual("file.h", lexer.CurrentFile);
|
||||
headerStream.Filename = "file2.h";
|
||||
AssertTokenOutput("random");
|
||||
headerStream.Filename = "file3.h";
|
||||
Assert.AreEqual("file3.h", lexer.CurrentFile);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFilenameOfTokenStaysConsistent()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some",
|
||||
"random",
|
||||
"tokens",
|
||||
"right",
|
||||
"here"
|
||||
});
|
||||
|
||||
Assert.AreEqual("file.h", lexer.CurrentFile);
|
||||
Assert.AreEqual("Some", lexer.PeekToken());
|
||||
|
||||
headerStream.Filename = "file2.h";
|
||||
|
||||
Assert.AreEqual("file.h", lexer.CurrentFile);
|
||||
Assert.AreEqual("Some", lexer.PeekToken());
|
||||
Assert.AreEqual("file.h", lexer.CurrentFile);
|
||||
|
||||
Assert.AreEqual("Some", lexer.NextToken());
|
||||
|
||||
Assert.AreEqual("file2.h", lexer.CurrentFile);
|
||||
|
||||
AssertTokenOutput("random", "tokens", "right", "here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTheLineOfTheTokenIsCorrect()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some",
|
||||
"random",
|
||||
"tokens",
|
||||
"right",
|
||||
"here"
|
||||
});
|
||||
|
||||
Assert.AreEqual(0, lexer.CurrentLine);
|
||||
AssertTokenOutput("Some");
|
||||
Assert.AreEqual(1, lexer.CurrentLine);
|
||||
AssertTokenOutput("random");
|
||||
Assert.AreEqual(2, lexer.CurrentLine);
|
||||
|
||||
lexer.SkipTokens(1);
|
||||
Assert.AreEqual(3, lexer.CurrentLine);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureLineOfTokenStaysConsistent()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"Some",
|
||||
"random",
|
||||
"tokens",
|
||||
"right",
|
||||
"here"
|
||||
});
|
||||
|
||||
Assert.AreEqual(0, lexer.CurrentLine);
|
||||
Assert.AreEqual("Some", lexer.PeekToken());
|
||||
Assert.AreEqual("random", lexer.PeekToken(1));
|
||||
|
||||
headerStream.Line = 3;
|
||||
|
||||
Assert.AreEqual(0, lexer.CurrentLine);
|
||||
Assert.AreEqual("Some", lexer.PeekToken());
|
||||
Assert.AreEqual("Some", lexer.NextToken());
|
||||
|
||||
Assert.AreEqual(1, lexer.CurrentLine);
|
||||
Assert.AreEqual("random", lexer.PeekToken());
|
||||
Assert.AreEqual("random", lexer.NextToken());
|
||||
|
||||
Assert.AreEqual(3, lexer.CurrentLine);
|
||||
Assert.AreEqual("right", lexer.PeekToken());
|
||||
Assert.AreEqual("right", lexer.NextToken());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTreatsUnusedSpecialCharactersAsWordCharacters()
|
||||
{
|
||||
headerStream.Lines.AddRange(new List<string>
|
||||
{
|
||||
"$ome _random token$",
|
||||
"right here"
|
||||
});
|
||||
|
||||
AssertTokenOutput("$ome", "_random", "token$", "right", "here");
|
||||
Assert.IsTrue(lexer.IsEndOfStream);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,253 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherArrayTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDecimalArraysAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "15", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureHexArraysAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "0x20", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureEnumValueArraysAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "ENUM_VALUE", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureInvalidEnumValueNameIsNotRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "09INVALID", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFirstSquareBracketIsRequiredToBeRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"13", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSecondSquareBracketIsRequiredToBeRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "13"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSquareBracketsAreRequiredToBeRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"13"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSquareBracketsNeedToBeInTheCorrectOrder()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"]", "13", "["
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamedOutputIsDecimalNumberForDecimalInput()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "13", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray().WithName("array_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("13", result.NamedMatches["array_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamedOutputIsDecimalNumberForHexInput()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "0x133", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray().WithName("array_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("307", result.NamedMatches["array_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamedOutputIsStringForEnumValueInput()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "HELLO_WORLD", "]"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray().WithName("array_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("HELLO_WORLD", result.NamedMatches["array_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"random", "string", "[", "5", "]", ";"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray();
|
||||
var result = matcher.Test(matchingContext, 2);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"[", "42", "]", "randomString"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray().WithTag("asdf");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, result.MatchedTags.Count);
|
||||
Assert.AreEqual("asdf", result.MatchedTags[0]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"nope", "[", "42", "]", "randomString"
|
||||
});
|
||||
|
||||
var matcher = new MatcherArray().WithTag("asdf");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,177 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherGroupAndTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
lexerMock = new Mock<ILexer>();
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAllTestsSuccessfulMakesGroupSuccessful()
|
||||
{
|
||||
var groupAnd = new MatcherGroupAnd
|
||||
(
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(true, 1)
|
||||
);
|
||||
|
||||
var result = groupAnd.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureLastTestFailingLetsGroupFail()
|
||||
{
|
||||
var groupAnd = new MatcherGroupAnd
|
||||
(
|
||||
new TestMatcher(true, 4),
|
||||
new TestMatcher(true, 2),
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(false, 0)
|
||||
);
|
||||
|
||||
var result = groupAnd.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureFirstTestFailingLetsGroupFail()
|
||||
{
|
||||
var groupAnd = new MatcherGroupAnd
|
||||
(
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(true, 1)
|
||||
);
|
||||
|
||||
var result = groupAnd.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTestsAreCalledWithCorrectTokenOffsets()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(true, 4),
|
||||
new TestMatcher(true, 2),
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(true, 1)
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var groupAnd = new MatcherGroupAnd(iTokenMatcherArray);
|
||||
|
||||
var result = groupAnd.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
|
||||
Assert.IsTrue(testMatchers[0].WasTested);
|
||||
Assert.AreEqual(0, testMatchers[0].TestTokenOffset);
|
||||
|
||||
Assert.IsTrue(testMatchers[1].WasTested);
|
||||
Assert.AreEqual(4, testMatchers[1].TestTokenOffset);
|
||||
|
||||
Assert.IsTrue(testMatchers[2].WasTested);
|
||||
Assert.AreEqual(6, testMatchers[2].TestTokenOffset);
|
||||
|
||||
Assert.IsTrue(testMatchers[3].WasTested);
|
||||
Assert.AreEqual(7, testMatchers[3].TestTokenOffset);
|
||||
|
||||
Assert.IsFalse(testMatchers[4].WasTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureGroupWithNoTestsThrowsException()
|
||||
{
|
||||
MatcherGroupAnd matcherGroup = null;
|
||||
|
||||
Assert.ThrowsException<ArgumentException>(
|
||||
() => matcherGroup = new MatcherGroupAnd()
|
||||
);
|
||||
|
||||
Assert.IsNull(matcherGroup);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(true, 3),
|
||||
new TestMatcher(true, 1)
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var groupAnd = new MatcherGroupAnd(iTokenMatcherArray);
|
||||
|
||||
var result = groupAnd.Test(matchingContext, 5);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
|
||||
Assert.AreEqual(5, testMatchers[0].TestTokenOffset);
|
||||
Assert.AreEqual(8, testMatchers[1].TestTokenOffset);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(true, 3).WithTag("testTagTheSecond"),
|
||||
new TestMatcher(true, 1).WithTag("testTagTheThird")
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var groupAnd = new MatcherGroupAnd(iTokenMatcherArray).WithTag("testTagTheFirst");
|
||||
|
||||
var result = groupAnd.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.MatchedTags.Count);
|
||||
Assert.AreEqual("testTagTheFirst", result.MatchedTags[0]);
|
||||
Assert.AreEqual("testTagTheSecond", result.MatchedTags[1]);
|
||||
Assert.AreEqual("testTagTheThird", result.MatchedTags[2]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(true, 3).WithTag("testTagTheSecond"),
|
||||
new TestMatcher(false, 1).WithTag("testTagTheThird")
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var groupAnd = new MatcherGroupAnd(iTokenMatcherArray).WithTag("testTagTheFirst");
|
||||
|
||||
var result = groupAnd.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,232 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherGroupLoopTest
|
||||
{
|
||||
private const string LoopToken = "loop_token";
|
||||
|
||||
private int testsUntilUnsuccessful;
|
||||
private int timesTested;
|
||||
private Mock<ILexer> lexerMock;
|
||||
private Mock<TokenMatcher> tokenMatcherMock;
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
timesTested = 0;
|
||||
testsUntilUnsuccessful = 0;
|
||||
lexerMock = new Mock<ILexer>();
|
||||
tokenMatcherMock = new Mock<TokenMatcher>();
|
||||
|
||||
tokenMatcherMock.Setup(matcher => matcher.Test(It.IsAny<MatchingContext>(), It.IsAny<int>()))
|
||||
.Returns(() =>
|
||||
{
|
||||
timesTested++;
|
||||
|
||||
if(testsUntilUnsuccessful == 0)
|
||||
return new TokenMatchingResult(false, 0);
|
||||
|
||||
testsUntilUnsuccessful--;
|
||||
|
||||
var matchResult = new TokenMatchingResult(true, 1);
|
||||
|
||||
matchResult.AddNamedMatch(LoopToken, "test");
|
||||
matchResult.AppendTag("testTag");
|
||||
|
||||
return matchResult;
|
||||
});
|
||||
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureZeroOneMultipleAcceptsNoSuccessfulTests()
|
||||
{
|
||||
testsUntilUnsuccessful = 0;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.ZeroOneMultiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureZeroOneMultipleAcceptsOneSuccessfulTest()
|
||||
{
|
||||
testsUntilUnsuccessful = 1;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.ZeroOneMultiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(2, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureZeroOneMultipleAcceptsMultipleSuccessfulTest()
|
||||
{
|
||||
testsUntilUnsuccessful = 5;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.ZeroOneMultiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(5, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(6, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureOneMultipleRejectsNoSuccessfulTests()
|
||||
{
|
||||
testsUntilUnsuccessful = 0;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureOneMultipleAcceptsOneSuccessfulTest()
|
||||
{
|
||||
testsUntilUnsuccessful = 1;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(2, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureOneMultipleAcceptsMultipleSuccessfulTests()
|
||||
{
|
||||
testsUntilUnsuccessful = 3;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(4, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMultipleRejectsNoSuccessfulTests()
|
||||
{
|
||||
testsUntilUnsuccessful = 0;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMultipleRejectsOneSuccessfulTest()
|
||||
{
|
||||
testsUntilUnsuccessful = 1;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(2, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMultipleAcceptsMultipleSuccessfulTests()
|
||||
{
|
||||
testsUntilUnsuccessful = 2;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(2, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(3, timesTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAllNamedMatchesAreIncluded()
|
||||
{
|
||||
testsUntilUnsuccessful = 10;
|
||||
var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(10, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(11, timesTested);
|
||||
|
||||
var namedMatches = result.NamedMatches[LoopToken];
|
||||
|
||||
Assert.AreEqual(10, namedMatches.Count);
|
||||
|
||||
foreach(var namedMatch in namedMatches)
|
||||
Assert.AreEqual("test", namedMatch);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
testsUntilUnsuccessful = 2;
|
||||
var groupLoop = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object);
|
||||
|
||||
var result = groupLoop.Test(matchingContext, 4);
|
||||
|
||||
tokenMatcherMock.Verify(matcher => matcher.Test(It.IsAny<MatchingContext>(), 4));
|
||||
tokenMatcherMock.Verify(matcher => matcher.Test(It.IsAny<MatchingContext>(), 5));
|
||||
tokenMatcherMock.Verify(matcher => matcher.Test(It.IsAny<MatchingContext>(), 6));
|
||||
tokenMatcherMock.VerifyNoOtherCalls();
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
testsUntilUnsuccessful = 4;
|
||||
var groupLoop = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object).WithTag("loopTag");
|
||||
|
||||
var result = groupLoop.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(5, result.MatchedTags.Count);
|
||||
Assert.AreEqual("loopTag", result.MatchedTags[0]);
|
||||
Assert.AreEqual("testTag", result.MatchedTags[1]);
|
||||
Assert.AreEqual("testTag", result.MatchedTags[2]);
|
||||
Assert.AreEqual("testTag", result.MatchedTags[3]);
|
||||
Assert.AreEqual("testTag", result.MatchedTags[4]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
testsUntilUnsuccessful = 1;
|
||||
var groupLoop = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object).WithTag("loopTag");
|
||||
|
||||
var result = groupLoop.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,85 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherGroupOptionalTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
lexerMock = new Mock<ILexer>();
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureIsSuccessfulWhenMatcherIsSuccessful()
|
||||
{
|
||||
var matcherGroup = new MatcherGroupOptional(new TestMatcher(true, 5));
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(5, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureIsSuccessfulWhenMatcherIsUnsuccessful()
|
||||
{
|
||||
var matcherGroup = new MatcherGroupOptional(new TestMatcher(false, 0));
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
var testMatcher = new TestMatcher(true, 1);
|
||||
var groupOptional = new MatcherGroupOptional(testMatcher);
|
||||
|
||||
var result = groupOptional.Test(matchingContext, 7);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
|
||||
Assert.AreEqual(7, testMatcher.TestTokenOffset);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
var testMatcher = new TestMatcher(true, 1).WithTag("testTag");
|
||||
var groupOptional = new MatcherGroupOptional(testMatcher).WithTag("optionalTag");
|
||||
|
||||
var result = groupOptional.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(2, result.MatchedTags.Count);
|
||||
Assert.AreEqual("optionalTag", result.MatchedTags[0]);
|
||||
Assert.AreEqual("testTag", result.MatchedTags[1]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesStillAddItsOwnTagWhenMatcherDoesNotMatch()
|
||||
{
|
||||
var testMatcher = new TestMatcher(false, 0).WithTag("testTag");
|
||||
var groupOptional = new MatcherGroupOptional(testMatcher).WithTag("optionalTag");
|
||||
|
||||
var result = groupOptional.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.MatchedTags.Count);
|
||||
Assert.AreEqual("optionalTag", result.MatchedTags[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,192 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherGroupOrTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
lexerMock = new Mock<ILexer>();
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAnyTestSuccessfulMakesGroupSuccessful()
|
||||
{
|
||||
var matcherGroup = new MatcherGroupOr
|
||||
(
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(true, 3),
|
||||
new TestMatcher(false, 0)
|
||||
);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureLastTestSuccessfulMakesGroupSuccessful()
|
||||
{
|
||||
var matcherGroup = new MatcherGroupOr
|
||||
(
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(true, 4)
|
||||
);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAllTestsSuccessfulMakesGroupSuccessful()
|
||||
{
|
||||
var matcherGroup = new MatcherGroupOr
|
||||
(
|
||||
new TestMatcher(true, 1),
|
||||
new TestMatcher(true, 2),
|
||||
new TestMatcher(true, 3),
|
||||
new TestMatcher(true, 4)
|
||||
);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNoTestsSuccessfulMakesGroupUnsuccessful()
|
||||
{
|
||||
var matcherGroup = new MatcherGroupOr
|
||||
(
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(false, 0)
|
||||
);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTestsAreCalledWithCorrectTokenOffsets()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(false, 0),
|
||||
new TestMatcher(true, 4),
|
||||
new TestMatcher(false, 0),
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var matcherGroup = new MatcherGroupOr(iTokenMatcherArray);
|
||||
|
||||
var result = matcherGroup.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
|
||||
Assert.IsTrue(testMatchers[0].WasTested);
|
||||
Assert.AreEqual(0, testMatchers[0].TestTokenOffset);
|
||||
|
||||
Assert.IsTrue(testMatchers[1].WasTested);
|
||||
Assert.AreEqual(0, testMatchers[1].TestTokenOffset);
|
||||
|
||||
Assert.IsTrue(testMatchers[2].WasTested);
|
||||
Assert.AreEqual(0, testMatchers[2].TestTokenOffset);
|
||||
|
||||
Assert.IsTrue(testMatchers[3].WasTested);
|
||||
Assert.AreEqual(0, testMatchers[3].TestTokenOffset);
|
||||
|
||||
Assert.IsFalse(testMatchers[4].WasTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureGroupWithNoTestsThrowsException()
|
||||
{
|
||||
MatcherGroupOr matcherGroup = null;
|
||||
|
||||
Assert.ThrowsException<ArgumentException>(
|
||||
() => matcherGroup = new MatcherGroupOr()
|
||||
);
|
||||
|
||||
Assert.IsNull(matcherGroup);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(true, 3),
|
||||
new TestMatcher(false, 1)
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var groupOr = new MatcherGroupOr(iTokenMatcherArray);
|
||||
|
||||
var result = groupOr.Test(matchingContext, 5);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
|
||||
Assert.AreEqual(5, testMatchers[0].TestTokenOffset);
|
||||
Assert.IsFalse(testMatchers[1].WasTested);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(false, 3).WithTag("testTagTheSecond"),
|
||||
new TestMatcher(true, 1).WithTag("testTagTheThird")
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var groupOr = new MatcherGroupOr(iTokenMatcherArray).WithTag("testTagTheFirst");
|
||||
|
||||
var result = groupOr.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(2, result.MatchedTags.Count);
|
||||
Assert.AreEqual("testTagTheFirst", result.MatchedTags[0]);
|
||||
Assert.AreEqual("testTagTheThird", result.MatchedTags[1]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
var testMatchers = new[]
|
||||
{
|
||||
new TestMatcher(false, 3).WithTag("testTagTheSecond"),
|
||||
new TestMatcher(false, 1).WithTag("testTagTheThird")
|
||||
};
|
||||
var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
|
||||
var groupOr = new MatcherGroupOr(iTokenMatcherArray).WithTag("testTagTheFirst");
|
||||
|
||||
var result = groupOr.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,192 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherLiteralTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMatchingSameStringReturnsSuccessful()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"const"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("const");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMatchingDifferentStringReturnsUnsuccessful()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"long"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("const");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMatchingIsCaseSensitive()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"CONST"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("const");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamedMatchIsLiteralItself()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"const"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("const").WithName("test_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("const", result.NamedMatches["test_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMatcherWithMultipleLiteralTokensMatchesWhenAllAreFound()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"const", "range", "of", "turtles"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("const", "range");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(2, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMatcherWithMultipleLiteralTokensDoesNotMatchWhenFirstTokenIsDifferent()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"static", "range", "of", "turtles"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("const", "range");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMatcherWithMultipleLiteralTokensDoesNotMatchWhenSecondTokenIsDifferent()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"const", "element", "of", "turtles"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("const", "const");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"strawberry", "cake", "is", "yummy"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("cake");
|
||||
var result = matcher.Test(matchingContext, 1);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"strawberry"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("strawberry").WithTag("strawberryMatcher");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, result.MatchedTags.Count);
|
||||
Assert.AreEqual("strawberryMatcher", result.MatchedTags[0]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"apple"
|
||||
});
|
||||
|
||||
var matcher = new MatcherLiteral("strawberry").WithTag("strawberryMatcher");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,208 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherNameTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRecognizesNormalName()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"variable_name"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureRecognizesUnderscoreAtTheBeginning()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"_variable_name"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsDigit()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"v4ri4bl3_n4m3"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAcceptDigitAtTheBeginning()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"5variable_name"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAcceptCKeyword()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"float"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAcceptSymbols()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"%$§"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAcceptEmptyString()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
""
|
||||
});
|
||||
|
||||
var matcher = new MatcherName();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamedOutputIsMatchedName()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"variable_n4me"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName().WithName("name_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("variable_n4me", result.NamedMatches["name_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"static", "int", "variable_n4me", "=", "5", ";"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName().WithName("name_token");
|
||||
var result = matcher.Test(matchingContext, 2);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("variable_n4me", result.NamedMatches["name_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"variable_n4me"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName().WithTag("very_cool_matcher");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, result.MatchedTags.Count);
|
||||
Assert.AreEqual("very_cool_matcher", result.MatchedTags[0]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"1337"
|
||||
});
|
||||
|
||||
var matcher = new MatcherName().WithTag("very_cool_matcher");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,208 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherNumberTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDecimalNumbersAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"1337"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureHexNumbersAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"0x1A4"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureHexNumbersWithInvalidLettersAreInvalid()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"0xAFZF"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureWordsAreInvalid()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"Hello"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSymbolsAreInvalid()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"%"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureJustHexPrefixIsInvalid()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"0x"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber();
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamedOutputIsDecimalNumberForDecimalInput()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"420"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber().WithName("number_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("420", result.NamedMatches["number_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamedOutputIsDecimalNumberForHexInput()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"0x1a5"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber().WithName("number_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("421", result.NamedMatches["number_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"int", "kek", "=", "1337", ";"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber();
|
||||
var result = matcher.Test(matchingContext, 3);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"1337"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber().WithTag("Taggerino");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, result.MatchedTags.Count);
|
||||
Assert.AreEqual("Taggerino", result.MatchedTags[0]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"not_a_number_yo"
|
||||
});
|
||||
|
||||
var matcher = new MatcherNumber().WithTag("Taggerino");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,310 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using Moq;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
using ZoneCodeGenerator.Parsing.Matching.Matchers;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
[TestClass]
|
||||
public class MatcherTypenameTest
|
||||
{
|
||||
private Mock<ILexer> lexerMock;
|
||||
private int tokenOffset;
|
||||
private List<string> tokens;
|
||||
|
||||
private MatchingContext matchingContext;
|
||||
|
||||
[TestInitialize]
|
||||
public void Setup()
|
||||
{
|
||||
tokenOffset = 0;
|
||||
tokens = new List<string>();
|
||||
|
||||
lexerMock = new Mock<ILexer>();
|
||||
|
||||
lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
|
||||
.Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
|
||||
lexerMock.Setup(lexer => lexer.NextToken())
|
||||
.Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
|
||||
lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
|
||||
.Callback((int count) => tokenOffset += count);
|
||||
|
||||
matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureBaseTypeNamesAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"int"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("int", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNormalTypeNamesAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"GfxWorld"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("GfxWorld", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureUnsignedTypeNamesAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"unsigned", "int"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(2, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("unsigned int", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSignedTypeNamesAreRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"signed", "int"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(2, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("signed int", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoubleLongIsRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"long", "long"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(2, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("long long", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoubleLongWithPrefixesIsRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"unsigned", "long", "long"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(3, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("unsigned long long", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoubleIntIsNotRecognized()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"int", "int"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("int", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureNamespacesAreAllowed()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"std", ":", ":", "string"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("std::string", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAcceptsTypeNamesWithNumbersAndUnderscores()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"std", ":", ":", "int32_t"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("std::int32_t", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureShortNamespacesAreAllowed()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"a", ":", ":", "b"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("a::b", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoubleColonPrefixIsNotAllowed()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
":", ":", "string"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.IsFalse(result.NamedMatches.ContainsKey("type_token"));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSingleDoubleColonNamespacesDoNotMatch()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"std", ":", "string"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(1, result.ConsumedTokenCount);
|
||||
Assert.AreEqual("std", result.NamedMatches["type_token"].ElementAtOrDefault(0));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSymbolsAreNotAllowed()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"%"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.IsFalse(result.NamedMatches.ContainsKey("type_token"));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureSymbolsWithUnsignedAreNotAllowed()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"unsigned", "%"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithName("type_token");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.IsFalse(result.NamedMatches.ContainsKey("type_token"));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureMakesCorrectUseOfTokenOffset()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"5", "4", "3", "2", "std", ":", ":", "string", "randomString", ";"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename();
|
||||
var result = matcher.Test(matchingContext, 4);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureAddsTagWhenMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"std", ":", ":", "something", "test"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithTag("naisu");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsTrue(result.Successful);
|
||||
Assert.AreEqual(4, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(1, result.MatchedTags.Count);
|
||||
Assert.AreEqual("naisu", result.MatchedTags[0]);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureDoesNotAddTagWhenNotMatched()
|
||||
{
|
||||
tokens.AddRange(new List<string>
|
||||
{
|
||||
"1337", "asdf", ":", ":", "something", "test"
|
||||
});
|
||||
|
||||
var matcher = new MatcherTypename().WithTag("naisu");
|
||||
var result = matcher.Test(matchingContext, 0);
|
||||
|
||||
Assert.IsFalse(result.Successful);
|
||||
Assert.AreEqual(0, result.ConsumedTokenCount);
|
||||
Assert.AreEqual(0, result.MatchedTags.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,44 +0,0 @@
|
||||
using ZoneCodeGenerator.Parsing.Matching;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
|
||||
{
|
||||
class TestMatcher : TokenMatcher
|
||||
{
|
||||
private readonly int tokenCount;
|
||||
private readonly string tokenName;
|
||||
|
||||
public bool Successful { get; set; }
|
||||
public int TestTokenOffset { get; private set; }
|
||||
public bool WasTested { get; private set; }
|
||||
|
||||
public TestMatcher(bool successful, int tokenCount, string tokenName = "")
|
||||
{
|
||||
Successful = successful;
|
||||
this.tokenCount = tokenCount;
|
||||
this.tokenName = tokenName;
|
||||
TestTokenOffset = 0;
|
||||
WasTested = false;
|
||||
}
|
||||
|
||||
protected override string GetIdentifier()
|
||||
{
|
||||
return "TestMatcher";
|
||||
}
|
||||
|
||||
protected override TokenMatchingResult PerformTest(MatchingContext context, int tokenOffset)
|
||||
{
|
||||
var result = new TokenMatchingResult(Successful, Successful ? tokenCount : 0);
|
||||
|
||||
if(result.Successful)
|
||||
result.AppendTag(Tag);
|
||||
|
||||
if(!string.IsNullOrEmpty(tokenName))
|
||||
result.AddNamedMatch(tokenName, "test");
|
||||
|
||||
TestTokenOffset = tokenOffset;
|
||||
WasTested = true;
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,45 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using ZoneCodeGenerator.Parsing;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Parsing.Mock
|
||||
{
|
||||
class IncludingParsingStreamTest : IIncludingParsingStream
|
||||
{
|
||||
public string Filename { get; set; }
|
||||
public int Line { get; set; }
|
||||
public List<string> Lines { get; }
|
||||
public bool EndOfStream => Line >= Lines.Count;
|
||||
public string LastInclude { get; private set; }
|
||||
public int IncludeCount { get; private set; }
|
||||
|
||||
public IncludingParsingStreamTest(string filename)
|
||||
{
|
||||
Line = 0;
|
||||
Filename = filename;
|
||||
Lines = new List<string>();
|
||||
LastInclude = "";
|
||||
IncludeCount = 0;
|
||||
}
|
||||
|
||||
public string ReadLine()
|
||||
{
|
||||
return EndOfStream ? "" : Lines[Line++];
|
||||
}
|
||||
|
||||
public void IncludeFile(string filename)
|
||||
{
|
||||
LastInclude = filename;
|
||||
IncludeCount++;
|
||||
}
|
||||
|
||||
public void Close()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
Close();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,142 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using ZoneCodeGenerator.Domain;
|
||||
using ZoneCodeGenerator.Persistence;
|
||||
|
||||
namespace ZoneCodeGeneratorTests.Persistence
|
||||
{
|
||||
[TestClass]
|
||||
public class InMemoryDataRepositoryTest
|
||||
{
|
||||
private IDataRepository dataRepository;
|
||||
|
||||
private DataTypeEnum enum1;
|
||||
private DataTypeEnum enum2;
|
||||
|
||||
private DataTypeStruct struct1;
|
||||
private DataTypeStruct struct2;
|
||||
|
||||
private DataTypeUnion union1;
|
||||
private DataTypeUnion union2;
|
||||
|
||||
private DataTypeTypedef typedef1;
|
||||
private DataTypeTypedef typedef2;
|
||||
|
||||
[TestInitialize]
|
||||
public void PrepareSampleStorage()
|
||||
{
|
||||
dataRepository = new InMemoryDataRepository();
|
||||
|
||||
enum1 = new DataTypeEnum("namespace1", "enum1", DataTypeBaseType.INT);
|
||||
enum2 = new DataTypeEnum("other_namespace", "enum2", DataTypeBaseType.SHORT);
|
||||
|
||||
struct1 = new DataTypeStruct("", "test_struct1", 4);
|
||||
struct2 = new DataTypeStruct("space", "aBeautifulStruct", 2);
|
||||
|
||||
union1 = new DataTypeUnion("", "u", 4);
|
||||
union2 = new DataTypeUnion("namespacesareaverynice", "averylongunionnamewhowouldevercreateanamethislong", 16);
|
||||
|
||||
var typeDeclaration1 = new TypeDeclaration(DataTypeBaseType.BOOL, new List<ReferenceType>
|
||||
{
|
||||
new ReferenceTypeArray(4),
|
||||
new ReferenceTypeArray(6)
|
||||
});
|
||||
typedef1 = new DataTypeTypedef("namespace1", "mytypedef", typeDeclaration1);
|
||||
var typeDeclaration2 = new TypeDeclaration(struct1, new List<ReferenceType>
|
||||
{
|
||||
new ReferenceTypePointer()
|
||||
});
|
||||
typedef2 = new DataTypeTypedef("", "struct1_p", typeDeclaration2);
|
||||
|
||||
dataRepository.Add(enum1);
|
||||
dataRepository.Add(enum2);
|
||||
dataRepository.Add(struct1);
|
||||
dataRepository.Add(struct2);
|
||||
dataRepository.Add(union1);
|
||||
dataRepository.Add(union2);
|
||||
dataRepository.Add(typedef1);
|
||||
dataRepository.Add(typedef2);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureEnumsCanBeSavedAndRestored()
|
||||
{
|
||||
var allEnums = new List<DataTypeEnum>(dataRepository.GetAllEnums());
|
||||
|
||||
Assert.AreEqual(2, allEnums.Count);
|
||||
|
||||
Assert.That.Contains(enum1, allEnums);
|
||||
Assert.That.Contains(enum2, allEnums);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureStructsCanBeSavedAndRestored()
|
||||
{
|
||||
var allEnums = new List<DataTypeStruct>(dataRepository.GetAllStructs());
|
||||
|
||||
Assert.AreEqual(2, allEnums.Count);
|
||||
Assert.That.Contains(struct1, allEnums);
|
||||
Assert.That.Contains(struct2, allEnums);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureUnionsCanBeSavedAndRestored()
|
||||
{
|
||||
var allUnions = new List<DataTypeUnion>(dataRepository.GetAllUnions());
|
||||
|
||||
Assert.AreEqual(2, allUnions.Count);
|
||||
Assert.That.Contains(union1, allUnions);
|
||||
Assert.That.Contains(union2, allUnions);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTypedefsCanBeSavedAndRestored()
|
||||
{
|
||||
var allTypedefs = new List<DataTypeTypedef>(dataRepository.GetAllTypedefs());
|
||||
|
||||
Assert.AreEqual(2, allTypedefs.Count);
|
||||
Assert.That.Contains(typedef1, allTypedefs);
|
||||
Assert.That.Contains(typedef2, allTypedefs);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureEnumsCanBeFoundByName()
|
||||
{
|
||||
var foundDataType1 = dataRepository.GetDataTypeByName("namespace1::enum1");
|
||||
Assert.AreEqual(enum1, foundDataType1);
|
||||
|
||||
var foundDataType2 = dataRepository.GetDataTypeByName("other_namespace::enum2");
|
||||
Assert.AreEqual(enum2, foundDataType2);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureStructsCanBeFoundByName()
|
||||
{
|
||||
var foundDataType1 = dataRepository.GetDataTypeByName("test_struct1");
|
||||
Assert.AreEqual(struct1, foundDataType1);
|
||||
|
||||
var foundDataType2 = dataRepository.GetDataTypeByName("space::aBeautifulStruct");
|
||||
Assert.AreEqual(struct2, foundDataType2);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureUnionsCanBeFoundByName()
|
||||
{
|
||||
var foundDataType1 = dataRepository.GetDataTypeByName("u");
|
||||
Assert.AreEqual(union1, foundDataType1);
|
||||
|
||||
var foundDataType2 = dataRepository.GetDataTypeByName("namespacesareaverynice::averylongunionnamewhowouldevercreateanamethislong");
|
||||
Assert.AreEqual(union2, foundDataType2);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void EnsureTypedefsCanBeFoundByName()
|
||||
{
|
||||
var foundDataType1 = dataRepository.GetDataTypeByName("namespace1::mytypedef");
|
||||
Assert.AreEqual(typedef1, foundDataType1);
|
||||
|
||||
var foundDataType2 = dataRepository.GetDataTypeByName("struct1_p");
|
||||
Assert.AreEqual(typedef2, foundDataType2);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
using System.Reflection;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
[assembly: AssemblyTitle("ZoneCodeGeneratorTests")]
|
||||
[assembly: AssemblyDescription("")]
|
||||
[assembly: AssemblyConfiguration("")]
|
||||
[assembly: AssemblyCompany("")]
|
||||
[assembly: AssemblyProduct("ZoneCodeGeneratorTests")]
|
||||
[assembly: AssemblyCopyright("Copyright © 2019")]
|
||||
[assembly: AssemblyTrademark("")]
|
||||
[assembly: AssemblyCulture("")]
|
||||
|
||||
[assembly: ComVisible(false)]
|
||||
|
||||
[assembly: Guid("c29242db-84d0-4a37-ad3f-19b72b23c7e0")]
|
||||
|
||||
// [assembly: AssemblyVersion("1.0.*")]
|
||||
[assembly: AssemblyVersion("1.0.0.0")]
|
||||
[assembly: AssemblyFileVersion("1.0.0.0")]
|
||||
Reference in New Issue
Block a user