/// <summary> /// Asserts that the current type has a method with parameters types of <paramref name="parameterTypes"/> and an expected access modifier. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="accessModifier">The C# access modifier for the constructor.</param> /// <param name="name">The name of the method.</param> /// <param name="parameterTypes">The types of the constructor's parameters.</param> /// <param name="returnType">The expected method's return type.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> HaveMethod(this TypeAssertions typeAssertions, CSharpAccessModifiers accessModifier, Type returnType, string name, IEnumerable <Type> parameterTypes, string because = "", params object[] reasonArgs) { return(HaveMethod(typeAssertions, accessModifier, false, returnType, name, parameterTypes, because, reasonArgs)); }
/// <summary> /// Asserts that the current type has a method with parameters types of <paramref name="parameterTypes"/> and an expected access modifier. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="accessModifier">The C# access modifier for the constructor.</param> /// <param name="name">The name of the method.</param> /// <param name="parameterTypes">The types of the constructor's parameters.</param> /// <param name="returnType">The expected method's return type.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> /// <param name="isAsync">Is the method expected to be async?</param> public static AndConstraint <TypeAssertions> HaveMethod(this TypeAssertions typeAssertions, CSharpAccessModifiers accessModifier, bool isAsync, Type returnType, string name, IEnumerable <Type> parameterTypes, string because = "", params object[] reasonArgs) { var parameterTypesArray = parameterTypes as Type[] ?? parameterTypes.ToArray(); var methodInfo = typeAssertions.Subject.GetMethod(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, parameterTypesArray, null); var methodAccessModifier = CSharpAccessModifiers.None; Type methodReturnType = null; if (methodInfo != null) { methodAccessModifier = methodInfo.GetCSharpAccessModifier(); methodReturnType = methodInfo.ReturnType; } Execute.Assertion.ForCondition(methodInfo != null && methodAccessModifier == accessModifier && methodReturnType == returnType && (methodInfo.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) != null) == isAsync) .BecauseOf(because, reasonArgs) .FailWith("Expected type {1} to contain method {2} {3} {4}({5}).", typeAssertions.Subject.FullName, accessModifier, returnType.Name, name, string.Join(", ", parameterTypesArray.Select(p => p.FullName)), accessModifier); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
/// <summary> /// Asserts that the current type does not expose a property named <paramref name="name"/>. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> /// <param name="name">The name of the method.</param> public static AndConstraint <TypeAssertions> NotHaveProperty(this TypeAssertions typeAssertions, string name, string because = "", params object[] reasonArgs) { Execute.Assertion.ForCondition(typeAssertions.Subject != null && typeAssertions.Subject.GetProperty(name) == null) .BecauseOf(because, reasonArgs) .FailWith("Expected type {0} to not contain property {1}.", typeAssertions.Subject.Name, name); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
public static AndConstraint <TypeAssertions> NotHaveStaticFields(this TypeAssertions assertions) { Type type = assertions.Subject; var staticFields = new List <IAmField>(SmartType.For(type).GetAllStaticFields()); staticFields.Should() .BeEmpty("SmartType " + type + " should not contain static fields, but: " + Environment.NewLine + ReflectionElementsList.Format(staticFields)); return(new AndConstraint <TypeAssertions>(assertions)); }
/// <summary> /// Asserts that the current type does not implement Interface <paramref name="interfaceType"/>. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="interfaceType">The interface that should not be implemented.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> Implement(this TypeAssertions typeAssertions, Type interfaceType, string because = "", params object[] reasonArgs) { Execute.Assertion.ForCondition(typeAssertions.Subject != null && typeAssertions.Subject.GetInterface(interfaceType.Name) == interfaceType) .BecauseOf(because, reasonArgs) .FailWith("Expected type {1} to implement interface {2}.", typeAssertions.Subject.Name, interfaceType.Name); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
/// <summary> /// Asserts that the current type has a property with the expected access modifier. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="setAccessModifier">Setter access modifier. Null if not settable.</param> /// <param name="getAccessModifier">Getter access modifier. Null if not gettable.</param> /// <param name="name">The name of the property.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> /// <param name="propertyType">The type of the indexer</param> public static AndConstraint <TypeAssertions> HaveProperty(this TypeAssertions typeAssertions, CSharpAccessModifiers?getAccessModifier, CSharpAccessModifiers?setAccessModifier, Type propertyType, string name, string because = "", params object[] reasonArgs) { var propertyInfo = typeAssertions.Subject.GetProperty( name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, propertyType, new Type[0], null); var validGetter = false; var validSetter = false; if (propertyInfo != null) { if (getAccessModifier.HasValue) { validGetter = propertyInfo.GetMethod != null && getAccessModifier == propertyInfo.GetMethod.GetCSharpAccessModifier(); } else { validGetter = !propertyInfo.CanRead; } if (setAccessModifier.HasValue) { validSetter = propertyInfo.SetMethod != null && setAccessModifier == propertyInfo.SetMethod.GetCSharpAccessModifier(); } else { validSetter = !propertyInfo.CanWrite; } } var getAccessModifierString = "no"; var setAccessModifierString = "no"; if (getAccessModifier.HasValue) { getAccessModifierString = getAccessModifier.Value.ToString(); } if (setAccessModifier.HasValue) { setAccessModifierString = setAccessModifier.Value.ToString(); } Execute.Assertion.ForCondition(propertyInfo != null && validGetter && validSetter) .BecauseOf(because, reasonArgs) .FailWith("Expected type {0} to have a {1} property {2} with {3} getter and {4} setter.", typeAssertions.Subject.FullName, propertyType.FullName, name, propertyType, getAccessModifierString, setAccessModifierString); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
public static AndConstraint <TypeAssertions> HaveEventWithShortName(this TypeAssertions assertions, string eventName) { var allEvents = SmartType.For(assertions.Subject).GetAllEvents(); allEvents.Should().Match( events => events.Any(ev => ev.HasName(eventName)), "Type " + assertions.Subject + " should define expected event " + eventName); return(new AndConstraint <TypeAssertions>(assertions)); }
public static void NotBeSubstitute(this TypeAssertions typeAssertions, string because = "", params object[] becauseArgs) { string typeName = typeAssertions.Subject.ToString(); Execute.Assertion .ForCondition(!typeName.StartsWith("Castle.Proxies")) .BecauseOf(because, becauseArgs) .FailWith(@"Expected type {0} to not be Substitute{reason}, but its type name begins with ""Castle.Proxies""", typeAssertions.Subject); }
public static AndConstraint <Type> Inherit <T>(this TypeAssertions assertions, string because = "", params object[] reasonArgs) { var type = assertions.Subject; Execute.Assertion .ForCondition(type.Inherits <T>()) .BecauseOf(because, reasonArgs) .FailWith("Expected type {0} to inherit from {1}{reason}", type, typeof(T)); return(new AndConstraint <Type>(type)); }
/// <summary> /// Asserts that the current type derives from the <paramref name="baseType"/>. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="baseType">The expected base type.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> BeDerivedFrom(this TypeAssertions typeAssertions, Type baseType, string because = "", params object[] reasonArgs) { var baseTypeMatched = typeAssertions.Subject.IsSubclassOf(baseType); Execute.Assertion.ForCondition(baseTypeMatched) .BecauseOf(because, reasonArgs) .FailWith("Expected type {1} to be derived from {2}.", typeAssertions.Subject.FullName, baseType.FullName); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
/// <summary> /// Asserts that the current type has explicitly implemented a property named <paramref name="name"/> of type /// <paramref name="type"/> defined on interface <paramref name="definingInterface"/>. /// /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="definingInterface">The interface being explicitly implemented.</param> /// <param name="getAccessModifier">The expected getter access modifier.</param> /// <param name="setAccessModifier">The expected getter access modifier.</param> /// <param name="type">The property type.</param> /// <param name="name">The name of the property</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> HaveExplicitProperty(this TypeAssertions typeAssertions, Type definingInterface, CSharpAccessModifiers?getAccessModifier, CSharpAccessModifiers?setAccessModifier, Type type, string name, string because = "", params object[] reasonArgs) { var isGettable = getAccessModifier != null; var isSettable = setAccessModifier != null; var explicitImplementations = typeAssertions.Subject.GetInterfaceMap(definingInterface) .TargetMethods.Where(m => m.IsPrivate && m.IsFinal).ToList(); var getterName = "get_" + name; var setterName = "set_" + name; var getters = explicitImplementations.Where( m => !m.GetParameters().Any() && m.Name.EndsWith(getterName)).ToList(); var setters = explicitImplementations.Where( m => m.GetParameters().Count() == 1 && m.Name.EndsWith(setterName)).ToList(); var typedGetters = getters.Where(m => m.ReturnType == type).ToList(); var typedSetters = setters.Where(m => m.GetParameters()[0].ParameterType == type).ToList(); var hasGetter = typedGetters.Any(); var hasSetter = typedSetters.Any(); Execute.Assertion.ForCondition(getters.Any() || setters.Any()) .BecauseOf(because, reasonArgs) .FailWith("Expected property {0}.{1} to exist, but it does not.", definingInterface.FullName, name); Execute.Assertion.ForCondition(typedGetters.Any() || typedSetters.Any()) .BecauseOf(because, reasonArgs) .FailWith("Expected property {0}.{1} of type {2} to exist, but it does not.", definingInterface.FullName, name, type); Execute.Assertion.ForCondition(setAccessModifier == null || typedGetters.Any()) .BecauseOf(because, reasonArgs) .FailWith("Expected property {0}.{1} to{2} be gettable, but it is{3}.", definingInterface.FullName, name, isGettable ? "" : " not", hasGetter ? "" : " not"); Execute.Assertion.ForCondition(hasGetter == isGettable) .BecauseOf(because, reasonArgs) .FailWith("Expected property {0}.{1} to{2} be gettable, but it is{3}.", definingInterface.FullName, name, isGettable ? "" : " not", hasGetter ? "" : " not"); Execute.Assertion.ForCondition(hasSetter == isSettable) .BecauseOf(because, reasonArgs) .FailWith("Expected property {0}.{1} to{2} be settable, but it is{3}.", definingInterface.FullName, name, isSettable ? "" : " not", hasSetter ? "" : " not"); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
public static AndConstraint <TypeAssertions> HaveUniqueConstants(this TypeAssertions assertions) { var constants = SmartType.For(assertions.Subject).GetAllConstants(); foreach (var constant in constants) { foreach (var otherConstant in constants) { constant.AssertNotDuplicateOf(otherConstant); } } return(new AndConstraint <TypeAssertions>(assertions)); }
/// <summary> /// Asserts that the current type does not explicitly implemented a method named <paramref name="name"/> defined on interface <paramref name="definingInterface"/>. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="definingInterface">The interface being explicitly implemented.</param> /// <param name="name">The name of the property</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> NotHaveExplicitMethod(this TypeAssertions typeAssertions, Type definingInterface, String name, string because = "", params object[] reasonArgs) { var explicitImplementations = typeAssertions.Subject.GetInterfaceMap(definingInterface); var explicitMethod = explicitImplementations.TargetMethods.FirstOrDefault( m => m.IsPrivate && m.IsFinal && m.Name.EndsWith("." + name)); Execute.Assertion.ForCondition(explicitMethod == null) .BecauseOf(because, reasonArgs) .FailWith("Expected method {0} not to exist.", explicitMethod == null ? string.Empty : explicitMethod.Name); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
public static void BeSubstituteOf <T>(this TypeAssertions typeAssertions, string because = "", params object[] becauseArgs) { string actualTypeName = typeAssertions.Subject.ToString(); string expectedRootTypeName = typeof(T).Name; string expectedTypeName = $"Castle.Proxies.{expectedRootTypeName}Proxy"; Execute.Assertion .ForCondition(actualTypeName.Equals(expectedTypeName)) .BecauseOf(because, becauseArgs) .FailWith(@"Expected type {0} to be a Substitute of {1}{reason}, but its type name is not {2}", typeAssertions.Subject, typeof(T), expectedTypeName); Execute.Assertion .ForCondition(typeAssertions.Subject.IsSubclassOf(typeof(T))) .BecauseOf(because, becauseArgs) .FailWith(@"Expected type {0} to be a Substitute of {1}{reason}, but it is not a subclass of it", typeAssertions.Subject, typeof(T)); }
public void AssertValidTypes() { TypeAssertions.AssertInheritedOrNull(EntityType, typeof(IEntity)); TypeAssertions.AssertInheritedOrNull(ViewModelType, typeof(IViewModel)); TypeAssertions.AssertInheritedOrNull(FormModelType, typeof(IFormModel)); if (ViewMappingConfigType != null) { TypeAssertions.AssertInheritedGenericTypeWithTypeArguments(ViewMappingConfigType, typeof(EntityViewModelMappingConfig <,>), EntityType, ViewModelType); } if (FormMappingConfigType != null) { TypeAssertions.AssertInheritedGenericTypeWithTypeArguments(FormMappingConfigType, typeof(EntityFormModelMappingConfig <,>), EntityType, FormModelType); } }
/// <summary> /// Asserts that the current type exposes an indexer with parameters types of <paramref name="parameterTypes"/> and an expected access modifier. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="parameterTypes">The types of the indexer's parameters.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> /// <param name="indexerType">The type of the indexer</param> /// <param name="setAccessModifier">Setter access modifier. Null if not settable.</param> /// /// <param name="getAccessModifier">Getter access modifier. Null if not gettable.</param> public static AndConstraint <TypeAssertions> HaveIndexer(this TypeAssertions typeAssertions, CSharpAccessModifiers?getAccessModifier, CSharpAccessModifiers?setAccessModifier, Type indexerType, IEnumerable <Type> parameterTypes, string because = "", params object[] reasonArgs) { var parameterTypesArray = parameterTypes as Type[] ?? parameterTypes.ToArray(); var propertyInfo = typeAssertions.Subject.GetProperty( "Item", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, indexerType, parameterTypesArray.ToArray(), null); var validGetter = false; var validSetter = false; if (propertyInfo != null) { if (getAccessModifier.HasValue) { validGetter = propertyInfo.GetMethod != null && getAccessModifier == propertyInfo.GetMethod.GetCSharpAccessModifier(); } else { validGetter = !propertyInfo.CanRead; } if (setAccessModifier.HasValue) { validSetter = propertyInfo.SetMethod != null && setAccessModifier == propertyInfo.SetMethod.GetCSharpAccessModifier(); } else { validSetter = !propertyInfo.CanWrite; } } Execute.Assertion.ForCondition(propertyInfo != null && validGetter && validSetter) .BecauseOf(because, reasonArgs) .FailWith("Expected type {0} to have a {1} indexer[{2}] with {3} getter and {4} setter.", typeAssertions.Subject.FullName, indexerType.FullName, string.Join(", ", parameterTypesArray.Select(p => p.FullName)), indexerType, getAccessModifier.HasValue ? getAccessModifier.ToString() : "no", setAccessModifier.HasValue ? setAccessModifier.ToString() : "no"); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
/// <summary> /// Asserts that the current type has explicitly implemented a method named <paramref name="name"/> defined on interface <paramref name="definingInterface"/>, accepting /// <paramref name="parameterTypes">parameterTypes of specified types</paramref> and returning /// <paramref name="returnType"/>. /// /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="definingInterface">The interface being explicitly implemented.</param> /// <param name="returnType">The type of the property.</param> /// <param name="name">The name of the property</param> /// <param name="parameterTypes">The types of the parameterTypes.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> HaveExplicitMethod(this TypeAssertions typeAssertions, Type definingInterface, String name, Type returnType, Type[] parameterTypes, string because = "", params object[] reasonArgs) { var explicitImplementations = typeAssertions.Subject.GetInterfaceMap(definingInterface) .TargetMethods.Where(m => m.IsPrivate && m.IsFinal); var methods = explicitImplementations.Where( m => m.ReturnType == returnType && m.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameterTypes) && m.Name.EndsWith(name)); Execute.Assertion.ForCondition(methods.Any()) .BecauseOf(because, reasonArgs) .FailWith("Expected method {0}.{1} to exist.", definingInterface.FullName, name); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
/// <summary> /// Asserts that the current type has a constructor with parameters types of <paramref name="parameterTypes"/> and an expected access modifier. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="accessModifier">The C# access modifier for the constructor.</param> /// <param name="parameterTypes">The types of the constructor's parameters.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> HaveConstructor(this TypeAssertions typeAssertions, CSharpAccessModifiers accessModifier, IEnumerable <Type> parameterTypes, string because = "", params object[] reasonArgs) { var parameterTypesArray = parameterTypes as Type[] ?? parameterTypes.ToArray(); var constructorInfo = typeAssertions.Subject.GetConstructor( BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, parameterTypesArray.ToArray(), null); var constructorAccessModifier = CSharpAccessModifiers.None; if (constructorInfo != null) { constructorAccessModifier = constructorInfo.GetCSharpAccessModifier(); } Execute.Assertion.ForCondition(constructorInfo != null && constructorAccessModifier == accessModifier) .BecauseOf(because, reasonArgs) .FailWith("Expected type {1} to have a {2} constructor with type parameterTypes {3}.", typeAssertions.Subject.FullName, string.Join(", ", parameterTypesArray.Select(p => p.FullName)), accessModifier); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
public static AndConstraint <TypeAssertions> BehaveLikeValue(this TypeAssertions o) { XAssert.IsValue(o.Subject); return(new AndConstraint <TypeAssertions>(o)); }
public static AndConstraint <TypeAssertions> HaveExactlyOneConstructorWithoutOptionalParameters(this TypeAssertions typeAssertions) { var publicConstructors = typeAssertions.Subject.GetConstructors(BindingFlags.Public | BindingFlags.Instance); Execute.Assertion.ForCondition(publicConstructors.Length == 1) .BecauseOf("because there should only be 1 public constructor") .FailWith("Expected {0} to have 1 public constructor{reason} but found {1} public constructors: {2}", typeAssertions.Subject, publicConstructors.Length, string.Join(", ", publicConstructors.Select((c, i) => $"constructor {i}: ({string.Join(", ", c.GetParameters().Select(p => p.Name))})"))); publicConstructors.Single().Should().NotHaveOptionalParameters(); return(new AndConstraint <TypeAssertions>(typeAssertions)); }
/// <summary> /// Asserts that the current type has a default constructor with an expected access modifier. /// </summary> /// <param name="typeAssertions">The TypeAssertion we are extending.</param> /// <param name="accessModifier">The C# access modifier for the constructor.</param> /// <param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.</param> /// <param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>.</param> public static AndConstraint <TypeAssertions> HaveDefaultConstructor(this TypeAssertions typeAssertions, CSharpAccessModifiers accessModifier, string because = "", params object[] reasonArgs) { return(HaveConstructor(typeAssertions, accessModifier, new Type[0], because, reasonArgs)); }