public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArraySequenceEqualArray), ArraySequenceEqualArray, ArraySequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualSimpleList), ArraySequenceEqualSimpleList, ArraySequenceEqualSimpleListRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualEnumerable), ArraySequenceEqualEnumerable, ArraySequenceEqualEnumerableRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualMethod), ArraySequenceEqualMethod, ArraySequenceEqualMethodRewritten);
TestsExtensions.TestEquals(nameof(SimpleListSequenceEqualArray), SimpleListSequenceEqualArray, SimpleListSequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(SimpleListSequenceEqualSimpleList), SimpleListSequenceEqualSimpleList, SimpleListSequenceEqualSimpleListRewritten);
TestsExtensions.TestEquals(nameof(SimpleListSequenceEqualEnumerable), SimpleListSequenceEqualEnumerable, SimpleListSequenceEqualEnumerableRewritten);
TestsExtensions.TestEquals(nameof(SimpleListSequenceEqualMethod), SimpleListSequenceEqualMethod, SimpleListSequenceEqualMethodRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSequenceEqualArray), EnumerableSequenceEqualArray, EnumerableSequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSequenceEqualSimpleList), EnumerableSequenceEqualSimpleList, EnumerableSequenceEqualSimpleListRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSequenceEqualEnumerable), EnumerableSequenceEqualEnumerable, EnumerableSequenceEqualEnumerableRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSequenceEqualMethod), EnumerableSequenceEqualMethod, EnumerableSequenceEqualMethodRewritten);
TestsExtensions.TestEquals(nameof(MethodSequenceEqualArray), MethodSequenceEqualArray, MethodSequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(MethodSequenceEqualSimpleList), MethodSequenceEqualSimpleList, MethodSequenceEqualSimpleListRewritten);
TestsExtensions.TestEquals(nameof(MethodSequenceEqualEnumerable), MethodSequenceEqualEnumerable, MethodSequenceEqualEnumerableRewritten);
TestsExtensions.TestEquals(nameof(MethodSequenceEqualMethod), MethodSequenceEqualMethod, MethodSequenceEqualMethodRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectSequenceEqualArray), ArraySelectSequenceEqualArray, ArraySelectSequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectSequenceEqualArraySelect), ArraySelectSequenceEqualArraySelect, ArraySelectSequenceEqualArraySelectRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereSequenceEqualArrayWhere), ArrayWhereSequenceEqualArrayWhere, ArrayWhereSequenceEqualArrayWhereRewritten);
TestsExtensions.TestEquals(nameof(SelectWhereArraySequenceEqualSelectWhereArray), SelectWhereArraySequenceEqualSelectWhereArray, SelectWhereArraySequenceEqualSelectWhereArrayRewritten);
TestsExtensions.TestEquals(nameof(RangeSequenceEqualArray), RangeSequenceEqualArray, RangeSequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(RepeatSequenceEqualArray), RepeatSequenceEqualArray, RepeatSequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(EmptySequenceEqualArray), EmptySequenceEqualArray, EmptySequenceEqualArrayRewritten);
TestsExtensions.TestEquals(nameof(RangeEmpty2Array), RangeEmpty2Array, RangeEmpty2ArrayRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualRange), ArraySequenceEqualRange, ArraySequenceEqualRangeRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualRepeat), ArraySequenceEqualRepeat, ArraySequenceEqualRepeatRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualEmpty), ArraySequenceEqualEmpty, ArraySequenceEqualEmptyRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualEmpty2), ArraySequenceEqualEmpty2, ArraySequenceEqualEmpty2Rewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualAll), ArraySequenceEqualAll, ArraySequenceEqualAllRewritten);
TestsExtensions.TestEquals(nameof(ArraySequenceEqualNull), ArraySequenceEqualNull, ArraySequenceEqualNullRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctSequenceEqualArrayDistinct), ArrayDistinctSequenceEqualArrayDistinct, ArrayDistinctSequenceEqualArrayDistinctRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctSequenceEqualArrayDistinct2), ArrayDistinctSequenceEqualArrayDistinct, ArrayDistinctSequenceEqualArrayDistinct2Rewritten);
}
public void ContainerShouldResolveFromParentOfParent_MT()
{
// Given
var expectedRef = Mock.Of <IMyService1>();
Func <IMyService1> func = () => expectedRef;
using (var container = Container.Create())
using (container.Bind <IMyService1>().As(Lifetime.Transient).To(ctx => func()))
{
var childRef = Mock.Of <IMyService>();
Func <IMyService1> childFunc = () => childRef;
TestsExtensions.Parallelize(() =>
{
// When
using (var childContainer1 = container.CreateChild())
using (var childContainer2 = childContainer1.CreateChild())
using (childContainer2.Bind <IMyService1>().As(Lifetime.Transient).To(ctx => childFunc()))
using (childContainer2.Bind <IMyService>().As(Lifetime.Transient).To(
ctx => new MyService((string)ctx.Args[0], ctx.Container.Parent.Parent.Inject <IMyService1>())))
{
// Then
var actualInstance = childContainer2.Resolve <IMyService>("abc");
actualInstance.ShouldBeOfType <MyService>();
((MyService)actualInstance).SomeRef.ShouldBe(expectedRef);
}
});
}
}
public void ContainerShouldResolveWhenSingletonLifetime_MT()
{
// Given
using (var container = Container.Create())
{
Func <IMyService> func = Mock.Of <IMyService>;
// When
using (container.Bind <IMyService>().As(Lifetime.Singleton).To(ctx => func()))
{
TestsExtensions.Parallelize(() =>
{
// Then
var instance1 = container.Resolve <IMyService>();
var instance2 = container.Resolve <IMyService>();
using (var childContainer = container.CreateChild())
{
var instance3 = childContainer.Resolve <IMyService>();
instance1.ShouldNotBeNull();
instance1.ShouldBe(instance2);
instance1.ShouldBe(instance3);
}
});
}
}
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(NullSelectMany), NullSelectMany, NullSelectManyRewritten);
TestsExtensions.TestEquals(nameof(NullableSelectMany), NullableSelectMany, NullableSelectManyRewritten);
TestsExtensions.TestEquals(nameof(SelectManyArray), SelectManyArray, SelectManyArrayRewritten);
TestsExtensions.TestEquals(nameof(SelectManyList), SelectManyList, SelectManyListRewritten);
TestsExtensions.TestEquals(nameof(SelectManySimpleList), SelectManySimpleList, SelectManySimpleListRewritten);
TestsExtensions.TestEquals(nameof(SelectManyEnumerable), SelectManyEnumerable, SelectManyEnumerableRewritten);
TestsExtensions.TestEquals(nameof(SelectManyArrayToArray), SelectManyArrayToArray, SelectManyArrayToArrayRewritten);
TestsExtensions.TestEquals(nameof(SelectManyListToArray), SelectManyListToArray, SelectManyListToArrayRewritten);
TestsExtensions.TestEquals(nameof(SelectManyEnumerableToArray), SelectManyEnumerableToArray, SelectManyEnumerableToArrayRewritten);
TestsExtensions.TestEquals(nameof(SelectManySimpleListToArray), SelectManySimpleListToArray, SelectManySimpleListToArrayRewritten);
TestsExtensions.TestEquals(nameof(SelectManyArrayToSimpleList), SelectManyArrayToSimpleList, SelectManyArrayToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(SelectManyListToSimpleList), SelectManyListToSimpleList, SelectManyListToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(SelectManyEnumerableToSimpleList), SelectManyEnumerableToSimpleList, SelectManyEnumerableToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(SelectManySimpleListToSimpleList), SelectManySimpleListToSimpleList, SelectManySimpleListToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(SelectManyArrayToList), SelectManyArrayToList, SelectManyArrayToListRewritten);
TestsExtensions.TestEquals(nameof(SelectManyListToList), SelectManyListToList, SelectManyListToListRewritten);
TestsExtensions.TestEquals(nameof(SelectManyEnumerableToList), SelectManyEnumerableToList, SelectManyEnumerableToListRewritten);
TestsExtensions.TestEquals(nameof(SelectManySimpleListToList), SelectManySimpleListToList, SelectManySimpleListToListRewritten);
TestsExtensions.TestEquals(nameof(SelectManyStaticArray), SelectManyStaticArray, SelectManyStaticArrayRewritten);
TestsExtensions.TestEquals(nameof(SelectManyMethodManySelector), SelectManyMethodManySelector, SelectManyMethodManySelectorRewritten);
TestsExtensions.TestEquals(nameof(StaticSelectMany), StaticSelectMany, StaticSelectManyRewritten);
TestsExtensions.TestEquals(nameof(StaticClassSelectMany), StaticClassSelectMany, StaticClassSelectManyRewritten);
TestsExtensions.TestEquals(nameof(MultipleSelectMany), MultipleSelectMany, MultipleSelectManyRewritten);
TestsExtensions.TestEquals(nameof(StaticSelectMany), StaticSelectMany, StaticSelectManyRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayTake), ArrayTake, ArrayTakeRewritten);
TestsExtensions.TestEquals(nameof(ArrayTake0), ArrayTake0, ArrayTake0Rewritten);
TestsExtensions.TestEquals(nameof(ArrayTakeM1), ArrayTakeM1, ArrayTakeM1Rewritten);
TestsExtensions.TestEquals(nameof(ArrayTake1000), ArrayTake1000, ArrayTake1000Rewritten);
TestsExtensions.TestEquals(nameof(ArrayTakeParam), ArrayTakeParam, ArrayTakeParamRewritten);
TestsExtensions.TestEquals(nameof(EnumerableTake), EnumerableTake, EnumerableTakeRewritten);
TestsExtensions.TestEquals(nameof(EnumerableTake0), EnumerableTake0, EnumerableTake0Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableTakeM1), EnumerableTakeM1, EnumerableTakeM1Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableTake1000), EnumerableTake1000, EnumerableTake1000Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableTakeParam), EnumerableTakeParam, EnumerableTakeParamRewritten);
TestsExtensions.TestEquals(nameof(RangeTake), RangeTake, RangeTakeRewritten);
TestsExtensions.TestEquals(nameof(RangeTake0), RangeTake0, RangeTake0Rewritten);
TestsExtensions.TestEquals(nameof(RangeTakeM1), RangeTakeM1, RangeTakeM1Rewritten);
TestsExtensions.TestEquals(nameof(RangeTake1000), RangeTake1000, RangeTake1000Rewritten);
TestsExtensions.TestEquals(nameof(RangeTakeParam), RangeTakeParam, RangeTakeParamRewritten);
TestsExtensions.TestEquals(nameof(RepeatTake), RepeatTake, RepeatTakeRewritten);
TestsExtensions.TestEquals(nameof(RepeatTake0), RepeatTake0, RepeatTake0Rewritten);
TestsExtensions.TestEquals(nameof(RepeatTakeM1), RepeatTakeM1, RepeatTakeM1Rewritten);
TestsExtensions.TestEquals(nameof(RepeatTake1000), RepeatTake1000, RepeatTake1000Rewritten);
TestsExtensions.TestEquals(nameof(RepeatTakeParam), RepeatTakeParam, RepeatTakeParamRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectTakeToArray), ArraySelectTakeToArray, ArraySelectTakeToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectTakeM1ToArray), ArraySelectTakeM1ToArray, ArraySelectTakeM1ToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereTakeToArray), ArrayWhereTakeToArray, ArrayWhereTakeToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereFalseTakeToArray), ArrayWhereFalseTakeToArray, ArrayWhereFalseTakeToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayTakeToArray), ArrayTakeToArray, ArrayTakeToArrayRewritten);
TestsExtensions.TestEquals(nameof(EnumerableTakeToArray), EnumerableTakeToArray, EnumerableTakeToArrayRewritten);
TestsExtensions.TestEquals(nameof(RangeTakeToArray), RangeTakeToArray, RangeTakeToArrayRewritten);
TestsExtensions.TestEquals(nameof(RepeatTakeToArray), RepeatTakeToArray, RepeatTakeToArrayRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArraySkip), ArraySkip, ArraySkipRewritten);
TestsExtensions.TestEquals(nameof(ArraySkip0), ArraySkip0, ArraySkip0Rewritten);
TestsExtensions.TestEquals(nameof(ArraySkipM1), ArraySkipM1, ArraySkipM1Rewritten);
TestsExtensions.TestEquals(nameof(ArraySkip1000), ArraySkip1000, ArraySkip1000Rewritten);
TestsExtensions.TestEquals(nameof(ArraySkipParam), ArraySkipParam, ArraySkipParamRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSkip), EnumerableSkip, EnumerableSkipRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSkip0), EnumerableSkip0, EnumerableSkip0Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableSkipM1), EnumerableSkipM1, EnumerableSkipM1Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableSkip1000), EnumerableSkip1000, EnumerableSkip1000Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableSkipParam), EnumerableSkipParam, EnumerableSkipParamRewritten);
TestsExtensions.TestEquals(nameof(RangeSkip), RangeSkip, RangeSkipRewritten);
TestsExtensions.TestEquals(nameof(RangeSkip0), RangeSkip0, RangeSkip0Rewritten);
TestsExtensions.TestEquals(nameof(RangeSkipM1), RangeSkipM1, RangeSkipM1Rewritten);
TestsExtensions.TestEquals(nameof(RangeSkip1000), RangeSkip1000, RangeSkip1000Rewritten);
TestsExtensions.TestEquals(nameof(RangeSkipParam), RangeSkipParam, RangeSkipParamRewritten);
TestsExtensions.TestEquals(nameof(RepeatSkip), RepeatSkip, RepeatSkipRewritten);
TestsExtensions.TestEquals(nameof(RepeatSkip0), RepeatSkip0, RepeatSkip0Rewritten);
TestsExtensions.TestEquals(nameof(RepeatSkipM1), RepeatSkipM1, RepeatSkipM1Rewritten);
TestsExtensions.TestEquals(nameof(RepeatSkip1000), RepeatSkip1000, RepeatSkip1000Rewritten);
TestsExtensions.TestEquals(nameof(RepeatSkipParam), RepeatSkipParam, RepeatSkipParamRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectSkipToArray), ArraySelectSkipToArray, ArraySelectSkipToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectSkipM1ToArray), ArraySelectSkipM1ToArray, ArraySelectSkipM1ToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereSkipToArray), ArrayWhereSkipToArray, ArrayWhereSkipToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereFalseSkipToArray), ArrayWhereFalseSkipToArray, ArrayWhereFalseSkipToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArraySkipToArray), ArraySkipToArray, ArraySkipToArrayRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSkipToArray), EnumerableSkipToArray, EnumerableSkipToArrayRewritten);
TestsExtensions.TestEquals(nameof(RangeSkipToArray), RangeSkipToArray, RangeSkipToArrayRewritten);
TestsExtensions.TestEquals(nameof(RepeatSkipToArray), RepeatSkipToArray, RepeatSkipToArrayRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayForEach), ArrayForEach, ArrayForEachRewritten);
TestsExtensions.TestEquals(nameof(EnumerableForEach), EnumerableForEach, EnumerableForEachRewritten);
TestsExtensions.TestEquals(nameof(NullForEach), NullForEach, NullForEachRewritten);
TestsExtensions.TestEquals(nameof(NullableForEach), NullableForEach, NullableForEachRewritten);
TestsExtensions.TestEquals(nameof(ArrayChangingParamsForEach), ArrayChangingParamsForEach, ArrayChangingParamsForEachRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(Repeat1), Repeat1, Repeat1Rewritten);
TestsExtensions.TestEquals(nameof(Repeat2), Repeat2, Repeat2Rewritten);
TestsExtensions.TestEquals(nameof(Repeat3), Repeat3, Repeat3Rewritten);
TestsExtensions.TestEquals(nameof(Repeat4), Repeat4, Repeat4Rewritten);
TestsExtensions.TestEquals(nameof(RepeatToArray), RepeatToArray, RepeatToArrayRewritten);
TestsExtensions.TestEquals(nameof(RepeatToList), RepeatToList, RepeatToListRewritten);
TestsExtensions.TestEquals(nameof(RepeatToSimpleList), RepeatToSimpleList, RepeatToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(RepeatDistinct), RepeatDistinct, RepeatDistinctRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(Range1), Range1, Range1Rewritten);
TestsExtensions.TestEquals(nameof(Range2), Range2, Range2Rewritten);
TestsExtensions.TestEquals(nameof(Range3), Range3, Range3Rewritten);
TestsExtensions.TestEquals(nameof(Range4), Range4, Range4Rewritten);
TestsExtensions.TestEquals(nameof(RangeToArray), RangeToArray, RangeToArrayRewritten);
TestsExtensions.TestEquals(nameof(RangeToList), RangeToList, RangeToListRewritten);
TestsExtensions.TestEquals(nameof(RangeToSimpleList), RangeToSimpleList, RangeToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(RangeDistinct), RangeDistinct, RangeDistinctRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayElementAtOrDefault), ArrayElementAtOrDefault, ArrayElementAtOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectElementAtOrDefault), ArraySelectElementAtOrDefault, ArraySelectElementAtOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereElementAtOrDefault), ArrayWhereElementAtOrDefault, ArrayWhereElementAtOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectWhereElementAtOrDefault), ArraySelectWhereElementAtOrDefault, ArraySelectWhereElementAtOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(ArrayElementAtOrDefaultParam), ArrayElementAtOrDefaultParam, ArrayElementAtOrDefaultParamRewritten);
TestsExtensions.TestEquals(nameof(EnumerableElementAtOrDefault), EnumerableElementAtOrDefault, EnumerableElementAtOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(ArrayElementAtOrDefaultOut), ArrayElementAtOrDefaultOut, ArrayElementAtOrDefaultOutRewritten);
TestsExtensions.TestEquals(nameof(ArrayElementAtOrDefaultWhereOut), ArrayElementAtOrDefaultWhereOut, ArrayElementAtOrDefaultWhereOutRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayDistinct), ArrayDistinct, ArrayDistinctRewritten);
TestsExtensions.TestEquals(nameof(ArrayDefaultComparerDistinct), ArrayDefaultComparerDistinct, ArrayDefaultComparerDistinctRewritten);
TestsExtensions.TestEquals(nameof(ArrayStrangeComparerDistinct), ArrayStrangeComparerDistinct, ArrayStrangeComparerDistinctRewritten);
TestsExtensions.TestEquals(nameof(ArrayRepeatDistinct), ArrayRepeatDistinct, ArrayRepeatDistinctRewritten);
TestsExtensions.TestEquals(nameof(EnumerableDistinct), EnumerableDistinct, EnumerableDistinctRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectDistinct), ArraySelectDistinct, ArraySelectDistinctRewritten);
TestsExtensions.TestEquals(nameof(RepeatArraySelectDistinct), RepeatArraySelectDistinct, RepeatArraySelectDistinctRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereSelectDistinct), ArrayWhereSelectDistinct, ArrayWhereSelectDistinctRewritten);
TestsExtensions.TestEquals(nameof(EnumerableDistinctToArray), EnumerableDistinctToArray, EnumerableDistinctToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctToArray), ArrayDistinctToArray, ArrayDistinctToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctToSimpleList), ArrayDistinctToSimpleList, ArrayDistinctToSimpleListRewritten);
}
public void TestIfSettingsAreSuccessfullySerialized()
{
var settings = SettingsModel.Initialize("Assets/UMVC.Editor.Tests/Settings.asset");
Assert.NotNull(settings);
settings.logo = TestsExtensions.RandomString();
settings.Save(out var newSettings);
Assert.NotNull(newSettings);
Assert.IsTrue(newSettings != settings);
Assert.IsTrue(newSettings.logo == settings.logo);
settings.Delete();
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayOfType), ArrayOfType, ArrayOfTypeRewritten);
TestsExtensions.TestEquals(nameof(ArrayOfType2), ArrayOfType2, ArrayOfType2Rewritten);
TestsExtensions.TestEquals(nameof(ArrayOfType3), ArrayOfType3, ArrayOfType3Rewritten);
TestsExtensions.TestEquals(nameof(ArrayOfType4), ArrayOfType4, ArrayOfType4Rewritten);
TestsExtensions.TestEquals(nameof(ArraySelectOfType), ArraySelectOfType, ArraySelectOfTypeRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereOfType), ArrayWhereOfType, ArrayWhereOfTypeRewritten);
TestsExtensions.TestEquals(nameof(ArrayOfTypeAverage), ArrayOfTypeAverage, ArrayOfTypeAverageRewritten);
TestsExtensions.TestEquals(nameof(ArrayOfTypeAny), ArrayOfTypeAny, ArrayOfTypeAnyRewritten);
TestsExtensions.TestEquals(nameof(ArrayOfTypeAggregate), ArrayOfTypeAggregate, ArrayOfTypeAggregateRewritten);
TestsExtensions.TestEquals(nameof(EnumerableOfType), EnumerableOfType, EnumerableOfTypeRewritten);
TestsExtensions.TestEquals(nameof(EnumerableOfTypeToArray), EnumerableOfTypeToArray, EnumerableOfTypeToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayOfTypeToArray), ArrayOfTypeToArray, ArrayOfTypeToArrayRewritten);
}
public void ContainerShouldResolveWhenGenericAutowiring_MT()
{
// Given
using var container = Container.Create();
// When
using (container.Bind(typeof(IMyGenericService <,>)).As(Lifetime.Transient).To(typeof(MyGenericService <,>)))
{
TestsExtensions.Parallelize(() =>
{
// Then
var actualInstance = container.Resolve <IMyGenericService <int, string> >();
actualInstance.ShouldBeOfType <MyGenericService <int, string> >();
});
}
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayCast), ArrayCast, ArrayCastRewritten);
TestsExtensions.TestEquals(nameof(ArrayCast2), ArrayCast2, ArrayCast2Rewritten);
TestsExtensions.TestEquals(nameof(ArrayCast3), ArrayCast3, ArrayCast3Rewritten);
TestsExtensions.TestEquals(nameof(ArrayCast4), ArrayCast4, ArrayCast4Rewritten);
TestsExtensions.TestEquals(nameof(ArraySelectCast), ArraySelectCast, ArraySelectCastRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereCast), ArrayWhereCast, ArrayWhereCastRewritten);
TestsExtensions.TestEquals(nameof(ArrayCastAverage), ArrayCastAverage, ArrayCastAverageRewritten);
TestsExtensions.TestEquals(nameof(ArrayCastAny), ArrayCastAny, ArrayCastAnyRewritten);
TestsExtensions.TestEquals(nameof(ArrayCastAggregate), ArrayCastAggregate, ArrayCastAggregateRewritten);
TestsExtensions.TestEquals(nameof(EnumerableCast), EnumerableCast, EnumerableCastRewritten);
TestsExtensions.TestEquals(nameof(EnumerableCastToArray), EnumerableCastToArray, EnumerableCastToArrayRewritten);
TestsExtensions.TestEquals(nameof(ArrayCastToArray), ArrayCastToArray, ArrayCastToArrayRewritten);
}
public void ShouldResolveChildContainer_MT()
{
// Given
using var parentContainer = Container.Create("parent");
TestsExtensions.Parallelize(() =>
{
// When
var childContainer1 = parentContainer.Create("child_1");
var childContainer2 = parentContainer.Create("child_2");
// Then
childContainer1.Parent.ShouldBe(parentContainer);
childContainer2.Parent.ShouldBe(parentContainer);
childContainer1.ShouldNotBeSameAs(childContainer2);
});
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayContains), ArrayContains, ArrayContainsRewritten);
TestsExtensions.TestEquals(nameof(ArrayContains2), ArrayContains2, ArrayContains2Rewritten);
TestsExtensions.TestEquals(nameof(ArrayContains3), ArrayContains3, ArrayContains3Rewritten);
TestsExtensions.TestEquals(nameof(ArraySelectContains), ArraySelectContains, ArraySelectContainsRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectContains2), ArraySelectContains2, ArraySelectContains2Rewritten);
TestsExtensions.TestEquals(nameof(ArraySelectContains3), ArraySelectContains3, ArraySelectContains3Rewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereContains), ArrayWhereContains, ArrayWhereContainsRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereContains2), ArrayWhereContains2, ArrayWhereContains2Rewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereContains3), ArrayWhereContains3, ArrayWhereContains3Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableContains), EnumerableContains, EnumerableContainsRewritten);
TestsExtensions.TestEquals(nameof(EnumerableContains2), EnumerableContains2, EnumerableContains2Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableContains3), EnumerableContains3, EnumerableContains3Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableContainsNot), EnumerableContainsNot, EnumerableContainsNotRewritten);
}
public void TestSingletonUpdateModel()
{
var logo = DerivedUMVC.Instance.Settings.logo;
DerivedUMVC.Instance.Settings.logo = TestsExtensions.RandomString();
DerivedUMVC.Instance.UpdateSettingsModel();
var settingsModelLogo = DerivedUMVC.Instance.Settings.logo;
DerivedUMVC.Instance.Settings.logo = TestsExtensions.RandomString();
DerivedUMVC.Instance.UpdateSettingsModel();
Assert.IsTrue(settingsModelLogo != DerivedUMVC.Instance.Settings.logo);
DerivedUMVC.Instance.Settings.logo = logo;
DerivedUMVC.Instance.UpdateSettingsModel();
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(Empty), Empty, EmptyRewritten);
TestsExtensions.TestEquals(nameof(EmptyToArray), EmptyToArray, EmptyToArrayRewritten);
TestsExtensions.TestEquals(nameof(EmptyToList), EmptyToList, EmptyToListRewritten);
TestsExtensions.TestEquals(nameof(EmptyToSimpleList), EmptyToSimpleList, EmptyToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(EmptySelect), EmptySelect, EmptySelectRewritten);
TestsExtensions.TestEquals(nameof(EmptyWhere), EmptyWhere, EmptyWhereRewritten);
TestsExtensions.TestEquals(nameof(EmptyDistinct), EmptyDistinct, EmptyDistinctRewritten);
TestsExtensions.TestEquals(nameof(EmptyCount), EmptyCount, EmptyCountRewritten);
TestsExtensions.TestEquals(nameof(EmptyContains), EmptyContains, EmptyContainsRewritten);
TestsExtensions.TestEquals(nameof(EmptyCast), EmptyCast, EmptyCastRewritten);
TestsExtensions.TestEquals(nameof(EmptyAny), EmptyAny, EmptyAnyRewritten);
TestsExtensions.TestEquals(nameof(EmptyAggregateDefault), EmptyAggregateDefault, EmptyAggregateDefaultRewritten);
TestsExtensions.TestEquals(nameof(EmptyAggregate), EmptyAggregate, EmptyAggregateRewritten);
TestsExtensions.TestEquals(nameof(EmptyAverage), EmptyAverage, EmptyAverageRewritten);
}
public void Extract_should_extract_voice()
{
var values = new[]
{
TestsExtensions.RandomArray(512).Select(array =>
TestsExtensions.RandomArray(300).Select(value => new[] { value }).ToArray()).ToArray()
};
var vox = new Vox {
Values = values
};
var embedding = this.embeddingExtractor.Extract(vox);
Assert.AreEqual(128, embedding.Length);
Assert.AreEqual(128, embedding.Values.Length);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(Single), Single, SingleRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSingle), EnumerableSingle, EnumerableSingleRewritten);
TestsExtensions.TestEquals(nameof(SingleCondition), SingleCondition, SingleConditionRewritten);
TestsExtensions.TestEquals(nameof(SingleFalseCondition), SingleFalseCondition, SingleFalseConditionRewritten);
TestsExtensions.TestEquals(nameof(SingleMethod), SingleMethod, SingleMethodRewritten);
TestsExtensions.TestEquals(nameof(SingleWhereMethod), SingleWhereMethod, SingleWhereMethodRewritten);
TestsExtensions.TestEquals(nameof(SelectSingleMethod), SelectSingleMethod, SelectSingleMethodRewritten);
TestsExtensions.TestEquals(nameof(RangeSingle), RangeSingle, RangeSingleRewritten);
TestsExtensions.TestEquals(nameof(Range1Single), Range1Single, Range1SingleRewritten);
TestsExtensions.TestEquals(nameof(RangeRepeat), RangeRepeat, RangeRepeatRewritten);
TestsExtensions.TestEquals(nameof(EmptySingle), EmptySingle, EmptySingleRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctSingle), ArrayDistinctSingle, ArrayDistinctSingleRewritten);
TestsExtensions.TestEquals(nameof(ArraySingleParam), ArraySingleParam, ArraySingleParamRewritten);
TestsExtensions.TestEquals(nameof(ArraySingleChangingParam), ArraySingleChangingParam, ArraySingleChangingParamRewritten);
TestsExtensions.TestEquals(nameof(ArraySingleUsingSingle), ArraySingleUsingSingle, ArraySingleUsingSingleRewritten);
}
public void ContainerShouldResolveGenericWhenComplex_MT()
{
// Given
using (var container = Container.Create())
{
// When
using (container.Bind <IMyGenericService <TT1, TT2> >().To <MyGenericService <TT1, TT2> >())
{
TestsExtensions.Parallelize(() =>
{
var instance = container.Resolve <Task <Func <IEnumerable <Lazy <Tuple <Func <IMyGenericService <string, int> >, IMyGenericService <string, int> > > > > > >();
// Then
instance.Result().Single().Value.Item1().ShouldBeOfType <MyGenericService <string, int> >();
});
}
}
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayAny), ArrayAny, ArrayAnyRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectAny), ArraySelectAny, ArraySelectAnyRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereAny), ArrayWhereAny, ArrayWhereAnyRewritten);
TestsExtensions.TestEquals(nameof(ArrayEmptyAny), ArrayEmptyAny, ArrayEmptyAnyRewritten);
TestsExtensions.TestEquals(nameof(ArraySelectEmptyAny), ArraySelectEmptyAny, ArraySelectEmptyAnyRewritten);
TestsExtensions.TestEquals(nameof(ArrayWhereEmptyAny), ArrayWhereEmptyAny, ArrayWhereEmptyAnyRewritten);
TestsExtensions.TestEquals(nameof(ArrayAnyFalse), ArrayAnyFalse, ArrayAnyFalseRewritten);
TestsExtensions.TestEquals(nameof(ArrayAnyPredicate), ArrayAnyPredicate, ArrayAnyPredicateRewritten);
TestsExtensions.TestEquals(nameof(ArrayAnyParameter), ArrayAnyParameter, ArrayAnyParameterRewritten);
TestsExtensions.TestEquals(nameof(ArrayAnyChangingParameter), ArrayAnyChangingParameter, ArrayAnyChangingParameterRewritten);
TestsExtensions.TestEquals(nameof(EnumerableAnyChangingParameter), EnumerableAnyChangingParameter, EnumerableAnyChangingParameterRewritten);
TestsExtensions.TestEquals(nameof(EnumerableAny), EnumerableAny, EnumerableAnyRewritten);
TestsExtensions.TestEquals(nameof(RepeatAny), RepeatAny, RepeatAnyRewritten);
TestsExtensions.TestEquals(nameof(RangeAny), RangeAny, RangeAnyRewritten);
TestsExtensions.TestEquals(nameof(RepeatAnyTrue), RepeatAnyTrue, RepeatAnyTrueRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(SingleOrDefault), SingleOrDefault, SingleOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(EnumerableSingleOrDefault), EnumerableSingleOrDefault, EnumerableSingleOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(SingleOrDefaultCondition), SingleOrDefaultCondition, SingleOrDefaultConditionRewritten);
TestsExtensions.TestEquals(nameof(SingleOrDefaultFalseCondition), SingleOrDefaultFalseCondition, SingleOrDefaultFalseConditionRewritten);
TestsExtensions.TestEquals(nameof(SingleOrDefaultMethod), SingleOrDefaultMethod, SingleOrDefaultMethodRewritten);
TestsExtensions.TestEquals(nameof(SingleOrDefaultWhereMethod), SingleOrDefaultWhereMethod, SingleOrDefaultWhereMethodRewritten);
TestsExtensions.TestEquals(nameof(SelectSingleOrDefaultMethod), SelectSingleOrDefaultMethod, SelectSingleOrDefaultMethodRewritten);
TestsExtensions.TestEquals(nameof(RangeSingleOrDefault), RangeSingleOrDefault, RangeSingleOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(Range1SingleOrDefault), Range1SingleOrDefault, Range1SingleOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(RangeRepeat), RangeRepeat, RangeRepeatRewritten);
TestsExtensions.TestEquals(nameof(EmptySingleOrDefault), EmptySingleOrDefault, EmptySingleOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctSingleOrDefault), ArrayDistinctSingleOrDefault, ArrayDistinctSingleOrDefaultRewritten);
TestsExtensions.TestEquals(nameof(ArraySingleOrDefaultParam), ArraySingleOrDefaultParam, ArraySingleOrDefaultParamRewritten);
TestsExtensions.TestEquals(nameof(ArraySingleOrDefaultChangingParam), ArraySingleOrDefaultChangingParam, ArraySingleOrDefaultChangingParamRewritten);
TestsExtensions.TestEquals(nameof(ArraySingleOrDefaultUsingSingleOrDefault), ArraySingleOrDefaultUsingSingleOrDefault, ArraySingleOrDefaultUsingSingleOrDefaultRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(First), First, FirstRewritten);
TestsExtensions.TestEquals(nameof(EnumerableFirst), EnumerableFirst, EnumerableFirstRewritten);
TestsExtensions.TestEquals(nameof(FirstCondition), FirstCondition, FirstConditionRewritten);
TestsExtensions.TestEquals(nameof(FirstFalseCondition), FirstFalseCondition, FirstFalseConditionRewritten);
TestsExtensions.TestEquals(nameof(FirstMethod), FirstMethod, FirstMethodRewritten);
TestsExtensions.TestEquals(nameof(FirstWhereMethod), FirstWhereMethod, FirstWhereMethodRewritten);
TestsExtensions.TestEquals(nameof(SelectFirstMethod), SelectFirstMethod, SelectFirstMethodRewritten);
TestsExtensions.TestEquals(nameof(RangeFirst), RangeFirst, RangeFirstRewritten);
TestsExtensions.TestEquals(nameof(Range1First), Range1First, Range1FirstRewritten);
TestsExtensions.TestEquals(nameof(RangeRepeat), RangeRepeat, RangeRepeatRewritten);
TestsExtensions.TestEquals(nameof(EmptyFirst), EmptyFirst, EmptyFirstRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctFirst), ArrayDistinctFirst, ArrayDistinctFirstRewritten);
TestsExtensions.TestEquals(nameof(ArrayFirstParam), ArrayFirstParam, ArrayFirstParamRewritten);
TestsExtensions.TestEquals(nameof(ArrayFirstChangingParam), ArrayFirstChangingParam, ArrayFirstChangingParamRewritten);
TestsExtensions.TestEquals(nameof(ArrayFirstUsingFirst), ArrayFirstUsingFirst, ArrayFirstUsingFirstRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayToArrayTest), ArrayToArrayTest, ArrayToArrayTestRewritten);
TestsExtensions.TestEquals(nameof(ListToArrayTest), ListToArrayTest, ListToArrayTestRewritten);
TestsExtensions.TestEquals(nameof(SimpleListToArrayTest), SimpleListToArrayTest, SimpleListToArrayTestRewritten);
TestsExtensions.TestEquals(nameof(EnumerableToArrayTest), EnumerableToArrayTest, EnumerableToArrayTestRewritten);
for (int i = -1; i < 1001; i++)
{
TestsExtensions.TestEquals(nameof(ArrayWhereParamToArrayTest) + i, () => ArrayWhereParamToArrayTest(i), () => ArrayWhereParamToArrayTestRewritten(i));
TestsExtensions.TestEquals(nameof(EnumerableWhereParamToArrayTest) + i, () => EnumerableWhereParamToArrayTest(i), () => EnumerableWhereParamToArrayTestRewritten(i));
TestsExtensions.TestEquals(nameof(SimpleListWhereParamToArrayTest) + i, () => SimpleListWhereParamToArrayTest(i), () => SimpleListWhereParamToArrayTestRewritten(i));
TestsExtensions.TestEquals(nameof(ListWhereParamToArrayTest) + i, () => ListWhereParamToArrayTest(i), () => ListWhereParamToArrayTestRewritten(i));
TestsExtensions.TestEquals(nameof(RangeWhereParamToArrayTest) + i, () => RangeWhereParamToArrayTest(i), () => RangeWhereParamToArrayTestRewritten(i));
TestsExtensions.TestEquals(nameof(RangeParamToArrayTest) + i, () => RangeParamToArrayTest(i), () => RangeParamToArrayTestRewritten(i));
TestsExtensions.TestEquals(nameof(RepeatParamToArrayTest) + i, () => RepeatParamToArrayTest(i), () => RepeatParamToArrayTestRewritten(i));
TestsExtensions.TestEquals(nameof(RepeatWhereParamToArrayTest) + i, () => RepeatWhereParamToArrayTest(i), () => RepeatWhereParamToArrayTestRewritten(i));
}
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(AggregateSum), AggregateSum, AggregateSumRewritten);
TestsExtensions.TestEquals(nameof(EnumerableAggregateSum), EnumerableAggregateSum, EnumerableAggregateSumRewritten);
TestsExtensions.TestEquals(nameof(AggregateCount), AggregateCount, AggregateCountRewritten);
TestsExtensions.TestEquals(nameof(AggregateEma), AggregateEma, AggregateEmaRewritten);
TestsExtensions.TestEquals(nameof(AggregateDoubleSum), AggregateDoubleSum, AggregateDoubleSumRewritten);
TestsExtensions.TestEquals(nameof(AggregateDoubleEma), AggregateDoubleEma, AggregateDoubleEmaRewritten);
TestsExtensions.TestEquals(nameof(AggregateDoubleFactorial), AggregateDoubleFactorial, AggregateDoubleFactorialRewritten);
TestsExtensions.TestEquals(nameof(AggregateDoubleAverage), AggregateDoubleAverage, AggregateDoubleAverageRewritten);
TestsExtensions.TestEquals(nameof(AggregateDoubleAverageSelected), AggregateDoubleAverageSelected, AggregateDoubleAverageSelectedRewritten);
TestsExtensions.TestEquals(nameof(AggregateDoubleAverageWhere), AggregateDoubleAverageWhere, AggregateDoubleAverageWhereRewritten);
TestsExtensions.TestEquals(nameof(AggregateRangeSum), AggregateRangeSum, AggregateRangeSumRewritten);
TestsExtensions.TestEquals(nameof(AggregateRangeFactorial0), AggregateRangeFactorial0, AggregateRangeFactorial0Rewritten);
TestsExtensions.TestEquals(nameof(AggregateRangeFactorial20), AggregateRangeFactorial20, AggregateRangeFactorial20Rewritten);
TestsExtensions.TestEquals(nameof(AggregateRangeFactorial100), AggregateRangeFactorial100, AggregateRangeFactorial100Rewritten);
TestsExtensions.TestEquals(nameof(AggregateEmpty), AggregateEmpty, AggregateEmptyRewritten);
TestsExtensions.TestEquals(nameof(AggregateEmptyDefault), AggregateEmptyDefault, AggregateEmptyDefaultRewritten);
TestsExtensions.TestEquals(nameof(AggregateNull), AggregateNull, AggregateNullRewritten);
}
public void ContainerShouldSupportWrapping_MT()
{
// Given
using (var container = Container.Create())
using (container.Bind <IMyWrapper>().To <Wrappered>())
{
TestsExtensions.Parallelize(() =>
{
// When
using (var childContainer = container.CreateChild())
using (childContainer.Bind <IMyWrapper>().To <Wrapper>(ctx => new Wrapper(ctx.Container.Parent.Inject <IMyWrapper>())))
{
// Then
var actualInstance = childContainer.Resolve <IMyWrapper>();
actualInstance.ShouldBeOfType <Wrapper>();
actualInstance.Wrapped.ShouldBeOfType <Wrappered>();
}
});
}
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayWhereToSimpleList), ArrayWhereToSimpleList, ArrayWhereToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(SelectWhereToSimpleList), SelectWhereToSimpleList, SelectWhereToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(MultipleSelectWhereToSimpleList), MultipleSelectWhereToSimpleList, MultipleSelectWhereToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(SelectWhereToArray), SelectWhereToArray, SelectWhereToArrayRewritten);
TestsExtensions.TestEquals(nameof(MultipleSelectWhereToArray), MultipleSelectWhereToArray, MultipleSelectWhereToArrayRewritten);
for (int i = -2; i < 1002; i++)
{
TestsExtensions.TestEquals(nameof(ParametrizedWhere) + i, () => ParametrizedWhere(i), () => ParametrizedWhereRewritten(i));
TestsExtensions.TestEquals(nameof(ParametrizedWhereToArray) + i, () => ParametrizedWhereToArray(i), () => ParametrizedWhereToArrayRewritten(i));
TestsExtensions.TestEquals(nameof(ParametrizedWhereToSimpleList) + i, () => ParametrizedWhereToSimpleList(i), () => ParametrizedWhereToSimpleListRewritten(i));
}
TestsExtensions.TestEquals(nameof(WhereChangingParam), WhereChangingParam, WhereChangingParamRewritten);
TestsExtensions.TestEquals(nameof(WhereChangingParamToArray), WhereChangingParamToArray, WhereChangingParamToArrayRewritten);
TestsExtensions.TestEquals(nameof(WhereChangingParamToSimpleList), WhereChangingParamToSimpleList, WhereChangingParamToSimpleListRewritten);
TestsExtensions.TestEquals(nameof(WhereIndexToArray), WhereIndexToArray, WhereIndexToArrayRewritten);
}
public void RunTests()
{
TestsExtensions.TestEquals(nameof(ArrayLongCount), ArrayLongCount, ArrayLongCountRewritten);
TestsExtensions.TestEquals(nameof(ArrayLongCount2), ArrayLongCount2, ArrayLongCount2Rewritten);
TestsExtensions.TestEquals(nameof(ArraySelectLongCount), ArraySelectLongCount, ArraySelectLongCountRewritten);
TestsExtensions.TestEquals(nameof(ArrayLongCount5), ArrayLongCount5, ArrayLongCount5Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableLongCount2), EnumerableLongCount2, EnumerableLongCount2Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableLongCount3), EnumerableLongCount3, EnumerableLongCount3Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableLongCount4), EnumerableLongCount4, EnumerableLongCount4Rewritten);
TestsExtensions.TestEquals(nameof(EnumerableLongCount5), EnumerableLongCount5, EnumerableLongCount5Rewritten);
TestsExtensions.TestEquals(nameof(RangeLongCount), RangeLongCount, RangeLongCountRewritten);
TestsExtensions.TestEquals(nameof(RangeSelectLongCount), RangeSelectLongCount, RangeSelectLongCountRewritten);
TestsExtensions.TestEquals(nameof(RangeWhereLongCount), RangeWhereLongCount, RangeWhereLongCountRewritten);
TestsExtensions.TestEquals(nameof(RangeLongCount2), RangeLongCount2, RangeLongCount2Rewritten);
TestsExtensions.TestEquals(nameof(RepeatLongCount), RepeatLongCount, RepeatLongCountRewritten);
TestsExtensions.TestEquals(nameof(ArrayMethodLongCount), ArrayMethodLongCount, ArrayMethodLongCountRewritten);
TestsExtensions.TestEquals(nameof(ArrayDistinctLongCount), ArrayDistinctLongCount, ArrayDistinctLongCountRewritten);
TestsExtensions.TestEquals(nameof(EmptyLongCount), EmptyLongCount, EmptyLongCountRewritten);
TestsExtensions.TestEquals(nameof(EmptyDistinctLongCount), EmptyDistinctLongCount, EmptyDistinctLongCountRewritten);
}
