public void ReadAndEraseCommentary()
{
var config = Configurable.CreateConfig("ReadAndEraseCommentary", "SomeDir").Clear();
config.ReadValue((byte)3, "SomeUInt8").SetComment("Hi!");
config.ReadValue(new int[] { 1, 2, 3 }, "SomeInt32Arr");
var accessor = config.ReadValue("Hello", "SomeString").SetComment("Hello!");
var actual1 = config.ToString();
var expected1 = @"SomeUInt8=3\\Hi!
SomeInt32Arr=1 2 3
SomeString=#'Hello'\\Hello!" + Global.NL;
Assert.AreEqual(expected1, actual1);
Assert.AreEqual("Hello!", accessor.Commentary);
accessor.SetComment(null);
var actual2 = config.ToString();
var expected2 = @"SomeUInt8=3\\Hi!
SomeInt32Arr=1 2 3
SomeString=#'Hello'" + Global.NL;
Assert.AreEqual(expected2, actual2);
Assert.AreEqual(null, accessor.Commentary);
}
public void WriteNullableValueTypes()
{
var config = Configurable.CreateConfig("WriteNullableValueTypes").Clear();
Assert.Throws <NotSupportedException>(() => config.ReadValue <int?>(null, "SomeInt32"));
Assert.Throws <NotSupportedException>(() => config.ReadValue(new double?[] { null, -1, 2, 2.345, null }, "SomeDoubleArr"));
}
public void ReadWriteModifyEnum()
{
var config = Configurable.CreateConfig("ReadWriteModifyEnum").Clear();
var accessor1 = config.ReadValue(new[] { ABC.A, ABC.B, ABC.C }, "EnumArr");
var accessor2 = config.ReadValue(ABC.B, "Enum");
{
var actual1 = config.ToString();
var expected1 = @"EnumArr=A B C
Enum=B" + Global.NL;
Assert.AreEqual(expected1, actual1);
}
{
accessor1.Value[1] = ABC.C;
accessor2.Value = ABC.C;
accessor1.Commentary = "it is array";
accessor2.Commentary = "it is single value";
var actual2 = config.ToString();
var expected2 = @"EnumArr=A C C\\it is array
Enum=C\\it is single value" + Global.NL;
Assert.AreEqual(expected2, actual2);
}
}
public void OpenAlreadyOpenedAsReadOnlyConfigAsReadWrite()
{
Configurable.CreateConfig("OpenAlreadyOpenedAsReadOnlyConfigAsReadWrite", "Access", ConfigAccess.READ_ONLY);
Configurable.CreateConfig("OpenAlreadyOpenedAsReadOnlyConfigAsReadWrite", "Access", ConfigAccess.READ_ONLY);
Assert.Throws <InvalidOperationException>(() =>
Configurable.CreateConfig("OpenAlreadyOpenedAsReadOnlyConfigAsReadWrite", "Access", ConfigAccess.READ_WRITE));
}
public void ReadArray()
{
var stream = "Arr=1 2 3".GetBytes(Encoding.UTF8).ToMemoryStream();
var config = Configurable.CreateConfig(stream);
Assert.AreEqual(new[] { 1, 2, 3 }, config.ReadValue(new int[0], "Arr").Value);
}
public void WriteValueAfterFileReleased()
{
var config = Configurable.CreateConfig("WriteValueAfterFileReleased").Clear();
Configurable.ReleaseFile(config.SourceInfo.FilePath);
Assert.Throws <ObjectDisposedException>(() => config.ReadValue("1", "Key1"));
}
public void WriteFlatStructObjectsToSubsections()
{
var config = Configurable.CreateConfig("WriteFlatStructObjectsToSubsections").Clear();
config.ReadObjectFrom(new V2(7, 8), "ROOT.SECTION", "Object4");
config.ReadObjectFrom(new V2(3, 4), "ROOT", "Object2");
config.ReadObjectFrom(new V2(1, 2), null, "Object1");
config.ReadObjectFrom(new V2(5, 6), "ROOT", "Object3");
var actual = config.ToString();
var expected = @"[Object1]
X=1
Y=2
[ROOT]
[ROOT.Object2]
X=3
Y=4
[ROOT.Object3]
X=5
Y=6
[ROOT.SECTION]
[ROOT.SECTION.Object4]
X=7
Y=8" + Global.NL;
Assert.AreEqual(expected, actual);
}
public void CreateTwoFieldsWithSameName()
{
var config = Configurable.CreateConfig("CreateTwoFieldsWithSameName").Clear();
config.ReadValue("ABC", "SomeValue");
Assert.Throws <InvalidOperationException>(() => config.ReadValue(123, "SomeValue"));
}
public void ReleaseFile()
{
var config = Configurable.CreateConfig("ReleaseFile").Clear();
Assert.Throws <IOException>(() => new FileStream(config.SourceInfo.FilePath, FileMode.Open));
Configurable.ReleaseFile(config.SourceInfo.FilePath);
Assert.DoesNotThrow(() => new FileStream(config.SourceInfo.FilePath, FileMode.Open));
}
public void WriteValueAfterClose()
{
var config = Configurable.CreateConfig("ReadValue_WriteValueAfterClose").Clear();
config.Close();
var value = config.ReadValue("1", "Key1");
Assert.AreEqual("1", value.Value);
}
public void ReadConfigFromStream()
{
var configData = @"SomeInt32 =10
SomeDouble =1.5" + Global.NL;
var stream = Encoding.UTF8.GetBytes(configData).ToMemoryStream();
var config = Configurable.CreateConfig(stream);
Assert.AreEqual(10, config.ReadValue(999, "SomeInt32").Value);
Assert.AreEqual(1.5, config.ReadValue(999D, "SomeDouble").Value);
}
public void ModifyAfterClose()
{
var config = Configurable.CreateConfig("ModifyAfterClose").Clear();
config.Close();
var value = config.ReadValue("1", "Key1");
value.Value = "2";
Assert.AreEqual("2", value.Value);
}
public void ModifyValue()
{
var config = Configurable.CreateConfig("ModifyValue", "").Clear();
config.ReadValue(10, "SomeInt32");
var accessor = config.ReadValue("Hello ", "SomeString");
config.ReadValue(3, "SomeByte");
accessor.Value = $"Hello {Global.Random.NextENWord()}";
}
public void ModifyArrayValue()
{
var config = Configurable.CreateConfig("ModifyArrayValue").Clear();
var accessor = config.ReadValue(new[] { 10, 20, 55 }, "SomeInt32Array");
var expected = Global.Random.NextUnique(0, 1000, 10).ToArray();
accessor.Value = expected;
var actual = accessor.Value;
Assert.AreEqual(expected, actual);
}
public void ReadFromEmptyReadOnlyConfig()
{
var config = Configurable.CreateConfig("ReadFromEmptyReadOnlyConfig", "Access", ConfigAccess.READ_ONLY);
var accessor1 = config.ReadValue(10, "SomeInt32");
var accessor2 = config.ReadValue(1.5, "SomeDouble");
var actual = config.ToString();
var expected = @"" + Global.NL;
Assert.AreEqual(expected, actual);
Assert.AreEqual(10, accessor1.Value);
Assert.AreEqual(1.5, accessor2.Value);
}
public void WriteValue()
{
var config = Configurable.CreateConfig("WriteValue", "SomeDir").Clear();
config.ReadValue(10, "SomeInt32");
config.ReadValue(1.3, "SomeDouble");
var actual = config.ToString();
var expected = @"SomeInt32=10
SomeDouble=1.3" + Global.NL;
Assert.AreEqual(expected, actual);
}
public void ReadFlatStructObjectsFromNotEmptyConfig()
{
var config = Configurable.CreateConfig("ReadFlatStructObjectsFromNotEmptyConfig").Clear();
config.ReadObject(new V2(1, 2), "Object1");
config.ReadObject(new V2(3, 4), "Object2");
config.Close();
Configurable.ReleaseFile(config.SourceInfo.FilePath);
config = Configurable.CreateConfig("ReadFlatStructObjectsFromNotEmptyConfig");
Assert.AreEqual(new V2(1, 2), config.ReadObject(V2.Zero, "Object1").Value);
Assert.AreEqual(new V2(3, 4), config.ReadObject(V2.Zero, "Object2").Value);
}
public void OverrideStandardMarshaller()
{
var config = Configurable.CreateConfig("OverrideStandardMarshaller").Clear()
.AddMarshaller <MyIntMarshaller>();
config.ReadValue(10, "SomeInt32");
var actual = config.ToString();
var expected = @"SomeInt32=DEC: 10
";
Assert.AreEqual(expected, actual);
}
public void ReadFromNotEmptyConfig()
{
var config = Configurable.CreateConfig("ReadFromNotEmptyConfig").Clear();
config.ReadValue("1", "Key1");
config.ReadValue("2", "Key2");
config.Close();
Configurable.ReleaseFile(config.SourceInfo.FilePath);
config = Configurable.CreateConfig("ReadFromNotEmptyConfig");
Assert.AreEqual("1", config.ReadValue("", "Key1").Value);
Assert.AreEqual("2", config.ReadValue("", "Key2").Value);
}
public void WriteArrayOfNullValues()
{
var config = Configurable.CreateConfig("WriteArrayOfNullValues").Clear();
config.ReadValue(
new MemoryStream[] { null, null, null },
"MemoryStreamArr");
var actual = config.ToString();
var expected = @"MemoryStreamArr=NULL NULL NULL
";
Assert.AreEqual(expected, actual);
}
public void ReadAfterClose()
{
var config = Configurable.CreateConfig("ReadAfterClose").Clear();
var written = config.ReadValue("1", "Key1");
config.Close();
Configurable.ReleaseFile(config.SourceInfo.FilePath);
config = Configurable.CreateConfig("ReadAfterClose");
config.Close();
var read = config.ReadValue("", "Key1");
Assert.AreEqual(written.Value, read.Value);
}
public void WriteCommentary()
{
var config = Configurable.CreateConfig("WriteCommentary", "SomeDir").Clear();
var accessor = config.ReadValue(10, "SomeInt32").SetComment("Hello!");
config.ReadValue(1.3, "SomeDouble");
var actual = config.ToString();
var expected = @"SomeInt32=10\\Hello!
SomeDouble=1.3" + Global.NL;
Assert.AreEqual(expected, actual);
Assert.AreEqual("Hello!", accessor.Commentary);
}
public void ReadNullValues()
{
var config = Configurable.CreateConfig("ReadNullValues").Clear();
config.ReadValue <string>(null, "String");
config.ReadValue <MemoryStream>(null, "MemoryStream");
config.Close();
Configurable.ReleaseFile(config.SourceInfo.FilePath);
config = Configurable.CreateConfig("ReadNullValues");
Assert.AreEqual(null, config.ReadValue("", "String").Value);
Assert.AreEqual(null, config.ReadValue(new MemoryStream(), "MemoryStream").Value);
}
public void WriteNullValues()
{
var config = Configurable.CreateConfig("WriteNullValues").Clear();
config.ReadValue <string>(null, "String");
config.ReadValue <MemoryStream>(null, "MemoryStream");
var actual = config.ToString();
var expected = @"String=NULL
MemoryStream=NULL
";
Assert.AreEqual(expected, actual);
}
public void WriteMultilineCommentary()
{
var config = Configurable.CreateConfig("WriteMultilineCommentary", "SomeDir").Clear();
var accessor = config.ReadValue(-1, "SomeInt32").SetComment($"First line - {Global.NL}second");
config.ReadValue(1.3e2, "SomeDouble");
var actual = config.ToString();
var expected = @"SomeInt32=-1\\First line - second
SomeDouble=130" + Global.NL;
Assert.AreEqual(expected, actual);
Assert.AreEqual($"First line - {Global.NL}second", accessor.Commentary);
}
public void WriteToCreatedFromStreamConfig()
{
var stream = File.Open(Path.GetTempFileName(), FileMode.Open);
var config = Configurable.CreateConfig(stream).Clear();
config.ReadValue(10, "SomeInt32");
config.ReadValue(1.3, "SomeDouble");
var actual = config.ToString();
var expected = @"SomeInt32=10
SomeDouble=1.3" + Global.NL;
Assert.AreEqual(expected, actual);
}
public void RemoveValues()
{
var config = Configurable.CreateConfig("RemoveValues").Clear();
var value1 = config.ReadValue(1, "Int1");
var value2 = config.ReadValue(2, "Int2");
var value3 = config.ReadValue(3, "Int3");
value1.Remove();
value3.Remove();
var actual = config.ToString();
var expected = @"Int2=2" + Global.NL;
Assert.AreEqual(expected, actual);
}
public void WriteСonsecutivelyToSingleSubsection()
{
var config = Configurable.CreateConfig("WriteСonsecutivelyToSingleSubsection").Clear();
config.ReadValueFrom("A", "Section1", "SomeString1");
config.ReadValueFrom("B", "Section1", "SomeString2");
var actual = config.ToString();
var expected = @"[Section1]
SomeString1=#'A'
SomeString2=#'B'
";
Assert.AreEqual(expected, actual);
}
public void WriteArrayValue()
{
var config = Configurable.CreateConfig("WriteArrayValue").Clear();
config.ReadValue(10, "SomeInt32");
config.ReadValue(new double[] { -1, 2, 2.345 }, "SomeDoubleArr");
config.ReadValue(new double[] { }, "SomeEmptyDoubleArr");
var actual = config.ToString();
var expected = @"SomeInt32=10
SomeDoubleArr=-1 2 2.345
SomeEmptyDoubleArr=" + Global.NL;
Assert.AreEqual(expected, actual);
}
public void AddMarshaller()
{
var config = Configurable.CreateConfig("AddMarshaller").Clear()
.AddMarshaller <VectorMarshaller>();
config.ReadValue(10, "SomeInt32");
config.ReadValue(new V2(-9, 9), "SomeV2");
var actual = config.ToString();
var expected = @"SomeInt32=10
SomeV2=X:-9 Y:9
";
Assert.AreEqual(expected, actual);
}