Initial commit

MaybeErrorTests/MaybeErrorTests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MaybeError\MaybeError.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+</Project>

MaybeErrorTests/MaybeTests.cs

@@ -0,0 +1,108 @@
+using MaybeError;
+
+namespace MaybeErrorTests;
+
+public class MaybeTests
+{
+	[Test]
+	public void HasValue()
+	{
+		Maybe<string> value = "Test";
+		if (value.HasValue)
+			Assert.That(value.Value, Is.EqualTo("Test"));
+		else
+			Assert.Fail();
+		Assert.That(value.Error, Is.Null);
+	}
+
+	[Test]
+	public void HasError()
+	{
+		Maybe<string> value = new InvalidOperationException();
+		if (value.HasError)
+			Assert.That(value.Error, Is.Not.Null);
+		else
+			Assert.Fail();
+		Assert.Throws<InvalidOperationException>(() => value.Value.ToLower());
+	}
+
+	[Test]
+	public void ImplicitValue()
+	{
+		Maybe<string> value = "Test";
+		Assert.That(value == "Test", Is.True);
+	}
+
+	[Test]
+	public void ImplicitError()
+	{
+		Maybe<string> value = new InvalidOperationException();
+		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
+	}
+
+	[Test]
+	public void ExplicitError()
+	{
+		Maybe<string, ExceptionError> value = new ExceptionError(new InvalidOperationException());
+		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
+	}
+
+	[Test]
+	public void Error()
+	{
+		Maybe<string> value = new Error("Test Error");
+		Assert.Throws<Exception>(() => value.Value.ToLower());
+		Assert.That(value.HasError);
+		Assert.That(value.Error?.Message, Is.EqualTo("Test Error"));
+	}
+
+	[Test]
+	public void ValueOrDefault()
+	{
+		Maybe<string> value = "Test";
+		Assert.That(value.ValueOrDefault(), Is.EqualTo("Test"));
+
+		value = new InvalidOperationException();
+		Assert.That(value.ValueOrDefault(), Is.Null);
+	}
+
+	[Test]
+	public void ValueOrDefaultWithDefault()
+	{
+		Maybe<string> value = "Test";
+		Assert.That(value.ValueOrDefault("Err"), Is.EqualTo("Test"));
+
+		value = new InvalidOperationException();
+		Assert.That(value.ValueOrDefault("Err"), Is.EqualTo("Err"));
+	}
+
+	[Test]
+	public void As()
+	{
+		Maybe<string> value = "Test";
+		Assert.That(value.As(v => v.Length), Is.EqualTo(4));
+
+		value = new InvalidOperationException();
+		Assert.Throws<InvalidOperationException>(() => value.As(v => v.Length));
+	}
+
+	[Test]
+	public void AsOrDefault()
+	{
+		Maybe<string> value = "Test";
+		Assert.That(value.AsOrDefault(v => v.Length), Is.EqualTo(4));
+
+		value = new InvalidOperationException();
+		Assert.That(value.AsOrDefault(v => v.Length), Is.EqualTo(0));
+	}
+
+	[Test]
+	public void AsOrDefaultWithValue()
+	{
+		Maybe<string> value = "Test";
+		Assert.That(value.AsOrDefault(v => v.Length, -4), Is.EqualTo(4));
+
+		value = new InvalidOperationException();
+		Assert.That(value.AsOrDefault(v => v.Length, -4), Is.EqualTo(-4));
+	}
+}

MaybeErrorTests/ValueMaybeTests.cs

@@ -0,0 +1,108 @@
+using MaybeError;
+
+namespace MaybeErrorTests;
+
+public class ValueMaybeTests
+{
+	[Test]
+	public void HasValue()
+	{
+		ValueMaybe<int> value = 1;
+		if(value.HasValue)
+			Assert.That(value.Value, Is.EqualTo(1));
+		else
+			Assert.Fail();
+		Assert.That(value.Error, Is.Null);
+	}
+
+	[Test]
+	public void HasError()
+	{
+		ValueMaybe<int> value = new InvalidOperationException();
+		if (value.HasError)
+			Assert.That(value.Error, Is.Not.Null);
+		else
+			Assert.Fail();
+		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
+	}
+
+	[Test]
+	public void ImplicitValue()
+	{
+		ValueMaybe<int> value = 1;
+		Assert.That(value == 1, Is.True);
+	}
+
+	[Test]
+	public void ImplicitError()
+	{
+		ValueMaybe<int> value = new InvalidOperationException();
+		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
+	}
+
+	[Test]
+	public void ExplicitError()
+	{
+		ValueMaybe<int, ExceptionError> value = new ExceptionError(new InvalidOperationException());
+		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
+	}
+
+	[Test]
+	public void Error()
+	{
+		ValueMaybe<int> value = new Error("Test Error");
+		Assert.Throws<Exception>(() => value.Value.ToString());
+		Assert.That(value.HasError);
+		Assert.That(value.Error?.Message, Is.EqualTo("Test Error"));
+	}
+
+	[Test]
+	public void ValueOrDefault()
+	{
+		ValueMaybe<int> value = 1;
+		Assert.That(value.ValueOrDefault(), Is.EqualTo(1));
+
+		value = new InvalidOperationException();
+		Assert.That(value.ValueOrDefault(), Is.Null);
+	}
+
+	[Test]
+	public void ValueOrDefaultWithDefault()
+	{
+		ValueMaybe<int> value = 1;
+		Assert.That(value.ValueOrDefault(3), Is.EqualTo(1));
+
+		value = new InvalidOperationException();
+		Assert.That(value.ValueOrDefault(3), Is.EqualTo(3));
+	}
+
+	[Test]
+	public void As()
+	{
+		ValueMaybe<int> value = 1;
+		Assert.That(value.As(v => v.ToString()), Is.EqualTo("1"));
+
+		value = new InvalidOperationException();
+		Assert.Throws<InvalidOperationException>(() => value.As(v => v.ToString()));
+	}
+
+	[Test]
+	public void AsOrDefault()
+	{
+		ValueMaybe<int> value = 1;
+		Assert.That(value.AsOrDefault(v => v.ToString()), Is.EqualTo("1"));
+
+		value = new InvalidOperationException();
+		Assert.That(value.AsOrDefault(v => v.ToString()), Is.Null);
+	}
+
+	[Test]
+	public void AsOrDefaultWithValue()
+	{
+		ValueMaybe<int> value = 1;
+		Assert.That(value.AsOrDefault(v => v.ToString(), "err"), Is.EqualTo("1"));
+
+		value = new InvalidOperationException();
+		Assert.That(value.AsOrDefault(v => v.ToString(), "err"), Is.EqualTo("err"));
+	}
+}