ImHashMapEntry
Namespace:
LamarCodeGeneration
We found 4 examples in language CSharp for this search.
You will see 24 fragments of code.
Other methods
Other methods
Project:Crystal
File:Utilities.cs
Examples:6
/// <summary>
/// Always a true condition.
/// </summary>
public static bool Always<T>(T _) => true;
/// <summary>
/// Identity function returning passed argument as result.
/// </summary>
public static T Id<T>(T x) => x;
/// <summary>
/// Forward pipe operator (`|>` in F#)
/// </summary>
public static R To<T, R>(this T x, Func<T, R> map) => map(x);
/// <summary>
/// Forward pipe operator (`|>` in F#) with the additional state A for two arguments function
/// </summary>
public static R To<T, S, R>(this T x, S state, Func<T, S, R> map) => map(x, state);
/// <summary>
/// Cast to the R type with the forward pipe operator (`|>` in F#)
/// </summary>
public static R To<R>(this object x) => (R)x;
/// <summary>
/// Forward pipe operator (`|>` in F#) but with side effect propagating the original `x` value
/// </summary>
public static T Do<T>(this T x, Action<T> effect)
{
effect(x);
return x;
}
Project:CsCheck
File:IMToolsTests.cs
Examples:6
[Fact]
public void ModelEqual_ImHashMap234()
{
Assert.True(Check.ModelEqual(
ImHashMap234<int, int>.Empty.AddOrUpdate(1, 2).AddOrUpdate(3, 4)
.Enumerate().Select(kv => ImTools.KeyValuePair.Pair(kv.Key, kv.Value)),
new Dictionary<int, int> { {3, 4}, {1, 2 } }
));
}
[Fact(Skip = "Experiment")]
public void AddOrUpdate_random_items_and_randomly_checking()
{
const int upperBound = 100000;
var savedSeed = new Random().Next(0, upperBound);
var rnd = new Random(savedSeed);
var m = ImHashMap234<int, int>.Empty;
for (var i = 0; i < 5000; i++)
{
var n = rnd.Next(0, upperBound);
m = m.AddOrUpdate(n, n);
Assert.Equal(n, m.GetValueOrDefault(n));
}
// non-existing keys
Assert.Equal(0, m.GetValueOrDefault(upperBound + 1));
Assert.Equal(0, m.GetValueOrDefault(-1));
}
[Fact(Skip = "Experiment")]
public void AddOrUpdate_random_items_and_randomly_checking_CsCheck()
{
const int upperBound = 11966;
Gen.Int[0, upperBound].Array[1, 12].Sample(ints =>
{
var m = ImHashMap234<int, int>.Empty;
foreach (var n in ints)
{
m = m.AddOrUpdate(n, n);
Assert.Equal(n, m.GetValueOrDefault(n));
}
Assert.Equal(0, m.GetValueOrDefault(upperBound + 1));
Assert.Equal(0, m.GetValueOrDefault(-1));
}, iter: 1_000/*, seed: "2Tt3UJ9PI4Hs3"*/);
}
static Gen<ImHashMap234<int, int>> GenMap(int upperBound) =>
Gen.Int[0, upperBound].ArrayUnique.SelectMany(ks =>
Gen.Int.Array[ks.Length].Select(vs =>
{
var m = ImHashMap234<int, int>.Empty;
for (int i = 0; i < ks.Length; i++)
m = m.AddOrUpdate(ks[i], vs[i]);
return m;
}));
[Fact(Skip = "Experiment")]
public void AddOrUpdate_Metamorphic()
{
const int upperBound = 100000;
GenMap(upperBound)
.Select(i => new ImHolder<ImHashMap234<int, int>> { Im = i })
.SampleMetamorphic(
Gen.Select(Gen.Int[0, upperBound], Gen.Int, Gen.Int[0, upperBound], Gen.Int).Metamorphic<ImHolder<ImHashMap234<int, int>>>(
(d, t) => d.Im = d.Im.AddOrUpdate(t.V0, t.V1).AddOrUpdate(t.V2, t.V3),
(d, t) => d.Im = t.V0 == t.V2 ? d.Im.AddOrUpdate(t.V2, t.V3) : d.Im.AddOrUpdate(t.V2, t.V3).AddOrUpdate(t.V0, t.V1)
)
, equal: (a, b) => Check.Equal(a.Im.Enumerate().Select(j => (j.Key, j.Value)), b.Im.Enumerate().Select(j => (j.Key, j.Value)))
, print: i => Check.Print(i.Im.Enumerate().Select(j => (j.Key, j.Value)))
);
}
[Fact(Skip = "Experiment")]
public void AddOrUpdate_ModelBased()
{
const int upperBound = 100000;
GenMap(upperBound).Select(d =>
{
var m = new Dictionary<int, int>();
foreach (var entry in d.Enumerate()) m[entry.Key] = entry.Value;
return (new ImHolder<ImHashMap234<int, int>> { Im = d }, m);
})
.SampleModelBased(
Gen.Int[0, upperBound].Select(Gen.Int).Operation<ImHolder<ImHashMap234<int, int>>, Dictionary<int, int>>((h, d, kv) =>
{
h.Im = h.Im.AddOrUpdate(kv.V0, kv.V1);
d[kv.V0] = kv.V1;
})
, equal: (h, d) =>
{
var he = h.Im.Enumerate().Select(kv => (kv.Key, kv.Value)).ToList();
return he.Count == d.Count && !he.Except(d.Select(kv => (kv.Key, kv.Value))).Any();
}
, printActual: h => Check.Print(h.Im.Enumerate().Select(kv => (kv.Key, kv.Value)))
, iter: 100_000
);
}
Project:DryIoc
File:ImTools.cs
Examples:6
/// <summary>
/// Always a true condition.
/// </summary>
public static bool Always<T>(T _) => true;
/// <summary>
/// Identity function returning passed argument as result.
/// </summary>
public static T Id<T>(T x) => x;
/// <summary>
/// Forward pipe operator (`|>` in F#)
/// </summary>
public static R To<T, R>(this T x, Func<T, R> map) => map(x);
/// <summary>
/// Forward pipe operator (`|>` in F#) with the additional state A for two arguments function
/// </summary>
public static R To<T, S, R>(this T x, S state, Func<T, S, R> map) => map(x, state);
/// <summary>
/// Cast to the R type with the forward pipe operator (`|>` in F#)
/// </summary>
public static R To<R>(this object x) => (R)x;
/// <summary>
/// Forward pipe operator (`|>` in F#) but with side effect propagating the original `x` value
/// </summary>
public static T Do<T>(this T x, Action<T> effect)
{
effect(x);
return x;
}
Project:ImTools
File:ImHashMap23Tests.cs
Examples:6
[Test]
public void Adding_to_ImHashMap_and_checking_the_tree_shape_on_each_addition()
{
var m = ImHashMap<int, string>.Empty;
Assert.AreEqual(null, m.GetValueOrDefault(0));
Assert.AreEqual(null, m.GetValueOrDefault(13));
Assert.IsEmpty(m.Enumerate());
Assert.AreEqual(0, m.Count());
m = m.AddOrUpdate(1, "a");
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(1, m.Count());
Assert.AreSame(m, m.AddOrKeep(1, "aa"));
var mr = m.Remove(1);
Assert.AreSame(ImHashMap<int, string>.Empty, mr);
Assert.AreEqual(0, mr.Count());
m = m.AddOrUpdate(2, "b");
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(2, m.Count());
Assert.AreSame(m, m.AddOrKeep(1, "aa").AddOrKeep(2, "bb"));
Assert.AreSame(m, m.Remove(0));
mr = m.Remove(2);
Assert.AreEqual("a", mr.GetValueOrDefault(1));
Assert.AreEqual(1, mr.Count());
m = m.AddOrUpdate(3, "c");
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(3, m.Count());
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
Assert.AreSame(m, m.Remove(0));
mr = m.Remove(2);
Assert.AreEqual("a", mr.GetValueOrDefault(1));
Assert.AreEqual("c", mr.GetValueOrDefault(3));
Assert.AreEqual(2, mr.Count());
m = m.AddOrUpdate(4, "d");
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(4, m.Count());
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
Assert.AreSame(m, m.Remove(0));
m = m.AddOrUpdate(5, "e");
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual("e", m.GetValueOrDefault(5));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(5, m.Count());
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
Assert.AreSame(m, m.Remove(0));
m = m.AddOrUpdate(6, "6");
Assert.AreEqual("6", m.GetValueOrDefault(6));
Assert.AreEqual("e", m.GetValueOrDefault(5));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(6, m.Count());
m = m.AddOrUpdate(7, "7");
Assert.AreEqual("7", m.GetValueOrDefault(7));
m = m.AddOrUpdate(8, "8");
Assert.AreEqual("8", m.GetValueOrDefault(8));
m = m.AddOrUpdate(9, "9");
Assert.AreEqual("9", m.GetValueOrDefault(9));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(9, m.Count());
m = m.AddOrUpdate(10, "10");
Assert.AreEqual("10", m.GetValueOrDefault(10));
Assert.AreEqual("9", m.GetValueOrDefault(9));
Assert.AreEqual("8", m.GetValueOrDefault(8));
Assert.AreEqual("7", m.GetValueOrDefault(7));
Assert.AreEqual("6", m.GetValueOrDefault(6));
Assert.AreEqual("e", m.GetValueOrDefault(5));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(11));
Assert.AreSame(m, m.AddOrKeep(8, "8!").AddOrKeep(5, "5!").AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(10, m.Count());
m = m.AddOrUpdate(11, "11");
m = m.AddOrUpdate(12, "12");
m = m.AddOrUpdate(13, "13");
Assert.AreEqual("11", m.GetValueOrDefault(11));
Assert.AreEqual("12", m.GetValueOrDefault(12));
Assert.AreEqual("13", m.GetValueOrDefault(13));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(13, m.Count());
m = m.AddOrUpdate(14, "14");
Assert.AreEqual("14", m.GetValueOrDefault(14));
Assert.AreEqual(14, m.Count());
m = m.AddOrUpdate(15, "15");
m = m.AddOrUpdate(16, "16");
m = m.AddOrUpdate(17, "17");
Assert.AreEqual("15", m.GetValueOrDefault(15));
Assert.AreEqual("16", m.GetValueOrDefault(16));
Assert.AreEqual("17", m.GetValueOrDefault(17));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(17, m.Count());
m = m.AddOrUpdate(18, "18");
Assert.AreEqual("18", m.GetValueOrDefault(18));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(18, m.Count());
var r = m.Remove(18).Remove(17).Remove(16);
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, r.Enumerate().Select(x => x.Hash));
Assert.IsNull(r.GetValueOrDefault(16));
var rr = r.Remove(16);
Assert.AreSame(r, rr);
m = m.AddOrUpdate(18, "18");
m = m.AddOrKeep(18, "18");
Assert.AreEqual("18", m.GetValueOrDefault(18));
m = m.AddOrUpdate(19, "19").AddOrUpdate(20, "20").AddOrUpdate(21, "21").AddOrUpdate(22, "22").AddOrUpdate(23, "23");
rr = m.Remove(25).Remove(21);
Assert.IsNull(rr.GetValueOrDefault(21));
}
[Test]
public void Adding_to_ImMap_and_checking_the_tree_shape_on_each_addition()
{
var m = ImMap<string>.Empty;
Assert.AreEqual(null, m.GetValueOrDefault(0));
Assert.AreEqual(null, m.GetValueOrDefault(13));
Assert.IsEmpty(m.Enumerate());
Assert.AreEqual(0, m.Count());
m = m.AddOrUpdate(1, "a");
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(1, m.Count());
Assert.AreSame(m, m.AddOrKeep(1, "aa"));
var mr = m.Remove(1);
Assert.AreSame(ImMap<string>.Empty, mr);
Assert.AreEqual(0, mr.Count());
m = m.AddOrUpdate(2, "b");
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(2, m.Count());
Assert.AreSame(m, m.AddOrKeep(1, "aa").AddOrKeep(2, "bb"));
Assert.AreSame(m, m.Remove(0));
mr = m.Remove(2);
Assert.AreEqual("a", mr.GetValueOrDefault(1));
Assert.AreEqual(1, mr.Count());
m = m.AddOrUpdate(3, "c");
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(3, m.Count());
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
Assert.AreSame(m, m.Remove(0));
mr = m.Remove(2);
Assert.AreEqual("a", mr.GetValueOrDefault(1));
Assert.AreEqual("c", mr.GetValueOrDefault(3));
Assert.AreEqual(2, mr.Count());
m = m.AddOrUpdate(4, "d");
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(4, m.Count());
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
Assert.AreSame(m, m.Remove(0));
m = m.AddOrUpdate(5, "e");
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual("e", m.GetValueOrDefault(5));
Assert.AreEqual(null, m.GetValueOrDefault(10));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(5, m.Count());
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
Assert.AreSame(m, m.Remove(0));
m = m.AddOrUpdate(6, "6");
Assert.AreEqual("6", m.GetValueOrDefault(6));
Assert.AreEqual("e", m.GetValueOrDefault(5));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(10));
Assert.AreSame(m, m.AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(6, m.Count());
m = m.AddOrUpdate(7, "7");
Assert.AreEqual("7", m.GetValueOrDefault(7));
m = m.AddOrUpdate(8, "8");
Assert.AreEqual("8", m.GetValueOrDefault(8));
m = m.AddOrUpdate(9, "9");
Assert.AreEqual("9", m.GetValueOrDefault(9));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(9, m.Count());
mr = m.Remove(9);
Assert.IsNull(mr.GetValueOrDefault(9));
m = m.AddOrUpdate(10, "10");
Assert.AreEqual("10", m.GetValueOrDefault(10));
Assert.AreEqual("9", m.GetValueOrDefault(9));
Assert.AreEqual("8", m.GetValueOrDefault(8));
Assert.AreEqual("7", m.GetValueOrDefault(7));
Assert.AreEqual("6", m.GetValueOrDefault(6));
Assert.AreEqual("e", m.GetValueOrDefault(5));
Assert.AreEqual("d", m.GetValueOrDefault(4));
Assert.AreEqual("c", m.GetValueOrDefault(3));
Assert.AreEqual("b", m.GetValueOrDefault(2));
Assert.AreEqual("a", m.GetValueOrDefault(1));
Assert.AreEqual(null, m.GetValueOrDefault(11));
Assert.AreSame(m, m.AddOrKeep(8, "8!").AddOrKeep(5, "5!").AddOrKeep(3, "aa").AddOrKeep(2, "bb").AddOrKeep(1, "cc"));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(10, m.Count());
m = m.AddOrUpdate(11, "11");
m = m.AddOrUpdate(12, "12");
m = m.AddOrUpdate(13, "13");
Assert.AreEqual("11", m.GetValueOrDefault(11));
Assert.AreEqual("12", m.GetValueOrDefault(12));
Assert.AreEqual("13", m.GetValueOrDefault(13));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(13, m.Count());
m = m.AddOrUpdate(14, "14");
Assert.AreEqual("14", m.GetValueOrDefault(14));
Assert.AreEqual(14, m.Count());
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }, m.Enumerate().Select(x => x.Hash));
m = m.AddOrUpdate(15, "15");
m = m.AddOrUpdate(16, "16");
m = m.AddOrUpdate(17, "17");
Assert.AreEqual("15", m.GetValueOrDefault(15));
Assert.AreEqual("16", m.GetValueOrDefault(16));
Assert.AreEqual("17", m.GetValueOrDefault(17));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(17, m.Count());
m = m.AddOrUpdate(18, "18");
Assert.AreEqual("18", m.GetValueOrDefault(18));
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 }, m.Enumerate().Select(x => x.Hash));
Assert.AreEqual(18, m.Count());
var r = m.Remove(18).Remove(17).Remove(16);
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, r.Enumerate().Select(x => x.Hash));
Assert.IsNull(r.GetValueOrDefault(16));
var rr = r.Remove(16);
Assert.AreSame(r, rr);
m = m.AddOrUpdate(18, "18");
m = m.AddOrKeep(18, "18");
Assert.AreEqual("18", m.GetValueOrDefault(18));
m = m.AddOrUpdate(19, "19").AddOrUpdate(20, "20").AddOrUpdate(21, "21").AddOrUpdate(22, "22").AddOrUpdate(23, "23");
rr = m.Remove(25).Remove(21);
Assert.IsNull(rr.GetValueOrDefault(21));
}
public override bool Equals(object o) => o is XKey<K> x && Key.Equals(x.Key);
public static XKey<K> Xk<K>(K key) => new XKey<K>(key);
[Test]
public void Adding_the_conflicting_keys_should_be_fun()
{
var m = ImHashMap<XKey<int>, string>.Empty;
Assert.AreEqual(null, m.GetValueOrDefault(Xk(0)));
Assert.AreEqual(null, m.GetValueOrDefault(Xk(13)));
m = m.AddOrUpdate(Xk(1), "a");
m = m.AddOrUpdate(Xk(2), "b");
Assert.AreNotEqual(typeof(ImHashMapEntry<XKey<int>, string>), m.GetType());
Assert.AreEqual("a", m.GetValueOrDefault(Xk(1)));
Assert.AreEqual("b", m.GetValueOrDefault(Xk(2)));
Assert.AreEqual(null, m.GetValueOrDefault(Xk(10)));
var mr = m.Remove(Xk(1));
Assert.AreNotEqual(typeof(ImHashMapEntry<XKey<int>, string>), m.GetType());
Assert.AreEqual(null, mr.GetValueOrDefault(Xk(1)));
Assert.AreEqual("b", mr.GetValueOrDefault(Xk(2)));
m = m.AddOrUpdate(Xk(3), "c");
mr = m.Remove(Xk(2));
Assert.AreNotEqual(typeof(ImHashMapEntry<XKey<int>, string>), m.GetType());
Assert.AreEqual("a", mr.GetValueOrDefault(Xk(1)));
Assert.AreEqual(null, mr.GetValueOrDefault(Xk(2)));
Assert.AreEqual("c", mr.GetValueOrDefault(Xk(3)));
}
[Test]
public void Adding_1000_keys_and_randomly_checking()
{
var m = ImHashMap<int, int>.Empty;
for (var i = 0; i < 5000; i++)
{
m = m.AddOrUpdate(i, i);
}
Assert.AreEqual(1, m.GetValueOrDefault(1));
Assert.AreEqual(0, m.GetValueOrDefault(0));
Assert.AreEqual(13, m.GetValueOrDefault(13));
Assert.AreEqual(66, m.GetValueOrDefault(66));
Assert.AreEqual(555, m.GetValueOrDefault(555));
Assert.AreEqual(333, m.GetValueOrDefault(333));
Assert.AreEqual(999, m.GetValueOrDefault(999));
// non-existing keys
Assert.AreEqual(0, m.GetValueOrDefault(10000));
Assert.AreEqual(0, m.GetValueOrDefault(-1));
}
LamarCodeGeneration.Util.ImHashMapEntry<K, V> : Entry
Fields :
public K Keypublic V Value
public Int32 Hash
Constructors :
public ImHashMapEntry(Int32 hash = , K key = )public ImHashMapEntry(Int32 hash = , K key = , V value = )
Methods :
public Int32 Count()public String ToString()
public Boolean get_IsEmpty()
public Type GetType()
public Boolean Equals(Object obj = )
public Int32 GetHashCode()