public void Generator_ForSequence1()
{
int[] expected = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
EnumerableGenerator <int> intEnumerableGenerator = new EnumerableGenerator <int>();
CollectionAssert.AreEqual(expected, intEnumerableGenerator.GetEnumerable(1, 1, 10, (cur, prev) => cur + prev).ToArray());
}
public void Generator_ForSequence2()
{
int[] expected = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
EnumerableGenerator <int> intEnumerableGenerator = new EnumerableGenerator <int>();
CollectionAssert.AreEqual(expected, intEnumerableGenerator.GetEnumerable(1, 2, 10, (cur, prev) => 6 * cur - 8 * prev).ToArray());
}
public PlayersQuantityTypeShouldBase()
{
BetCards.AddRange(EnumerableGenerator.Generate(5, x => new Mock <IBetCard>().Object));
ListOfPlayers = new List <Mock <IPlayer> > {
PlayerOne, PlayerTwo, PlayerThree, PlayerFour, PlayerFive
};
ListOfPlayers.ForEach(x => x.Setup(s => s.GiveCard(It.IsAny <IBetCard>())));
}
public void Not_Allow_More_Neither_Less_Than_Five_Cards(int countOfCards)
{
Action act = () => _sut.GiveBetCards(new
ReadOnlyCollection <IBetCard>(EnumerableGenerator
.Generate <IBetCard>(countOfCards, x => new Mock <IBetCard>().Object)));
act.Should().Throw <ArgumentException>();
}
object exec <T>()
{
Type type = typeof(IEnumerable <>).MakeGenericType(typeof(T));
EnumerableGenerator generator = new EnumerableGenerator(new TypeGenericParametersProvider(), new GenericTypeGenerator());
return(generator.GenerateEnumerable(type));
}
public void GeneratesCorrectType(Type argumentType)
{
var generator = new EnumerableGenerator(elementGeneratorType: typeof(ConstantGenerator), elementGeneratorConstructorArguments: 42);
var random = new FuzzRandom();
var generatedValue = generator.Generate(Mock.Of <IFuzzProfile>(), argumentType, random);
Assert.IsInstanceOfType(generatedValue, argumentType);
}
public PlayerManagerShould()
{
_betCards = new ReadOnlyCollection <IBetCard>(EnumerableGenerator.Generate(5, x => new Mock <IBetCard>().Object));
_mockgGenericMixStrategy.Setup(x => x.Mix <IBetCard>(It.IsAny <List <IBetCard> >()))
.Returns(EnumerableGenerator.Generate(10, x => new Mock <IBetCard>().Object));
_sut = new PlayersManager(_mockPlayers.Object, _mockRacingCardManager.Object, _mockgGenericMixStrategy.Object);
}
public RacingCardsShould()
{
_racingCards = EnumerableGenerator.Generate <IRacingCard>(5, x =>
{
return(new Mock <IRacingCard>().Object);
});
_sut = Domain.RacingCards.RacingCards.Create(_racingCards);
}
public RacingCardOnDeskManagerShould()
{
_listOfRacing = new List <IRacingCard> {
new Mock <IRacingCard>().Object, new Mock <IRacingCard>().Object, new Mock <IRacingCard>().Object
};
var returnList = EnumerableGenerator.Generate(1, x => new Mock <IRacingCard>().Object);
_sut = new RacingCardOnDeskManager();
}
public void TestTwoMethod()
{
int[] array = new int[] { 1, 2 };
EnumerableScanner.ScanMixedRadix(array, Show);
foreach (int[] item in EnumerableGenerator.GetMixedRadixEnumerator(array))
{
Show(item);
}
}
public void Generator_ForSequence3()
{
double[] expected = { 1, 2, 2.5, 3.3, 4.05757575757576, 4.87086926018965, 5.70389834408211, 6.55785277425587, 7.42763417076325, 8.31053343902137 };
EnumerableGenerator <double> doubleEnumerableGenerator = new EnumerableGenerator <double>();
var result = doubleEnumerableGenerator.GetEnumerable(1, 2, 10, (cur, prev) => cur + prev / cur).ToArray();
for (int i = 0; i < result.Length; i++)
{
Assert.AreEqual(expected[i], result[i], 0.0000001);
}
}
public void DefaultsToProfileElementGenerator()
{
var generator = new EnumerableGenerator();
var random = new FuzzRandom();
var profile = new Mock <IFuzzProfile>();
profile.Setup(c => c.GeneratorFor(typeof(int))).Returns(new ConstantGenerator(42));
var generatedValue = generator.Generate(profile.Object, typeof(IList <int>), random);
Assert.IsInstanceOfType(generatedValue, typeof(IList <int>));
}
private void Return_Count_Of_Racing_Cards(int countOfCards)
{
var listOfRacingCards = EnumerableGenerator.Generate(countOfCards, x => new Mock <IRacingCard>().Object);
_mockRacingCardsFactory.Setup(x => x.Create()).Returns(listOfRacingCards);
_mockGenericMixStrategy.Setup(x => x.Mix <IRacingCard>(It.IsAny <List <IRacingCard> >()))
.Returns(new ReadOnlyCollection <IRacingCard>(listOfRacingCards));
_mockMixDiscartCards.Setup(x => x.MixAll())
.Returns(new ReadOnlyCollection <IRacingCard>(listOfRacingCards));
_sut = new RacingCardManager(_mockRacingCardsFactory.Object,
_mockGenericMixStrategy.Object,
_mockMixDiscartCards.Object);
_sut.CountOfCards.Should().Be(countOfCards);
}
public void CanGenerate(Type type, bool canGenerate)
{
var actual = new EnumerableGenerator().CanGenerate(new TestFuzzProfile(), type);
Assert.AreEqual(canGenerate, actual);
}
public static void WriteEnumerable()
{
var settings = Settings();
File.WriteAllText("C:\\Git\\_GuOrg\\Gu.Units\\Gu.Units\\Enumerable.generated.cs", EnumerableGenerator.Code(settings));
}
private void Return_Numbers_In_Different_Position(int countOfValues)
{
var listOfRacingCards = EnumerableGenerator.Generate(countOfValues, (index) => index);
listOfRacingCards.SequenceEqual(_sut.Mix(listOfRacingCards)).Should().Be(false);
}
