public void TestParseIncompleteSectionUnit()
{
using (var reader = new StringReader("[section"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidTokenException>(() => parser.ParseUnitOfType <SectionUnit>());
}
}
public void TestDontParseDefaultSection()
{
using (var reader = new StringReader($"[{Section.DefaultSectionName}]"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidTokenException>(() => parser.ParseUnitOfType <SectionUnit>());
}
}
public void TestParseOfType()
{
using (var reader = new StringReader("[section]"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidUnitException>(() => parser.ParseUnitOfType <NameUnit>());
}
}
public void TestNoSkipLeadingNewlineStrongParsing()
{
using (var reader = new StringReader("\na"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidTokenException>(() => parser.ParseUnitOfType <NameUnit>(skipNewline: false));
}
}
public void TestInvalidAssignment()
{
using (var reader = new StringReader("value=value"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidUnitException>(() => parser.ParseUnitOfType <AssignmentUnit>());
}
}
public void TestParseTooLargeHexLiteral()
{
using (var reader = new StringReader("0xFFFFFFFFFFFFFFFFF"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidLiteralException>(() => parser.ParseUnitOfType <ValueUnit>());
}
}
public void TestParseTooLargeInteger()
{
using (var reader = new StringReader("9223372036854775808"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidLiteralException>(() => parser.ParseUnitOfType <ValueUnit>());
}
}
public void TestIncompleteString()
{
using (var reader = new StringReader("\""))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <EndOfDocumentException>(() => parser.ParseUnitOfType <ValueUnit>());
}
}
public void TestNewlineInString()
{
using (var reader = new StringReader("\"Hello,\nWorld!\""))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
Assert.Throws <InvalidTokenException>(() => parser.ParseUnitOfType <ValueUnit>());
}
}
public void TestComments()
{
using (var reader = new StringReader("#comment\n#comment\n[section]"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <SectionUnit>();
Assert.AreEqual("comment\ncomment", unit.Comment);
}
}
public void TestParseNameUnit()
{
using (var reader = new StringReader("name123_"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <NameUnit>(allowSingleUnitTransform: false);
Assert.AreEqual("name123_", unit.SourceTokenString());
Assert.AreEqual("name123_", unit.Name);
}
}
public void TestComment()
{
using (var reader = new StringReader("#comment\nvalue=10"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var prop = Property.FromParsedAssignmentUnit(parser.ParseUnitOfType <AssignmentUnit>(), IniOptions.Default);
Assert.AreEqual("comment", prop.Comment);
}
}
public void TestPositions()
{
using (var reader = new StringReader("#comment\n[section]"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <SectionUnit>();
Assert.AreEqual(new Position(1, 0), unit.Position);
}
}
public void TestSkipLeadingNewline()
{
using (var reader = new StringReader("\n[section]"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <SectionUnit>();
Assert.AreEqual("[section]", unit.SourceTokenString());
Assert.AreEqual("section", unit.Name);
}
}
public void TestVerbatimEscapeSequenceString()
{
using (var reader = new StringReader(@"@""Hello,\nWorld!"""))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <ValueUnit>();
Assert.AreEqual(@"@""Hello,\nWorld!""", unit.SourceTokenString());
Assert.AreEqual(@"Hello,\nWorld!", unit.Value);
}
}
public void TestParseFalse()
{
using (var reader = new StringReader("false"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <ValueUnit>();
Assert.AreEqual("false", unit.SourceTokenString());
Assert.AreEqual(false, unit.Value);
}
}
public void TestParseDoubleQuotedString()
{
using (var reader = new StringReader("\"Hello, World!\""))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <ValueUnit>();
Assert.AreEqual("\"Hello, World!\"", unit.SourceTokenString());
Assert.AreEqual("Hello, World!", unit.Value);
}
}
public void TestParseBinaryLiteral()
{
using (var reader = new StringReader("0b0101100101011001"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <ValueUnit>();
Assert.AreEqual("0b0101100101011001", unit.SourceTokenString());
Assert.AreEqual(22873UL, unit.Value);
}
}
public void TestParseHexLiteralType2()
{
using (var reader = new StringReader("&Hdeadbeef"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <ValueUnit>();
Assert.AreEqual("&Hdeadbeef", unit.SourceTokenString());
Assert.AreEqual(3735928559UL, unit.Value);
}
}
public void TestParseFloatingPointNegative()
{
using (var reader = new StringReader("-1.1"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <ValueUnit>();
Assert.AreEqual("-1.1", unit.SourceTokenString());
Assert.AreEqual(-1.1d, unit.Value);
}
}
public void TestFromParsedSection()
{
using (var reader = new StringReader("#comment\n[section]"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var section = Section.FromParsedSectionUnit(parser.ParseUnitOfType <SectionUnit>(), IniOptions.Default);
Assert.AreEqual("comment", section.Comment);
Assert.AreEqual("section", section.Name);
}
}
public void TestFromIntegerAssignment()
{
using (var reader = new StringReader("value=10"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var prop = Property.FromParsedAssignmentUnit(parser.ParseUnitOfType <AssignmentUnit>(), IniOptions.Default);
Assert.AreEqual("value", prop.Name);
Assert.AreEqual(10L, prop.GetValueAs <long>());
}
}
public void TestFromFloatingPointAssignment()
{
using (var reader = new StringReader("value=1.1"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var prop = Property.FromParsedAssignmentUnit(parser.ParseUnitOfType <AssignmentUnit>(), IniOptions.Default);
Assert.AreEqual("value", prop.Name);
Assert.AreEqual(1.1d, prop.GetValueAs <double>());
}
}
public void TestFromBooleanAssignment()
{
using (var reader = new StringReader("value=true"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var prop = Property.FromParsedAssignmentUnit(parser.ParseUnitOfType <AssignmentUnit>(), IniOptions.Default);
Assert.AreEqual("value", prop.Name);
Assert.AreEqual(true, prop.GetValueAs <bool>());
}
}
public void TestFromStringAssignment()
{
using (var reader = new StringReader("value=\"Hello, World!\""))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var prop = Property.FromParsedAssignmentUnit(parser.ParseUnitOfType <AssignmentUnit>(), IniOptions.Default);
Assert.AreEqual("value", prop.Name);
Assert.AreEqual("Hello, World!", prop.GetValueAs <string>());
}
}
public void TestEscapeSequences(
[Values(@"\b", @"\n", @"\r", @"\t", @"\v", @"\\", @"\'", @"\""")] string input,
[Values("\b", "\n", "\r", "\t", "\v", "\\", "'", "\"")] string escape)
{
using (var reader = new StringReader($"\"{input}\""))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <ValueUnit>();
Assert.AreEqual($"\"{input}\"", unit.SourceTokenString());
Assert.AreEqual(escape, unit.Value);
}
}
public void TestParseFloatingPointAssignment()
{
using (var reader = new StringReader("value=1.1"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <AssignmentUnit>();
Assert.AreEqual("value=1.1", unit.SourceTokenString());
Assert.AreEqual("value", unit.Name);
Assert.AreEqual(1.1d, unit.Value);
}
}
public void TestParseStringAssignment()
{
using (var reader = new StringReader("value='Hello, World!'"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
var unit = parser.ParseUnitOfType <AssignmentUnit>();
Assert.AreEqual("value='Hello, World!'", unit.SourceTokenString());
Assert.AreEqual("value", unit.Name);
Assert.AreEqual("Hello, World!", unit.Value);
}
}
public void TestNoSkipLeadingNewlineFlexibleParsing()
{
var options = new IniOptions(propertyParsing: PropertyParsing.Flexible);
using (var reader = new StringReader("\na"))
using (var parser = new Parser.Parser(reader, options))
{
var unit = parser.ParseUnitOfType <ValueUnit>(skipNewline: false);
Assert.AreEqual("\na", unit.SourceTokenString());
Assert.AreEqual("\na", unit.Value);
}
}
public void TestParseMultipleUnits()
{
using (var reader = new StringReader("[section] [section]\n[section]"))
using (var parser = new Parser.Parser(reader, IniOptions.Default))
{
for (var i = 0; i < 3; i++)
{
var unit = parser.ParseUnitOfType <SectionUnit>();
Assert.AreEqual("[section]", unit.SourceTokenString());
Assert.AreEqual("section", unit.Name);
}
}
}
