Add IsAssignableFrom and IsNotAssignableFrom type assertions

TUnit.Assertions/Assertions/PropertyAssertion.cs

@@ -133,6 +133,18 @@ public IsNotAssignableToAssertion<TTarget, TObject> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, TObject>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, TObject> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, TObject>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, TObject> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, TObject>(Context);
+    }
+
     /// <summary>
     /// Asserts that the parent object is NOT of the specified type.
     /// Example: await Assert.That(obj).HasProperty(x => x.Name).IsEqualTo("test").IsNotTypeOf<BaseClass>();

TUnit.Assertions/Assertions/Strings/ParseAssertions.cs

@@ -265,6 +265,18 @@ public IsNotAssignableToAssertion<TTarget, T> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, T>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, T> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, T>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, T> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, T>(Context);
+    }
+
     /// <summary>
     /// Asserts that the parsed value is NOT of the specified type.
     /// Example: await Assert.That("123").WhenParsedInto<object>().IsNotTypeOf<string>();

TUnit.Assertions/Conditions/ListAssertions.cs

@@ -158,6 +158,20 @@ public IsNotAssignableToAssertion<TExpected, TItem> IsNotAssignableTo<TExpected>
         Context.ExpressionBuilder.Append($".IsNotAssignableTo<{typeof(TExpected).Name}>()");
         return new IsNotAssignableToAssertion<TExpected, TItem>(Context);
     }
+
+    /// <inheritdoc />
+    public IsAssignableFromAssertion<TExpected, TItem> IsAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsAssignableFromAssertion<TExpected, TItem>(Context);
+    }
+
+    /// <inheritdoc />
+    public IsNotAssignableFromAssertion<TExpected, TItem> IsNotAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsNotAssignableFromAssertion<TExpected, TItem>(Context);
+    }
 }
 
 /// <summary>
@@ -259,6 +273,20 @@ public IsNotAssignableToAssertion<TExpected, TItem> IsNotAssignableTo<TExpected>
         Context.ExpressionBuilder.Append($".IsNotAssignableTo<{typeof(TExpected).Name}>()");
         return new IsNotAssignableToAssertion<TExpected, TItem>(Context);
     }
+
+    /// <inheritdoc />
+    public IsAssignableFromAssertion<TExpected, TItem> IsAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsAssignableFromAssertion<TExpected, TItem>(Context);
+    }
+
+    /// <inheritdoc />
+    public IsNotAssignableFromAssertion<TExpected, TItem> IsNotAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsNotAssignableFromAssertion<TExpected, TItem>(Context);
+    }
 }
 
 /// <summary>

TUnit.Assertions/Conditions/MemberAssertion.cs

@@ -169,6 +169,18 @@ public IsNotAssignableToAssertion<TTarget, T> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, T>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, T> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, T>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, T> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, T>(Context);
+    }
+
     /// <summary>
     /// Asserts that the value is NOT of the specified type.
     /// Example: await Assert.That(obj).Member(x => x.Property).Satisfies(val => val.IsNotTypeOf<int>());

TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs

@@ -160,6 +160,20 @@ public IsNotAssignableToAssertion<TExpected, TItem> IsNotAssignableTo<TExpected>
         Context.ExpressionBuilder.Append($".IsNotAssignableTo<{typeof(TExpected).Name}>()");
         return new IsNotAssignableToAssertion<TExpected, TItem>(Context);
     }
+
+    /// <inheritdoc />
+    public IsAssignableFromAssertion<TExpected, TItem> IsAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsAssignableFromAssertion<TExpected, TItem>(Context);
+    }
+
+    /// <inheritdoc />
+    public IsNotAssignableFromAssertion<TExpected, TItem> IsNotAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsNotAssignableFromAssertion<TExpected, TItem>(Context);
+    }
 }
 
 /// <summary>
@@ -261,6 +275,20 @@ public IsNotAssignableToAssertion<TExpected, TItem> IsNotAssignableTo<TExpected>
         Context.ExpressionBuilder.Append($".IsNotAssignableTo<{typeof(TExpected).Name}>()");
         return new IsNotAssignableToAssertion<TExpected, TItem>(Context);
     }
+
+    /// <inheritdoc />
+    public IsAssignableFromAssertion<TExpected, TItem> IsAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsAssignableFromAssertion<TExpected, TItem>(Context);
+    }
+
+    /// <inheritdoc />
+    public IsNotAssignableFromAssertion<TExpected, TItem> IsNotAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsNotAssignableFromAssertion<TExpected, TItem>(Context);
+    }
 }
 
 /// <summary>

TUnit.Assertions/Conditions/TypeOfAssertion.cs

@@ -190,6 +190,106 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TValue> m
     protected override string GetExpectation() => $"to not be assignable to {_targetType.Name}";
 }
 
+/// <summary>
+/// Asserts that a value's type is assignable from a specific type (the value's type is a base type or same as TTarget).
+/// Works with both direct value assertions and exception assertions (via .And after Throws).
+/// </summary>
+public class IsAssignableFromAssertion<TTarget, TValue> : Assertion<TValue>
+{
+    private readonly Type _targetType;
+
+    public IsAssignableFromAssertion(
+        AssertionContext<TValue> context)
+        : base(context)
+    {
+        _targetType = typeof(TTarget);
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TValue> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        object? objectToCheck = null;
+
+        // If we have an exception (from Throws/ThrowsExactly), check that
+        if (exception != null)
+        {
+            objectToCheck = exception;
+        }
+        // Otherwise check the value
+        else if (value != null)
+        {
+            objectToCheck = value;
+        }
+        else
+        {
+            return Task.FromResult(AssertionResult.Failed("value was null"));
+        }
+
+        var actualType = objectToCheck.GetType();
+
+        if (actualType.IsAssignableFrom(_targetType))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed($"type {actualType.Name} is not assignable from {_targetType.Name}"));
+    }
+
+    protected override string GetExpectation() => $"to be assignable from {_targetType.Name}";
+}
+
+/// <summary>
+/// Asserts that a value's type is NOT assignable from a specific type.
+/// Works with both direct value assertions and exception assertions (via .And after Throws).
+/// </summary>
+public class IsNotAssignableFromAssertion<TTarget, TValue> : Assertion<TValue>
+{
+    private readonly Type _targetType;
+
+    public IsNotAssignableFromAssertion(
+        AssertionContext<TValue> context)
+        : base(context)
+    {
+        _targetType = typeof(TTarget);
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TValue> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        object? objectToCheck = null;
+
+        // If we have an exception (from Throws/ThrowsExactly), check that
+        if (exception != null)
+        {
+            objectToCheck = exception;
+        }
+        // Otherwise check the value
+        else if (value != null)
+        {
+            objectToCheck = value;
+        }
+        else
+        {
+            return Task.FromResult(AssertionResult.Failed("value was null"));
+        }
+
+        var actualType = objectToCheck.GetType();
+
+        if (!actualType.IsAssignableFrom(_targetType))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed($"type {actualType.Name} is assignable from {_targetType.Name}"));
+    }
+
+    protected override string GetExpectation() => $"to not be assignable from {_targetType.Name}";
+}
+
 /// <summary>
 /// Asserts that a value is exactly of the specified type (using runtime Type parameter).
 /// </summary>

TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs

@@ -53,6 +53,26 @@ IsNotAssignableToAssertion<TTarget, TCollection> IAssertionSource<TCollection>.I
             "Use: Assert.That(value).IsNotAssignableTo<IList<int>>().HasCount().EqualTo(5)");
     }
 
+    /// <summary>
+    /// Not supported on CountWrapper - use IsAssignableFrom on the assertion source before calling HasCount().
+    /// </summary>
+    IsAssignableFromAssertion<TTarget, TCollection> IAssertionSource<TCollection>.IsAssignableFrom<TTarget>()
+    {
+        throw new NotSupportedException(
+            "IsAssignableFrom is not supported after HasCount(). " +
+            "Use: Assert.That(value).IsAssignableFrom<IList<int>>().HasCount().EqualTo(5)");
+    }
+
+    /// <summary>
+    /// Not supported on CountWrapper - use IsNotAssignableFrom on the assertion source before calling HasCount().
+    /// </summary>
+    IsNotAssignableFromAssertion<TTarget, TCollection> IAssertionSource<TCollection>.IsNotAssignableFrom<TTarget>()
+    {
+        throw new NotSupportedException(
+            "IsNotAssignableFrom is not supported after HasCount(). " +
+            "Use: Assert.That(value).IsNotAssignableFrom<IList<int>>().HasCount().EqualTo(5)");
+    }
+
     /// <summary>
     /// Not supported on CountWrapper - use IsNotTypeOf on the assertion source before calling HasCount().
     /// </summary>

TUnit.Assertions/Conditions/Wrappers/LengthWrapper.cs

@@ -50,6 +50,26 @@ IsNotAssignableToAssertion<TTarget, string> IAssertionSource<string>.IsNotAssign
             "Use: Assert.That(value).IsNotAssignableTo<string>().HasLength().EqualTo(5)");
     }
 
+    /// <summary>
+    /// Not supported on LengthWrapper - use IsAssignableFrom on the assertion source before calling HasLength().
+    /// </summary>
+    IsAssignableFromAssertion<TTarget, string> IAssertionSource<string>.IsAssignableFrom<TTarget>()
+    {
+        throw new NotSupportedException(
+            "IsAssignableFrom is not supported after HasLength(). " +
+            "Use: Assert.That(value).IsAssignableFrom<string>().HasLength().EqualTo(5)");
+    }
+
+    /// <summary>
+    /// Not supported on LengthWrapper - use IsNotAssignableFrom on the assertion source before calling HasLength().
+    /// </summary>
+    IsNotAssignableFromAssertion<TTarget, string> IAssertionSource<string>.IsNotAssignableFrom<TTarget>()
+    {
+        throw new NotSupportedException(
+            "IsNotAssignableFrom is not supported after HasLength(). " +
+            "Use: Assert.That(value).IsNotAssignableFrom<string>().HasLength().EqualTo(5)");
+    }
+
     /// <summary>
     /// Not supported on LengthWrapper - use IsNotTypeOf on the assertion source before calling HasLength().
     /// </summary>

TUnit.Assertions/Core/IAssertionSource.cs

@@ -42,4 +42,14 @@ public interface IAssertionSource<TValue> : IAssertionSource
     /// Asserts that the value's type is NOT assignable to the specified type.
     /// </summary>
     IsNotAssignableToAssertion<TExpected, TValue> IsNotAssignableTo<TExpected>();
+
+    /// <summary>
+    /// Asserts that the value's type is assignable from the specified type.
+    /// </summary>
+    IsAssignableFromAssertion<TExpected, TValue> IsAssignableFrom<TExpected>();
+
+    /// <summary>
+    /// Asserts that the value's type is NOT assignable from the specified type.
+    /// </summary>
+    IsNotAssignableFromAssertion<TExpected, TValue> IsNotAssignableFrom<TExpected>();
 }

TUnit.Assertions/Sources/AsyncDelegateAssertion.cs

@@ -153,6 +153,18 @@ TypeOfAssertion<Task, TExpected> IAssertionSource<Task>.IsTypeOf<TExpected>()
         return new IsNotAssignableToAssertion<TTarget, object?>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, object?> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, object?>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, object?> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, object?>(Context);
+    }
+
     /// <summary>
     /// Explicit interface implementation for Task assignability checking.
     /// Asserts that the task itself is assignable to the specified type.
@@ -173,6 +185,26 @@ IsNotAssignableToAssertion<TTarget, Task> IAssertionSource<Task>.IsNotAssignable
         return new IsNotAssignableToAssertion<TTarget, Task>(TaskContext);
     }
 
+    /// <summary>
+    /// Explicit interface implementation for Task assignability checking.
+    /// Asserts that the task itself is assignable from the specified type.
+    /// </summary>
+    IsAssignableFromAssertion<TTarget, Task> IAssertionSource<Task>.IsAssignableFrom<TTarget>()
+    {
+        TaskContext.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, Task>(TaskContext);
+    }
+
+    /// <summary>
+    /// Explicit interface implementation for Task assignability checking.
+    /// Asserts that the task itself is not assignable from the specified type.
+    /// </summary>
+    IsNotAssignableFromAssertion<TTarget, Task> IAssertionSource<Task>.IsNotAssignableFrom<TTarget>()
+    {
+        TaskContext.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, Task>(TaskContext);
+    }
+
     /// <summary>
     /// Asserts that the value is NOT of the specified type.
     /// Example: await Assert.That(async () => await SomeMethodAsync()).IsNotTypeOf<int>();

TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs

@@ -173,6 +173,20 @@ public IsNotAssignableToAssertion<TExpected, IAsyncEnumerable<TItem>> IsNotAssig
         return new IsNotAssignableToAssertion<TExpected, IAsyncEnumerable<TItem>>(Context);
     }
 
+    /// <inheritdoc />
+    public IsAssignableFromAssertion<TExpected, IAsyncEnumerable<TItem>> IsAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsAssignableFromAssertion<TExpected, IAsyncEnumerable<TItem>>(Context);
+    }
+
+    /// <inheritdoc />
+    public IsNotAssignableFromAssertion<TExpected, IAsyncEnumerable<TItem>> IsNotAssignableFrom<TExpected>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TExpected).Name}>()");
+        return new IsNotAssignableFromAssertion<TExpected, IAsyncEnumerable<TItem>>(Context);
+    }
+
     // CheckAsync is not overridden here - it's abstract in Assertion<T>
     // Each concrete assertion class will implement it
 }