public void AreSingleton()
{
for (var i = 0; i < 8; i++)
{
SigoAssert.Same(Sigo.Create(i), Sigo.Create(i));
}
}
public void Trees_compare_theirProton()
{
var a = Sigo.Create(3, "k", "v");
var b = Sigo.Create(0, "k", "v");
SigoAssert.NotEqual(a, b);
}
/// <summary>
/// try to return part of a if a is frozen
/// try to return part of b if b is frozen
/// return new sigo
/// </summary>
public static ISigo Merge(ISigo a, ISigo b)
{
ISigo r;
if (b is SigoLeaf)
{
r = b;
return(Select(r, a, b));
}
if (a is SigoLeaf)
{
if ((b.Flags & Bits.M) == 0)
{
r = a;
return(Select(r, a, b));
}
r = Merge(Sigo.Create(Bits.LMR), b);
return(Select(r, a, b));
}
r = Sigo.Create(Bits.Proton(a.Flags | b.Flags));
var keys = a.Keys.Union(b.Keys);
foreach (var key in keys)
{
r = r.Set1(key, Merge(a.Get1(key), b.Get1(key)));
}
return(Select(r, a, b));
}
public void Ignore_frozen_bit()
{
SigoAssert.Equal(
Hash(Sigo.Create(0, "x", 1)),
Hash(Sigo.Create(0, "x", 1).Freeze())
);
}
public void Associative()
{
var a = Sigo.Create(1,
"a/x", "ax",
"a/y", "ay",
"b", "b"
);
// add "/a/z": az
var b = Sigo.Create(0, "a/z", "az");
// change "/b": "b+"
var c = Sigo.Create(0, "b", "b+");
var abc1 = Sigo.Merge(Sigo.Merge(a, b), c);
var abc2 = Sigo.Merge(a, Sigo.Merge(b, c));
var expect = Sigo.Create(3,
"a/x", "ax",
"a/y", "ay",
"a/z", "az",
"b", "b+"
);
SigoAssert.Equal(abc1, abc2);
SigoAssert.Equal(expect, abc2);
}
public static ISigo From(object o)
{
switch (o)
{
case null:
return(Sigo.Create(3));
case ISigo sigo:
return(sigo);
case bool b:
return(From(b));
case int _:
case long _:
case float _:
return(From(Convert.ToDouble(o)));
case double d:
return(From(d));
case string s:
return(From(s));
case IDictionary dict:
return(From(dict));
case IEnumerable list:
return(From(list));
default:
throw new NotImplementedException($"{o.GetType().Name}");
}
}
public static ISigo Create(int lmr, params object[] pvs)
{
var i = 0;
var ret = Sigo.Create(lmr);
while (i < pvs.Length)
{
var path = Paths.ToPath(pvs[i++]);
var value = Sigo.From(pvs[i++]);
if (path == null)
{
return(value);
}
if (path is string key)
{
if (key == "")
{
return(value);
}
ret = ret.Set1(key, value);
}
else if (path is string[] keys)
{
ret = ret.SetN(keys, value, 0);
}
}
return(ret);
}
public void If_sigosAreEqual_then_hashsAreEqual()
{
var sigos = new List <ISigo> {
Sigo.From("a"),
Sigo.From("a"),
Sigo.From("b"),
Sigo.Create(0),
Sigo.Create(3),
Sigo.Create(1, "x", "1", "y", "2").Freeze(),
Sigo.Create(1, "y", "2", "x", "1"),
Sigo.Create(1, "y", "2", "x", "2"),
Sigo.Create(1, "diff", "2", "x", "1")
};
foreach (var a in sigos)
{
foreach (var b in sigos)
{
if (a.Equals(b))
{
// THIS IS A MUST
SigoAssert.Equal(Hash(a), Hash(b));
}
else
{
// THIS IS A SHOULD
SigoAssert.NotEqual(Hash(a), Hash(b));
}
}
}
}
public void Object_flag_default()
{
var expected = new[] {
Sigo.Create(3)
};
SigoAssert.Equal(expected, Gen("{ }"));
}
public void AreFrozen()
{
for (var i = 0; i < 8; i++)
{
var sigo = Sigo.Create(i);
SigoAssert.Equal(Bits.F + i, sigo.Flags);
}
}
public void ShouldEqual()
{
var a1 = Sigo.From(1);
var a2 = Sigo.From(1);
SigoAssert.Equal(a1, a2);
SigoAssert.Equal(new[] { a1, a2 }, new[] { a2, a1 });
}
private static void LoadConfiguration()
{
try {
config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
context = Sigo.Parse(config.AppSettings.Settings["context"].Value);
} catch (Exception) {
// ignored
}
}
public void Trees_compare_theirChildren()
{
var a = Sigo.Create(0, "k", "v+");
var b = Sigo.Create(0, "k", "v+");
var c = Sigo.Create(0, "k", "v-");
SigoAssert.Equal(a, b);
SigoAssert.NotEqual(b, c);
}
public void Trees_only_compare_using_referenceEquals()
{
var tree1 = Sigo.Create(3).Set1("k", Sigo.From("v"));
var tree2 = Sigo.Create(3).Set1("k", Sigo.From("v"));
SigoAssert.True(Sigo.Same(tree1, tree1));
SigoAssert.False(Sigo.Same(tree1, tree2));
}
public void Trees_dontCompare_theirNeutron()
{
var a = Sigo.Create(3, "k", "v");
var b = Sigo.Create(3, "k", "v").Freeze();
SigoAssert.NotEqual(a.Flags, b.Flags);
SigoAssert.Equal(a, b);
}
public void Trees_compare_deeply()
{
var a1 = Sigo.Create(0, "a/b/c/d", "v+");
var a2 = Sigo.Create(0, "a/b/c/d", "v+");
var b1 = Sigo.Create(0, "a/b/c/d", "v-");
SigoAssert.Equal(a1, a2);
SigoAssert.NotEqual(a1, b1);
}
public void AllowPathDuplicated_overwritingChild()
{
var user = Sigo.Create(3,
"user/id", 100.0,
"user/id", 200.0,
"user/id", 200.0);
SigoAssert.Equal(200.0, user.Get1("user").Get1("id").Data);
}
public void Trees_dontCompare_theirChildOder()
{
var a = Sigo.Create(3, "k1", "v1", "k2", "v2");
var b = Sigo.Create(3, "k2", "v2", "k1", "v1");
SigoAssert.NotEqual(a.Keys.First(), b.Keys.First());
SigoAssert.Equal(a, b);
}
public void Frozen_return_self()
{
var leaf = Sigo.From("leaf");
var e3 = Sigo.Create(3);
var tree = Sigo.Create(3, "k", "v").Freeze();
SigoAssert.Same(leaf, leaf.Clone());
SigoAssert.Same(e3, e3.Clone());
SigoAssert.Same(tree, tree.Clone());
}
public void Object_flag_()
{
var expected = new[] {
Sigo.Create(0),
Sigo.Create(3),
Sigo.Create(7)
};
SigoAssert.Equal(expected, Gen("{037}"));
}
public void Never_throw_overflow_exception()
{
var n = int.MaxValue / 100;
for (int i = 0; i < 1000; i++)
{
var s = Sigo.Create(0, "x", n * i, "y", n);
Hash(s);
}
}
public void Object_field_()
{
var expected = new[] {
Sigo.Create(3, "x", 1),
Sigo.Create(3, "x", 2),
Sigo.Create(3, "x", 3)
};
SigoAssert.Equal(expected, Gen("{x: 1|2|3}"));
}
public void AddNewChild()
{
var s0 = Sigo.Create(0);
var s1 = s0.Set1("k1", v1).Freeze();
var s2 = s1.Set1("k2", v2).Freeze();
SigoAssert.Equal(v1, s2.Get1("k1"));
SigoAssert.Equal(v2, s2.Get1("k2"));
SigoAssert.Equal(256 * 2 + 16 + 6, s2.Flags);
}
public void Object_field_auto()
{
var expected = new[] {
Sigo.Create(3, "money", "USD"),
Sigo.Create(3, "money", "VND")
};
Gen("money='USD'|'VND'");
SigoAssert.Equal(expected, Gen("{money}"));
}
public void Leafs_compare_data_using_equals()
{
var v1 = Sigo.From("v");
var v2 = Sigo.From("v");
var x1 = Sigo.From("x");
SigoAssert.True(Sigo.Same(v1, v1));
SigoAssert.True(Sigo.Same(v1, v2));
SigoAssert.False(Sigo.Same(v1, x1));
}
public void Object_field_optional()
{
var expected = new[] {
Sigo.Create(3),
Sigo.Create(3, "x", 1),
Sigo.Create(3, "y", 1),
Sigo.Create(3, "x", 1, "y", 1)
};
SigoAssert.Equal(expected, Gen("{x?: 1, y?:1}"));
}
public void AddNewChild()
{
var s = Sigo.Create(0);
s = s.Set1("k1", v1);
s = s.Set1("k2", v2);
SigoAssert.Equal(v1, s.Get1("k1"));
SigoAssert.Equal(v2, s.Get1("k2"));
SigoAssert.Equal(256 * 2 + 6, s.Flags);
}
public static ISigo From(IDictionary dict)
{
var sigo = Sigo.Create(3);
foreach (DictionaryEntry e in dict)
{
sigo = sigo.Set(e.Key.ToString(), From(e.Value));
}
return(sigo);
}
public void AllowPath()
{
var user = Sigo.Create(3,
"name/first", "Phat",
"name/last", "Dam",
"male", true);
SigoAssert.Equal("Phat", user.Get1("name").Get1("first").Data);
SigoAssert.Equal("Dam", user.Get1("name").Get1("last").Data);
SigoAssert.Equal(true, user.Get1("male").Data);
}
public void TODO_strict(bool allow, string path)
{
if (allow)
{
SigoAssert.Equal("v", Sigo.Create(3, path, "v").Get(path).Data);
}
else
{
SigoAssert.ThrowsAny <Exception>(() => Sigo.Create(3, path, "v"));
}
}
