6277926364

Committed 22 Sep 2023 06:38PM UTC coverage: 73.953% (-9.2%) from 83.158%

Build # 6277926364

Build Type

push

github

Committed by

web-flow

Commit Message

Add IsIndexable (#28)

Run Details

323 of 452 branches covered (0.0%)

Branch coverage included in aggregate %.

349 of 349 new or added lines in 18 files covered. (100.0%)

648 of 861 relevant lines covered (75.26%)

20.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.11

/NetFabric.Reflection/Reflection/TypeExtensions.IsAsyncEnumerable.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Threading.Tasks;

namespace NetFabric.Reflection;

public static partial class TypeExtensions
{        
    /// <summary>
    /// Gets a value indicating whether 'await foreach' considers <see cref="System.Type"/> to be enumerable.
    /// </summary>
    /// <param name="type">The <see cref="System.Type"/> to test.</param>
    /// <returns><c>true</c> if 'await foreach' considers <see cref="System.Type"/> to be enumerable; otherwise, <c>false</c>.</returns>
    public static bool IsAsyncEnumerable(this Type type)
        => IsAsyncEnumerable(type, out _, out _);

    /// <summary>
    /// Gets a value indicating whether 'await foreach' considers <see cref="System.Type"/> to be enumerable.
    /// </summary>
    /// <param name="type">The <see cref="System.Type"/> to test.</param>
    /// <param name="enumerableInfo">If methods returns <c>true</c>, contains information on the methods 'await foreach' will use to enumerate.</param>
    /// <returns><c>true</c> if 'await foreach' considers <see cref="System.Type"/> to be enumerable; otherwise, <c>false</c>.</returns>
    public static bool IsAsyncEnumerable(this Type type, [NotNullWhen(true)] out AsyncEnumerableInfo? enumerableInfo)
        => IsAsyncEnumerable(type, out enumerableInfo, out _);

    /// <summary>
    /// Gets a value indicating whether 'await foreach' considers <see cref="System.Type"/> to be enumerable.
    /// </summary>
    /// <param name="type">The <see cref="System.Type"/> to test.</param>
    /// <param name="enumerableInfo">If methods returns <c>true</c>, contains information on the methods 'await foreach' will use to enumerate.</param>
    /// <param name="error">Gets information on what error caused the method to return <c>false</c>.</param>
    /// <returns><c>true</c> if 'await foreach' considers <see cref="System.Type"/> to be enumerable; otherwise, <c>false</c>.</returns>
    public static bool IsAsyncEnumerable(this Type type,
        [NotNullWhen(true)] out AsyncEnumerableInfo? enumerableInfo,
        out IsAsyncEnumerableError error)
    {
        var getAsyncEnumerator = type.GetPublicMethod(NameOf.GetAsyncEnumerator, typeof(CancellationToken));
        getAsyncEnumerator ??= type.GetPublicMethod(NameOf.GetAsyncEnumerator);
        if (getAsyncEnumerator is null && !type.IsInterface && type.ImplementsInterface(typeof(IAsyncEnumerable<>), out var genericArguments))
        {       
            var interfaceType = typeof(IAsyncEnumerable<>).MakeGenericType(genericArguments); 
            getAsyncEnumerator ??= interfaceType.GetPublicMethod(NameOf.GetAsyncEnumerator, typeof(CancellationToken));
            getAsyncEnumerator ??= interfaceType.GetPublicMethod(NameOf.GetAsyncEnumerator);
        }        
        if (getAsyncEnumerator is null)
        {
            enumerableInfo = default;
            error = IsAsyncEnumerableError.MissingGetAsyncEnumerator;
            return false;
        }

        var enumeratorType = getAsyncEnumerator.ReturnType;
        
        var current = enumeratorType.GetPublicReadProperty(NameOf.Current);
        var moveNextAsync = enumeratorType.GetPublicMethod(NameOf.MoveNextAsync);

        if ((current is null || moveNextAsync is null) && !type.IsInterface)
        {
            if (type.ImplementsInterface(typeof(IAsyncEnumerator<>), out genericArguments))
            {
                var interfaceType = typeof(IAsyncEnumerator<>).MakeGenericType(genericArguments);
                current ??= interfaceType.GetPublicReadProperty(NameOf.Current);
                moveNextAsync ??= interfaceType.GetPublicMethod(NameOf.MoveNextAsync);
            }
        }

        if (current is null)
        {
            enumerableInfo = default;
            error = IsAsyncEnumerableError.MissingCurrent;
            return false;
        }
        
        if (moveNextAsync is null || moveNextAsync.ReturnType != typeof(ValueTask<bool>))
        {
            enumerableInfo = default;
            error = IsAsyncEnumerableError.MissingMoveNextAsync;
            return false;
        }
        
        _ = enumeratorType.IsAsyncDisposable(out var dispose);

        enumerableInfo = new AsyncEnumerableInfo(
            getAsyncEnumerator: getAsyncEnumerator,
            new AsyncEnumeratorInfo(current, moveNextAsync)
            {
                DisposeAsync = dispose,
                IsValueType = getAsyncEnumerator.ReturnType.IsValueType,
                IsAsyncEnumeratorInterface = enumeratorType.IsInterface,
            }
        );
        error = IsAsyncEnumerableError.None; 
        return true;
    }
}

1	using System;
2	using System.Collections;
3	using System.Collections.Generic;
4	using System.Diagnostics.CodeAnalysis;
5	using System.Threading;
6	using System.Threading.Tasks;
7
8	namespace NetFabric.Reflection;
9
10	public static partial class TypeExtensions
11	{
12	/// <summary>
13	/// Gets a value indicating whether 'await foreach' considers <see cref="System.Type"/> to be enumerable.
14	/// </summary>
15	/// <param name="type">The <see cref="System.Type"/> to test.</param>
16	/// <returns><c>true</c> if 'await foreach' considers <see cref="System.Type"/> to be enumerable; otherwise, <c>false</c>.</returns>
17	public static bool IsAsyncEnumerable(this Type type)
18	=> IsAsyncEnumerable(type, out _, out _);	×
19
20	/// <summary>
21	/// Gets a value indicating whether 'await foreach' considers <see cref="System.Type"/> to be enumerable.
22	/// </summary>
23	/// <param name="type">The <see cref="System.Type"/> to test.</param>
24	/// <param name="enumerableInfo">If methods returns <c>true</c>, contains information on the methods 'await foreach' will use to enumerate.</param>
25	/// <returns><c>true</c> if 'await foreach' considers <see cref="System.Type"/> to be enumerable; otherwise, <c>false</c>.</returns>
26	public static bool IsAsyncEnumerable(this Type type, [NotNullWhen(true)] out AsyncEnumerableInfo? enumerableInfo)
27	=> IsAsyncEnumerable(type, out enumerableInfo, out _);	×
28
29	/// <summary>
30	/// Gets a value indicating whether 'await foreach' considers <see cref="System.Type"/> to be enumerable.
31	/// </summary>
32	/// <param name="type">The <see cref="System.Type"/> to test.</param>
33	/// <param name="enumerableInfo">If methods returns <c>true</c>, contains information on the methods 'await foreach' will use to enumerate.</param>
34	/// <param name="error">Gets information on what error caused the method to return <c>false</c>.</param>
35	/// <returns><c>true</c> if 'await foreach' considers <see cref="System.Type"/> to be enumerable; otherwise, <c>false</c>.</returns>
36	public static bool IsAsyncEnumerable(this Type type,
37	[NotNullWhen(true)] out AsyncEnumerableInfo? enumerableInfo,
38	out IsAsyncEnumerableError error)
39	{
40	var getAsyncEnumerator = type.GetPublicMethod(NameOf.GetAsyncEnumerator, typeof(CancellationToken));	13✔
41	getAsyncEnumerator ??= type.GetPublicMethod(NameOf.GetAsyncEnumerator);	13✔
42	if (getAsyncEnumerator is null && !type.IsInterface && type.ImplementsInterface(typeof(IAsyncEnumerable<>), out var genericArguments))	13✔
43	{
44	var interfaceType = typeof(IAsyncEnumerable<>).MakeGenericType(genericArguments);	1✔
45	getAsyncEnumerator ??= interfaceType.GetPublicMethod(NameOf.GetAsyncEnumerator, typeof(CancellationToken));	1✔
46	getAsyncEnumerator ??= interfaceType.GetPublicMethod(NameOf.GetAsyncEnumerator);	1!
47	}
48	if (getAsyncEnumerator is null)	13✔
49	{
50	enumerableInfo = default;	1✔
51	error = IsAsyncEnumerableError.MissingGetAsyncEnumerator;	1✔
52	return false;	1✔
53	}
54
55	var enumeratorType = getAsyncEnumerator.ReturnType;	12✔
56
57	var current = enumeratorType.GetPublicReadProperty(NameOf.Current);	12✔
58	var moveNextAsync = enumeratorType.GetPublicMethod(NameOf.MoveNextAsync);	12✔
59
60	if ((current is null \|\| moveNextAsync is null) && !type.IsInterface)	12✔
61	{
62	if (type.ImplementsInterface(typeof(IAsyncEnumerator<>), out genericArguments))	2!
63	{
64	var interfaceType = typeof(IAsyncEnumerator<>).MakeGenericType(genericArguments);	×
65	current ??= interfaceType.GetPublicReadProperty(NameOf.Current);	×
66	moveNextAsync ??= interfaceType.GetPublicMethod(NameOf.MoveNextAsync);	×
67	}
68	}
69
70	if (current is null)	12✔
71	{
72	enumerableInfo = default;	1✔
73	error = IsAsyncEnumerableError.MissingCurrent;	1✔
74	return false;	1✔
75	}
76
77	if (moveNextAsync is null \|\| moveNextAsync.ReturnType != typeof(ValueTask<bool>))	11✔
78	{
79	enumerableInfo = default;	2✔
80	error = IsAsyncEnumerableError.MissingMoveNextAsync;	2✔
81	return false;	2✔
82	}
83
84	_ = enumeratorType.IsAsyncDisposable(out var dispose);	9✔
85
86	enumerableInfo = new AsyncEnumerableInfo(	9✔
87	getAsyncEnumerator: getAsyncEnumerator,	9✔
88	new AsyncEnumeratorInfo(current, moveNextAsync)	9✔
89	{	9✔
90	DisposeAsync = dispose,	9✔
91	IsValueType = getAsyncEnumerator.ReturnType.IsValueType,	9✔
92	IsAsyncEnumeratorInterface = enumeratorType.IsInterface,	9✔
93	}	9✔
94	);	9✔
95	error = IsAsyncEnumerableError.None;	9✔
96	return true;	9✔
97	}
98	}

NetFabric / NetFabric.CodeAnalysis / 6277926364

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous