feat: add IsAssignableFrom<T>() and IsNotAssignableFrom<T>() assertions

TUnit.Assertions.Tests/TypeAssertionAmbiguityTests.cs

@@ -150,6 +150,169 @@ await Assert.That(async () =>
         }).Throws<TUnit.Assertions.Exceptions.AssertionException>();
     }
 
+    // ============ IsAssignableFrom TESTS ============
+
+    [Test]
+    public async Task IsAssignableFrom_DerivedToBase_Passes()
+    {
+        IElement element = new Element();
+        await Assert.That(element).IsAssignableFrom<Element>();
+    }
+
+    [Test]
+    public async Task IsAssignableFrom_ExactType_Passes()
+    {
+        Element element = new Element();
+        await Assert.That(element).IsAssignableFrom<Element>();
+    }
+
+    [Test]
+    public async Task IsAssignableFrom_BaseAcceptsDerived_Passes()
+    {
+        Element element = new Element();
+        await Assert.That(element).IsAssignableFrom<DerivedElement>();
+    }
+
+    [Test]
+    public async Task IsAssignableFrom_InterfaceAcceptsDerived_Passes()
+    {
+        IElement element = new Element();
+        await Assert.That(element).IsAssignableFrom<DerivedElement>();
+    }
+
+    [Test]
+    public async Task IsAssignableFrom_Fails_WhenNotAssignable()
+    {
+        await Assert.That(async () =>
+        {
+            DerivedElement derived = new DerivedElement();
+            await Assert.That(derived).IsAssignableFrom<string>();
+        }).Throws<TUnit.Assertions.Exceptions.AssertionException>();
+    }
+
+    [Test]
+    public async Task IsAssignableFrom_ObjectVariable_Passes()
+    {
+        object obj = new Element();
+        await Assert.That(obj).IsAssignableFrom<DerivedElement>();
+    }
+
+    // ============ IsNotAssignableFrom TESTS ============
+
+    [Test]
+    public async Task IsNotAssignableFrom_UnrelatedTypes_Passes()
+    {
+        DerivedElement derived = new DerivedElement();
+        await Assert.That(derived).IsNotAssignableFrom<string>();
+    }
+
+    [Test]
+    public async Task IsNotAssignableFrom_DerivedFromBase_Passes()
+    {
+        DerivedElement derived = new DerivedElement();
+        await Assert.That(derived).IsNotAssignableFrom<Element>();
+    }
+
+    [Test]
+    public async Task IsNotAssignableFrom_Fails_WhenAssignable()
+    {
+        await Assert.That(async () =>
+        {
+            Element element = new Element();
+            await Assert.That(element).IsNotAssignableFrom<DerivedElement>();
+        }).Throws<TUnit.Assertions.Exceptions.AssertionException>();
+    }
+
+    // ============ IsAssignableFrom EDGE CASE TESTS ============
+
+    [Test]
+    public async Task IsAssignableFrom_Fails_WhenNull()
+    {
+        await Assert.That(async () =>
+        {
+            Element? element = null;
+            await Assert.That(element).IsAssignableFrom<DerivedElement>();
+        }).Throws<TUnit.Assertions.Exceptions.AssertionException>();
+    }
+
+    [Test]
+    public async Task IsNotAssignableFrom_Fails_WhenNull()
+    {
+        await Assert.That(async () =>
+        {
+            Element? element = null;
+            await Assert.That(element).IsNotAssignableFrom<string>();
+        }).Throws<TUnit.Assertions.Exceptions.AssertionException>();
+    }
+
+    [Test]
+    public async Task IsAssignableFrom_WithException_ChecksExceptionType()
+    {
+        await Assert.That(async () =>
+        {
+            throw new InvalidOperationException("test");
+        }).Throws<InvalidOperationException>()
+          .And
+          .IsAssignableFrom<InvalidOperationException>();
+    }
+
+    [Test]
+    public async Task IsNotAssignableFrom_WithException_ChecksExceptionType()
+    {
+        await Assert.That(async () =>
+        {
+            throw new InvalidOperationException("test");
+        }).Throws<InvalidOperationException>()
+          .And
+          .IsNotAssignableFrom<string>();
+    }
+
+    // ============ IsAssignableFrom CHAINING TESTS ============
+
+    [Test]
+    public async Task IsAssignableFrom_Chained_NoAmbiguity()
+    {
+        IElement element = new Element();
+        await Assert.That(element)
+            .IsNotNull()
+            .And
+            .IsAssignableFrom<Element>()
+            .And
+            .IsAssignableFrom<DerivedElement>();
+    }
+
+    [Test]
+    public async Task IsNotAssignableFrom_Chained_NoAmbiguity()
+    {
+        DerivedElement derived = new DerivedElement();
+        await Assert.That(derived)
+            .IsNotNull()
+            .And
+            .IsNotAssignableFrom<string>()
+            .And
+            .IsNotAssignableFrom<Element>();
+    }
+
+    // ============ IsAssignableFrom IN MEMBER LAMBDA TESTS ============
+
+    [Test]
+    public async Task IsAssignableFrom_InMemberLambda_NoAmbiguity()
+    {
+        var container = new Container { ElementProperty = new Element() };
+
+        await Assert.That(container)
+            .Member(c => c.ElementProperty, assert => assert.IsAssignableFrom<Element>());
+    }
+
+    [Test]
+    public async Task IsNotAssignableFrom_InMemberLambda_NoAmbiguity()
+    {
+        var container = new Container { ElementProperty = new Element() };
+
+        await Assert.That(container)
+            .Member(c => c.ElementProperty, assert => assert.IsNotAssignableFrom<string>());
+    }
+
     // ============ ISSUE #3737 REGRESSION TESTS ============
 
     [Test]
@@ -320,6 +483,27 @@ await Assert.That(obj)
             .IsNotAssignableTo<DerivedElement>();
     }
 
+    [Test]
+    public async Task AllSixMethods_InSingleChain_NoAmbiguity()
+    {
+        object obj = new Element();
+
+        await Assert.That(obj)
+            .IsNotNull()
+            .And
+            .IsNotTypeOf<string>()
+            .And
+            .IsTypeOf<Element>()
+            .And
+            .IsAssignableTo<IElement>()
+            .And
+            .IsNotAssignableTo<DerivedElement>()
+            .And
+            .IsAssignableFrom<DerivedElement>()
+            .And
+            .IsNotAssignableFrom<string>();
+    }
+
     // ============ LAMBDA ASSERTION CONTEXTS (.Member) ============
 
     private class Container

TUnit.Assertions/Assertions/PropertyAssertion.cs

@@ -133,6 +133,18 @@ public IsNotAssignableToAssertion<TTarget, TObject> IsNotAssignableTo<TTarget>()
         return new IsNotAssignableToAssertion<TTarget, TObject>(Context);
     }
 
+    public IsAssignableFromAssertion<TSource, TObject> IsAssignableFrom<TSource>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TSource).Name}>()");
+        return new IsAssignableFromAssertion<TSource, TObject>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TSource, TObject> IsNotAssignableFrom<TSource>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TSource).Name}>()");
+        return new IsNotAssignableFromAssertion<TSource, 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<TSource, T> IsAssignableFrom<TSource>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TSource).Name}>()");
+        return new IsAssignableFromAssertion<TSource, T>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TSource, T> IsNotAssignableFrom<TSource>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TSource).Name}>()");
+        return new IsNotAssignableFromAssertion<TSource, 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<TSource, T> IsAssignableFrom<TSource>()
+    {
+        Context.ExpressionBuilder.Append($".IsAssignableFrom<{typeof(TSource).Name}>()");
+        return new IsAssignableFromAssertion<TSource, T>(Context);
+    }
+
+    public IsNotAssignableFromAssertion<TSource, T> IsNotAssignableFrom<TSource>()
+    {
+        Context.ExpressionBuilder.Append($".IsNotAssignableFrom<{typeof(TSource).Name}>()");
+        return new IsNotAssignableFromAssertion<TSource, 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>