public MethodAnalyzerTests() { var t = typeof(SomeTypeWithManyMethods); _doVoidInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.DoVoid)) !); _acceptIntVoidInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.AcceptIntVoid)) !); _echoStringInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.EchoString)) !); _doTaskInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.DoTask)) !); _doValueTaskInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.DoValueTask)) !); _doAndReturnValueTaskInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.DoAndReturnValueTask)) !); _returnTaskInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.ReturnTask)) !); _multiInspection = new MethodInspection( t, t.GetMethod(nameof(SomeTypeWithManyMethods.Multi)) !); }
public void Return_type_is_correct() { var inspection = new MethodInspection(_inspectedType, _inspectedMethod); Assert.NotNull(inspection.ReturnType); Assert.Equal(typeof(int), inspection.ReturnType); }
public void Constructor_parameters_are_used() { var inspection = new MethodInspection(_inspectedType, _inspectedMethod); Assert.NotNull(inspection.InspectedType); Assert.Same(_inspectedType, inspection.InspectedType); Assert.NotNull(inspection.InspectedMethod); Assert.Same(_inspectedMethod, inspection.InspectedMethod); }
public void Can_be_deconstructed() { var inspection = new MethodInspection(_inspectedType, _inspectedMethod); var(inspectedType, inspectedMethod, parameters, returnType) = inspection; Assert.Same(_inspectedType, inspectedType); Assert.Same(_inspectedMethod, inspectedMethod); Assert.Equal(3, parameters.Count); Assert.Equal(typeof(int), returnType); }
public void Parameters_are_correct() { var inspection = new MethodInspection(_inspectedType, _inspectedMethod); Assert.NotNull(inspection.Parameters); Assert.NotEmpty(inspection.Parameters); Assert.Equal(3, inspection.Parameters.Count); Assert.Equal(typeof(Guid), inspection.Parameters[0].ParameterType); Assert.Equal(typeof(string), inspection.Parameters[1].ParameterType); Assert.Equal(typeof(IDisposable), inspection.Parameters[2].ParameterType); }
public bool IsMatch( MethodInspection inspection, Type requestType, bool allowCancellationTokenParameter, [NotNullWhen(true)] out MethodInfo?match) { match = null; var(_, method, parameters, _) = inspection; if (parameters.Count == 0 && requestType == typeof(void)) { match = method; return(true); } if (parameters.Count > 2) { return(false); } if (parameters.Count == 2) { if (!allowCancellationTokenParameter) { return(false); } if (!AcceptsCancellationToken(inspection)) { return(false); } } var theParameter = parameters[0]; if (IsSameOrCompatible(baseType: theParameter.ParameterType, requestType)) { match = method; return(true); } return(false); }
public bool IsMatch( MethodInspection inspection, Type requestType, Type responseType, bool allowCancellationTokenParameter, [NotNullWhen(true)] out MethodInfo?match) { match = null; if (!IsMatch(inspection, requestType, allowCancellationTokenParameter, out _)) { return(false); } // Method has the correct input parameter. // Check the return type! var(_, method, _, returnType) = inspection; if (IsSameOrCompatible(baseType: responseType, returnType)) { match = method; return(true); } // The return type may be an awaitable! // (Task<TResponse>, ValueTask<TResponse>, ...) if (!returnType.IsAwaitableWithResult(out var awaitResultType)) { return(false); } if (IsSameOrCompatible(baseType: responseType, awaitResultType)) { // It's a match: Task/ValueTask/Awaitable of TResponse. match = method; return(true); } return(false); }
public bool AcceptsCancellationToken(MethodInspection inspection) => AcceptCancellationToken(inspection.Parameters);