Welcome to the Lounge

public static string Run()
    {
    try
        {
        testsRun = 0;
        testsPassed = 0;
        testsFailed = 0;
        outText.Clear();
        Range ra = new Range(0, 4);       //
        Range rb = new Range(5, 9);       // Contiguous with ra
        Range rc = new Range(10, 14);     // Contiguous with rb
        Range rd = new Range(1, 3);       // Intersects ra, not contiguous with rb
        Range re = new Range(6, 8);       // Intersects rb, not contiguous with rc
        Range rf = new Range(16, 19);     // Not contiguous with anything.
        Range rg = new Range(0, 0);       // Single element.
        Range rh = new Range(1, 1);       // Single element.
        Range ri = new Range(2, 2);       // Single element.
        Range rj = new Range(0, 19);      // All elements.
        Range rk = new Range(0, 4);       // Identical to ra

        CheckInt(ra.Count, 5);
        CheckInt(ra.Min, 0);
        CheckInt(ra.Max, 4);
        CheckString(ra, "(0:4)");
        CheckString(ra.UnionWith(re), "(0:4) | (6:8)");

        Check(Range.GetEmpty(), new int[0]);

        Check(ra, new int[] { 0, 1, 2, 3, 4, });
        Check(new Range(new int[] { 0, 1, 2, 5, 6, 7 }.AsEnumerable()), new int[] { 0, 1, 2, 5, 6, 7 });
        Check(ra.UnionWith(ra), new int[] { 0, 1, 2, 3, 4 });
        Check(ra.UnionWith(rb), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
        Check(rb.UnionWith(rc), new int[] { 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 });
        Check(ra.UnionWith(rc), new int[] { 0, 1, 2, 3, 4, 10, 11, 12, 13, 14 });
        Check(ra.UnionWith(re), new int[] { 0, 1, 2, 3, 4, 6, 7, 8 });
        Check(ra.UnionWith(rg), new int[] { 0, 1, 2, 3, 4 });
        Check(rb.UnionWith(rg), new int[] { 0, 5, 6, 7, 8, 9 });
        Check(rg.UnionWith(rh).UnionWith(ri), new int[] { 0, 1, 2 });
        CheckInt(ra.UnionWith(rc).Count, 10);
        CheckInt(ra.UnionWith(rc).Min, 0);
        CheckInt(ra.UnionWith(rc).Max, 14);

        Check(ra.Intersecting(ra), new int[] { 0, 1, 2, 3, 4 });
        Check(ra.Intersecting(rb), new int[0]);
        Check(rb.Intersecting(rc), new int[0]);
        Check(ra.Intersecting(rc), new int[0]);
        Check(ra.Intersecting(rg), new int[] { 0 });
        Check(rb.Intersecting(rg), new int[0]);
        Check(rg.Intersecting(rh).Intersecting(ri), new int[0]);

        Check(ra.Excepting(ra), new int[0]);
        Check(ra.Excepting(rb), new int[] { 0, 1, 2, 3, 4 });
        Check(rb.Excepting(rc), new int[] { 5, 6, 7, 8, 9 });
        Check(ra.Excepting(rc), new int[] { 0, 1, 2, 3, 4 });
        Check(ra.Excepting(rg), new int[] { 1, 2, 3, 4 });
        Check(rj.Excepting(rh).Excepting(rb).Excepting(rf), new int[] { 0, 2, 3, 4, 10, 11, 12, 13, 14, 15 });
        Check(rg.Excepting(rh).Excepting(ri), new int[] { 0 });

        Check(ra.EndAt(rj.Max), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 });
        Check(rf.StartAt(ra.Min), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 });
        Check(ra.UnionWith(re).MakeContiguous(), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });

        Check(ra.Add(5), new int[] { 0, 1, 2, 3, 4, 5 });
        Check(ra.Add(-1), new int[] { -1, 0, 1, 2, 3, 4 });
        Check(ra.AddRange(new int[] { 5, -1 }), new int[] { -1, 0, 1, 2, 3, 4, 5 });
        Check(ra + 5, new int[] { 0, 1, 2, 3, 4, 5 });
        Check(ra + -1, new int[] { -1, 0, 1, 2, 3, 4 });
        Check(ra + new int[] { 5, -1 }, new int[] { -1, 0, 1, 2, 3, 4, 5 });
        Check(ra + rb, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

        Check(ra.Remove(1), new int[] { 0, 2, 3, 4 });
        Check(ra.RemoveRange(new int[] { 1, 2 }), new int[] { 0, 3, 4 });
        Check(ra - 1, new int[] { 0, 2, 3, 4 });
        Check(ra - -1, new int[] { 0, 1, 2, 3, 4 });
        Check(ra - new int[] { 1, 2 }, new int[] { 0, 3, 4 });
        Check(ra - rd, new int[] { 0, 4 });

        CheckBool(ra.Equals(rk), true);
        CheckBool(ra.Equals((object)rk), true);
        CheckBool(ra == rk, true);
        CheckBool(ra != rk, false);

        CheckBool(ra.IsContiguousWith(rb), true);
        CheckBool(ra.IsContiguousWith(rc), false);
        CheckBool(ra.IsContiguousWith(rd), false);
        CheckBool(ra.IsIntersecting(rb), false);
        CheckBool(ra.IsIntersecting(rc), false);
        CheckBool(ra.IsIntersecting(rd), true);

        }
    catch (Exception ex)
        {
        outText.AppendLine($"Exception in testing: \"{ex.Message}\"");
        }
    outText.AppendLine($"Tests: {testsRun}: Passed: {testsPassed} Failed: {testsFailed}");
    return outText.ToString();
    }

/// <summary>
/// Check a boolean result
/// </summary>
/// <param name="result"></param>
/// <param name="expected"></param>
private static void CheckBool(bool result, bool expected)
    {
    testsRun++;
    if (result == expected)
        {
        testsPassed++;
        return;
        }
    ReportFailure("Logical test failed", result.ToString(), expected.ToString());
    }
/// <summary>
/// Check a integer result
/// </summary>
/// <param name="result"></param>
/// <param name="expected"></param>
private static void CheckInt(int result, int expected)
    {
    testsRun++;
    if (result == expected)
        {
        testsPassed++;
        return;
        }
    ReportFailure("Integer comparison failed", result.ToString(), expected.ToString());
    }
/// <summary>
/// Check a string result
/// </summary>
/// <param name="result"></param>
/// <param name="expected"></param>
private static void CheckString(Range range, string expected)
    {
    testsRun++;
    string strRange = range.ToString();
    if (strRange == expected)
        {
        testsPassed++;
        return;
        }
    ReportFailure("Human readable data did not match", strRange, expected);
    }
/// <summary>
/// Check a Range result
/// </summary>
/// <param name="result"></param>
/// <param name="expected"></param>
private static void Check(Range range, int[] expected)
    {
    testsRun++;
    string result = "Range length incorrect";
    if (range.Count == expected.Length)
        {
        result = "Range values did not match";
        if (Enumerable.SequenceEqual(range, expected))
            {
            testsPassed++;
            return;
            }
        }
    ReportFailure(result, range, expected);
    }
/// <summary>
/// Report a failure
/// </summary>
/// <param name="result"></param>
/// <param name="range"></param>
/// <param name="expected"></param>
private static void ReportFailure(string result, string range, string expected)
    {
    testsFailed++;
    outText.AppendLine($"Test #{testsRun}: {result} ");
    outText.AppendLine($"   Got     : {range}");
    outText.AppendLine($"   Expected: {expected}");
    }
/// <summary>
/// Report a failure
/// </summary>
/// <param name="result"></param>
/// <param name="range"></param>
/// <param name="expected"></param>
private static void ReportFailure(string result, Range range, int[] expected)
    {
    testsFailed++;
    outText.AppendLine($"Test #{testsRun}: {result} ");
    outText.AppendLine($"   Got     : {string.Join(", ", range.Select(r => r.ToString()))}");
    outText.AppendLine($"   Expected: {string.Join(", ", expected.Select(r => r.ToString()))}");
    }
}