mirror of
https://github.com/Laupetin/OpenAssetTools.git
synced 2025-06-10 14:58:10 -05:00
Import code from previous AssetBuilder version
This commit is contained in:
Jan
@ -0,0 +1,161 @@
|
||||
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.Testing.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));
|
||||
|
||||
// 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,318 @@
|
||||
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.Testing.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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,394 @@
|
||||
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.Testing.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");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,121 @@
|
||||
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.Testing.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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,140 @@
|
||||
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.Testing.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();
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user