public void Test()
{
var rand = new Random(3);
List<string> list1 = new List<string>();
WeakList<string> list2 = new WeakList<string>();
for (int x = 0; x < 1000; x++)
{
var str = x.ToString();
list1.Add(str);
list2.Add(str);
if (!list1.SequenceEqual(list2))
throw new Exception("Lists are not the same.");
}
for (int x = 1000; x < 2000; x++)
{
var str = x.ToString();
var removeItem = list1[rand.Next(list1.Count)];
list1.Remove(removeItem);
list2.Remove(removeItem);
if (!list1.SequenceEqual(list2))
throw new Exception("Lists are not the same.");
list1.Add(str);
list2.Add(str);
if (!list1.SequenceEqual(list2))
throw new Exception("Lists are not the same.");
}
for (int x = 0; x < 100; x++)
{
list1.RemoveAt(rand.Next(list1.Count));
GC.Collect();
if (!list1.SequenceEqual(list2))
throw new Exception("Lists are not the same.");
}
list2.Clear();
foreach (var data in list2)
throw new Exception();
}
public RenderableList Clone()
{
var result = new RenderableList(Name + "_copy", LocalMatrix, this.Select(x => x.Clone()))
{
IsEnabled = IsEnabled,
IsReflectable = IsReflectable,
ParentMatrix = ParentMatrix,
BoundingBox = BoundingBox
};
_clones.Add(result);
return(result);
}
public void Test_GcCollect()
{
var weakList = new WeakList <object>();
weakList.Add(new Object());
GC.Collect();
GC.WaitForPendingFinalizers();
weakList.Clear(true);
Assert.IsTrue(weakList.Count == 0, "Item must be collected by the GC collector");
}
public void TestRemovedStillUnload()
{
WeakList <Container> references = new WeakList <Container>();
AddStep("populate panels", () =>
{
references.Clear();
for (int i = 0; i < 16; i++)
{
flow.Add(new Container
{
Size = new Vector2(128),
Children = new Drawable[]
{
new DelayedLoadUnloadWrapper(() =>
{
var container = new Container
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
new TestBox {
RelativeSizeAxes = Axes.Both
}
},
};
references.Add(container);
return(container);
}, 500, 2000),
new SpriteText {
Text = i.ToString()
},
}
});
}
});
AddUntilStep("references loaded", () => references.Count() == 16 && references.All(c => c.IsLoaded));
AddStep("Remove all panels", () => flow.Clear(false));
AddUntilStep("references lost", () =>
{
GC.Collect();
return(!references.Any());
});
}
public void TestAddAfterClear()
{
var objects = new List <object>
{
new object(),
new object(),
new object(),
};
object newObject = new object();
var list = new WeakList <object>();
foreach (object o in objects)
{
list.Add(o);
}
list.Clear();
list.Add(newObject);
Assert.That(list.Count(), Is.EqualTo(1));
Assert.That(list, Does.Contain(newObject));
}
protected override void OnAttached()
{
base.OnAttached();
DockLayoutManager manager = AssociatedObject as DockLayoutManager;
if (manager != null && !managers.Contains(manager))
{
lock (managers) {
foreach (var m in managers)
{
DockLayoutManagerLinker.Link(manager, m);
}
managers.Add(manager);
}
}
}
/// <summary>
/// Creates an object that can be used to get updated snapshots from this <see cref="ArchiveList{TKey,TValue}"/>.
/// Client must call <see cref="IDisposable.Dispose"/> method when finished with these resources as they will not
/// automatically be reclaimed by the garbage collector. Class will not be initiallized until calling <see cref="ArchiveListSnapshot{TKey,TValue}.UpdateSnapshot"/>.
/// </summary>
/// <returns></returns>
public ArchiveListSnapshot <TKey, TValue> CreateNewClientResources()
{
ArchiveListSnapshot <TKey, TValue> resources;
lock (m_syncRoot)
{
if (m_disposed)
{
throw new Exception("Object is disposing");
}
resources = new ArchiveListSnapshot <TKey, TValue>(ReleaseClientResources, UpdateSnapshot);
m_allSnapshots.Add(resources);
}
return(resources);
}
public TreeStream <TKey, TValue> Read(SortedTreeEngineReaderOptions readerOptions, SeekFilterBase <TKey> keySeekFilter, MatchFilterBase <TKey, TValue> keyMatchFilter, WorkerThreadSynchronization workerThreadSynchronization)
{
if (m_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
SequentialReaderStream <TKey, TValue> stream = m_server.Read(readerOptions, keySeekFilter, keyMatchFilter, workerThreadSynchronization);
if (!stream.EOS)
{
stream.Disposed += OnStreamDisposal;
lock (m_syncRoot)
m_openStreams.Add(stream);
}
return(stream);
}
public void Test_GcCannotCollect()
{
var weakList = new WeakList <object>();
//holding strong reference
var item = new Object();
TestContext.Properties.Add("item", item);
weakList.Add(item);
GC.Collect();
GC.WaitForPendingFinalizers();
weakList.Clear(true);
Assert.AreEqual(1, weakList.Count);
TestContext.Properties.Remove("item");
}
private (WeakList <object> list, object[] alive) generateWeakObjects()
{
var allObjects = new[]
{
new object(),
new object(),
new object(),
new object(),
new object(),
};
var list = new WeakList <object>();
foreach (var obj in allObjects)
{
list.Add(obj);
}
return(list, new[] { allObjects[1], allObjects[2], allObjects[4] });
}
private (WeakList <object> list, object[] aliveObjects) generateWeakList()
{
var objects = new List <object>
{
new object(),
new object(),
new object(),
new object(),
new object(),
new object(),
};
var list = new WeakList <object>();
foreach (object o in objects)
{
list.Add(o);
}
return(list, new[] { objects[1], objects[2], objects[4] });
}
public void TestTasksCanceledDuringLoadSequence()
{
var references = new WeakList <TestBox>();
AddStep("populate panels", () =>
{
references.Clear();
for (int i = 0; i < 16; i++)
{
DelayedLoadUnloadWrapper loadUnloadWrapper;
flow.Add(new Container
{
Size = new Vector2(128),
Child = loadUnloadWrapper = new DelayedLoadUnloadWrapper(() =>
{
var content = new TestBox {
RelativeSizeAxes = Axes.Both
};
references.Add(content);
return(content);
}, 0),
});
// cancel load tasks after the delayed load has started.
loadUnloadWrapper.DelayedLoadStarted += _ => game.Schedule(() => loadUnloadWrapper.UnbindAllBindables());
}
});
AddStep("remove all panels", () => flow.Clear(false));
AddUntilStep("references lost", () =>
{
GC.Collect();
return(!references.Any());
});
}
public void TestWeakList()
{
var wl = new WeakList<object>();
AddObject(wl);
Assert.AreEqual(1, wl.Count);
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
AddObject(wl);
Assert.AreEqual(1, wl.Count);
var o = new object();
wl.Add(o);
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
Assert.AreEqual(2, wl.Count);
int iC = 0;
foreach (var item in wl) iC++;
Assert.AreEqual(1, iC);
Assert.AreEqual(2, wl.Count);
GC.KeepAlive(o);
}
private Player loadPlayerFor(Ruleset r)
{
var beatmap = CreateBeatmap(r);
var working = new TestWorkingBeatmap(beatmap);
workingWeakReferences.Add(working);
Beatmap.Value = working;
Beatmap.Value.Mods.Value = new[] { r.GetAllMods().First(m => m is ModNoFail) };
Player?.Exit();
var player = CreatePlayer(r);
playerWeakReferences.Add(player);
LoadComponentAsync(player, p =>
{
Player = p;
LoadScreen(p);
});
return(player);
}
public void TestRemoveAllUsingRemoveAtFromBothSides()
{
var objects = new List <object>
{
new object(),
new object(),
new object(),
new object(),
new object(),
new object(),
new object(),
new object(),
new object(),
};
var list = new WeakList <object>();
foreach (object o in objects)
{
list.Add(o);
}
for (int i = 0; i < objects.Count; i++)
{
if (i % 2 == 0)
{
list.RemoveAt(0);
}
else
{
list.RemoveAt(list.Count() - 1);
}
}
Assert.That(list.Count(), Is.Zero);
}
void AddObject(WeakList <object> wl)
{
wl.Add(new Object());
}
private void Add(WeakList <object> list, ObjectReference value)
{
list.Add(value.Strong);
}
/// <summary> /// Begins tracking a <see cref="IVertexBatch"/>, resetting its counters every frame. This should be invoked once for every <see cref="IVertexBatch"/> in use. /// </summary> /// <param name="batch">The batch to register.</param> internal static void RegisterVertexBatch(IVertexBatch batch) => reset_scheduler.Add(() => all_batches.Add(batch));
/// <summary>
/// Add the IrecieveMessageEntity in a tag (create the tag if doesnt exists)
/// </summary>
/// <param name="tag"></param>
/// <param name="Agente"></param>
public void AddgrouptagRecieveEntity(string tag, IRecieveMessageEntity Agente)
{
System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(tag));
System.Diagnostics.Debug.Assert(Agente != null);
if (!IdEntity.ContainsKey(Agente.GetId()))
{
throw new Exception("The following instance is not in the mapper, add it beforing calling this: " + Agente.ToString());
}
if (tagRecieveEntity.ContainsKey(tag))
{
tagRecieveEntity[tag].Add(Agente);
}
else
{
WeakList<IRecieveMessageEntity> l = new WeakList<IRecieveMessageEntity>();
l.Add(Agente);
tagRecieveEntity.Add(tag, l);
}
if (recieveEntityTag.ContainsKey(Agente.GetId()))
{
recieveEntityTag[Agente.GetId()].Add(tag);
}
else
{
recieveEntityTag[Agente.GetId()] = new List<string>();
recieveEntityTag[Agente.GetId()].Add(tag);
}
}
private void Add(WeakList<object> list, ObjectReference value)
{
list.Add(value.Strong);
}
/// <summary>
/// Adds given retargeting assembly for this compilation into the cache.
/// <see cref="CommonReferenceManager.SymbolCacheAndReferenceManagerStateGuard"/> must be locked while calling this method.
/// </summary>
internal void CacheRetargetingAssemblySymbolNoLock(IAssemblySymbol assembly)
{
_retargetingAssemblySymbols.Add(assembly);
}
private void Add(WeakList <object> list, ObjectReference <C> value)
{
value.UseReference(r => list.Add(r));
}
public void TestUnloadViaScroll()
{
WeakList <Container> references = new WeakList <Container>();
AddStep("populate panels", () =>
{
references.Clear();
for (int i = 0; i < 16; i++)
{
flow.Add(new Container
{
Size = new Vector2(128),
Children = new Drawable[]
{
new DelayedLoadUnloadWrapper(() =>
{
var container = new Container
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
new TestBox {
RelativeSizeAxes = Axes.Both
}
},
};
references.Add(container);
return(container);
}, 500, 2000),
new SpriteText {
Text = i.ToString()
},
}
});
}
flow.Add(
new Container
{
Size = new Vector2(128, 1280),
});
});
AddUntilStep("references loaded", () => references.Count() == 16 && references.All(c => c.IsLoaded));
AddAssert("check schedulers present", () => scroll.Scheduler.HasPendingTasks);
AddStep("scroll to end", () => scroll.ScrollToEnd());
AddUntilStep("repeating schedulers removed", () => !scroll.Scheduler.HasPendingTasks);
AddUntilStep("references lost", () =>
{
GC.Collect();
return(!references.Any());
});
AddStep("scroll to start", () => scroll.ScrollToStart());
AddUntilStep("references restored", () => references.Count() == 16);
}
public void TestRemoveThenAdd()
{
WeakList <Container> references = new WeakList <Container>();
int loadCount = 0;
AddStep("populate panels", () =>
{
references.Clear();
loadCount = 0;
for (int i = 0; i < 16; i++)
{
flow.Add(new Container
{
Size = new Vector2(128),
Children = new Drawable[]
{
new DelayedLoadUnloadWrapper(() =>
{
TestBox testBox;
var container = new Container
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
testBox = new TestBox {
RelativeSizeAxes = Axes.Both
}
},
};
testBox.OnLoadComplete += _ =>
{
references.Add(container);
loadCount++;
};
return(container);
}, 500, 2000),
new SpriteText {
Text = i.ToString()
},
}
});
}
});
IReadOnlyList <Container> previousChildren = null;
AddUntilStep("all loaded", () => loadCount == 16);
AddStep("Remove all panels", () =>
{
previousChildren = flow.Children.ToList();
flow.Clear(false);
});
AddStep("Add panels back", () => flow.Children = previousChildren);
AddWaitStep("wait for potential unload", 20);
AddAssert("load count hasn't changed", () => loadCount == 16);
}
protected static void AddReference(Timer timer)
{
_runningTimers.Add(timer);
}
void AddObject(WeakList<object> wl) { wl.Add(new Object()); }
private void Add(WeakList<object> list, ObjectReference<C> value)
{
value.UseReference(r => list.Add(r));
}