jussi/DotTiled
1
0
Fork 0
mirror of https://github.com/dcronqvist/DotTiled.git synced 2025-02-05 08:52:50 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add FromEnum to CustomEnumDefinition with tests

Browse source
This commit is contained in:
Daniel Cronqvist 2024-09-07 13:16:29 +02:00
parent 58b0ad3493
commit 0a77a9fec7
3 changed files with 149 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

203
src/DotTiled.Tests/OptionalTests.cs
View file

@ -1,208 +1,5 @@
namespace DotTiled.Tests;
// public class OptionalTests
// {
// [Fact]
// public void HasValue_WhenValueIsSet_ReturnsTrue()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act & Assert
// Assert.True(optional.HasValue);
// }
// [Fact]
// public void HasValue_WhenValueIsNotSet_ReturnsFalse()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act & Assert
// Assert.False(optional.HasValue);
// }
// [Fact]
// public void Value_WhenValueIsSet_ReturnsValue()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var value = optional.Value;
// // Assert
// Assert.Equal(42, value);
// }
// [Fact]
// public void Value_WhenValueIsNotSet_ThrowsInvalidOperationException()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act & Assert
// _ = Assert.Throws<InvalidOperationException>(() => optional.Value);
// }
// [Fact]
// public void ImplicitConversionFromValue_CreatesOptionalWithValue()
// {
// // Arrange
// Optional<int> optional = 42;
// // Act & Assert
// Assert.True(optional.HasValue);
// Assert.Equal(42, optional.Value);
// }
// [Fact]
// public void ImplicitConversionToValue_ReturnsValue()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// int value = optional;
// // Assert
// Assert.Equal(42, value);
// }
// [Fact]
// public void ToString_WhenValueIsSet_ReturnsValueToString()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.ToString();
// // Assert
// Assert.Equal("42", result);
// }
// [Fact]
// public void ToString_WhenValueIsNotSet_ReturnsEmpty()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act
// var result = optional.ToString();
// // Assert
// Assert.Equal("Empty", result);
// }
// [Fact]
// public void Equals_WithObject_ReturnsTrueWhenValueIsEqual()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.Equals(42);
// // Assert
// Assert.True(result);
// }
// [Fact]
// public void Equals_WithObject_ReturnsFalseWhenValueIsNotEqual()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.Equals(43);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void Equals_WithObject_ReturnsFalseWhenValueIsNotSet()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act
// var result = optional.Equals(42);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void Equals_WithOptional_ReturnsTrueWhenValueIsEqual()
// {
// // Arrange
// var optional1 = new Optional<int>(42);
// var optional2 = new Optional<int>(42);
// // Act
// var result = optional1.Equals(optional2);
// // Assert
// Assert.True(result);
// }
// [Fact]
// public void Equals_WithOptional_ReturnsFalseWhenValueIsNotEqual()
// {
// // Arrange
// var optional1 = new Optional<int>(42);
// var optional2 = new Optional<int>(43);
// // Act
// var result = optional1.Equals(optional2);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void Equals_WithOptional_ReturnsFalseWhenValueIsNotSet()
// {
// // Arrange
// var optional1 = new Optional<int>();
// var optional2 = new Optional<int>(42);
// // Act
// var result = optional1.Equals(optional2);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void GetHashCode_WhenValueIsSet_ReturnsValueHashCode()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.GetHashCode();
// // Assert
// Assert.Equal(42.GetHashCode(), result);
// }
// [Fact]
// public void GetHashCode_WhenValueIsNotSet_ReturnsZero()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act
// var result = optional.GetHashCode();
// // Assert
// Assert.Equal(0, result);
// }
// }
public class OptionalTests
{
// Constructor Tests

110
src/DotTiled.Tests/Properties/CustomTypes/CustomEnumDefinitionTests.cs
View file

@ -0,0 +1,110 @@
namespace DotTiled.Tests;
public class CustomEnumDefinitionTests
{
private static void AssertCustomEnumDefinitionEqual(CustomEnumDefinition expected, CustomEnumDefinition actual)
{
DotTiledAssert.AssertEqual(expected.ID, actual.ID, nameof(CustomEnumDefinition.ID));
DotTiledAssert.AssertEqual(expected.Name, actual.Name, nameof(CustomEnumDefinition.Name));
DotTiledAssert.AssertEqual(expected.StorageType, actual.StorageType, nameof(CustomEnumDefinition.StorageType));
DotTiledAssert.AssertEqual(expected.ValueAsFlags, actual.ValueAsFlags, nameof(CustomEnumDefinition.ValueAsFlags));
DotTiledAssert.AssertListOrdered(expected.Values, actual.Values, nameof(CustomEnumDefinition.Values));
}
[Fact]
public void FromEnum_Type_WhenTypeIsNotEnum_ThrowsArgumentException()
{
// Arrange
var type = typeof(string);
// Act & Assert
Assert.Throws<ArgumentException>(() => CustomEnumDefinition.FromEnum(type));
}
private enum TestEnum1 { Value1, Value2, Value3 }
[Fact]
public void FromEnum_Type_WhenTypeIsEnum_ReturnsCustomEnumDefinition()
{
// Arrange
var type = typeof(TestEnum1);
var expected = new CustomEnumDefinition
{
ID = 0,
Name = "TestEnum1",
StorageType = CustomEnumStorageType.Int,
Values = ["Value1", "Value2", "Value3"],
ValueAsFlags = false
};
// Act
var result = CustomEnumDefinition.FromEnum(type);
// Assert
AssertCustomEnumDefinitionEqual(expected, result);
}
[Flags]
private enum TestEnum2 { Value1, Value2, Value3 }
[Fact]
public void FromEnum_Type_WhenEnumIsFlags_ReturnsCustomEnumDefinition()
{
// Arrange
var type = typeof(TestEnum2);
var expected = new CustomEnumDefinition
{
ID = 0,
Name = "TestEnum2",
StorageType = CustomEnumStorageType.Int,
Values = ["Value1", "Value2", "Value3"],
ValueAsFlags = true
};
// Act
var result = CustomEnumDefinition.FromEnum(type);
// Assert
AssertCustomEnumDefinitionEqual(expected, result);
}
[Fact]
public void FromEnum_T_WhenTypeIsEnum_ReturnsCustomEnumDefinition()
{
// Arrange
var expected = new CustomEnumDefinition
{
ID = 0,
Name = "TestEnum1",
StorageType = CustomEnumStorageType.Int,
Values = ["Value1", "Value2", "Value3"],
ValueAsFlags = false
};
// Act
var result = CustomEnumDefinition.FromEnum<TestEnum1>();
// Assert
AssertCustomEnumDefinitionEqual(expected, result);
}
[Fact]
public void FromEnum_T_WhenEnumIsFlags_ReturnsCustomEnumDefinition()
{
// Arrange
var expected = new CustomEnumDefinition
{
ID = 0,
Name = "TestEnum2",
StorageType = CustomEnumStorageType.Int,
Values = ["Value1", "Value2", "Value3"],
ValueAsFlags = true
};
// Act
var result = CustomEnumDefinition.FromEnum<TestEnum2>();
// Assert
AssertCustomEnumDefinitionEqual(expected, result);
}
}

43
src/DotTiled/Properties/CustomTypes/CustomEnumDefinition.cs
View file

@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace DotTiled;
@ -46,8 +47,42 @@ public class CustomEnumDefinition : ICustomTypeDefinition
/// </summary>
public bool ValueAsFlags { get; set; }
// public CustomEnumDefinition FromEnum(Type enumType)
// {
// if (!enumType.Is)
// }
/// <summary>
/// Creates a custom enum definition from the specified enum type.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static CustomEnumDefinition FromEnum<T>() where T : Enum
{
var type = typeof(T);
var isFlags = type.GetCustomAttributes(typeof(FlagsAttribute), false).Length != 0;
return new CustomEnumDefinition
{
Name = type.Name,
StorageType = CustomEnumStorageType.Int,
Values = Enum.GetNames(type).ToList(),
ValueAsFlags = isFlags
};
}
/// <summary>
/// Creates a custom enum definition from the specified enum type.
/// </summary>
/// <returns></returns>
public static CustomEnumDefinition FromEnum(Type type)
{
if (!type.IsEnum)
throw new ArgumentException("Type must be an enum.", nameof(type));
var isFlags = type.GetCustomAttributes(typeof(FlagsAttribute), false).Length != 0;
return new CustomEnumDefinition
{
Name = type.Name,
StorageType = CustomEnumStorageType.Int,
Values = Enum.GetNames(type).ToList(),
ValueAsFlags = isFlags
};
}
}