From 2e4c28b4ed77104b14edcc62c9c4f5f4eff52100 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 17 Feb 2026 00:18:10 +0000
Subject: [PATCH 1/2] Initial plan


From 6336076648b6cbe3e1cd42068c83047210ebae56 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 17 Feb 2026 00:26:43 +0000
Subject: [PATCH 2/2] Add IsAssignableFrom and IsNotAssignableFrom assertions

- Add IsAssignableFromAssertion and IsNotAssignableFromAssertion classes
- Add IsAssignableFrom/IsNotAssignableFrom to IAssertionSource interface
- Implement in all assertion source classes
- Update public API snapshots

Co-authored-by: thomhurst <30480171+thomhurst@users.noreply.github.com>
---
 .../Assertions/PropertyAssertion.cs           |  12 +++
 .../Assertions/Strings/ParseAssertions.cs     |  12 +++
 TUnit.Assertions/Conditions/ListAssertions.cs |  28 +++++
 .../Conditions/MemberAssertion.cs             |  12 +++
 .../Conditions/ReadOnlyListAssertions.cs      |  28 +++++
 .../Conditions/TypeOfAssertion.cs             | 100 ++++++++++++++++++
 .../Conditions/Wrappers/CountWrapper.cs       |  20 ++++
 .../Conditions/Wrappers/LengthWrapper.cs      |  20 ++++
 TUnit.Assertions/Core/IAssertionSource.cs     |  10 ++
 .../Sources/AsyncDelegateAssertion.cs         |  32 ++++++
 .../Sources/AsyncEnumerableAssertionBase.cs   |  14 +++
 .../Sources/AsyncFuncAssertion.cs             |  12 +++
 .../Sources/CollectionAssertionBase.cs        |  12 +++
 TUnit.Assertions/Sources/DelegateAssertion.cs |  12 +++
 TUnit.Assertions/Sources/FuncAssertion.cs     |  12 +++
 .../Sources/MemoryAssertionBase.cs            |  12 +++
 TUnit.Assertions/Sources/TaskAssertion.cs     |  32 ++++++
 TUnit.Assertions/Sources/ValueAssertion.cs    |  22 ++++
 ...Has_No_API_Changes.DotNet10_0.verified.txt |  46 ++++++++
 ..._Has_No_API_Changes.DotNet8_0.verified.txt |  46 ++++++++
 ..._Has_No_API_Changes.DotNet9_0.verified.txt |  46 ++++++++
 ...ary_Has_No_API_Changes.Net4_7.verified.txt |  44 ++++++++
 22 files changed, 584 insertions(+)

diff --git a/TUnit.Assertions/Assertions/PropertyAssertion.cs b/TUnit.Assertions/Assertions/PropertyAssertion.cs
index 5b167cf11e..e756de2392 100644
--- a/TUnit.Assertions/Assertions/PropertyAssertion.cs
+++ b/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>();
diff --git a/TUnit.Assertions/Assertions/Strings/ParseAssertions.cs b/TUnit.Assertions/Assertions/Strings/ParseAssertions.cs
index 6de293bcf0..47f2580e61 100644
--- a/TUnit.Assertions/Assertions/Strings/ParseAssertions.cs
+++ b/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>();
diff --git a/TUnit.Assertions/Conditions/ListAssertions.cs b/TUnit.Assertions/Conditions/ListAssertions.cs
index eee34331dc..0a7b0e9d6f 100644
--- a/TUnit.Assertions/Conditions/ListAssertions.cs
+++ b/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>
diff --git a/TUnit.Assertions/Conditions/MemberAssertion.cs b/TUnit.Assertions/Conditions/MemberAssertion.cs
index 1e06c83f86..c1ef097170 100644
--- a/TUnit.Assertions/Conditions/MemberAssertion.cs
+++ b/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>());
diff --git a/TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs b/TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs
index ead5c113ff..9cade6088f 100644
--- a/TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs
+++ b/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>
diff --git a/TUnit.Assertions/Conditions/TypeOfAssertion.cs b/TUnit.Assertions/Conditions/TypeOfAssertion.cs
index 50a1ebeb0a..f5261ec5b3 100644
--- a/TUnit.Assertions/Conditions/TypeOfAssertion.cs
+++ b/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>
diff --git a/TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs b/TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs
index f2b2ea3364..70eb43d4e1 100644
--- a/TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs
+++ b/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>
diff --git a/TUnit.Assertions/Conditions/Wrappers/LengthWrapper.cs b/TUnit.Assertions/Conditions/Wrappers/LengthWrapper.cs
index c1d027bfcf..4518e6068f 100644
--- a/TUnit.Assertions/Conditions/Wrappers/LengthWrapper.cs
+++ b/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>
diff --git a/TUnit.Assertions/Core/IAssertionSource.cs b/TUnit.Assertions/Core/IAssertionSource.cs
index 92a34e915a..719adddad7 100644
--- a/TUnit.Assertions/Core/IAssertionSource.cs
+++ b/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>();
 }
diff --git a/TUnit.Assertions/Sources/AsyncDelegateAssertion.cs b/TUnit.Assertions/Sources/AsyncDelegateAssertion.cs
index 0d2ea6c352..8d3aa0f18d 100644
--- a/TUnit.Assertions/Sources/AsyncDelegateAssertion.cs
+++ b/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>();
diff --git a/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs b/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
index 2f2652b4f2..0d91f209fb 100644
--- a/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
+++ b/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
 }
diff --git a/TUnit.Assertions/Sources/AsyncFuncAssertion.cs b/TUnit.Assertions/Sources/AsyncFuncAssertion.cs
index 0c4484b04f..4b9bee1764 100644
--- a/TUnit.Assertions/Sources/AsyncFuncAssertion.cs
+++ b/TUnit.Assertions/Sources/AsyncFuncAssertion.cs
@@ -55,6 +55,18 @@ public IsNotAssignableToAssertion<TTarget, TValue> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, TValue>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, TValue> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, TValue> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
     /// <summary>
     /// Asserts that the async function result is NOT of the specified type.
     /// Example: await Assert.That(async () => await GetValueAsync()).IsNotTypeOf<int>();
diff --git a/TUnit.Assertions/Sources/CollectionAssertionBase.cs b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
index 3025455b68..9d2111e07c 100644
--- a/TUnit.Assertions/Sources/CollectionAssertionBase.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
@@ -67,6 +67,18 @@ public IsNotAssignableToAssertion<TTarget, TCollection> IsNotAssignableTo<TTarge
         return new IsNotAssignableToAssertion<TTarget, TCollection>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, TCollection> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, TCollection>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, TCollection> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, TCollection>(Context);
+    }
+
     /// <summary>
     /// Asserts that the collection is NOT of the specified type.
     /// This allows chaining additional assertions on the value.
diff --git a/TUnit.Assertions/Sources/DelegateAssertion.cs b/TUnit.Assertions/Sources/DelegateAssertion.cs
index 142aa6e0ee..0af64b8ed9 100644
--- a/TUnit.Assertions/Sources/DelegateAssertion.cs
+++ b/TUnit.Assertions/Sources/DelegateAssertion.cs
@@ -58,6 +58,18 @@ public DelegateAssertion(Action action, string? expression)
         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>
     /// Asserts that the value is NOT of the specified type.
     /// Example: await Assert.That(() => SomeMethod()).IsNotTypeOf<int>();
diff --git a/TUnit.Assertions/Sources/FuncAssertion.cs b/TUnit.Assertions/Sources/FuncAssertion.cs
index bcdf9a4450..352178097b 100644
--- a/TUnit.Assertions/Sources/FuncAssertion.cs
+++ b/TUnit.Assertions/Sources/FuncAssertion.cs
@@ -55,6 +55,18 @@ public IsNotAssignableToAssertion<TTarget, TValue> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, TValue>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, TValue> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, TValue> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
     /// <summary>
     /// Asserts that the value is NOT of the specified type.
     /// Example: await Assert.That(() => GetValue()).IsNotTypeOf<int>();
diff --git a/TUnit.Assertions/Sources/MemoryAssertionBase.cs b/TUnit.Assertions/Sources/MemoryAssertionBase.cs
index 20ba2d74fc..424bc1bdd7 100644
--- a/TUnit.Assertions/Sources/MemoryAssertionBase.cs
+++ b/TUnit.Assertions/Sources/MemoryAssertionBase.cs
@@ -67,6 +67,18 @@ public IsNotAssignableToAssertion<TTarget, TMemory> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, TMemory>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, TMemory> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, TMemory>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, TMemory> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, TMemory>(Context);
+    }
+
     public IsNotTypeOfAssertion<TMemory, TExpected> IsNotTypeOf<TExpected>()
     {
         Context.ExpressionBuilder.Append($".IsNotTypeOf<{typeof(TExpected).Name}>()");
diff --git a/TUnit.Assertions/Sources/TaskAssertion.cs b/TUnit.Assertions/Sources/TaskAssertion.cs
index bfc7504263..abdab0f1c0 100644
--- a/TUnit.Assertions/Sources/TaskAssertion.cs
+++ b/TUnit.Assertions/Sources/TaskAssertion.cs
@@ -85,6 +85,18 @@ public IsNotAssignableToAssertion<TTarget, TValue> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, TValue>(Context);
     }
 
+    public IsAssignableFromAssertion<TTarget, TValue> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TTarget, TValue> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
     /// <summary>
     /// Explicit interface implementation for Task&lt;TValue?&gt; assignability checking.
     /// Asserts that the task itself is assignable to the specified type.
@@ -105,6 +117,26 @@ public IsNotAssignableToAssertion<TTarget, TValue> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, Task<TValue?>>(TaskContext);
     }
 
+    /// <summary>
+    /// Explicit interface implementation for Task&lt;TValue?&gt; assignability checking.
+    /// Asserts that the task itself is assignable from the specified type.
+    /// </summary>
+    IsAssignableFromAssertion<TTarget, Task<TValue?>> IAssertionSource<Task<TValue?>>.IsAssignableFrom<TTarget>()
+    {
+        TaskContext.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, Task<TValue?>>(TaskContext);
+    }
+
+    /// <summary>
+    /// Explicit interface implementation for Task&lt;TValue?&gt; assignability checking.
+    /// Asserts that the task itself is not assignable from the specified type.
+    /// </summary>
+    IsNotAssignableFromAssertion<TTarget, Task<TValue?>> IAssertionSource<Task<TValue?>>.IsNotAssignableFrom<TTarget>()
+    {
+        TaskContext.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, Task<TValue?>>(TaskContext);
+    }
+
     /// <summary>
     /// Asserts that the task result is NOT of the specified type.
     /// Example: await Assert.That(GetValueAsync()).IsNotTypeOf<int>();
diff --git a/TUnit.Assertions/Sources/ValueAssertion.cs b/TUnit.Assertions/Sources/ValueAssertion.cs
index b6ce07b451..12408ab3d9 100644
--- a/TUnit.Assertions/Sources/ValueAssertion.cs
+++ b/TUnit.Assertions/Sources/ValueAssertion.cs
@@ -78,6 +78,28 @@ public IsNotAssignableToAssertion<TTarget, TValue> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, TValue>(Context);
     }
 
+    /// <summary>
+    /// Asserts that the value's type is assignable from the specified type.
+    /// This instance method allows single type parameter usage without needing to specify the source type.
+    /// Example: await Assert.That(myObject).IsAssignableFrom&lt;DerivedClass&gt;();
+    /// </summary>
+    public IsAssignableFromAssertion<TTarget, TValue> IsAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
+    /// <summary>
+    /// Asserts that the value's type is NOT assignable from the specified type.
+    /// This instance method allows single type parameter usage without needing to specify the source type.
+    /// Example: await Assert.That(myObject).IsNotAssignableFrom&lt;DerivedClass&gt;();
+    /// </summary>
+    public IsNotAssignableFromAssertion<TTarget, TValue> IsNotAssignableFrom<TTarget>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TTarget).Name}>()");
+        return new IsNotAssignableFromAssertion<TTarget, TValue>(Context);
+    }
+
     /// <summary>
     /// Asserts that the value is NOT of the specified type.
     /// This instance method allows single type parameter usage without needing to specify the source type.
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
index 59497a2138..cb6e575781 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -337,7 +337,9 @@ namespace .Assertions
     {
         public .<TObject> Context { get; }
         public .<TObject?> GetAwaiter() { }
+        public .<TTarget, TObject> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TObject> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsNotAssignableTo<TTarget>() { }
         public .<TObject, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TObject, TExpected> IsTypeOf<TExpected>() { }
@@ -409,7 +411,9 @@ namespace .
         public WhenParsedIntoAssertion(.<string> stringContext, ? formatProvider = null) { }
         protected override .<.> CheckAsync(.<T> metadata) { }
         protected override string GetExpectation() { }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -608,7 +612,9 @@ namespace .Conditions
     {
         public AssertionSourceAdapter(.<T> context) { }
         public .<T> Context { get; }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -1273,6 +1279,12 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    public class IsAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1325,6 +1337,12 @@ namespace .Conditions
         public .<TCollection, TItem> Using(.<TItem> comparer) { }
         public .<TCollection, TItem> Using(<TItem?, TItem?, bool> equalityPredicate) { }
     }
+    public class IsNotAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsNotAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsNotAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsNotAssignableToAssertion(.<TValue> context) { }
@@ -1416,8 +1434,10 @@ namespace .Conditions
     {
         public ListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1452,8 +1472,10 @@ namespace .Conditions
     {
         public ListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1663,8 +1685,10 @@ namespace .Conditions
     {
         public ReadOnlyListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1699,8 +1723,10 @@ namespace .Conditions
     {
         public ReadOnlyListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -2344,7 +2370,9 @@ namespace .Core
     public interface IAssertionSource<TValue> : .
     {
         .<TValue> Context { get; }
+        .<TExpected, TValue> IsAssignableFrom<TExpected>();
         .<TExpected, TValue> IsAssignableTo<TExpected>();
+        .<TExpected, TValue> IsNotAssignableFrom<TExpected>();
         .<TExpected, TValue> IsNotAssignableTo<TExpected>();
         .<TValue, TExpected> IsNotTypeOf<TExpected>();
         .<TValue, TExpected> IsTypeOf<TExpected>();
@@ -5561,11 +5589,13 @@ namespace .Sources
     {
         public AsyncDelegateAssertion(<.> action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
         public .<.> IsCanceled() { }
         public .<.> IsCompleted() { }
         public .<.> IsCompletedSuccessfully() { }
         public .<.> IsFaulted() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<.> IsNotCanceled() { }
         public .<.> IsNotCompleted() { }
@@ -5593,8 +5623,10 @@ namespace .Sources
         public .<TItem> DoesNotContain(TItem expected, .<TItem>? comparer = null, [.("expected")] string? expression = null) { }
         protected override string GetExpectation() { }
         public .<TItem> HasCount(int expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, .<TItem>> IsAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsAssignableTo<TExpected>() { }
         public .<TItem> IsEmpty() { }
+        public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5608,7 +5640,9 @@ namespace .Sources
     {
         public AsyncFuncAssertion(<.<TValue?>> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -5651,10 +5685,12 @@ namespace .Sources
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
         public .<TCollection, TItem> HasSingleItem() { }
+        public .<TTarget, TCollection> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsEmpty() { }
         public .<TCollection, TItem> IsInDescendingOrder() { }
         public .<TCollection, TItem> IsInOrder() { }
+        public .<TTarget, TCollection> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5672,7 +5708,9 @@ namespace .Sources
     {
         public DelegateAssertion( action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<object?, TExpected> IsNotTypeOf<TExpected>() { }
         public .<object?, TExpected> IsTypeOf<TExpected>() { }
@@ -5709,7 +5747,9 @@ namespace .Sources
     {
         public FuncAssertion(<TValue?> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -5764,10 +5804,12 @@ namespace .Sources
         protected override string GetExpectation() { }
         public .<TMemory, TItem> HasDistinctItems() { }
         public .<TMemory, TItem> HasSingleItem() { }
+        public .<TTarget, TMemory> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TMemory> IsAssignableTo<TTarget>() { }
         public .<TMemory, TItem> IsEmpty() { }
         public .<TMemory, TItem> IsInDescendingOrder() { }
         public .<TMemory, TItem> IsInOrder() { }
+        public .<TTarget, TMemory> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TMemory> IsNotAssignableTo<TTarget>() { }
         public .<TMemory, TItem> IsNotEmpty() { }
         public .<TMemory, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5866,11 +5908,13 @@ namespace .Sources
     {
         public TaskAssertion(.<TValue?> task, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
         public .<.<TValue>> IsCanceled() { }
         public .<.<TValue>> IsCompleted() { }
         public .<.<TValue>> IsCompletedSuccessfully() { }
         public .<.<TValue>> IsFaulted() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<.<TValue>> IsNotCanceled() { }
         public .<.<TValue>> IsNotCompleted() { }
@@ -5888,7 +5932,9 @@ namespace .Sources
         protected ValueAssertion(.<TValue> context) { }
         public ValueAssertion(TValue? value, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
index c01ad50b4b..d19099168f 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
@@ -320,7 +320,9 @@ namespace .Assertions
     {
         public .<TObject> Context { get; }
         public .<TObject?> GetAwaiter() { }
+        public .<TTarget, TObject> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TObject> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsNotAssignableTo<TTarget>() { }
         public .<TObject, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TObject, TExpected> IsTypeOf<TExpected>() { }
@@ -392,7 +394,9 @@ namespace .
         public WhenParsedIntoAssertion(.<string> stringContext, ? formatProvider = null) { }
         protected override .<.> CheckAsync(.<T> metadata) { }
         protected override string GetExpectation() { }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -591,7 +595,9 @@ namespace .Conditions
     {
         public AssertionSourceAdapter(.<T> context) { }
         public .<T> Context { get; }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -1256,6 +1262,12 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    public class IsAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1308,6 +1320,12 @@ namespace .Conditions
         public .<TCollection, TItem> Using(.<TItem> comparer) { }
         public .<TCollection, TItem> Using(<TItem?, TItem?, bool> equalityPredicate) { }
     }
+    public class IsNotAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsNotAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsNotAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsNotAssignableToAssertion(.<TValue> context) { }
@@ -1399,8 +1417,10 @@ namespace .Conditions
     {
         public ListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1435,8 +1455,10 @@ namespace .Conditions
     {
         public ListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1646,8 +1668,10 @@ namespace .Conditions
     {
         public ReadOnlyListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1682,8 +1706,10 @@ namespace .Conditions
     {
         public ReadOnlyListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -2323,7 +2349,9 @@ namespace .Core
     public interface IAssertionSource<TValue> : .
     {
         .<TValue> Context { get; }
+        .<TExpected, TValue> IsAssignableFrom<TExpected>();
         .<TExpected, TValue> IsAssignableTo<TExpected>();
+        .<TExpected, TValue> IsNotAssignableFrom<TExpected>();
         .<TExpected, TValue> IsNotAssignableTo<TExpected>();
         .<TValue, TExpected> IsNotTypeOf<TExpected>();
         .<TValue, TExpected> IsTypeOf<TExpected>();
@@ -5509,11 +5537,13 @@ namespace .Sources
     {
         public AsyncDelegateAssertion(<.> action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
         public .<.> IsCanceled() { }
         public .<.> IsCompleted() { }
         public .<.> IsCompletedSuccessfully() { }
         public .<.> IsFaulted() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<.> IsNotCanceled() { }
         public .<.> IsNotCompleted() { }
@@ -5541,8 +5571,10 @@ namespace .Sources
         public .<TItem> DoesNotContain(TItem expected, .<TItem>? comparer = null, [.("expected")] string? expression = null) { }
         protected override string GetExpectation() { }
         public .<TItem> HasCount(int expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, .<TItem>> IsAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsAssignableTo<TExpected>() { }
         public .<TItem> IsEmpty() { }
+        public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5556,7 +5588,9 @@ namespace .Sources
     {
         public AsyncFuncAssertion(<.<TValue?>> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -5598,10 +5632,12 @@ namespace .Sources
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
         public .<TCollection, TItem> HasSingleItem() { }
+        public .<TTarget, TCollection> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsEmpty() { }
         public .<TCollection, TItem> IsInDescendingOrder() { }
         public .<TCollection, TItem> IsInOrder() { }
+        public .<TTarget, TCollection> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5619,7 +5655,9 @@ namespace .Sources
     {
         public DelegateAssertion( action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<object?, TExpected> IsNotTypeOf<TExpected>() { }
         public .<object?, TExpected> IsTypeOf<TExpected>() { }
@@ -5656,7 +5694,9 @@ namespace .Sources
     {
         public FuncAssertion(<TValue?> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -5711,10 +5751,12 @@ namespace .Sources
         protected override string GetExpectation() { }
         public .<TMemory, TItem> HasDistinctItems() { }
         public .<TMemory, TItem> HasSingleItem() { }
+        public .<TTarget, TMemory> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TMemory> IsAssignableTo<TTarget>() { }
         public .<TMemory, TItem> IsEmpty() { }
         public .<TMemory, TItem> IsInDescendingOrder() { }
         public .<TMemory, TItem> IsInOrder() { }
+        public .<TTarget, TMemory> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TMemory> IsNotAssignableTo<TTarget>() { }
         public .<TMemory, TItem> IsNotEmpty() { }
         public .<TMemory, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5813,11 +5855,13 @@ namespace .Sources
     {
         public TaskAssertion(.<TValue?> task, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
         public .<.<TValue>> IsCanceled() { }
         public .<.<TValue>> IsCompleted() { }
         public .<.<TValue>> IsCompletedSuccessfully() { }
         public .<.<TValue>> IsFaulted() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<.<TValue>> IsNotCanceled() { }
         public .<.<TValue>> IsNotCompleted() { }
@@ -5835,7 +5879,9 @@ namespace .Sources
         protected ValueAssertion(.<TValue> context) { }
         public ValueAssertion(TValue? value, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
index 2a4e6c380f..cc57b1d110 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
@@ -337,7 +337,9 @@ namespace .Assertions
     {
         public .<TObject> Context { get; }
         public .<TObject?> GetAwaiter() { }
+        public .<TTarget, TObject> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TObject> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsNotAssignableTo<TTarget>() { }
         public .<TObject, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TObject, TExpected> IsTypeOf<TExpected>() { }
@@ -409,7 +411,9 @@ namespace .
         public WhenParsedIntoAssertion(.<string> stringContext, ? formatProvider = null) { }
         protected override .<.> CheckAsync(.<T> metadata) { }
         protected override string GetExpectation() { }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -608,7 +612,9 @@ namespace .Conditions
     {
         public AssertionSourceAdapter(.<T> context) { }
         public .<T> Context { get; }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -1273,6 +1279,12 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    public class IsAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1325,6 +1337,12 @@ namespace .Conditions
         public .<TCollection, TItem> Using(.<TItem> comparer) { }
         public .<TCollection, TItem> Using(<TItem?, TItem?, bool> equalityPredicate) { }
     }
+    public class IsNotAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsNotAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsNotAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsNotAssignableToAssertion(.<TValue> context) { }
@@ -1416,8 +1434,10 @@ namespace .Conditions
     {
         public ListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1452,8 +1472,10 @@ namespace .Conditions
     {
         public ListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1663,8 +1685,10 @@ namespace .Conditions
     {
         public ReadOnlyListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1699,8 +1723,10 @@ namespace .Conditions
     {
         public ReadOnlyListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -2344,7 +2370,9 @@ namespace .Core
     public interface IAssertionSource<TValue> : .
     {
         .<TValue> Context { get; }
+        .<TExpected, TValue> IsAssignableFrom<TExpected>();
         .<TExpected, TValue> IsAssignableTo<TExpected>();
+        .<TExpected, TValue> IsNotAssignableFrom<TExpected>();
         .<TExpected, TValue> IsNotAssignableTo<TExpected>();
         .<TValue, TExpected> IsNotTypeOf<TExpected>();
         .<TValue, TExpected> IsTypeOf<TExpected>();
@@ -5561,11 +5589,13 @@ namespace .Sources
     {
         public AsyncDelegateAssertion(<.> action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
         public .<.> IsCanceled() { }
         public .<.> IsCompleted() { }
         public .<.> IsCompletedSuccessfully() { }
         public .<.> IsFaulted() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<.> IsNotCanceled() { }
         public .<.> IsNotCompleted() { }
@@ -5593,8 +5623,10 @@ namespace .Sources
         public .<TItem> DoesNotContain(TItem expected, .<TItem>? comparer = null, [.("expected")] string? expression = null) { }
         protected override string GetExpectation() { }
         public .<TItem> HasCount(int expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, .<TItem>> IsAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsAssignableTo<TExpected>() { }
         public .<TItem> IsEmpty() { }
+        public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5608,7 +5640,9 @@ namespace .Sources
     {
         public AsyncFuncAssertion(<.<TValue?>> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -5651,10 +5685,12 @@ namespace .Sources
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
         public .<TCollection, TItem> HasSingleItem() { }
+        public .<TTarget, TCollection> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsEmpty() { }
         public .<TCollection, TItem> IsInDescendingOrder() { }
         public .<TCollection, TItem> IsInOrder() { }
+        public .<TTarget, TCollection> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5672,7 +5708,9 @@ namespace .Sources
     {
         public DelegateAssertion( action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<object?, TExpected> IsNotTypeOf<TExpected>() { }
         public .<object?, TExpected> IsTypeOf<TExpected>() { }
@@ -5709,7 +5747,9 @@ namespace .Sources
     {
         public FuncAssertion(<TValue?> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -5764,10 +5804,12 @@ namespace .Sources
         protected override string GetExpectation() { }
         public .<TMemory, TItem> HasDistinctItems() { }
         public .<TMemory, TItem> HasSingleItem() { }
+        public .<TTarget, TMemory> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TMemory> IsAssignableTo<TTarget>() { }
         public .<TMemory, TItem> IsEmpty() { }
         public .<TMemory, TItem> IsInDescendingOrder() { }
         public .<TMemory, TItem> IsInOrder() { }
+        public .<TTarget, TMemory> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TMemory> IsNotAssignableTo<TTarget>() { }
         public .<TMemory, TItem> IsNotEmpty() { }
         public .<TMemory, TExpected> IsNotTypeOf<TExpected>() { }
@@ -5866,11 +5908,13 @@ namespace .Sources
     {
         public TaskAssertion(.<TValue?> task, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
         public .<.<TValue>> IsCanceled() { }
         public .<.<TValue>> IsCompleted() { }
         public .<.<TValue>> IsCompletedSuccessfully() { }
         public .<.<TValue>> IsFaulted() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<.<TValue>> IsNotCanceled() { }
         public .<.<TValue>> IsNotCompleted() { }
@@ -5888,7 +5932,9 @@ namespace .Sources
         protected ValueAssertion(.<TValue> context) { }
         public ValueAssertion(TValue? value, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
index d8f7e630fd..0e750b0ef9 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
@@ -279,7 +279,9 @@ namespace .Assertions
     {
         public .<TObject> Context { get; }
         public .<TObject?> GetAwaiter() { }
+        public .<TTarget, TObject> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TObject> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TObject> IsNotAssignableTo<TTarget>() { }
         public .<TObject, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TObject, TExpected> IsTypeOf<TExpected>() { }
@@ -351,7 +353,9 @@ namespace .
         public WhenParsedIntoAssertion(.<string> stringContext, ? formatProvider = null) { }
         protected override .<.> CheckAsync(.<T> metadata) { }
         protected override string GetExpectation() { }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -462,7 +466,9 @@ namespace .Conditions
     {
         public AssertionSourceAdapter(.<T> context) { }
         public .<T> Context { get; }
+        public .<TTarget, T> IsAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsAssignableTo<TTarget>() { }
+        public .<TTarget, T> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, T> IsNotAssignableTo<TTarget>() { }
         public .<T, TExpected> IsNotTypeOf<TExpected>() { }
         public .<T, TExpected> IsTypeOf<TExpected>() { }
@@ -1102,6 +1108,12 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    public class IsAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1152,6 +1164,12 @@ namespace .Conditions
         public .<TCollection, TItem> Using(.<TItem> comparer) { }
         public .<TCollection, TItem> Using(<TItem?, TItem?, bool> equalityPredicate) { }
     }
+    public class IsNotAssignableFromAssertion<TTarget, TValue> : .<TValue>
+    {
+        public IsNotAssignableFromAssertion(.<TValue> context) { }
+        protected override .<.> CheckAsync(.<TValue> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsNotAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsNotAssignableToAssertion(.<TValue> context) { }
@@ -1243,8 +1261,10 @@ namespace .Conditions
     {
         public ListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1279,8 +1299,10 @@ namespace .Conditions
     {
         public ListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1487,8 +1509,10 @@ namespace .Conditions
     {
         public ReadOnlyListItemAtSource(.<TList> listContext, int index) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -1523,8 +1547,10 @@ namespace .Conditions
     {
         public ReadOnlyListLastItemSource(.<TList> listContext) { }
         public .<TItem> Context { get; }
+        public .<TExpected, TItem> IsAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsAssignableTo<TExpected>() { }
         public .<TList, TItem> IsEqualTo(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, TItem> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, TItem> IsNotAssignableTo<TExpected>() { }
         public .<TList, TItem> IsNotEqualTo(TItem expected, [.("expected")] string? expression = null) { }
         public .<TList, TItem> IsNotNull() { }
@@ -2105,7 +2131,9 @@ namespace .Core
     public interface IAssertionSource<TValue> : .
     {
         .<TValue> Context { get; }
+        .<TExpected, TValue> IsAssignableFrom<TExpected>();
         .<TExpected, TValue> IsAssignableTo<TExpected>();
+        .<TExpected, TValue> IsNotAssignableFrom<TExpected>();
         .<TExpected, TValue> IsNotAssignableTo<TExpected>();
         .<TValue, TExpected> IsNotTypeOf<TExpected>();
         .<TValue, TExpected> IsTypeOf<TExpected>();
@@ -4849,10 +4877,12 @@ namespace .Sources
     {
         public AsyncDelegateAssertion(<.> action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
         public .<.> IsCanceled() { }
         public .<.> IsCompleted() { }
         public .<.> IsFaulted() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<.> IsNotCanceled() { }
         public .<.> IsNotCompleted() { }
@@ -4879,8 +4909,10 @@ namespace .Sources
         public .<TItem> DoesNotContain(TItem expected, .<TItem>? comparer = null, [.("expected")] string? expression = null) { }
         protected override string GetExpectation() { }
         public .<TItem> HasCount(int expected, [.("expected")] string? expression = null) { }
+        public .<TExpected, .<TItem>> IsAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsAssignableTo<TExpected>() { }
         public .<TItem> IsEmpty() { }
+        public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
@@ -4894,7 +4926,9 @@ namespace .Sources
     {
         public AsyncFuncAssertion(<.<TValue?>> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -4936,10 +4970,12 @@ namespace .Sources
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
         public .<TCollection, TItem> HasSingleItem() { }
+        public .<TTarget, TCollection> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsEmpty() { }
         public .<TCollection, TItem> IsInDescendingOrder() { }
         public .<TCollection, TItem> IsInOrder() { }
+        public .<TTarget, TCollection> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
@@ -4957,7 +4993,9 @@ namespace .Sources
     {
         public DelegateAssertion( action, string? expression) { }
         public .<object?> Context { get; }
+        public .<TTarget, object?> IsAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsAssignableTo<TTarget>() { }
+        public .<TTarget, object?> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, object?> IsNotAssignableTo<TTarget>() { }
         public .<object?, TExpected> IsNotTypeOf<TExpected>() { }
         public .<object?, TExpected> IsTypeOf<TExpected>() { }
@@ -4994,7 +5032,9 @@ namespace .Sources
     {
         public FuncAssertion(<TValue?> func, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }
@@ -5105,10 +5145,12 @@ namespace .Sources
     {
         public TaskAssertion(.<TValue?> task, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
         public .<.<TValue>> IsCanceled() { }
         public .<.<TValue>> IsCompleted() { }
         public .<.<TValue>> IsFaulted() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<.<TValue>> IsNotCanceled() { }
         public .<.<TValue>> IsNotCompleted() { }
@@ -5125,7 +5167,9 @@ namespace .Sources
         protected ValueAssertion(.<TValue> context) { }
         public ValueAssertion(TValue? value, string? expression) { }
         public .<TValue> Context { get; }
+        public .<TTarget, TValue> IsAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsAssignableTo<TTarget>() { }
+        public .<TTarget, TValue> IsNotAssignableFrom<TTarget>() { }
         public .<TTarget, TValue> IsNotAssignableTo<TTarget>() { }
         public .<TValue, TExpected> IsNotTypeOf<TExpected>() { }
         public .<TValue, TExpected> IsTypeOf<TExpected>() { }