public void Add_WithFooClassListSource_AddsTableArray()
{
// Arrange
var tbl = Toml.Create();
// Act
var newTbl = tbl.Add("x", FooClassList.List1).Added;
// Assert
FooClassList.List1.AssertIs(newTbl);
FooClassList.List1.AssertIs(tbl["x"]);
}
public void Add_WithFooStruct_AddsTable()
{
// Arrange
var tbl = Toml.Create();
// Act
var newTbl = tbl.Add("x", FooStruct.Foo1).Added;
// Assert
FooStruct.Foo1.AssertIs(tbl["x"]);
FooStruct.Foo1.AssertIs(newTbl);
}
internal static Config <T> CreateInternal <T>(Func <T> createDefault, IMergeConfigStore store)
where T : class
{
createDefault.CheckNotNull(nameof(createDefault));
store.CheckNotNull(nameof(store));
var cfg = createDefault();
store.EnsureExists(Toml.Create(cfg));
return(new Config <T>(store));
}
public void Clone_WhenSourceTableHasTypeInline_CloneTableHasSameTableType()
{
// Arrange
var tbl = Toml.Create();
tbl.TableType = TomlTable.TableTypes.Inline;
// Act
var cloned = tbl.Clone();
// Assert
cloned.TableType.Should().Be(tbl.TableType);
}
public void CreateArray_WhenSingleValueGiven_CreatesCorrespondingArray()
{
var tbl = Toml.Create();
var diff = Toml.Create().CreateAttachedValue(true);
var a = tbl.CreateAttachedArray(new List <TomlValue>()
{
tbl.CreateAttachedValue(true)
});
a.Length.Should().Be(1);
a[0].Get <bool>().Should().Be(true);
}
private TomlTable MergeTables(Func <IConfigStore, TomlTable> loadSingle)
{
Assert(this.stores.Count > 0, AssertAtLeastOneConfigMsg);
TomlTable merged = Toml.Create();
foreach (var c in this.stores)
{
merged.OverwriteWithValuesForLoadFrom(loadSingle(c));
}
return(merged);
}
public void CreateAttached_WhenTomlIntIsPassed_ThrowsInvalidOperation()
{
// Arrange
var tbl = Toml.Create();
var ti = tbl.Add("X", 1);
// Act
Action a = () => this.rootSource.CreateAttached(ti);
// Assert
a.ShouldThrow <ArgumentException>(
because: "It is not allowed to convert TOML objects to new attached TOML tables");
}
public void OverwriteForSaveFrom_WhenTargetTableDoesntContainRow_AllTargetTableRowsGetDeleted()
{
// Arrange
var tgtTable = Toml.Create();
tgtTable.AddValue("x", 0);
var fromTable = Toml.Create();
// Act
tgtTable.OverwriteWithValuesForSaveFrom(fromTable, addNewRows: false);
// Assert
tgtTable.Count.Should().Be(0);
}
public void OverwriteForSaveFrom_WhenTargetTableDoesntContainRow_RowWillNotBeAddedToTargetTable()
{
// Arrange
var targetTable = Toml.Create();
var fromTable = Toml.Create();
fromTable.AddValue("x", 0);
// Act
targetTable.OverwriteWithValuesForSaveFrom(fromTable, addNewRows: false);
// Assert
targetTable.Count.Should().Be(0);
}
public void WriteFile_WithFloat_WritesCultureInvariant()
{
// Arrange
var tt = Toml.Create();
tt.AddValue("TheFloat", 1.2);
// Act
Toml.WriteFile(tt, this.fn);
// Assert
var s = File.ReadAllText(this.fn);
s.Should().Be("TheFloat = 1.2\r\n");
}
public void Write_WithFloat_WritesCultureInvariant()
{
// Arrange
var tt = Toml.Create();
tt.Add("TheFloat", 1.2);
// Act
var s = Toml.WriteString(tt);
Toml.WriteFile(tt, "test123.toml");
// Assert
s.Should().Be("TheFloat = 1.2\r\n");
}
protected static void CreateMergedTestAppConfig(out string mainFile, out string userFile)
{
mainFile = "initMainSettings".TestRunUniqueName(Toml.FileExtension);
userFile = "initUserSettings".TestRunUniqueName(Toml.FileExtension);
var main = TestData.TestAppSettings.GlobalSettings;
var userSettings = TestData.TestAppSettings.User1Settings;
var user = Toml.Create();
user.AddTableFromClass(nameof(main.User), userSettings);
// Act
Toml.WriteFile(main, mainFile);
Toml.WriteFile(user, userFile);
}
public bool EnsureExists(TomlTable content)
{
Assert(this.stores.Count > 0, AssertAtLeastOneConfigMsg);
// Create broadest scope table
bool neededToCreate = false;
neededToCreate |= this.stores.First().EnsureExists(content);
// Initialize empty files for all other existing scopes
foreach (var s in this.stores.Skip(1))
{
neededToCreate |= s.EnsureExists(Toml.Create());
}
return(neededToCreate);
}
public void GivenDottedKeyValueWithAppendComment_WhenWrittenToFile_WritesCommentBeforeLine()
{
// Arrange
var tbl = Toml.Create();
var obj = tbl.CreateEmptyAttachedTable(TomlTable.TableTypes.Dotted);
tbl.Add(nameof(obj), obj);
obj.Add("x", 1).Added.AddComment("The Comment", CommentLocation.Append);
// Act
var tml = Toml.WriteString(tbl);
// Assert
tml.Should().BeAfterTransforms(StringTransformForComparison, @"
[obj]
x=1#TheComment");
}
public void VerifyIssue44_UpdateTomlTableArrayRow_WasFixed()
{
// Arrange
var tb = Toml.Create();
var tList = new List <TestTable>();
tList.Add(new TestTable("first", DateTimeOffset.MaxValue));
tb.Add("test", tList);
tList.Add(new TestTable("second", DateTimeOffset.MinValue));
// Act
var ta = tb.Update("test", tList);
// Assert
tb["test"].Should().BeOfType <TomlTableArray>();
ta.Added[0].Get <TestTable>().timestamp.Should().Be(DateTimeOffset.MaxValue);
ta.Added[1].Get <TestTable>().timestamp.Should().Be(DateTimeOffset.MinValue);
}
public void Write_WhenTableWasReadAsDotted_WritesTableAsDottedTableAgain()
{
// Arrange
var root = Toml.Create(TomlTable.TableTypes.Dotted);
var adat = new Dictionary <string, object>()
{
{ "b", 1 },
{ "c", 2 },
};
root.Add("a", adat, TomlTable.TableTypes.Dotted);
// Act
var written = Toml.WriteString(root);
// Assert
written.ShouldBeSemanticallyEquivalentTo("a.b=1 a.c=2");
}
public void VerifyIssue29_WhenConversionHasError_TheErrorMessgeIsSomewhatUseful()
{
// Arrange
var cfg = TomlSettings.Create(c => c
.ConfigureType <Item>(type => type
.WithConversionFor <TomlString>(conv => conv
.FromToml(s => Item.Parse(s.Value)))));
TomlTable tbl = Toml.Create(cfg);
tbl.Add("Item", "Item Parse Value");
// Act
Action a = () => tbl.Get <ItmRoot>();
// Assert
a.ShouldThrow <InvalidOperationException>().WithMessage(
"Failed to convert TOML object with key 'Item', type 'string' and value 'Item Parse Value' " +
"to object property with name 'Item' and type 'Nett.Tests.VerifyIssuesTests+Item'.")
.WithInnerMessage("Simulate conversion error");
}
private void SaveConfig()
{
TomlTable appSettings = Toml.Create();
appSettings.Add("ListenPort", ServerPort);
if (ConfigTable.ContainsKey("Application"))
{
ConfigTable.Remove("Application");
}
ConfigTable.Add("Application", appSettings);
foreach (var item in Items)
{
(item as IConfigViewModel).SaveConfig(ConfigTable);
}
Toml.WriteFile(ConfigTable, CONFIG_FILE);
}
public void VerifyIssue51_InlineTableSerializedInWrongParentTable_IsFixed()
{
// Arrange
var table = Toml.Create();
var root = table.Add("Root", new object(), TomlTable.TableTypes.Default).Added;
root.Add("A", new object(), TomlTable.TableTypes.Default);
root.Add("B", new object(), TomlTable.TableTypes.Inline);
// Act
var ser = Toml.WriteString(table);
// Assert
ser.ShouldBeSemanticallyEquivalentTo(@"
[Root]
B = { }
[Root.A]
");
}
public void VerifyIssue42_SerializedIntoWrongTable_WasFixed()
{
var tbl = Toml.Create();
tbl.Add("root1", 1); // These three keys added at root level
tbl.Add("root2", 2);
tbl.Add("root3", 3);
var t2 = tbl.Add("Level2", Toml.Create()).Added;
t2.Add("second1", "x");
t2.Add("second2", "y");
tbl.Add("root4", 4); // Added at root level but spuriously written into [Level2.Level3]
var t3 = t2.Add("Level3", Toml.Create()).Added;
t3.Add("third1", "a");
t3.Add("third2", "b");
t2.Add("second3", "z"); // Added to [Level2] but spuriously written into [Level2.Level3]
tbl.Add("root5", 5); // Added at root level but spuriously written into [Level2.Level3]
var result = Toml.WriteString(tbl);
result.Trim().ShouldBeNormalizedEqualTo(@"
root1 = 1
root2 = 2
root3 = 3
root4 = 4
root5 = 5
[Level2]
second1 = ""x""
second2 = ""y""
second3 = ""z""
[Level2.Level3]
third1 = ""a""
third2 = ""b""".Trim());
}
public static TomlTable Clone(this TomlTable input)
{
input.CheckNotNull(nameof(input));
TomlTable cloned = Toml.Create(input.Root.Settings);
cloned.TableType = input.TableType;
foreach (var r in input.InternalRows)
{
switch (r.Value.TomlType)
{
case TomlObjectType.Table: cloned.AddRow(r.Key, ((TomlTable)r.Value).Clone()); break;
case TomlObjectType.ArrayOfTables: cloned.AddRow(r.Key, ((TomlTableArray)r.Value).Clone()); break;
default: cloned[r.Key.Value] = r.Value; break;
}
}
return(cloned);
}
public KeyManager(string keyName, TomlTable parent, Action flush)
{
// Set Mod Name
KeyName = keyName.PathEscape();
// Assign TOML Structure
_parent = parent;
try
{
// Try to get table from existing structure
_settings = _parent.Get <TomlTable>(KeyName);
}
catch (KeyNotFoundException)
{
// Create new table if it doesn't exist
_parent[KeyName] = Toml.Create();
_settings = _parent.Get <TomlTable>(KeyName);
}
// Define Interfaces
_getter = new Getter(_settings, flush);
_setter = new Setter(_settings, flush);
}
public void Write_WhenNestedTableIsInlineTable_NestedTableIsWrittenAsInlineTable()
{
// Arrange
var root = Toml.Create(TomlTable.TableTypes.Dotted);
var adat = new Dictionary <string, object>()
{
{ "b", 1 },
{ "c", 2 },
};
var a = root.Add("a", adat, TomlTable.TableTypes.Dotted).Added;
var ndat = new Dictionary <string, object>()
{
{ "x", 3 },
};
a.Add("n", ndat, TomlTable.TableTypes.Inline);
// Act
var written = Toml.WriteString(root);
// Assert
written.ShouldBeSemanticallyEquivalentTo("a.b=1 a.c=2 a.n={x=3}");
}
static CombineTablesTests()
{
X = Toml.Create();
X.Add(XKey, XVal);
X.Add(SameKey, XVal);
var xs = X.Add(SubTableKey, Toml.Create());
xs.Add(SubTableValueKey, XSubTableVal);
Y = Toml.Create();
Y.Add(YKey, YVal);
Y.Add(SameKey, YVal);
var ys = Y.Add(SubTableKey, X.CreateEmptyAttachedTable());
ys.Add(SubTableValueKey, YSubTableVal);
Dx = Toml.Create();
Dx.Add("a", (long)1);
Dx.Add("c", (long)3).AddComment("xcc");
Dy = Toml.Create();
Dy.Add("b", (long)2).AddComment("ybc");
Dy.Add("c", (long)4).AddComment("ycc");
}
public void Write_WhenDottedTablesAreNested_WritesTablesAsDottedTables()
{
// Arrange
var root = Toml.Create(TomlTable.TableTypes.Dotted);
var adat = new Dictionary <string, object>()
{
{ "b", 1 },
{ "c", 2 },
};
var a = root.Add("a", adat, TomlTable.TableTypes.Dotted);
var ndat = new Dictionary <string, object>()
{
{ "x", 3 },
};
a.ConfigureAdded(n => n.Add("n", ndat, TomlTable.TableTypes.Dotted));
// Act
var written = Toml.WriteString(root);
// Assert
written.ShouldBeSemanticallyEquivalentTo("a.b=1 a.c=2 a.n.x=3");
}
internal void Save()
{
UpdateExecutionInterval();
_executionInterval.IfSome(ei =>
{
if (ei != default)
{
var(ms, n) = ei;
var tomlTable = Toml.Create();
tomlTable.Add(nameof(ms), ms);
tomlTable.Add(nameof(n), n);
var pathToExecutionInterval = Simulation.GetPrivatePath(new[] { nameof(SimData) }, EXECUTION_INTERVAL_FILE_NAME);
try
{
Toml.WriteFile(tomlTable, pathToExecutionInterval);
}
catch (Exception ex)
{
Log.Error(ex, $"{nameof(SimExecutionInterval)}.{nameof(Save)}");
}
}
});
}
/// <inheritdoc />
public void SaveToFile()
{
if (_configFile == null)
{
Logger.Warning("[CFG] Cannot save the config file, because one was never loaded.");
return;
}
try
{
var tblRoot = Toml.Create();
foreach (var kvCVar in _configVars)
{
var cVar = kvCVar.Value;
var name = kvCVar.Key;
var value = cVar.Value;
if (value == null && cVar.Registered)
{
value = cVar.DefaultValue;
}
if (value == null)
{
Logger.Error($"[CFG] CVar {name} has no value or default value, was the default value registered as null?");
continue;
}
var keyIndex = name.LastIndexOf(TABLE_DELIMITER);
var tblPath = name.Substring(0, keyIndex).Split(TABLE_DELIMITER);
var keyName = name.Substring(keyIndex + 1);
// locate the Table in the config tree
var table = tblRoot;
foreach (var curTblName in tblPath)
{
if (!table.TryGetValue(curTblName, out TomlObject tblObject))
{
tblObject = table.AddTable(curTblName);
}
table = tblObject as TomlTable ?? throw new InvalidConfigurationException($"[CFG] Object {curTblName} is being used like a table, but it is a {tblObject}. Are your CVar names formed properly?");
}
//runtime unboxing, either this or generic hell... ¯\_(ツ)_/¯
switch (value)
{
case Enum val:
table.AddValue(keyName, (int)(object)val); // asserts Enum value != (ulong || long)
break;
case int val:
table.AddValue(keyName, val);
break;
case long val:
table.AddValue(keyName, val);
break;
case bool val:
table.AddValue(keyName, val);
break;
case string val:
table.AddValue(keyName, val);
break;
case float val:
table.AddValue(keyName, val);
break;
case double val:
table.AddValue(keyName, val);
break;
default:
Logger.Warning($"[CFG] Cannot serialize '{name}', unsupported type.");
break;
}
}
Toml.WriteFile(tblRoot, _configFile);
Logger.Info($"[CFG] Server config saved to '{_configFile}'.");
}
catch (Exception e)
{
Logger.Warning($"[CFG] Cannot save the config file '{_configFile}'.\n {e.Message}");
}
}
private TomlObject TryWrapInConvertProxy(TomlObject obj, Func <TomlObject> resolveParent)
{
var conv = obj.Root.Settings.TryGetToTomlConverter(this.clrType);
if (conv != null)
{
var convBack = obj.Root.Settings.TryGetConverter(obj.GetType(), this.clrType);
if (convBack != null)
{
var instance = convBack.Convert(obj.Root, obj, this.clrType);
var parentTable = (TomlTable)resolveParent();
var proxy = new ConversionMappingTableProxy(
this.key, parentTable, instance.GetType(), obj.GetType(), Toml.Create(instance), conv);
return(proxy);
}
}
return(obj);
}
private MultiLevelTableScenario()
{
this.Table = Toml.Create(this.Clr);
}
private TomlTable CreateEmpty()
{
return(Toml.Create());
}
