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); }