public void GetFallback(int i)
{
var thing = new ConcurrentIndexed <int, string>();
Assert.Equal("not hello", thing.GetOrAdd(i, () => "not hello"));
Assert.Equal("not hello", thing.GetOrAdd(i, () => "hello"));
}
public void GetOrAdd_Func()
{
var target = new ConcurrentIndexed <int, string>();
Assert.Equal("1", target.GetOrAdd(1, () => "1"));
Assert.Equal("1", target.GetOrAdd(1, () => "1!"));
}
public void UpdateFallback(int i)
{
var thing = new ConcurrentIndexed <int, string>();
Assert.Equal("not hello", thing.DoOrAdd(i, (x) => x + " world", "not hello"));
Assert.Equal("not hello", thing.GetOrThrow(i));
}
public void Setup()
{
random = new Random((int)DateTime.Now.Ticks);
mine = new ConcurrentIndexed <int, string>();
concurrentDictionary = new ConcurrentDictionary <int, string>();
void cdRead()
{
for (var i = 0; i < Reps; i++)
{
concurrentDictionary[random.Next(1, RandomRange + 1)] = "";
}
}
cdActions = new List <Action>();
for (int i = 0; i < Threads; i++)
{
cdActions.Add(cdRead);
}
void myRead()
{
for (var i = 0; i < Reps; i++)
{
mine.Set(random.Next(1, RandomRange + 1), "");
}
}
myActions = new List <Action>();
for (int i = 0; i < Threads; i++)
{
myActions.Add(myRead);
}
}
public void AddOrThrow_Func()
{
var target = new ConcurrentIndexed <int, string>();
target.AddOrThrow(1, () => "1");
Assert.ThrowsAny <Exception>(() => target.AddOrThrow(1, () => "1!"));
}
public void UpdateOrThrow()
{
var target = new ConcurrentIndexed <int, string>();
Assert.ThrowsAny <Exception>(() => target.UpdateOrThrow(1, x => x + "!"));
target.Set(1, "1");
Assert.Equal("1!", target.UpdateOrThrow(1, x => x + "!"));
}
public void AddUpdate(int i)
{
var thing = new ConcurrentIndexed <int, string>();
thing.DoOrAdd(i, (s) => s + " world", "hello");
Assert.Equal("hello", thing.GetOrThrow(i));
thing.DoOrAdd(i, (s) => s + " world", "hello");
Assert.Equal("hello world", thing.GetOrThrow(i));
}
public void DoOrAdd()
{
var target = new ConcurrentIndexed <int, string>();
target.DoOrAdd(1, x => "1!", "1");
Assert.Equal("1", target.GetOrThrow(1));
target.DoOrAdd(1, x => "1!", "1");
Assert.Equal("1!", target.GetOrThrow(1));
}
public void Set()
{
var target = new ConcurrentIndexed <int, string>();
target.Set(1, "1");
Assert.Equal("1", target.GetOrThrow(1));
target.Set(1, "1!");
Assert.Equal("1!", target.GetOrThrow(1));
}
public void GetOrTrhow()
{
var target = new ConcurrentIndexed <int, string>();
Assert.ThrowsAny <Exception>(() => target.GetOrThrow(1));
target.AddOrThrow(1, "1");
Assert.Equal("1", target.GetOrThrow(1));
}
public void TryGetValue()
{
var target = new ConcurrentIndexed <int, string>();
Assert.False(target.TryGetValue(1, out var _));
target.AddOrThrow(1, "1");
Assert.True(target.TryGetValue(1, out var second));
Assert.Equal("1", second);
}
public void TryRemove(int i)
{
var thing = new ConcurrentIndexed <int, string>();
Assert.True(thing.TryAdd(i, "world"));
Assert.Single(thing);
Assert.True(thing.TryRemove(i, out var value));
Assert.Empty(thing);
Assert.Equal("world", value);
Assert.True(thing.TryAdd(i, "world"));
Assert.Single(thing);
}
public void AddUpdateOrThrow(int i)
{
var thing = new ConcurrentIndexed <int, string>();
thing.AddOrThrow(i, "hello");
Assert.Equal("hello", thing.GetOrThrow(i));
Assert.Throws <Exception>(() =>
{
thing.AddOrThrow(i, "hello");
});
thing.UpdateOrThrow(i, (s) => s + " world");
Assert.Equal("hello world", thing.GetOrThrow(i));
}
public void Enumerate()
{
var thing = new ConcurrentIndexed <int, string>();
for (var i = 0; i < 100; i++)
{
thing.AddOrThrow(i, () => $"{i}");
}
var count = 0;
foreach (var uhh in thing)
{
count++;
}
Assert.Equal(100, count);
}
public void DoOrThrow_Func()
{
var target = new ConcurrentIndexed <int, string>();
Assert.ThrowsAny <Exception>(() => target.DoOrThrow(1, x => x + "!"));
target.AddOrThrow(1, "1");
string s = null;
target.DoOrThrow(1, x => {
s = x + "!";
return(x);
});
Assert.Equal("1!", s);
}
public async Task AddUpdateParallel()
{
{
var thing = new ConcurrentIndexed <int, string>();
var tasks = new List <Task>();
for (var i = 0; i < 100; i += 3)
{
tasks.Add(Task.Run(() => AddUpdate(i)));
tasks.Add(Task.Run(() => GetFallback(i + 1)));
tasks.Add(Task.Run(() => UpdateFallback(i + 2)));
}
await Task.WhenAll(tasks.ToArray());
}
}
public void AddAndRemove()
{
var random = new Random();
for (int i = 0; i < 10000; i++)
{
const int V = 1000;
var check = new int[V];
var thing = new ConcurrentIndexed <int, string>();
int count = 0;
Parallel.Invoke(new int[10000].Select <int, Action>(_ => () => {
var value = random.Next(1000);
if (random.Next(2) == 1)
{
if (thing.TryAdd(value, value.ToString()))
{
Interlocked.Increment(ref check[value]);
Interlocked.Increment(ref count);
}
}
else
{
if (thing.TryRemove(value, out var _))
{
Interlocked.Decrement(ref check[value]);
Interlocked.Decrement(ref count);
}
}
}).ToArray());
Assert.Equal(count, thing.Count);
for (int j = 0; j < V; j++)
{
Assert.Equal(check[j] > 0, thing.ContainsKey(j));
}
foreach (var item in thing)
{
Assert.True(check[item.Key] > 0);
}
}
}
public void Setup()
{
concurrentHashIndexedTree2 = new ConcurrentIndexed <HashTest, int>();
for (var i = 1; i <= Items; i++)
{
concurrentHashIndexedTree2.GetOrAdd(new HashTest(1, i), i);
}
concurrentDictionary2 = new ConcurrentDictionary <HashTest, int>();
for (var i = 1; i <= Items; i++)
{
concurrentDictionary2.GetOrAdd(new HashTest(1, i), i);
}
rawConcurrentHashIndexed = new ConcurrentIndexed <int, int>();
rawConcurrentHashIndexed.GetOrAdd(1, 1);
dict = new Dictionary <int, int>
{
[1] = 1
};
concurrentHashIndexedTree = new ConcurrentIndexed <int, int>();
concurrentHashIndexedTree.Set(1, 1);
//concurrentHashIndexedTree.GetOrAdd(new IndexedListNode<int, Concurrent<int>>(1, new Concurrent<int>(1)));
//concurrentHashIndexedTree.GetOrAdd(new IndexedListNode<int, int>(1,1));
concurrentDictionary = new ConcurrentDictionary <int, int>
{
[1] = 1
};
//var r = new Random((int)DateTime.Now.Ticks);
//data = new Tuple<int, int>[Threads][];
//for (int i = 0; i < Threads; i++)
//{
// data[i] = new Tuple<int, int>[Items];
// for (int j = 0; j < Items; j++)
// {
// data[i][j] = new Tuple<int, int>(r.Next(1, 1000), r.Next(1, 1000));
// }
//}
}
public void DoubleIterate()
{
for (int k = 0; k < 1000; k++)
{
var student = new ConcurrentIndexed <int, int>();
for (int i = 0; i < 10; i++)
{
student.GetOrAdd(i, i);
}
var count = 0;
foreach (var x in student)
{
foreach (var y in student)
{
count++;
}
}
Assert.Equal(100, count);
}
}
public void TryGetValue()
{
var target = new ConcurrentIndexed <HashTestHelper, int>();
target.AddOrThrow(new HashTestHelper(1, 1), 1);
target.AddOrThrow(new HashTestHelper(1, 2), 2);
target.AddOrThrow(new HashTestHelper(1, 3), 3);
target.AddOrThrow(new HashTestHelper(1, 4), 4);
target.AddOrThrow(new HashTestHelper(1, 5), 5);
target.AddOrThrow(new HashTestHelper(1, 6), 6);
Assert.True(target.TryGetValue(new HashTestHelper(1, 1), out var res1));
Assert.Equal(1, res1);
Assert.True(target.TryGetValue(new HashTestHelper(1, 2), out var res2));
Assert.Equal(2, res2);
Assert.True(target.TryGetValue(new HashTestHelper(1, 3), out var res3));
Assert.Equal(3, res3);
Assert.True(target.TryGetValue(new HashTestHelper(1, 4), out var res4));
Assert.Equal(4, res4);
Assert.True(target.TryGetValue(new HashTestHelper(1, 5), out var res5));
Assert.Equal(5, res5);
Assert.True(target.TryGetValue(new HashTestHelper(1, 6), out var res6));
Assert.Equal(6, res6);
}
public InterpetedStaticScope(ConcurrentIndexed <IKey, IInterpetedMember> backing, IRunTimeAnyRoot root) : base(root)
{
Backing = backing ?? throw new ArgumentNullException(nameof(backing));
}
// TODO, I think the type just passes through here
// like everywhere else
public static IInterpetedStaticScope StaticScope(ConcurrentIndexed <IKey, IInterpetedMember> backing, IInterfaceModuleType type)
=> Root(new Func <IRunTimeAnyRoot, RunTimeAnyRootEntry>[] { StaticScopeIntention(backing, type) }).Has <IInterpetedStaticScope>();
public static Func <IRunTimeAnyRoot, RunTimeAnyRootEntry> StaticScopeIntention(ConcurrentIndexed <IKey, IInterpetedMember> backing, IInterfaceModuleType type) => root => new RunTimeAnyRootEntry(new InterpetedStaticScope(backing, root), type);
