mirror of
https://github.com/Laupetin/OpenAssetTools.git
synced 2025-04-21 16:45:44 +00:00
319 lines
11 KiB
C#
319 lines
11 KiB
C#
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());
|
|
}
|
|
}
|
|
}
|