public async Task DefaultIfEmptyWithInt64SourceWithDefaultValueIsEquivalentToDefaultIfEmptyTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <long>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <long>();
// Arrange 'defaultValue' parameter
var defaultValue = 5;
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.DefaultIfEmpty <long>(source, defaultValue);
// Act
var result = await AsyncQueryable.DefaultIfEmpty <long>(asyncSource, defaultValue).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task ConcatWithInt32SourceWithFirstWithSecondIsEquivalentToConcatTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'first' parameter
var first = GetQueryable <int>();
// Arrange 'second' parameter
var second = GetQueryable <int>();
// Arrange 'asyncFirst' parameter
var asyncFirst = queryAdapter.GetAsyncQueryable <int>();
// Arrange 'asyncSecond' parameter
var asyncSecond = queryAdapter.GetAsyncQueryable <int>();
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.Concat <int>(first, second);
// Act
var result = await AsyncQueryable.Concat <int>(asyncFirst, asyncSecond).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task ToListAsyncWithInt32SourceCanceledCancellationTokenThrowsOperationCanceledExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <int>();
// Arrange 'cancellationToken' parameter
using var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
cancellationTokenSource.Cancel();
// Act
// -
// Assert
await Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
await AsyncQueryable.ToListAsync <int>(asyncSource, cancellationToken).ConfigureAwait(false);
});
}
public async Task DistinctWithInt64SourceWithComparerIsEquivalentToDistinctTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <long>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <long>();
// Arrange 'comparer' parameter
var comparer = EqualityComparer <long> .Default;
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.Distinct <long>(source, comparer);
// Act
var result = await AsyncQueryable.Distinct <long>(asyncSource, comparer).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task SkipLastWithNullableDecimalSourceWithCountIsEquivalentToSkipLastTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <decimal?>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <decimal?>();
// Arrange 'count' parameter
var count = 5;
// Arrange 'expectedResult' parameter
var expectedResult =
EnumerableExtension
.SkipLast <decimal?>(source, count);
// Act
var result = await AsyncQueryable.SkipLast <decimal?>(asyncSource, count).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task AppendWithNullableDecimalSourceWithElementIsEquivalentToAppendTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <decimal?>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <decimal?>();
// Arrange 'element' parameter
var element = 5;
// Arrange 'expectedResult' parameter
var expectedResult =
Enumerable
.Append <decimal?>(source, element);
// Act
var result = await AsyncQueryable.Append <decimal?>(asyncSource, element).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task ToListAsyncWithInt32SourceIsEquivalentToToListTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <int>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <int>();
// Arrange 'cancellationToken' parameter
var cancellationToken = CancellationToken.None;
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.ToList <int>(source);
// Act
var result = await AsyncQueryable.ToListAsync <int>(asyncSource, cancellationToken).ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task ElementAtOrDefaultAsyncWithInt32SourceWithIndexNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <int> asyncSource = null !;
// Arrange 'index' parameter
var index = 5;
// Arrange 'cancellationToken' parameter
var cancellationToken = CancellationToken.None;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.ElementAtOrDefaultAsync <int>(asyncSource, index, cancellationToken).ConfigureAwait(false);
});
}
public async Task ElementAtOrDefaultAsyncWithInt64SourceWithIndexCanceledCancellationTokenThrowsOperationCanceledExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <long>();
// Arrange 'index' parameter
var index = 5;
// Arrange 'cancellationToken' parameter
using var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
cancellationTokenSource.Cancel();
// Act
// -
// Assert
await Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
await AsyncQueryable.ElementAtOrDefaultAsync <long>(asyncSource, index, cancellationToken).ConfigureAwait(false);
});
}
public async Task ElementAtOrDefaultAsyncWithInt64SourceWithIndexIsEquivalentToElementAtOrDefaultTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <long>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <long>();
// Arrange 'index' parameter
var index = 5;
// Arrange 'cancellationToken' parameter
var cancellationToken = CancellationToken.None;
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.ElementAtOrDefault <long>(source, index);
// Act
var result = await AsyncQueryable.ElementAtOrDefaultAsync <long>(asyncSource, index, cancellationToken).ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task TakeWithInt32SourceWithCountIsEquivalentToTakeTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <int>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <int>();
// Arrange 'count' parameter
var count = 5;
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.Take <int>(source, count);
// Act
var result = await AsyncQueryable.Take <int>(asyncSource, count).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task DistinctWithDoubleSourceNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <double> asyncSource = null !;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.Distinct <double>(asyncSource).ToListAsync().ConfigureAwait(false);
});
}
public async Task ReverseWithNullableInt64SourceNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <long?> asyncSource = null !;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.Reverse <long?>(asyncSource).ToListAsync().ConfigureAwait(false);
});
}
public async Task OfTypeWithInt32ResultNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <object> asyncSource = null !;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.OfType <int>(asyncSource).ToListAsync().ConfigureAwait(false);
});
}
public async Task DefaultIfEmptyWithNullableSingleSourceNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <float?> asyncSource = null !;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.DefaultIfEmpty <float?>(asyncSource).ToListAsync().ConfigureAwait(false);
});
}
public async Task OfTypeWithInt32ResultIsEquivalentToOfTypeTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var sourcePart1 = GetQueryable <double>().Select(p => (object)p);
var sourcePart2 = GetQueryable <decimal?>().Select(p => (object)p);
var sourcePart3 = GetQueryable <float?>().Select(p => (object)p);
var sourcePart4 = GetQueryable <double?>().Select(p => (object)p);
var sourcePart5 = GetQueryable <decimal>().Select(p => (object)p);
var sourcePart6 = GetQueryable <float>().Select(p => (object)p);
var sourcePart7 = GetQueryable <long?>().Select(p => (object)p);
var sourcePart8 = GetQueryable <int?>().Select(p => (object)p);
var sourcePart9 = GetQueryable <long>().Select(p => (object)p);
var sourcePart10 = GetQueryable <int>().Select(p => (object)p);
var source = sourcePart1.Concat(sourcePart2).Concat(sourcePart3).Concat(sourcePart4).Concat(sourcePart5).Concat(sourcePart6).Concat(sourcePart7).Concat(sourcePart8).Concat(sourcePart9).Concat(sourcePart10);
// Arrange 'asyncSource' parameter
var asyncSourcePart1 = queryAdapter.GetAsyncQueryable <double>().Select(p => (object)p);
var asyncSourcePart2 = queryAdapter.GetAsyncQueryable <decimal?>().Select(p => (object)p);
var asyncSourcePart3 = queryAdapter.GetAsyncQueryable <float?>().Select(p => (object)p);
var asyncSourcePart4 = queryAdapter.GetAsyncQueryable <double?>().Select(p => (object)p);
var asyncSourcePart5 = queryAdapter.GetAsyncQueryable <decimal>().Select(p => (object)p);
var asyncSourcePart6 = queryAdapter.GetAsyncQueryable <float>().Select(p => (object)p);
var asyncSourcePart7 = queryAdapter.GetAsyncQueryable <long?>().Select(p => (object)p);
var asyncSourcePart8 = queryAdapter.GetAsyncQueryable <int?>().Select(p => (object)p);
var asyncSourcePart9 = queryAdapter.GetAsyncQueryable <long>().Select(p => (object)p);
var asyncSourcePart10 = queryAdapter.GetAsyncQueryable <int>().Select(p => (object)p);
var asyncSource = asyncSourcePart1.Concat(asyncSourcePart2).Concat(asyncSourcePart3).Concat(asyncSourcePart4).Concat(asyncSourcePart5).Concat(asyncSourcePart6).Concat(asyncSourcePart7).Concat(asyncSourcePart8).Concat(asyncSourcePart9).Concat(asyncSourcePart10);
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.OfType <int>(source);
// Act
var result = await AsyncQueryable.OfType <int>(asyncSource).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task TakeWithInt64SourceWithCountNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <long> asyncSource = null !;
// Arrange 'count' parameter
var count = 5;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.Take <long>(asyncSource, count).ToListAsync().ConfigureAwait(false);
});
}
public async Task DistinctWithInt64SourceWithComparerNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <long> asyncSource = null !;
// Arrange 'comparer' parameter
var comparer = EqualityComparer <long> .Default;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.Distinct <long>(asyncSource, comparer).ToListAsync().ConfigureAwait(false);
});
}
public async Task ReverseWithNullableInt32SourceIsEquivalentToReverseTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <int?>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <int?>();
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.Reverse <int?>(source);
// Act
var result = await AsyncQueryable.Reverse <int?>(asyncSource).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task AppendWithInt32SourceWithElementNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <int> asyncSource = null !;
// Arrange 'element' parameter
var element = 5;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.Append <int>(asyncSource, element).ToListAsync().ConfigureAwait(false);
});
}
public async Task ConcatWithDoubleSourceWithFirstWithSecondNullSecondThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncFirst' parameter
var asyncFirst = queryAdapter.GetAsyncQueryable <double>();
// Arrange 'asyncSecond' parameter
IAsyncEnumerable <double> asyncSecond = null !;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.Concat <double>(asyncFirst, asyncSecond).ToListAsync().ConfigureAwait(false);
});
}
public async Task ToListAsyncWithInt64SourceNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <long> asyncSource = null !;
// Arrange 'cancellationToken' parameter
var cancellationToken = CancellationToken.None;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.ToListAsync <long>(asyncSource, cancellationToken).ConfigureAwait(false);
});
}
public async Task DistinctWithDoubleSourceIsEquivalentToDistinctTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <double>();
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <double>();
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.Distinct <double>(source);
// Act
var result = await AsyncQueryable.Distinct <double>(asyncSource).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task CastWithNullableDecimalResultIsEquivalentToCastTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'source' parameter
var source = GetQueryable <decimal?>().Select(p => (object)p);
// Arrange 'asyncSource' parameter
var asyncSource = queryAdapter.GetAsyncQueryable <decimal?>().Select(p => (object)p);
// Arrange 'expectedResult' parameter
var expectedResult = Enumerable.Cast <decimal?>(source);
// Act
var result = await AsyncQueryable.Cast <decimal?>(asyncSource).ToListAsync().ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task DefaultIfEmptyWithInt64SourceWithDefaultValueNullSourceThrowsArgumentNullExceptionTest()
{
// Arrange
// Arrange 'queryAdapter' parameter
var queryAdapter = await GetQueryAdapterAsync(DisallowAll);
// Arrange 'asyncSource' parameter
IAsyncQueryable <long> asyncSource = null !;
// Arrange 'defaultValue' parameter
var defaultValue = 5;
// Act
// -
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await AsyncQueryable.DefaultIfEmpty <long>(asyncSource, defaultValue).ToListAsync().ConfigureAwait(false);
});
}
