icdsystems/ICD.Common.Utils
1
0
Fork 0
mirror of https://github.com/ICDSystems/ICD.Common.Utils.git synced 2026-02-11 18:54:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Extension methods for determining if a type is numeric

Browse Source
This commit is contained in:
Chris Cameron
2017-11-17 11:38:01 -05:00
parent 4f46a3ebda
commit 546cabf0b4
2 changed files with 172 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
ICD.Common.Utils.Tests/Extensions/TypeExtensionsTest.cs
View File

@@ -5,61 +5,112 @@ using NUnit.Framework;
namespace ICD.Common.Utils.Tests.Extensions
{
[TestFixture]
public sealed class TypeExtensionsTest
{
[Test]
public void IsAssignableToTest()
{
Assert.IsTrue(typeof(string).IsAssignableTo(typeof(object)));
Assert.IsFalse(typeof(object).IsAssignableTo(typeof(string)));
}
[TestFixture]
public sealed class TypeExtensionsTest
{
[TestCase(typeof(byte), true)]
[TestCase(typeof(decimal), true)]
[TestCase(typeof(double), true)]
[TestCase(typeof(float), true)]
[TestCase(typeof(int), true)]
[TestCase(typeof(long), true)]
[TestCase(typeof(sbyte), true)]
[TestCase(typeof(short), true)]
[TestCase(typeof(uint), true)]
[TestCase(typeof(ulong), true)]
[TestCase(typeof(ushort), true)]
[TestCase(typeof(string), false)]
public void IsNumericTest(Type value, bool expected)
{
Assert.AreEqual(expected, value.IsNumeric());
}
[Test]
public void GetAllTypesTest()
{
Type[] allTypes = typeof(B).GetAllTypes().ToArray();
[TestCase(typeof(byte), false)]
[TestCase(typeof(decimal), true)]
[TestCase(typeof(double), true)]
[TestCase(typeof(float), true)]
[TestCase(typeof(int), true)]
[TestCase(typeof(long), true)]
[TestCase(typeof(sbyte), true)]
[TestCase(typeof(short), true)]
[TestCase(typeof(uint), false)]
[TestCase(typeof(ulong), false)]
[TestCase(typeof(ushort), false)]
[TestCase(typeof(string), false)]
public void IsSignedNumericTest(Type value, bool expected)
{
Assert.AreEqual(expected, value.IsSignedNumeric());
}
Assert.AreEqual(6, allTypes.Length);
[TestCase(typeof(byte), false)]
[TestCase(typeof(decimal), true)]
[TestCase(typeof(double), true)]
[TestCase(typeof(float), true)]
[TestCase(typeof(int), false)]
[TestCase(typeof(long), false)]
[TestCase(typeof(sbyte), false)]
[TestCase(typeof(short), false)]
[TestCase(typeof(uint), false)]
[TestCase(typeof(ulong), false)]
[TestCase(typeof(ushort), false)]
[TestCase(typeof(string), false)]
public void IsDecimalNumericTest(Type value, bool expected)
{
Assert.AreEqual(expected, value.IsDecimalNumeric());
}
Assert.IsTrue(allTypes.Contains(typeof(E)));
Assert.IsTrue(allTypes.Contains(typeof(D)));
Assert.IsTrue(allTypes.Contains(typeof(C)));
Assert.IsTrue(allTypes.Contains(typeof(B)));
Assert.IsTrue(allTypes.Contains(typeof(A)));
Assert.IsTrue(allTypes.Contains(typeof(object)));
}
[TestCase(typeof(string), typeof(object), true)]
[TestCase(typeof(object), typeof(string), false)]
public void IsAssignableToTest(Type a, Type b, bool expected)
{
Assert.AreEqual(expected, a.IsAssignableTo(b));
}
[Test]
public void GetBaseTypesTest()
{
Type[] baseTypes = typeof(B).GetBaseTypes().ToArray();
[Test]
public void GetAllTypesTest()
{
Type[] allTypes = typeof(B).GetAllTypes().ToArray();
Assert.AreEqual(2, baseTypes.Length);
Assert.AreEqual(6, allTypes.Length);
Assert.IsFalse(baseTypes.Contains(typeof(B)));
Assert.IsTrue(baseTypes.Contains(typeof(A)));
Assert.IsTrue(baseTypes.Contains(typeof(object)));
}
Assert.IsTrue(allTypes.Contains(typeof(E)));
Assert.IsTrue(allTypes.Contains(typeof(D)));
Assert.IsTrue(allTypes.Contains(typeof(C)));
Assert.IsTrue(allTypes.Contains(typeof(B)));
Assert.IsTrue(allTypes.Contains(typeof(A)));
Assert.IsTrue(allTypes.Contains(typeof(object)));
}
private interface C
{
}
[Test]
public void GetBaseTypesTest()
{
Type[] baseTypes = typeof(B).GetBaseTypes().ToArray();
private interface D
{
}
Assert.AreEqual(2, baseTypes.Length);
private interface E : C, D
{
}
Assert.IsFalse(baseTypes.Contains(typeof(B)));
Assert.IsTrue(baseTypes.Contains(typeof(A)));
Assert.IsTrue(baseTypes.Contains(typeof(object)));
}
private class A
{
}
private interface C
{
}
private class B : A, E
{
}
}
}
private interface D
{
}
private interface E : C, D
{
}
private class A
{
}
private class B : A, E
{
}
}
}

75
ICD.Common.Utils/Extensions/TypeExtensions.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using ICD.Common.Utils.Collections;
#if SIMPLSHARP
using Crestron.SimplSharp.Reflection;
#else
@@ -10,6 +11,78 @@ namespace ICD.Common.Utils.Extensions
{
public static class TypeExtensions
{
private static readonly IcdHashSet<Type> s_NumericTypes = new IcdHashSet<Type>
{
typeof(byte),
typeof(decimal),
typeof(double),
typeof(float),
typeof(int),
typeof(long),
typeof(sbyte),
typeof(short),
typeof(uint),
typeof(ulong),
typeof(ushort)
};
private static readonly IcdHashSet<Type> s_SignedNumericTypes = new IcdHashSet<Type>
{
typeof(decimal),
typeof(double),
typeof(float),
typeof(int),
typeof(long),
typeof(sbyte),
typeof(short),
};
private static readonly IcdHashSet<Type> s_DecimalNumericTypes = new IcdHashSet<Type>
{
typeof(decimal),
typeof(double),
typeof(float),
};
/// <summary>
/// Returns true if the given type is a numeric type.
/// </summary>
/// <param name="extends"></param>
/// <returns></returns>
public static bool IsNumeric(this Type extends)
{
if (extends == null)
throw new ArgumentException("extends");
return s_NumericTypes.Contains(extends);
}
/// <summary>
/// Returns true if the given type is a signed numeric type.
/// </summary>
/// <param name="extends"></param>
/// <returns></returns>
public static bool IsSignedNumeric(this Type extends)
{
if (extends == null)
throw new ArgumentException("extends");
return s_SignedNumericTypes.Contains(extends);
}
/// <summary>
/// Returns true if the given type is a non-integer numeric type.
/// </summary>
/// <param name="extends"></param>
/// <returns></returns>
public static bool IsDecimalNumeric(this Type extends)
{
if (extends == null)
throw new ArgumentException("extends");
return s_DecimalNumericTypes.Contains(extends);
}
public static Assembly GetAssembly(this Type extends)
{
if (extends == null)
@@ -68,7 +141,7 @@ namespace ICD.Common.Utils.Extensions
{
extends = extends
#if !SIMPLSHARP
.GetTypeInfo()
.GetTypeInfo()
#endif
.BaseType;