public void AddRemoveAndCount()
{
for (int i = 0; i < 10000; i++)
{
var random = new Random();
var removed = 0;
var subject = new ConcurrentLinkedList <int>();
var toAdd = random.Next(0, 1000);
var toRemove = random.Next(0, 1000);
var actions = new List <Action>();
for (int j = 0; j < toAdd; j++)
{
actions.Add(() => subject.Add(0));
}
for (int j = 0; j < toRemove; j++)
{
actions.Add(() =>
{
if (subject.RemoveStart())
{
Interlocked.Increment(ref removed);
}
});
}
Parallel.Invoke(actions.OrderBy(x => random.NextDouble()).ToArray());
Assert.Equal(toAdd - removed, subject.Count);
Assert.Equal(toAdd - removed, subject.Count());
}
}
//internal void OnDisconnect(Func<Exception, Task> onDisconnect)
//{
//}
//IAsyncEnumerable does not really make sense here
public void ApplyInputs(Dictionary <Guid, PlayerInputs> inputs)
{
gameState.Handle(gameStateTracker.UpdateGameState());
PlayerInputApplyer.Apply(gameState, inputs);
//foreach (var (p1, p2) in PhysicsEngine2.PlayerPairs(gameState))
//{
// PhysicsMath2.TryPushBallBall(p1, p2);
//}
gameState.Simulate(gameStateTracker);
// clear out effects after a few frames
var nextCollisions = new ConcurrentLinkedList <GameState.Collision>();
foreach (var item in gameState.collisions.Where(x => x.Frame + 3 > gameState.Frame))
{
nextCollisions.Add(item);
}
gameState.collisions = nextCollisions;
var nextGoalsScored = new ConcurrentLinkedList <GameState.GoalScored>();
foreach (var item in gameState.GoalsScored.Where(x => x.Frame + 3 > gameState.Frame))
{
nextGoalsScored.Add(item);
}
gameState.GoalsScored = nextGoalsScored;
}
public SessionClient(Action <ActionToken> actionChangeCallback)
{
_actionChangeCallback = actionChangeCallback;
IsHandleFrameEnabled = true;
RunningActions = new ConcurrentLinkedList <ActionBase>();
PendingExclusiveActions = new ConcurrentQueue <ActionBase>();
}
public Enumerator(ConcurrentLinkedList <T> list)
{
_List = list;
_Current = default;
_CurrentAddress = list._HeadAddress;
MoveNext();
}
private ConcurrentLinkedList <BOX <int> > AddCheckEntries(bool bTail = true, int countEntries = 10)
{
var LL = new ConcurrentLinkedList <BOX <int> >();
var n = new List <int>(Enumerable.Range(0, countEntries));
foreach (var i in n)
{
if (bTail)
{
LL.AddTail(new BOX <int>(i));
}
else
{
LL.AddHead(new BOX <int>(i));
}
}
var nFound = 0;
var node = LL.Head;
do
{
Assert.AreNotEqual(node.Value, null);
Assert.AreEqual(true, n.Contains(node.Value.VALUE));
nFound++;
}while ((node = node.Next) != null);
Trace.WriteLine(string.Format("Total Entries {0}", LL.Count), "info");
Assert.AreEqual(nFound, n.Count);
return(LL);
}
public static void Handle(this GameState gameState, GameStateUpdate gameStateUpdate)
{
gameState.Frame = gameStateUpdate.Frame;
gameState.GameBall = gameStateUpdate.Ball;
var nextCollisions = new ConcurrentLinkedList <Collision>();
foreach (var item in gameStateUpdate.Collisions)
{
nextCollisions.Add(item);
}
gameState.collisions = nextCollisions;
gameState.CountDownState = gameStateUpdate.CountDownState;
var nextGoalsScores = new ConcurrentLinkedList <GoalScored>();
foreach (var item in gameStateUpdate.GoalsScored)
{
nextGoalsScores.Add(item);
}
gameState.GoalsScored = nextGoalsScores;
var nextPlayers = new RawConcurrentIndexed <Guid, Player>();
foreach (var item in gameStateUpdate.Players)
{
nextPlayers.TryAdd(item.Id, item);
}
gameState.players = nextPlayers;
gameState.RightScore = gameStateUpdate.RightScore;
gameState.LeftScore = gameStateUpdate.LeftScore;
}
public PublisherThread(NMSConnectionFactory factory, ConcurrentLinkedList <Message> messageSource, String topic, String user, String password)
{
this.factory = factory;
this.messageSource = messageSource;
this.topic = topic;
this.user = user;
this.password = password;
}
public void AddBeforeIsNotContainsTargetNodeThenAddedValueAsNewFirstNode()
{
var list = new ConcurrentLinkedList <int>();
list.AddLast(10);
var newNode = list.AddBefore(new ConcurrentLinkedListNode <int>(), 35);
Assert.Equal(newNode, list.First);
}
public void AddAfterContainsTargetNodeButHeIsLast()
{
var list = new ConcurrentLinkedList <int>();
var node = list.AddLast(10);
var addedNode = list.AddAfter(node, 35);
Assert.Equal(addedNode, list.Last);
}
public void AddBeforeContainsTargetNode()
{
var list = new ConcurrentLinkedList <int>();
var node = list.AddLast(10);
var addedNode = list.AddBefore(node, 35);
Assert.Equal(addedNode, node.Prev);
}
public void AddFirstTest()
{
var list = new ConcurrentLinkedList <Guid>();
var array = Enumerable.Range(0, 4).Select(x => Guid.NewGuid()).ToArray();
foreach (var value in array.Reverse())
{
list.AddFirst(value);
}
list.ToArray().Should().Equal(array);
}
public void AddLastByItemIsNodeResultNodeHasNoOneNodePrev()
{
var list = new ConcurrentLinkedList <int>();
var node = new ConcurrentLinkedListNode <int>()
{
Value = 10
};
list.AddFirst(node);
Assert.NotNull(list._root);
Assert.Null(node.Prev);
}
public void AddAtHeadCheckCount()
{
var LL = new ConcurrentLinkedList <BOX <int> >();
var n = Enumerable.Range(0, 100);
foreach (var i in n)
{
LL.AddHead(new BOX <int>(i));
}
Trace.WriteLine(string.Format("Total Entries{0}", LL.Count), "info");
Assert.AreEqual(LL.Count, n.Count());
}
public void AddFirstByItemParamResultNodeHasNoOneNodePrev()
{
var list = new ConcurrentLinkedList <int>();
list.AddFirst(10);
list.AddFirst(5);
list.AddFirst(3);
var node = list.AddFirst(7);
Assert.NotNull(list._root);
Assert.Null(node.Prev);
Assert.NotNull(list.First);
Assert.Equal(7, list.First.Value);
}
public void AddLastByItemResultNodeHasNoOneNodeNext()
{
var list = new ConcurrentLinkedList <int>();
list.AddLast(10);
list.AddLast(5);
list.AddLast(6);
var node = list.AddLast(11);
Assert.NotNull(list._root);
Assert.Null(node.Next);
Assert.NotNull(list.Last);
Assert.Equal(11, list.Last.Value);
}
public void AddParallelTest()
{
var list = new ConcurrentLinkedList <Guid>();
var array = Enumerable.Range(0, 1024).Select(_ => Guid.NewGuid()).ToArray();
Parallel.ForEach(array, () => - 1, (guid, state, index) =>
{
if (index == -1)
{
return(list.AddFirst(guid));
}
else
{
return(list.AddAfter(index, guid));
}
}, i => { });
list.ToArray().Should().BeEquivalentTo(array);
}
private ConcurrentLinkedList <BOX <long> > CreateProducersConsumers(int countEntries,
int TailProducers,
int TailConsumers,
int HeadProducers,
int HeadConsumers,
int MaxProducerRandomDelay,
int MaxConsumersRandomDelay,
int InitialConsumerDelay = 10)
{
var currentEntry = 0;
var totalProduced = 0;
var totalConsumed = 0;
var LL = new ConcurrentLinkedList <BOX <long> >();
var rnd = new Random();
List <Task <int> > consumerTasks = new List <Task <int> >();
List <Task <int> > producerTasks = new List <Task <int> >();
Func <bool, string, Task <int> > producer = async(bIsTail, producerId) =>
{
var produced = 0;
Trace.WriteLine(string.Format("Producer {0} is {1}", producerId, bIsTail ? "Tail" : "Head"));
while (Interlocked.Increment(ref currentEntry) <= countEntries)
{
produced++;
var newVal = DateTime.UtcNow.Ticks;
Trace.WriteLine(string.Format("Producer {0} + {1}", producerId, newVal));
if (bIsTail)
{
LL.AddTail(new BOX <long>(newVal));
}
else
{
LL.AddHead(new BOX <long>(newVal));
}
await Task.Delay(rnd.Next(0, MaxProducerRandomDelay));
}
return(produced);
};
Func <bool, string, Task <int> > consumer = async(bIsTail, consumerId) =>
{
// all consumer wait a bit this almost elminate the need for that CX below
await Task.Delay(InitialConsumerDelay); //
Trace.WriteLine(string.Format("Consumer {0} is {1}", consumerId, bIsTail ? "Tail" : "Head"));
var consumed = 0;
BOX <long> node;
while ((bIsTail && null != (node = LL.RemoveTail())) || (!bIsTail && null != (node = LL.RemoveHead())))
{
Assert.AreNotEqual(null, node.VALUE);
Trace.WriteLine(string.Format("Consumer {0} - {1}", consumerId, node.VALUE));
consumed++;
await Task.Delay(rnd.Next(0, MaxConsumersRandomDelay));
}
Trace.WriteLine(string.Format("Consumer {0} is {1} -- Exited", consumerId, bIsTail ? "Tail" : "Head"));
return(consumed);
};
// give a head start for consumers.
for (int p = 1; p <= TailProducers + HeadProducers; p++)
{
//avoid hoisted variables.
var isTail = (TailProducers > 0 && p <= TailProducers);
var producerName = string.Concat("P", p);
producerTasks.Add(Task.Run(
async() => await producer(isTail, producerName))
);
}
for (int c = 1; c <= TailConsumers + HeadConsumers; c++)
{
var isTail = (TailConsumers > 0 && c <= TailConsumers);
var consumerName = string.Concat("C", c);
consumerTasks.Add(Task.Run(
async() => await consumer(isTail, consumerName))
);
}
Task.WhenAll(producerTasks).Wait();
Task.WhenAll(consumerTasks).Wait();
// if after all said and done we still have items consume them.
if (LL.Count > 0)
{
Trace.WriteLine("Consumers exited before producers completed work, creating a CX", "warnings");
totalConsumed += Task <int> .Run(async() => await consumer(true, "CX")).Result;
}
// calculate all produced and consumed
foreach (var p in producerTasks)
{
totalProduced += p.Result;
}
foreach (var c in consumerTasks)
{
totalConsumed += c.Result;
}
// are we clean?
Trace.WriteLine(string.Format("completed produced:{0} consumed:{1}", totalProduced, totalConsumed), "info");
Assert.AreEqual(totalProduced, totalConsumed);
return(LL);
}
public ThreadedStringListener()
{
cll = new ConcurrentLinkedList<string> ();
}
public void AddBeforeIsNotContainsNodes()
{
var list = new ConcurrentLinkedList <int>();
Assert.Throws <Exception>(() => list.AddBefore(new ConcurrentLinkedListNode <int>(), 10));
}
