/// <summary>
/// Read the IniGroup name.
/// [group1]
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
public static string ReadKey(IIniParser parser)
{
StringBuilder buffer = new StringBuilder();
int iterationCount = 0;
// Read until ":" colon.
while (parser.CurrentChar != IniParserConstants.Colon.ToString() &&
iterationCount <= parser.Settings.MaxLengthOfKey)
{
buffer.Append(parser.CurrentChar);
iterationCount++;
// Advance the parser to next char.
parser.Read();
}
// Error out if current char is not ":".
if (parser.CurrentChar != IniParserConstants.Colon.ToString())
{
parser.Errors.Add("Expected colon ':' at : " + parser.CurrentCharIndex);
}
else
{
// Advance the parser to after the ":" colon.
parser.Read();
}
return(buffer.ToString());
}
/// <summary>
/// Read a multi-line value.
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
public static string ReadValueMultiLine(IIniParser parser)
{
StringBuilder buffer = new StringBuilder();
string currentChar = string.Empty;
// Read until ":" colon.
while (currentChar != IniParserConstants.DoubleQuote)
{
// Escape char
if (currentChar == IniParserConstants.Escape)
{
currentChar = parser.Read().ToString();
buffer.Append(currentChar);
}
else
{
buffer.Append(currentChar);
}
currentChar = parser.Read().ToString();
}
// Error out if current char is not ":".
if (parser.CurrentChar != IniParserConstants.DoubleQuote)
{
parser.Errors.Add("Expected double quote '\"' to end multi-line value at : " + parser.CurrentCharIndex);
}
return(buffer.ToString());
}
public void LoadConfiguration_ShouldLoadString()
{
var testString = "test_string_to_save";
_iniParser.Read(nameof(ImmutableConfiguration), nameof(ImmutableConfiguration.TestString)).Returns(testString);
var result = _iniWrapper.LoadConfiguration <ImmutableConfiguration>();
result.TestString.Should().Be(testString);
}
public void LoadConfiguration_ShouldLoadString()
{
var testString = "test_string_to_save";
_iniParser.Read(AttributeWithOnlySectionReadTestConfigurationConstants.TestStringSection, nameof(AttributeWithOnlySectionReadTestConfiguration.TestString)).Returns(testString);
var result = _iniWrapper.LoadConfiguration <AttributeWithOnlySectionReadTestConfiguration>();
_iniParser.Received(1).Read(AttributeWithOnlySectionReadTestConfigurationConstants.TestStringSection, nameof(AttributeWithOnlySectionReadTestConfiguration.TestString));
result.TestString.Should().Be(testString);
}
public void LoadConfiguration_ShouldSaveCorrectLoadString()
{
var testString = "test_string_to_save";
_iniParser.Read(AttributeReadTestConfigurationConstants.TestStringSection, AttributeReadTestConfigurationConstants.TestStringKey).Returns(testString);
var result = _iniWrapper.LoadConfiguration <AttributeReadTestConfiguration>();
_iniParser.Received(1).Read(AttributeReadTestConfigurationConstants.TestStringSection, AttributeReadTestConfigurationConstants.TestStringKey);
result.TestString.Should().Be(testString);
}
public void LoadConfiguration_CorrectReadIntIntIReadonlyDictionary()
{
_iniParser.Read(nameof(ReadonlyCollectionsConfiguration.IReadonlyDictionary), null).Returns("1=1\02=2\03=3");
var expected = new Dictionary <int, int>
{
[1] = 1,
[2] = 2,
[3] = 3
};
var result = _iniWrapper.LoadConfiguration <ReadonlyCollectionsConfiguration>();
result.IReadonlyDictionary.Should().BeEquivalentTo(expected);
}
public void OldIniParserRead()
{
for (var i = 0; i < ReadIteration; i++)
{
_oldIniParser.Read("Configuration", "Test");
}
}
public void LoadConfiguration_ShouldLoadDateTimeAndTimeSpan()
{
var dateTime = new DateTime(2019, 02, 07, 18, 58, 58);
var timeSpan = new TimeSpan(10, 10, 10);
var datetimeOffset = new DateTimeOffset(2019, 02, 07, 18, 58, 10, TimeSpan.FromMinutes(20));
_iniParser.Read(nameof(TimeConfiguration), nameof(TimeConfiguration.DateTime)).Returns(dateTime.ToString("O"));
_iniParser.Read(nameof(TimeConfiguration), nameof(TimeConfiguration.TimeSpan)).Returns(timeSpan.ToString());
_iniParser.Read(nameof(TimeConfiguration), nameof(TimeConfiguration.DateTimeOffset)).Returns(datetimeOffset.ToString());
var result = _iniWrapper.LoadConfiguration <TimeConfiguration>();
result.DateTime.Should().Be(dateTime);
result.TimeSpan.Should().Be(timeSpan);
result.DateTimeOffset.Should().Be(datetimeOffset);
}
public void LoadConfiguration_ShouldLoadGuid()
{
var configuration = new GuidConfiguration()
{
Guid = Guid.NewGuid(),
Uri = new Uri("http://testttt.com/")
};
_iniParser.Read(nameof(GuidConfiguration), nameof(GuidConfiguration.Guid)).Returns(configuration.Guid.ToString());
_iniParser.Read(nameof(GuidConfiguration), nameof(GuidConfiguration.Uri)).Returns(configuration.Uri.ToString());
var result = _iniWrapper.LoadConfiguration <GuidConfiguration>();
result.Guid.Should().Be(configuration.Guid);
result.Uri.Should().Be(configuration.Uri);
}
public object ReadValue(IMemberInfoWrapper memberInfoWrapper, object configuration, Type configurationType)
{
var(converter, defaultConverter, typeDetailsInformation) = _iniConverterFactory.GetConverter(memberInfoWrapper.GetMemberType(), 0, memberInfoWrapper);
if (typeDetailsInformation.TypeCode == TypeCode.ComplexObject)
{
return(converter.ParseReadValue(null, typeDetailsInformation.Type, null));
}
var iniValue = new IniValue()
{
Section = _iniValueManager.GetSection(configurationType, memberInfoWrapper),
Key = _iniValueManager.GetKey(memberInfoWrapper)
};
try
{
var iniContext = new IniContext(memberInfoWrapper, typeDetailsInformation, iniValue, _iniParser, defaultConverter);
var readValue = _iniParser.Read(iniValue.Section, iniValue.Key);
return(converter.ParseReadValue(readValue, typeDetailsInformation.Type, iniContext));
}
catch (FormatException)
{
throw new IniWrongFormatException($"Wrong format in {iniValue} expected type: {memberInfoWrapper.GetMemberType()}");
}
}
public void NewWrapperRead()
{
for (var i = 0; i < ReadIteration; i++)
{
_iniParser.Read("Configuration", "Test");
}
}
public void LoadConfiguration_CorrectEnumOutOfRange()
{
_iniParser.Read(nameof(TestConfiguration), nameof(TestConfiguration.TestEnum)).Returns("1000");
var result = _iniWrapper.LoadConfiguration <TestConfiguration>();
result.TestEnum.Should().Be((TestEnum)1000);
}
public void LoadConfiguration_ShouldThrow_WhenWrongFormattedIntIsInFile()
{
_iniParser.Read(nameof(TestConfigurationField), nameof(TestConfigurationField.TestInt)).Returns("wrong_formatted_int");
Action result = () => _iniWrapper.LoadConfiguration<TestConfigurationField>();
result.Should().Throw<IniWrongFormatException>();
}
public void ShouldThrow_WhenPropertyIsWithoutSetter_And_WithoutIniIgnoreAttribute()
{
_iniParser.Read(nameof(ConfigurationWithoutSetter), nameof(ConfigurationWithoutSetter.Test)).Returns("1");
Action loading = () => _iniWrapper.LoadConfiguration <ConfigurationWithoutSetter>();
loading.Should().Throw <ArgumentException>().WithMessage($"Please add setter to property with name {nameof(ConfigurationWithoutSetter.Test)} in type {typeof(ConfigurationWithoutSetter)} " +
$"or decorate it with IniIgnoreAttribute.");
}
public void LoadConfiguration_CorrectReadNullableIntList()
{
_iniParser.Read(nameof(NullableIEnumerableConfiguration), nameof(NullableIEnumerableConfiguration.NullableIntList)).Returns("1,2,3,4,5,6,7,8");
var expected = new List <int?> {
1, 2, 3, 4, 5, 6, 7, 8
};
var result = _iniWrapper.LoadConfiguration <NullableIEnumerableConfiguration>();
result.NullableIntList.Should().BeEquivalentTo(expected);
}
public void LoadConfiguration_ShouldLoadCorrectIEnumerableOfNullableComplexType()
{
var config = new ListOfComplexDataNullableConfiguration()
{
TestConfigurations = new List <NullableConfiguration>()
{
new NullableConfiguration
{
TestNullableChar = 'x',
TestNullableEnum = TestEnum.Five,
TestNullableInt = null,
TestNullableUint = 10,
},
new NullableConfiguration
{
TestNullableChar = 'y',
TestNullableEnum = TestEnum.Three,
TestNullableInt = 100,
TestNullableUint = null,
},
}
};
_iniParser.Read($"{nameof(NullableConfiguration)}_0", null).Returns("notEmpty");
_iniParser.Read($"{nameof(NullableConfiguration)}_0", nameof(NullableConfiguration.TestNullableChar)).Returns("x");
_iniParser.Read($"{nameof(NullableConfiguration)}_0", nameof(NullableConfiguration.TestNullableEnum)).Returns("5");
_iniParser.Read($"{nameof(NullableConfiguration)}_0", nameof(NullableConfiguration.TestNullableInt)).Returns("");
_iniParser.Read($"{nameof(NullableConfiguration)}_0", nameof(NullableConfiguration.TestNullableUint)).Returns("10");
_iniParser.Read($"{nameof(NullableConfiguration)}_1", null).Returns("notEmpty");
_iniParser.Read($"{nameof(NullableConfiguration)}_1", nameof(NullableConfiguration.TestNullableChar)).Returns("y");
_iniParser.Read($"{nameof(NullableConfiguration)}_1", nameof(NullableConfiguration.TestNullableEnum)).Returns("3");
_iniParser.Read($"{nameof(NullableConfiguration)}_1", nameof(NullableConfiguration.TestNullableInt)).Returns("100");
_iniParser.Read($"{nameof(NullableConfiguration)}_1", nameof(NullableConfiguration.TestNullableUint)).Returns("");
var result = _iniWrapper.LoadConfiguration <ListOfComplexDataNullableConfiguration>();
result.Should().BeEquivalentTo(config);
}
public void SaveConfiguration_ShouldSaveCorrectComplexType()
{
var testString = "test_string_to_save";
var config = new ComplexTestConfigurationField()
{
TestConfiguration = new TestConfigurationField()
{
TestString = testString,
TestChar = 'T',
TestInt = 10,
TestUint = 100u,
TestUintList = new List <uint>()
{
1, 2, 3, 4
}
}
};
_iniParser.Read(nameof(TestConfigurationField), nameof(TestConfigurationField.TestString)).Returns(testString);
_iniParser.Read(nameof(TestConfigurationField), nameof(TestConfigurationField.TestChar)).Returns(config.TestConfiguration.TestChar.ToString());
_iniParser.Read(nameof(TestConfigurationField), nameof(TestConfigurationField.TestInt)).Returns(config.TestConfiguration.TestInt.ToString());
_iniParser.Read(nameof(TestConfigurationField), nameof(TestConfigurationField.TestUint)).Returns(config.TestConfiguration.TestUint.ToString());
_iniParser.Read(nameof(TestConfigurationField), nameof(TestConfigurationField.TestUintList)).Returns("1,2,3,4");
var result = _iniWrapper.LoadConfiguration <ComplexTestConfigurationField>();
result.TestConfiguration.TestChar.Should().Be(config.TestConfiguration.TestChar);
result.TestConfiguration.TestStringList.Should().BeEquivalentTo(config.TestConfiguration.TestStringList);
result.TestConfiguration.TestEnum.Should().Be(config.TestConfiguration.TestEnum);
result.TestConfiguration.TestEnumList.Should().BeEquivalentTo(config.TestConfiguration.TestEnumList);
result.TestConfiguration.TestInt.Should().Be(config.TestConfiguration.TestInt);
result.TestConfiguration.TestUint.Should().Be(config.TestConfiguration.TestUint);
result.TestConfiguration.TestUintList.Should().BeEquivalentTo(config.TestConfiguration.TestUintList);
result.TestConfiguration.TestString.Should().Be(config.TestConfiguration.TestString);
result.TestConfiguration.TestIntList.Should().BeEquivalentTo(config.TestConfiguration.TestIntList);
}
/// <summary>
/// Read the IniGroup name.
/// [group1]
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
public static string ReadGroup(IIniParser parser)
{
StringBuilder buffer = new StringBuilder();
// Exclude the "[" bracket from consuming the token("group name").
if (parser.CurrentChar == IniParserConstants.BracketLeft)
{
parser.Read();
}
int iterationCount = 0;
// Read until "]" right bracket.
while (parser.CurrentChar != IniParserConstants.BracketRight &&
iterationCount <= parser.Settings.MaxLengthOfGroup)
{
buffer.Append(parser.CurrentChar);
iterationCount++;
// Advance the parser to next char.
parser.Read();
}
// Error out if current char is not "]".
if (parser.CurrentChar != IniParserConstants.BracketRight)
{
parser.Errors.Add("Expected closing bracket ']' at : " + parser.CurrentCharIndex);
}
else
{
// Advance the parser to after the "]" closing bracket.
parser.Read();
}
return(buffer.ToString());
}
public void RawRead()
{
var config = new ConfigurationBenchmark()
{
InnerConfiguration = new InnerConfiguration()
};
config.Age = int.Parse(_rawIniParser.Read("ConfigurationBenchmark", "Age"));
config.Test = int.Parse(_rawIniParser.Read("ConfigurationBenchmark", "Test"));
config.Description = _rawIniParser.Read("ConfigurationBenchmark", "Description");
var readValue = _rawIniParser.Read("ConfigurationBenchmark", "ListInt");
config.ListInt = readValue.Split(',').Select(value => int.Parse(value)).ToList();
config.InnerConfiguration.Description = _rawIniParser.Read("InnerConfiguration", "Description");
config.InnerConfiguration.Age = int.Parse(_rawIniParser.Read("InnerConfiguration", "Age"));
}
public void LoadConfiguration_ShouldLoadListOfComplexType()
{
var testString = "xteststring";
_iniParser.Read($"{nameof(TestConfigurationField)}_0", nameof(TestConfigurationField.TestInt)).Returns("20");
_iniParser.Read($"{nameof(TestConfigurationField)}_0", nameof(TestConfigurationField.TestChar)).Returns("x");
_iniParser.Read($"{nameof(TestConfigurationField)}_0", nameof(TestConfigurationField.TestEnum)).Returns("Five");
_iniParser.Read($"{nameof(TestConfigurationField)}_0", nameof(TestConfigurationField.TestString)).Returns(testString);
_iniParser.Read($"{nameof(TestConfigurationField)}_0", nameof(TestConfigurationField.TestIntList)).Returns("10,20,30,40");
_iniParser.Read($"{nameof(TestConfigurationField)}_0", nameof(TestConfigurationField.TestStringList)).Returns("10aa,xxx20,3www0,40ddd");
var testString1 = "sdasdaoiu2mn2k";
_iniParser.Read($"{nameof(TestConfigurationField)}_1", nameof(TestConfigurationField.TestInt)).Returns("25");
_iniParser.Read($"{nameof(TestConfigurationField)}_1", nameof(TestConfigurationField.TestChar)).Returns("y");
_iniParser.Read($"{nameof(TestConfigurationField)}_1", nameof(TestConfigurationField.TestEnum)).Returns("Four");
_iniParser.Read($"{nameof(TestConfigurationField)}_1", nameof(TestConfigurationField.TestString)).Returns(testString1);
_iniParser.Read($"{nameof(TestConfigurationField)}_1", nameof(TestConfigurationField.TestIntList)).Returns("101,202,303,404");
_iniParser.Read($"{nameof(TestConfigurationField)}_1", nameof(TestConfigurationField.TestStringList)).Returns("10sssaa,xxxrer20,3rewrwwww0,40erwreddd");
_iniParser.Read($"{nameof(TestConfigurationField)}_0", null).Returns(x => "notEmptySectionResult");
_iniParser.Read($"{nameof(TestConfigurationField)}_1", null).Returns(x => "notEmptySectionResult");
var result = _iniWrapper.LoadConfiguration <ListOfComplesDataConfigurationField>();
result.TestConfigurations.Should().HaveCount(2);
result.TestConfigurations.ElementAt(0).TestInt.Should().Be(20);
result.TestConfigurations.ElementAt(0).TestChar.Should().Be('x');
result.TestConfigurations.ElementAt(0).TestEnum.Should().Be(TestEnum.Five);
result.TestConfigurations.ElementAt(0).TestString.Should().Be(testString);
result.TestConfigurations.ElementAt(0).TestIntList.Should().BeEquivalentTo(new List <int> {
10, 20, 30, 40
});
result.TestConfigurations.ElementAt(0).TestStringList.Should().BeEquivalentTo(new List <string> {
"10aa", "xxx20", "3www0", "40ddd"
});
result.TestConfigurations.ElementAt(1).TestInt.Should().Be(25);
result.TestConfigurations.ElementAt(1).TestChar.Should().Be('y');
result.TestConfigurations.ElementAt(1).TestEnum.Should().Be(TestEnum.Four);
result.TestConfigurations.ElementAt(1).TestString.Should().Be(testString1);
result.TestConfigurations.ElementAt(1).TestIntList.Should().BeEquivalentTo(new List <int> {
101, 202, 303, 404
});
result.TestConfigurations.ElementAt(1).TestStringList.Should().BeEquivalentTo(new List <string> {
"10sssaa", "xxxrer20", "3rewrwwww0", "40erwreddd"
});
}