nunit-core team mailing list archive

[Launchpad Bug Tracker <901192@xxxxxxxxxxxxxxxxxx>]

You have been subscribed to a public bug:

Currently, NUnit supports a number of generic constraints that define
the type of the tested expression at compile time (if they succeed):
Is.TypeOf<T>(), Is.AssignableTo<T>(), and Is.InstanceOf<T>(). (Note that
Is.AssignableFrom<T>() is not a candidate for this feature request
because it only defines a derived type!)

Those constraint factory methods currently return instances of non-
generic expression types (e.g., ExactTypeConstraint, etc.) that inherit
the ordinary, untyped constraint expression factory methods, so that you
can write, for example: Is.TypeOf<object>().With.Property ("P").EqualTo
(42). Note that when "With" is called, the type information specified at
the TypeOf<T> call gets lost and the Property constraint needs to take
the property name by string rather than, for example, by expression.

Passing the property name as string is bad as an invalid name will not
trigger a compile-time error and as automated refactorings (e.g.,
renaming the property) will not take notice of the property name.

Therefore, change TypeOf<T>, AssignableTo<T>, and InstanceOf<T> to
return generic subclasses of the contraint types (e.g.,
ExactTypeConstraint<T>) that redefine Constraint.With to retain the type
information. Provide generic variants of ConstraintExpression and
ResolvableConstraintExpression to allow for nested strongly typed
constraints. Then provide a generic version of the Property constraint
factory method.

Here is what the code could look like for NUnit 2.6 (with non-breaking
changes).

public class ExactTypeConstraint<T> : ExactTypeConstraint
{
  public new ConstraintExpression<T> With { get { ... } }
}

public class ConstraintExpression<T> : ConstraintExpression 
{
  public new ConstraintExpression<T> With { get { ... } }
  public new ConstraintExpression<T> And { get { ... } }
  // ...

  public ResolvableConstraintExpression<T> Property<TR> (Expression<Func<T, TR>> propertyAccessor);
}

public class ResolvableConstraintExpression<T> : ResolvableConstraintExpression
{
  public new ConstraintExpression<T> With { get { ... } }
  public new ConstraintExpression<T> And { get { ... } }
}

That way, one could write constraints similar to:
Is.TypeOf<object>().With.Property (o => o.P).EqualTo (42).And.Property (o => o.P2).EqualTo (43)

** Affects: nunit-3.0
     Importance: Medium
         Status: Triaged


** Tags: feature
-- 
Feature request: Provide a strongly typed variant of the Property constraint
https://bugs.launchpad.net/bugs/901192
You received this bug notification because you are a member of NUnit Core Developers, which is the registrant for NUnit Framework.