Amatsugu/MaybeError
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added Map and MapError
All checks were successful
.NET / build (push) Successful in 34s
Details

Browse Source
This commit is contained in:
Amatsugu
2025-08-18 09:59:04 -04:00
parent d2fe7edbce
commit 77396d252e
16 changed files with 1590 additions and 1490 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
MaybeErrorTests/MaybeErrorTests.csproj
View File

@@ -1,28 +1,28 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net9.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>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net9.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>

270
MaybeErrorTests/MaybeTests.cs
View File

@@ -1,118 +1,154 @@
using MaybeError;
using MaybeError.Errors;
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.Multiple(() =>
{
Assert.That(value.HasValue);
Assert.That(value == "Test", Is.True);
});
}
[Test]
public void ImplicitError()
{
Maybe<string> value = new InvalidOperationException();
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void ExplicitError()
{
Maybe<string, ExceptionError> value = new ExceptionError(new InvalidOperationException());
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void Error()
{
Maybe<string> value = new Error("Test Error");
Assert.Throws<Exception>(() => value.Value.ToLower());
Assert.Multiple(() =>
{
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));
}
using MaybeError;
using MaybeError.Errors;
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.Multiple(() =>
{
Assert.That(value.HasValue);
Assert.That(value == "Test", Is.True);
});
}
[Test]
public void ImplicitError()
{
Maybe<string> value = new InvalidOperationException();
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void ExplicitError()
{
Maybe<string, ExceptionError> value = new ExceptionError(new InvalidOperationException());
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void Error()
{
Maybe<string> value = new Error("Test Error");
Assert.Throws<Exception>(() => value.Value.ToLower());
Assert.Multiple(() =>
{
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));
}
[Test]
public void MapTest()
{
Maybe<string> value = "Test";
var valueMapped = value.Map(v => $"A{v}");
Assert.That(valueMapped.HasValue, Is.True);
Assert.That(valueMapped.Value, Is.EqualTo("ATest"));
}
[Test]
public void MapTestError()
{
Maybe<string> value = new Error("Err");
var valueMapped = value.Map(v => $"A{v}");
Assert.That(valueMapped.HasError, Is.True);
}
[Test]
public void MapErrorTest()
{
Maybe<string> value = "Test";
var valueMapped = value.MapError(v => new Error($"A{v}"));
Assert.That(valueMapped.HasValue, Is.True);
Assert.That(valueMapped.Value, Is.EqualTo("Test"));
}
[Test]
public void MapErrorTestError()
{
Maybe<string> value = new Error("Err");
var valueMapped = value.MapError(v => new Error($"A{v.Message}"));
Assert.That(valueMapped.HasError, Is.True);
Assert.That(valueMapped.Error!.Message, Is.EqualTo("AErr"));
}
}

270
MaybeErrorTests/ValueMaybeTests.cs
View File

@@ -1,118 +1,154 @@
using MaybeError;
using MaybeError.Errors;
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.Multiple(() =>
{
Assert.That(value.HasValue);
Assert.That(value == 1, Is.True);
});
}
[Test]
public void ImplicitError()
{
ValueMaybe<int> value = new InvalidOperationException();
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void ExplicitError()
{
ValueMaybe<int, ExceptionError> value = new ExceptionError(new InvalidOperationException());
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void Error()
{
ValueMaybe<int> value = new Error("Test Error");
Assert.Throws<Exception>(() => value.Value.ToString());
Assert.Multiple(() =>
{
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"));
}
using MaybeError;
using MaybeError.Errors;
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.Multiple(() =>
{
Assert.That(value.HasValue);
Assert.That(value == 1, Is.True);
});
}
[Test]
public void ImplicitError()
{
ValueMaybe<int> value = new InvalidOperationException();
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void ExplicitError()
{
ValueMaybe<int, ExceptionError> value = new ExceptionError(new InvalidOperationException());
Assert.That(value.HasError);
Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
}
[Test]
public void Error()
{
ValueMaybe<int> value = new Error("Test Error");
Assert.Throws<Exception>(() => value.Value.ToString());
Assert.Multiple(() =>
{
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"));
}
[Test]
public void MapTest()
{
ValueMaybe<int> value = 1;
var valueMapped = value.Map(v => v + 1);
Assert.That(valueMapped.HasValue, Is.True);
Assert.That(valueMapped.Value, Is.EqualTo(2));
}
[Test]
public void MapTestError()
{
ValueMaybe<int> value = new Error("Err");
var valueMapped = value.Map(v => v + 1);
Assert.That(valueMapped.HasError, Is.True);
}
[Test]
public void MapErrorTest()
{
Maybe<int> value = 1;
var valueMapped = value.MapError(v => new Error($"A{v}"));
Assert.That(valueMapped.HasValue, Is.True);
Assert.That(valueMapped.Value, Is.EqualTo(1));
}
[Test]
public void MapErrorTestError()
{
ValueMaybe<int> value = new Error("Err");
var valueMapped = value.MapError(v => new Error($"A{v.Message}"));
Assert.That(valueMapped.HasError, Is.True);
Assert.That(valueMapped.Error!.Message, Is.EqualTo("AErr"));
}
}