public void RemoveAt_OK()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
sa.RemoveAt(1);
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity after RemoveAt(...).");
Assert.AreEqual(2, sa.Count, "Incorrect count after RemoveAt(...).");
Assert.AreEqual(1, sa.Sparsity, "Incorrect sparsity after RemoveAt(...).");
Assert.AreEqual(0.5M, sa.SparsityPercent, "Incorrect sparsity percent after RemoveAt(...).");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0
}), "Incorrect keys after RemoveAt(...).");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, decimal.Zero }), "Unequal elements in sparse array after RemoveAt(...)");
}
public void Remove_ValueDoesNotExist()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
Assert.AreEqual(-1, sa.IndexOf(3M), "Incorrect index for non-existent value.");
Assert.IsFalse(sa.Remove(3M), "Incorrect return result for removing existing value.");
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity after Remove(...).");
Assert.AreEqual(2, sa.Count, "Incorrect count after Remove(...).");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity after Remove(...).");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent after Remove(...).");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys after Remove(...).");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array after Remove(...)");
Assert.AreEqual(-1, sa.IndexOf(3M), "Incorrect index for non-existent value after Remove(...).");
}
public void Clear_OK()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
sa.Clear();
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity after Clear().");
Assert.AreEqual(2, sa.Count, "Incorrect count after Clear().");
Assert.AreEqual(0, sa.Sparsity, "Incorrect sparsity after Clear().");
Assert.AreEqual(0.0M, sa.SparsityPercent, "Incorrect sparsity percent after Clear().");
Assert.AreEqual(0, sa.Keys.Count(), "Incorrect keys after Clear().");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 0M, 0M }), "Unequal elements in sparse array after Clear()");
}
public void Clone_OK()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
var clone = (SparseArray <decimal>)sa.Clone();
Assert.AreEqual(sa.IsReadOnly, clone.IsReadOnly, "Incorrect readonly value after Clone().");
Assert.AreEqual(sa.Capacity, clone.Capacity, "Incorrect capacity after Clone().");
Assert.AreEqual(sa.Count, clone.Count, "Incorrect count after Clone().");
Assert.AreEqual(sa.Sparsity, clone.Sparsity, "Incorrect sparsity after Clone().");
Assert.AreEqual(sa.SparsityPercent, clone.SparsityPercent, "Incorrect sparsity percent after Clone().");
Assert.IsTrue(clone.Keys.SequenceEqual(sa.Keys), "Incorrect keys after Clone().");
Assert.AreSame(sa.Comparer, clone.Comparer, "Incorrect explicit comparer after Clone().");
Assert.IsTrue(clone.ToArray().SequenceEqual(sa.ToArray()), "Unequal elements in sparse array after Clone()");
}
public void ToArrayTest()
{
var a = new SparseArray <bool> {
[5] = true, [90] = false
};
Assert.That(a.ToArray(), Is.EquivalentTo(new[] { true, false }));
}
public void Indexer_Set_OK()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
sa[1] = 3M;
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 3M }), "Unequal elements in sparse array after indexer set.");
}
public void Constructor_Capacity_OK_NoComparer()
{
var sa = new SparseArray <decimal>(3);
Assert.IsFalse(sa.IsReadOnly, "Incorrect readonly value.");
Assert.AreEqual(3, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(3, sa.Count, "Incorrect count.");
Assert.AreEqual(0, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(0, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.AreSame(Comparer <decimal> .Default, sa.Comparer, "Incorrect default comparer.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 0M, 0M, 0M }), "Unequal elements in sparse array");
}
public void IndexOf_ValueExists()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
Assert.AreEqual(1, sa.IndexOf(2M), "Incorrect index for existing value.");
}
public void CopyTo_NullArray()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
Assert.ThrowsException <ArgumentNullException>(() => sa.CopyTo(null, 0));
}
public void CopyTo_Array_CorrectSize_ArrayIndex_TooLarge()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
Assert.ThrowsException <InvalidOperationException>(() => sa.CopyTo(new decimal[2], 1));
}
public void Contains_ValueExists()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
Assert.IsTrue(sa.Contains(2M), "Failed to find value that should exist");
}
public void Constructor_Enumerable_OK_NoComparer()
{
var sa = new SparseArray <decimal>(new List <decimal> {
0M, 1M, 0M, 2M
});
Assert.IsFalse(sa.IsReadOnly, "Incorrect readonly value.");
Assert.AreEqual(4, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(4, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(0.5M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
1, 3
}), "Incorrect keys.");
Assert.AreSame(Comparer <decimal> .Default, sa.Comparer, "Incorrect default comparer.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 0M, 1M, 0M, 2M }), "Unequal elements in sparse array");
}
public void Constructor_Dictionary_OK_NonEmptyDictionary_ExactLenght()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.IsFalse(sa.IsReadOnly, "Incorrect readonly value.");
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.AreSame(Comparer <decimal> .Default, sa.Comparer, "Incorrect default comparer.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
}
public void Constructor_Dictionary_OK_WithComparer()
{
var comparer = new MockComparer <decimal>();
var sa = new SparseArray <decimal>(4, new Dictionary <int, decimal>()
{
{ 1, 1M }, { 3, 2M }
}, comparer);
Assert.IsFalse(sa.IsReadOnly, "Incorrect readonly value.");
Assert.AreEqual(4, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(4, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(0.5M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
1, 3
}), "Incorrect keys.");
Assert.AreSame(comparer, sa.Comparer, "Incorrect explicit comparer.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 0M, 1M, 0M, 2M }), "Unequal elements in sparse array");
}
public void CopyTo_OK_Array_Larger_Offset()
{
var sa = new SparseArray <decimal>(2, new Dictionary <int, decimal>()
{
{ 0, 1M }, { 1, 2M }
});
Assert.AreEqual(2, sa.Capacity, "Incorrect capacity.");
Assert.AreEqual(2, sa.Count, "Incorrect count.");
Assert.AreEqual(2, sa.Sparsity, "Incorrect sparsity.");
Assert.AreEqual(1.0M, sa.SparsityPercent, "Incorrect sparsity percent.");
Assert.IsTrue(sa.Keys.SequenceEqual(new List <int> {
0, 1
}), "Incorrect keys.");
Assert.IsTrue(sa.ToArray().SequenceEqual(new[] { 1M, 2M }), "Unequal elements in sparse array");
var ar = new decimal[4];
sa.CopyTo(ar, 1);
Assert.IsTrue(ar.SequenceEqual(new[] { decimal.Zero, 1M, 2M, decimal.Zero }), "Unequal elements in sparse array");
}
private bool Layout(ControlListBase parent, LayoutEventArgs layoutEventArgs, Size proposedSize)
{
if (parent == null)
{
throw new InvalidCastException(nameof(ColumnLayoutEngine) + " can only be used to layout controls derived from " + nameof(ControlListBase));
}
if (proposedSize == Size.Empty)
{
proposedSize = parent.ClientSize;
}
if (parent.BaseItems != null && parent.BaseItems.Count > 0)
{
System.Diagnostics.Debug.WriteLine(parent.Name + ": Layout:");
System.Diagnostics.Debug.WriteLine($" ClientSize:{proposedSize}, Margin:{parent.Margin}, Padding:{parent.Padding}, Cols:{parent.RepeatColumns}, Spacing:{parent.ItemSpacing}, Items:{parent.BaseItems.Count}, Dir:{parent.RepeatDirection}, Even:{parent.SpaceEvenly}");
itemBounds.Clear();
using (Graphics g = parent.CreateGraphics())
{
// Determine the start coordinate of each column
int colWidth = (parent.ClientSize.Width - parent.Padding.Horizontal - ((parent.RepeatColumns - 1) * parent.ItemSpacing.Width)) / parent.RepeatColumns;
Point[] colPos = new Point[parent.RepeatColumns];
for (int x = 0; x < parent.RepeatColumns; x++)
{
colPos[x] = new Point(parent.Padding.Left + (x * (colWidth + parent.ItemSpacing.Width)), parent.Padding.Top);
}
// Get the base height of all items and the max height
int maxItemHeight = 0;
idealSize.Height = 0;
Size maxSize = new Size(colWidth, 0);
for (int i = 0; i < parent.BaseItems.Count; i++)
{
Size sz = parent.MeasureItem(g, i, maxSize);
itemBounds[i] = new Rectangle(Point.Empty, sz);
// Calculate maximum item height
maxItemHeight = Math.Max(maxItemHeight, sz.Height);
}
// Calculate the positions of each item
int curCol = 0;
for (int i = 0; i < parent.BaseItems.Count; i++)
{
// Set bounds of the item
itemBounds[i] = new Rectangle(colPos[curCol], itemBounds[i].Size);
// Set top position of next item
colPos[curCol].Y += (parent.SpaceEvenly ? maxItemHeight : itemBounds[i].Height) + parent.ItemSpacing.Height;
if (parent.RepeatDirection == GroupControls.RepeatDirection.Horizontal)
{
if (++curCol == parent.RepeatColumns)
{
curCol = 0;
}
}
// If parent.ItemSpacing evenly we can determine all locations now by changing column count at pure divisions
/*if (parent.SpaceEvenly && parent.RepeatDirection == GroupControls.RepeatDirection.Vertical && i > 0)
* {
* if (i % (parent.BaseItems.Count / parent.RepeatColumns) == 0 && curCol <= (parent.BaseItems.Count % parent.RepeatColumns))
* curCol++;
* }*/
}
// Split vertical parent.RepeatColumns and reset positions of items
if (parent.RepeatDirection == GroupControls.RepeatDirection.Vertical && parent.RepeatColumns > 1)
{
int idealColHeight = colPos[0].Y / parent.RepeatColumns;
int thisColBottom = idealColHeight;
int y = parent.Padding.Top + parent.Margin.Top;
for (int i = 0; i < parent.BaseItems.Count; i++)
{
Rectangle iBounds = itemBounds[i];
Rectangle nBounds = Rectangle.Empty;
if ((i + 1) < parent.BaseItems.Count)
{
nBounds = itemBounds[i + 1];
}
if (curCol > 0)
{
itemBounds[i] = new Rectangle(new Point(colPos[curCol].X, y), itemBounds[i].Size);
}
colPos[curCol].Y = itemBounds[i].Bottom + parent.ItemSpacing.Height;
if ((iBounds.Bottom > thisColBottom || nBounds.Bottom > thisColBottom) && (curCol + 1 < parent.RepeatColumns))
{
if (Math.Abs(iBounds.Bottom - idealColHeight) < Math.Abs(nBounds.Bottom - idealColHeight))
{
y = parent.Padding.Top;
curCol++;
thisColBottom = iBounds.Bottom + parent.ItemSpacing.Height + idealColHeight;
}
}
else
{
y += (parent.SpaceEvenly ? maxItemHeight : itemBounds[i].Height) + parent.ItemSpacing.Height;
}
}
}
// Set ideal height
idealSize.Height = 0;
for (int c = 0; c < parent.RepeatColumns; c++)
{
if (idealSize.Height < colPos[c].Y)
{
idealSize.Height = colPos[c].Y;
}
}
idealSize.Height = idealSize.Height - parent.ItemSpacing.Height + parent.Padding.Bottom;
}
// Set scroll height and autosize to ideal height
parent.AutoScrollMinSize = new Size(parent.ClientRectangle.Width, idealSize.Height);
if (parent.AutoSize)
{
parent.Height = idealSize.Height;
}
System.Diagnostics.Debug.WriteLine(" " + string.Join(" ", Array.ConvertAll(itemBounds.ToArray(), r => $"({r})")));
}
return(parent.AutoSize);
}
