9434033067

Committed 09 Jun 2024 04:41AM UTC coverage: 87.884% (+12.8%) from 75.051%

Build # 9434033067

Build Type

push

github

Committed by

JaCraig

Commit Message

fix: Finished with the table objects and adding tests for them

Added robust testing and improved null handling in Table classes
 This commit introduces a series of enhancements and tests to the `Table`, `TableRow`, and `TableCell` classes. The classes now handle null values more gracefully, with updated methods such as `Add`, `Contains`, `CopyTo`, `Insert`, `Remove`, and `RemoveAt` to include null checks. The `FixedLengthField` class has been refactored for readability and now implements the `IObjectConvertable` interface. New test methods have been added to `FixedLengthFieldTests.cs`, `TableCellTests`, `TableRowTests.cs`, and a new `TableTests` class has been introduced. These tests cover a wide range of functionalities and edge cases, following the Arrange-Act-Assert pattern using the Xunit testing framework.

Run Details

428 of 514 branches covered (83.27%)

Branch coverage included in aggregate %.

40 of 46 new or added lines in 4 files covered. (86.96%)

4 existing lines in 2 files now uncovered.

602 of 658 relevant lines covered (91.49%)

2661.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.8

/Archivist/DataTypes/Table.cs

﻿using Archivist.BaseClasses;
using Archivist.Interfaces;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace Archivist.DataTypes
{
    /// <summary>
    /// Represents a table in the Archivist system.
    /// </summary>
    /// <seealso cref="FileBaseClass{Table}"/>
    public class Table : FileBaseClass<Table>, IComparable<Table>, IEquatable<Table>, IListConvertable, IList<TableRow>
    {
        /// <summary>
        /// Gets the headers of the table.
        /// </summary>
        /// <value>The headers.</value>
        public List<string> Columns { get; } = new List<string>();

        /// <summary>
        /// Gets the number of rows in the table.
        /// </summary>
        public int Count => Rows.Count;

        /// <summary>
        /// Gets a value indicating whether the table is read-only.
        /// </summary>
        public bool IsReadOnly => false;

        /// <summary>
        /// Gets the rows of the table.
        /// </summary>
        private List<TableRow> Rows { get; } = new List<TableRow>();

        /// <summary>
        /// Gets or sets the row at the specified index.
        /// </summary>
        /// <param name="index">The index of the table.</param>
        /// <returns>The row at the specified index.</returns>
        /// <exception cref="ArgumentOutOfRangeException">The index is out of range.</exception>
        public TableRow this[int index]
        {
            get
            {
                if (index < 0 || index >= Rows.Count)
                    throw new ArgumentOutOfRangeException(nameof(index));
                return Rows[index];
            }
            set
            {
                if (index < 0 || index >= Rows.Count)
                    throw new ArgumentOutOfRangeException(nameof(index));
                Rows[index] = value ?? new TableRow(Columns);
            }
        }

        /// <summary>
        /// Determines whether two table objects are not equal.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns><c>true</c> if the two table objects are not equal; otherwise, <c>false</c>.</returns>
        public static bool operator !=(Table? left, Table? right)
        {
            return !(left == right);
        }

        /// <summary>
        /// Determines whether the first table object is less than the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is less than the second table object; otherwise, <c>false</c>.
        /// </returns>
        public static bool operator <(Table? left, Table? right)
        {
            return left is null ? right is not null : left.CompareTo(right) < 0;
        }

        /// <summary>
        /// Determines whether the first table object is less than or equal to the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is less than or equal to the second table object;
        /// otherwise, <c>false</c>.
        /// </returns>
        public static bool operator <=(Table? left, Table? right)
        {
            return left is null || left.CompareTo(right) <= 0;
        }

        /// <summary>
        /// Determines whether two table objects are equal.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns><c>true</c> if the two table objects are equal; otherwise, <c>false</c>.</returns>
        public static bool operator ==(Table? left, Table? right)
        {
            if (left is null)
                return right is null;
            return left.Equals(right);
        }

        /// <summary>
        /// Determines whether the first table object is greater than the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is greater than the second table object;
        /// otherwise, <c>false</c>.
        /// </returns>
        public static bool operator >(Table? left, Table? right)
        {
            return left?.CompareTo(right) > 0;
        }

        /// <summary>
        /// Determines whether the first table object is greater than or equal to the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is greater than or equal to the second table
        /// object; otherwise, <c>false</c>.
        /// </returns>
        public static bool operator >=(Table? left, Table? right)
        {
            return left is null ? right is null : left.CompareTo(right) >= 0;
        }

        /// <summary>
        /// Adds a row to the table.
        /// </summary>
        /// <param name="item">The row to add to the table.</param>
        public void Add(TableRow? item) => Rows.Add(item ?? new TableRow(Columns));

        /// <summary>
        /// Adds a new row to the table.
        /// </summary>
        /// <returns>The new row.</returns>
        public TableRow AddRow()
        {
            var Row = new TableRow(Columns);
            Rows.Add(Row);
            return Row;
        }

        /// <summary>
        /// Clears the table.
        /// </summary>
        public void Clear() => Rows.Clear();

        /// <summary>
        /// Compares the current table object with another table object.
        /// </summary>
        /// <param name="other">The table object to compare with this table object.</param>
        /// <returns>A value that indicates the relative order of the table objects being compared.</returns>
        public override int CompareTo(Table? other)
        {
            if (other is null)
                return 1;
            return other.GetContent()?.CompareTo(GetContent()) ?? 1;
        }

        /// <summary>
        /// Determines if the table contains the specified row.
        /// </summary>
        /// <param name="item">The row to find in the table.</param>
        /// <returns><c>true</c> if the table contains the row; otherwise, <c>false&gt;</c>.</returns>
        public bool Contains(TableRow? item) => item is not null && Rows.Contains(item);

        /// <summary>
        /// Converts this instance into the object array of the type specified.
        /// </summary>
        /// <typeparam name="TObject">The type of the object.</typeparam>
        /// <returns>The resulting array.</returns>
        public List<TObject?> ConvertTo<TObject>() => Rows.ConvertAll(x => x.ConvertTo<TObject?>());

        /// <summary>
        /// Copies the rows of the table to an array, starting at a particular array index.
        /// </summary>
        /// <param name="array">The array to copy the rows to.</param>
        /// <param name="arrayIndex">The index in the array at which to start copying the rows.</param>
        public void CopyTo(TableRow[]? array, int arrayIndex)
        {
            if (array is null)
                return;
            if (arrayIndex < 0 || arrayIndex >= array.Length)
                throw new ArgumentOutOfRangeException(nameof(arrayIndex));
            Rows.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Determines whether the current table object is equal to another table object.
        /// </summary>
        /// <param name="obj">The table object to compare with this table object.</param>
        /// <returns>
        /// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
        /// </returns>
        public override bool Equals(object? obj) => obj is Table Table && Equals(Table);

        /// <summary>
        /// Determines whether the current table object is equal to another table object.
        /// </summary>
        /// <param name="other">The table object to compare with this table object.</param>
        /// <returns>
        /// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
        /// </returns>
        public override bool Equals(Table? other)
        {
            if (ReferenceEquals(this, other))
                return true;
            if (other is null)
                return false;
            return GetContent() == other.GetContent();
        }

        /// <summary>
        /// Gets the content of the table.
        /// </summary>
        /// <returns>The content of the table.</returns>
        public override string? GetContent()
        {
            return new StringBuilder()
                    .AppendJoin(' ', Columns)
                    .Append('\n')
                    .AppendJoin('\n', Rows)
                    .ToString();
        }

        /// <summary>
        /// Returns an enumerator that iterates through the rows of the table.
        /// </summary>
        /// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
        public IEnumerator<TableRow> GetEnumerator() => Rows.GetEnumerator();

        /// <summary>
        /// Returns an enumerator that iterates through the rows of the table.
        /// </summary>
        /// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        /// <summary>
        /// Returns the hash code for the current table object.
        /// </summary>
        /// <returns>A hash code for the current table object.</returns>
        public override int GetHashCode()
        {
            var HashCode = new HashCode();
            foreach (var Column in Columns)
            {
                HashCode.Add(Column);
            }
            foreach (TableRow Row in Rows)
            {
                HashCode.Add(Row);
            }
            return HashCode.ToHashCode();
        }

        /// <summary>
        /// Returns the index of the specified row in the table.
        /// </summary>
        /// <param name="item">The row to find in the table.</param>
        /// <returns>The index of the row in the table.</returns>
        public int IndexOf(TableRow? item) => Rows.IndexOf(item!);

        /// <summary>
        /// Inserts a row into the table at the specified index.
        /// </summary>
        /// <param name="index">The index at which to insert the row.</param>
        /// <param name="item">The row to insert into the table.</param>
        public void Insert(int index, TableRow? item)
        {
            if (index < 0)
                index = 0;
            if (index > Count)
                index = Count;
            item ??= new TableRow(Columns);
            Rows.Insert(index, item);
        }

        /// <summary>
        /// Removes the first occurrence of a specific row from the table.
        /// </summary>
        /// <param name="item">The row to remove from the table.</param>
        /// <returns><c>true</c> if the row was successfully removed; otherwise, <c>false&gt;</c>.</returns>
        public bool Remove(TableRow? item) => item is not null && Rows.Remove(item);

        /// <summary>
        /// Removes the row at the specified index.
        /// </summary>
        /// <param name="index">The index of the row to remove.</param>
        public void RemoveAt(int index)
        {
            if (index < 0 || index >= Count)
                return;
            Rows.RemoveAt(index);
        }
    }
}

1	using Archivist.BaseClasses;
2	using Archivist.Interfaces;
3	using System;
4	using System.Collections;
5	using System.Collections.Generic;
6	using System.Text;
7
8	namespace Archivist.DataTypes
9	{
10	/// <summary>
11	/// Represents a table in the Archivist system.
12	/// </summary>
13	/// <seealso cref="FileBaseClass{Table}"/>
14	public class Table : FileBaseClass<Table>, IComparable<Table>, IEquatable<Table>, IListConvertable, IList<TableRow>
15	{
16	/// <summary>
17	/// Gets the headers of the table.
18	/// </summary>
19	/// <value>The headers.</value>
20	public List<string> Columns { get; } = new List<string>();	219✔
21
22	/// <summary>
23	/// Gets the number of rows in the table.
24	/// </summary>
25	public int Count => Rows.Count;	7✔
26
27	/// <summary>
28	/// Gets a value indicating whether the table is read-only.
29	/// </summary>
30	public bool IsReadOnly => false;	2✔
31
32	/// <summary>
33	/// Gets the rows of the table.
34	/// </summary>
35	private List<TableRow> Rows { get; } = new List<TableRow>();	257✔
36
37	/// <summary>
38	/// Gets or sets the row at the specified index.
39	/// </summary>
40	/// <param name="index">The index of the table.</param>
41	/// <returns>The row at the specified index.</returns>
42	/// <exception cref="ArgumentOutOfRangeException">The index is out of range.</exception>
43	public TableRow this[int index]
44	{
45	get
46	{
47	if (index < 0 \|\| index >= Rows.Count)	15✔
48	throw new ArgumentOutOfRangeException(nameof(index));	10✔
49	return Rows[index];	5✔
50	}
51	set
52	{
53	if (index < 0 \|\| index >= Rows.Count)	11✔
54	throw new ArgumentOutOfRangeException(nameof(index));	10✔
55	Rows[index] = value ?? new TableRow(Columns);	1!
56	}	1✔
57	}
58
59	/// <summary>
60	/// Determines whether two table objects are not equal.
61	/// </summary>
62	/// <param name="left">The first table object.</param>
63	/// <param name="right">The second table object.</param>
64	/// <returns><c>true</c> if the two table objects are not equal; otherwise, <c>false</c>.</returns>
65	public static bool operator !=(Table? left, Table? right)
66	{
67	return !(left == right);	6✔
68	}
69
70	/// <summary>
71	/// Determines whether the first table object is less than the second table object.
72	/// </summary>
73	/// <param name="left">The first table object.</param>
74	/// <param name="right">The second table object.</param>
75	/// <returns>
76	/// <c>true</c> if the first table object is less than the second table object; otherwise, <c>false</c>.
77	/// </returns>
78	public static bool operator <(Table? left, Table? right)
79	{
80	return left is null ? right is not null : left.CompareTo(right) < 0;	4✔
81	}
82
83	/// <summary>
84	/// Determines whether the first table object is less than or equal to the second table object.
85	/// </summary>
86	/// <param name="left">The first table object.</param>
87	/// <param name="right">The second table object.</param>
88	/// <returns>
89	/// <c>true</c> if the first table object is less than or equal to the second table object;
90	/// otherwise, <c>false</c>.
91	/// </returns>
92	public static bool operator <=(Table? left, Table? right)
93	{
94	return left is null \|\| left.CompareTo(right) <= 0;	4✔
95	}
96
97	/// <summary>
98	/// Determines whether two table objects are equal.
99	/// </summary>
100	/// <param name="left">The first table object.</param>
101	/// <param name="right">The second table object.</param>
102	/// <returns><c>true</c> if the two table objects are equal; otherwise, <c>false</c>.</returns>
103	public static bool operator ==(Table? left, Table? right)
104	{
105	if (left is null)	12✔
106	return right is null;	4✔
107	return left.Equals(right);	8✔
108	}
109
110	/// <summary>
111	/// Determines whether the first table object is greater than the second table object.
112	/// </summary>
113	/// <param name="left">The first table object.</param>
114	/// <param name="right">The second table object.</param>
115	/// <returns>
116	/// <c>true</c> if the first table object is greater than the second table object;
117	/// otherwise, <c>false</c>.
118	/// </returns>
119	public static bool operator >(Table? left, Table? right)
120	{
121	return left?.CompareTo(right) > 0;	4✔
122	}
123
124	/// <summary>
125	/// Determines whether the first table object is greater than or equal to the second table object.
126	/// </summary>
127	/// <param name="left">The first table object.</param>
128	/// <param name="right">The second table object.</param>
129	/// <returns>
130	/// <c>true</c> if the first table object is greater than or equal to the second table
131	/// object; otherwise, <c>false</c>.
132	/// </returns>
133	public static bool operator >=(Table? left, Table? right)
134	{
135	return left is null ? right is null : left.CompareTo(right) >= 0;	4✔
136	}
137
138	/// <summary>
139	/// Adds a row to the table.
140	/// </summary>
141	/// <param name="item">The row to add to the table.</param>
142	public void Add(TableRow? item) => Rows.Add(item ?? new TableRow(Columns));	3✔
143
144	/// <summary>
145	/// Adds a new row to the table.
146	/// </summary>
147	/// <returns>The new row.</returns>
148	public TableRow AddRow()
149	{
150	var Row = new TableRow(Columns);	16✔
151	Rows.Add(Row);	16✔
152	return Row;	16✔
153	}
154
155	/// <summary>
156	/// Clears the table.
157	/// </summary>
158	public void Clear() => Rows.Clear();	2✔
159
160	/// <summary>
161	/// Compares the current table object with another table object.
162	/// </summary>
163	/// <param name="other">The table object to compare with this table object.</param>
164	/// <returns>A value that indicates the relative order of the table objects being compared.</returns>
165	public override int CompareTo(Table? other)
166	{
167	if (other is null)	13✔
168	return 1;	5✔
169	return other.GetContent()?.CompareTo(GetContent()) ?? 1;	8!
170	}
171
172	/// <summary>
173	/// Determines if the table contains the specified row.
174	/// </summary>
175	/// <param name="item">The row to find in the table.</param>
176	/// <returns><c>true</c> if the table contains the row; otherwise, <c>false></c>.</returns>
177	public bool Contains(TableRow? item) => item is not null && Rows.Contains(item);	3✔
178
179	/// <summary>
180	/// Converts this instance into the object array of the type specified.
181	/// </summary>
182	/// <typeparam name="TObject">The type of the object.</typeparam>
183	/// <returns>The resulting array.</returns>
184	public List<TObject?> ConvertTo<TObject>() => Rows.ConvertAll(x => x.ConvertTo<TObject?>());	5✔
185
186	/// <summary>
187	/// Copies the rows of the table to an array, starting at a particular array index.
188	/// </summary>
189	/// <param name="array">The array to copy the rows to.</param>
190	/// <param name="arrayIndex">The index in the array at which to start copying the rows.</param>
191	public void CopyTo(TableRow[]? array, int arrayIndex)
192	{
193	if (array is null)	3✔
194	return;	2✔
195	if (arrayIndex < 0 \|\| arrayIndex >= array.Length)	1!
NEW 196	throw new ArgumentOutOfRangeException(nameof(arrayIndex));	×
197	Rows.CopyTo(array, arrayIndex);	1✔
198	}	1✔
199
200	/// <summary>
201	/// Determines whether the current table object is equal to another table object.
202	/// </summary>
203	/// <param name="obj">The table object to compare with this table object.</param>
204	/// <returns>
205	/// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
206	/// </returns>
207	public override bool Equals(object? obj) => obj is Table Table && Equals(Table);	6✔
208
209	/// <summary>
210	/// Determines whether the current table object is equal to another table object.
211	/// </summary>
212	/// <param name="other">The table object to compare with this table object.</param>
213	/// <returns>
214	/// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
215	/// </returns>
216	public override bool Equals(Table? other)
217	{
218	if (ReferenceEquals(this, other))	14!
UNCOV 219	return true;	×
220	if (other is null)	14✔
221	return false;	3✔
222	return GetContent() == other.GetContent();	11✔
223	}
224
225	/// <summary>
226	/// Gets the content of the table.
227	/// </summary>
228	/// <returns>The content of the table.</returns>
229	public override string? GetContent()
230	{
231	return new StringBuilder()	41✔
232	.AppendJoin(' ', Columns)	41✔
233	.Append('\n')	41✔
234	.AppendJoin('\n', Rows)	41✔
235	.ToString();	41✔
236	}
237
238	/// <summary>
239	/// Returns an enumerator that iterates through the rows of the table.
240	/// </summary>
241	/// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
242	public IEnumerator<TableRow> GetEnumerator() => Rows.GetEnumerator();	7✔
243
244	/// <summary>
245	/// Returns an enumerator that iterates through the rows of the table.
246	/// </summary>
247	/// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
248	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();	1✔
249
250	/// <summary>
251	/// Returns the hash code for the current table object.
252	/// </summary>
253	/// <returns>A hash code for the current table object.</returns>
254	public override int GetHashCode()
255	{
256	var HashCode = new HashCode();	6✔
257	foreach (var Column in Columns)	20✔
258	{
259	HashCode.Add(Column);	4✔
260	}
261	foreach (TableRow Row in Rows)	20✔
262	{
263	HashCode.Add(Row);	4✔
264	}
265	return HashCode.ToHashCode();	6✔
266	}
267
268	/// <summary>
269	/// Returns the index of the specified row in the table.
270	/// </summary>
271	/// <param name="item">The row to find in the table.</param>
272	/// <returns>The index of the row in the table.</returns>
273	public int IndexOf(TableRow? item) => Rows.IndexOf(item!);	3✔
274
275	/// <summary>
276	/// Inserts a row into the table at the specified index.
277	/// </summary>
278	/// <param name="index">The index at which to insert the row.</param>
279	/// <param name="item">The row to insert into the table.</param>
280	public void Insert(int index, TableRow? item)
281	{
282	if (index < 0)	3!
NEW 283	index = 0;	×
284	if (index > Count)	3!
NEW 285	index = Count;	×
286	item ??= new TableRow(Columns);	3✔
287	Rows.Insert(index, item);	3✔
288	}	3✔
289
290	/// <summary>
291	/// Removes the first occurrence of a specific row from the table.
292	/// </summary>
293	/// <param name="item">The row to remove from the table.</param>
294	/// <returns><c>true</c> if the row was successfully removed; otherwise, <c>false></c>.</returns>
295	public bool Remove(TableRow? item) => item is not null && Rows.Remove(item);	3✔
296
297	/// <summary>
298	/// Removes the row at the specified index.
299	/// </summary>
300	/// <param name="index">The index of the row to remove.</param>
301	public void RemoveAt(int index)
302	{
303	if (index < 0 \|\| index >= Count)	2!
NEW 304	return;	×
305	Rows.RemoveAt(index);	2✔
306	}	2✔
307	}
308	}

JaCraig / Archivist / 9434033067

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous