Seasons of Love - Ode to C#

MyLove loveOfCSharp = "CSharp";
var howDoILoveThee = loveOfCSharp.AllTheWays.Count();

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using Xunit;
using Shouldly;
					
public class OdeToCSharp
{
    public static void Main() {
        MyLove loveOfCSharp = "CSharp";
        var howDoILoveThee = loveOfCSharp.AllTheWays.Count();
        Console.WriteLine($"{ nameof(howDoILoveThee).ToWords() } ({ loveOfCSharp })? Ways = { howDoILoveThee }");

		// Run all unit tests with a crude test runner
		var allTestsSucceeded = RunUnitTests<AdventTests>();
		
		Console.WriteLine(allTestsSucceeded ? "All tests passed!" : "Test failures occurred");
    }
	
	private static bool RunUnitTests<T>() where T: class, new()
	{
		bool overallSuccess = true;
		var tests = new T();
		var testMethods = tests
			.GetType()
			.GetMethods(BindingFlags.Public | BindingFlags.Instance)
			.Where(mi => mi.ReturnType == typeof(void))
			.Where(mi => mi.GetCustomAttributes<Xunit.FactAttribute>(inherit: false).Any())
			.ToArray();
		
		foreach(var testMethodInfo in testMethods)
		{
			var testMethodName = testMethodInfo.Name;
			Console.Write($"Executing test { testMethodName }...");
			try
			{
				testMethodInfo.Invoke(tests, new object[] {});
				
				Console.WriteLine("PASSED!");
			}
			catch(Exception ex)
			{
				overallSuccess = false;
				Console.WriteLine($"FAILED - {ex}");
			}
		}
		
		return overallSuccess;
	}
}

public class MyLove: IComparable<MyLove>
{
	private const string SIGN_OF_LOVE = "<3!";
    private const int MAX_LOVE = 1000;

    private enum MyDeclaredLoves: int
    {
        God = 0,
        Spouse = -1,
        Children = -2,
        RestOfFamily = - 3,
        Friends = - 4,
        CSharp = Friends - 1,
        Bacon = CSharp - 1,
        AllOtherThings = CSharp - 10
    }

    private string _thingILove;
    private int _howFarDownTheList;
	private MyDeclaredLoves _levelOfLove;

    public IEnumerable<string> AllTheWays => Enumerable.Repeat(SIGN_OF_LOVE, MAX_LOVE + _howFarDownTheList).ToArray();

    public IEnumerable<string> ThingsILoveMore => 
		typeof(MyDeclaredLoves)
		    .GetEnumValuesDictionary<MyDeclaredLoves>()
            .Where(kvp => ((int)kvp.Value) > _howFarDownTheList)
            .Select(kvp => $"{kvp.Key}")
			.ToArray();

    public MyLove(string thingILove)
    {
        _thingILove = thingILove;
        _howFarDownTheList = DetermineWhereOnTheList(_thingILove, out _levelOfLove);
    }

    private int DetermineWhereOnTheList(string thingIMightLove, out MyDeclaredLoves levelOfLove)
    {
        if(!MyDeclaredLoves.TryParse(thingIMightLove, out levelOfLove))
			levelOfLove = MyDeclaredLoves.AllOtherThings;
        return (int)levelOfLove;
    }

    public MyLove(object objectOfAffection): this($"{objectOfAffection}") {}

    public override string ToString() { return $"my love of {_thingILove}"; }

	int IComparable<MyLove>.CompareTo(MyLove otherLove) { return this._howFarDownTheList.CompareTo(otherLove._howFarDownTheList); }

    public static implicit operator MyLove(string thingILove) { return new MyLove(thingILove); }
	
	public static bool operator >(MyLove firstLove, MyLove secondLove)
	{
		return ((IComparable<MyLove>)firstLove).CompareTo(secondLove) > 0;
	}

	public static bool operator <(MyLove firstLove, MyLove secondLove)
	{
		return ((IComparable<MyLove>)firstLove).CompareTo(secondLove) < 0;
	}
	
	public static bool operator ==(MyLove firstLove, MyLove secondLove)
	{
		return ((IComparable<MyLove>)firstLove).CompareTo(secondLove) == 0;
	}
	
	public static bool operator !=(MyLove firstLove, MyLove secondLove)
	{
		return ((IComparable<MyLove>)firstLove).CompareTo(secondLove) != 0;
	}
	
	public override int GetHashCode() => _thingILove.GetHashCode();
	public override bool Equals(object o) { return this.GetHashCode() == o.GetHashCode(); }
	
	public static explicit operator int(MyLove love) => (int)love._levelOfLove;
}

public static class AdventExtensions
{
    public static string ToWords(this string instance) {
		// a crude word splitter using look behind and look ahead
        return string.Join(" ", Regex.Split(instance ?? "", @"(?<=[^A-Z]|I)(?=[A-Z])"));
    }

    public static IEnumerable<string> HowDoILoveThee(this string objectOfAffection)
    {
        MyLove waysILoveThee = objectOfAffection;
        var result = waysILoveThee.AllTheWays;
        return result;
    }
	
	public static IDictionary<string, object> GetEnumValuesDictionary<T>(this Type type) where T: System.Enum
	{
		return type
			.GetFields()
			.Where(f => f.IsLiteral)
			.ToDictionary(f => f.Name, f => f.GetRawConstantValue());
	}
	
	public static IEnumerable<T> Dump<T>(this IEnumerable<T> source, string title = null, bool includeTypeInfo = false)
	{
		// Note (JM, 12/07/2023): This method is inspired by LINQPad's super useful Dump() method that allows
		// outputting just about anything, then returns to "regularly-scheduled" programming
		if(!string.IsNullOrEmpty(title))
		{
			Console.WriteLine($"# { title }");
		}
		if(includeTypeInfo)
		{
			Console.WriteLine($"[{ typeof(T).FullName }]");
		}
		if(((object)source) == null)
		{
			Console.WriteLine("[null]");
			return source;
		}
		Type type = typeof(T);
		if(type.IsAssignableTo(typeof(IEnumerable)))
		{
			var items = ((IEnumerable)source).Cast<object>().Select(i=>$"{i}");
			Console.WriteLine("[" + string.Join("," + Environment.NewLine, items) + "]");
		}
		else
		{
			Console.WriteLine($"VALUE = {source}");
		}
		return source;
	}
}

public class AdventTests
{
	private const string YES_I_COULD_USE_A_CONSTANT_FOR_CSHARP = "CSharp";
	private const string BACON_IS_DEFINITELY_A_CONSTANT_DUH = "Bacon";
	
    [Fact]
    public void OdeToMyLove_WaysILoveCSharpIsNotZero()
    {
        var ways = "CSharp".HowDoILoveThee().Count();
        ways.ShouldBeGreaterThan(0);
    }

    [Fact]
    public void OdeToMyLove_LoveCSharpShouldExceed500()
    {
        var ways = "CSharp".HowDoILoveThee().Count();
        ways.ShouldBeGreaterThan(500);
    }

    [Fact]
    public void OdeToMyLove_WaysILoveCSharpExceedsWaysILoveBacon_ShockingIKnow()
    {
        var waysILoveCSharp = YES_I_COULD_USE_A_CONSTANT_FOR_CSHARP.HowDoILoveThee().Count();
        var waysILoveBacon = BACON_IS_DEFINITELY_A_CONSTANT_DUH.HowDoILoveThee().Count();
        waysILoveCSharp.ShouldBeGreaterThan(waysILoveBacon);
    }
  
    [Fact]
    public void OdeToMyLove_ILoveGodSpouseChildrenAndFriendsMoreThanBaconAndCSharpButItsClose()
    {
        var thingsILoveMore = new []{ "God", "Spouse", "Children", "Friends" };
        var nearTheTopButNotAsFar = new[]{ "Bacon", "CSharp" };

		var wrongPriorities = thingsILoveMore
			.Select(t => (MyLove)t)
			.SelectMany(l => l.ThingsILoveMore.Dump(title: $"Things I love more than {l}"))
			.Dump(title: "All the things I love more...")
			.Intersect(nearTheTopButNotAsFar.Dump(title: "Things near the top, but not as far ="))
			.ToArray()
			.Dump(title: "Intersection");
		
		wrongPriorities.ShouldBeEmpty();
    }
	
	[Fact]
	public void OdeToMyLove_ILoveCSharpMoreThanBacon()
	{
		MyLove loveOfCSharp = "CSharp";
		MyLove loveOfBacon = "Bacon";
		
		(loveOfCSharp > loveOfBacon).ShouldBeTrue();
	}
	
	[Fact]
	public void OdeToMyLove_ILoveOtherThingsAboutTheSame()
	{
		MyLove firstRandomLove = "IceCream";
		MyLove secondRandomLove = "VideoGames";
		
		(firstRandomLove == secondRandomLove).ShouldBeTrue();
	}
	
	[Fact]
	public void OdeToMyLove_ThingsILoveMoreThanGodShouldBeEmpty()
	{
		MyLove loveForGod = "God";
		loveForGod.ThingsILoveMore.Dump(title: "Things I love more than God").ShouldBeEmpty();
	}
	
	[Fact]
	public void ToWords_CamelCaseIdentifier_SplitsCorrectly()
	{
		string expectedValue = "expected Value";
		string howDoILoveThee = "how Do I Love Thee";
		
		(nameof(expectedValue)).ToWords().ShouldBe(expectedValue);
		
		(nameof(howDoILoveThee)).ToWords().ShouldBe(howDoILoveThee);
	}
}