public static Arbitrary <PartyComposition> Generate()
{
return(Arb.From(from adults in Gen.Choose(1, 10)
from children in Gen.Choose(0, 10)
from babies in Gen.Choose(0, 10)
select new PartyComposition(adults, children, babies)));
}
public static void Samples()
{
//[testMutableList]
Prop.ForAll(Arb.From(Gen.Choose(1, 10)), Arb.From <int[]>(), (capacity, itemsToAdd) => {
var underTest = new List <int>(capacity);
underTest.AddRange(itemsToAdd);
return(underTest.Count == itemsToAdd.Length);
})
.QuickCheck();
//[/testMutableList]
//[replay]
Prop.ForAll((int x) => Math.Abs(x) >= 0)
.Check(new Configuration {
Replay = FsCheck.Random.StdGen.NewStdGen(1145655947, 296144285)
});
//[/replay]
//[configuration]
var configuration = Configuration.Quick;
configuration.MaxNbOfTest = 1000;
configuration.QuietOnSuccess = true;
true.ToProperty().Check(configuration);
//[/configuration]
}
public static Gen <TimeEntriesLogViewModel> ForTimeEntriesLogViewModel(MonthPredicate filter)
{
var monthsGenerator = Gen.Choose(1, 12).Where(filter);
var yearGenerator = Gen.Choose(2007, DateTime.UtcNow.Year);
return(Arb.Default
.Array <DateTimeOffset>()
.Generator
.Select(dateTimes =>
{
var source = Substitute.For <ITogglDataSource>();
var timeService = Substitute.For <ITimeService>();
var navigationService = Substitute.For <IMvxNavigationService>();
var viewModel = new TimeEntriesLogViewModel(source, navigationService);
var year = yearGenerator.Sample(0, 1).First();
var observable = dateTimes
.Select(newDateWithGenerator(monthsGenerator, year))
.Select(d => TimeEntry.Builder.Create(-1).SetStart(d).SetDescription("").Build())
.Apply(Observable.Return);
source.TimeEntries.GetAll().Returns(observable);
return viewModel;
}));
}
public void RunBeforeAnyTests()
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("En-Us");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("En-Us");
Gen.Choose(1, 44);
}
public void MapDateGenerator()
{
var gen = Gen.Choose(1, 30)
.Select(x => new DateTime(2019, 11, x).ToString("u"));
var value = Gen.Sample(0, 10, gen);
}
public static void Main()
{
Func <int[], bool> rev = xs => xs.Reverse().Reverse().SequenceEqual(xs);
Prop.ForAll(Gen.ListOf(100, Gen.Choose(100, 200)).ToArbitrary(), x => x.Reverse().Reverse().SequenceEqual(x)).VerboseCheck();
Gen.ListOf(10, Gen.Choose(0, 1000));
Gen.Choose(0, 100).Select(x => Gen.Choose(x, x + 100));
var l = Gen.Choose(0, 100).Sample(10, 1).ToList();
l.Sort();
foreach (var x in l)
{
Console.WriteLine(x);
}
Prop.ForAll <int>(a => new Func <bool>(() => 1 / a == 1 / a).When(a != 0)).VerboseCheck();
var property = Prop.ForAll(MyClass.MyClasses(), mc => { return(mc != null); });
property.VerboseCheck();
Prop.ForAll(MyClass.Choose(Enumerable.Range(0, 100).ToArray()).ToArbitrary(), x => x > 0).VerboseCheck();
Console.WriteLine("Press any key to continue...");
Console.ReadKey(true);
}
public void MapGenerator()
{
var gen = Gen.Choose(0, 127)
.Select(x => (byte)x);
var value = Gen.Sample(0, 10, gen);
}
public void PutDealItem_NegativeQuantity_ShouldBeBadRequest()
{
//init
var materialsResult = materialController.GetMaterials(1, int.MaxValue).GetObject <PagedResult <Material> >().Queryable.ToArray();
var deals = dealController.Deals(1, int.MaxValue).GetObject <PagedResult <Deal> >().Queryable.ToArray();
var materialsGen = ControllerHelper.ChooseFrom(materialsResult);
var dealsGen = ControllerHelper.ChooseFrom(deals);
Prop.ForAll <int[]>((i) =>
{
//execution
var deal = dealsGen.Sample(0, 1).Head;
var dealItems = sut.GetDealItemsOfDeal(deal.Id).GetObject <IEnumerable <DealItem> >().ToArray();
var dealItem = ControllerHelper.ChooseFrom(dealItems).Sample(0, 1).Head;
var material = materialsGen.Sample(0, 1).Head;
dealItem.MaterialId = material.Id;
dealItem.DealId = deal.Id;
var price = Gen.Choose(1, 100000000).Sample(0, 1).Head;
dealItem.PricePerOne = price;
var quantity = Gen.Choose(-10000000, -1).Sample(0, 1).Head;
dealItem.Quantity = quantity;
var result = sut.PutDealItem(dealItem.Id, dealItem).Result;
Assert.IsInstanceOf <BadRequestResult>(result);
}).QuickCheckThrowOnFailure();
}
public void PutDealItem_InvalidMaterialId_ShouldbeBadRequest()
{
//init
var materialsResult = materialController.GetMaterials(1, int.MaxValue).GetObject <PagedResult <Material> >().Queryable.Select(x => x.Id).ToList();
var deals = dealController.Deals(1, int.MaxValue).GetObject <PagedResult <Deal> >().Queryable.ToArray();
var materialIdArb = Arb.Generate <int>().Where(i => !materialsResult.Contains(i)).ToArbitrary();
Prop.ForAll(materialIdArb, (materialId) =>
{
var deal = ControllerHelper.ChooseFrom(deals).Sample(0, 1).Head;
var dealItems = sut.GetDealItemsOfDeal(deal.Id).GetObject <IEnumerable <DealItem> >().ToArray();
var dealItem = ControllerHelper.ChooseFrom(dealItems).Sample(0, 1).Head;
dealItem.MaterialId = materialId;
dealItem.DealId = deal.Id;
var price = Gen.Choose(1, 1000000).Sample(0, 1).Head;
dealItem.PricePerOne = price;
var quantity = Gen.Choose(1, 1000).Sample(0, 1).Head;
dealItem.Quantity = quantity;
//execution
var result = sut.PutDealItem(dealItem.Id, dealItem).Result;
//assertion
Assert.IsInstanceOf <BadRequestResult>(result);
}).QuickCheckThrowOnFailure();
}
public void PutDealItem_ValidData_ShoulBeUpdated()
{
//init
var materialsResult = materialController.GetMaterials(1, int.MaxValue).GetObject <PagedResult <Material> >().Queryable.ToArray();
var deals = dealController.Deals(1, int.MaxValue).GetObject <PagedResult <Deal> >().Queryable.ToArray();
var materialsGen = ControllerHelper.ChooseFrom(materialsResult);
var dealsGen = ControllerHelper.ChooseFrom(deals);
Prop.ForAll <int[]>((i) =>
{
//execution
var deal = dealsGen.Sample(0, 1).Head;
var dealItems = sut.GetDealItemsOfDeal(deal.Id).GetObject <IEnumerable <DealItem> >().ToArray();
var dealItem = ControllerHelper.ChooseFrom(dealItems).Sample(0, 1).Head;
var material = materialsGen.Sample(0, 1).Head;
dealItem.MaterialId = material.Id;
dealItem.DealId = deal.Id;
var price = Gen.Choose(1, 1000000).Sample(0, 1).Head;
dealItem.PricePerOne = price;
var quantity = Gen.Choose(1, 1000).Sample(0, 1).Head;
dealItem.Quantity = quantity;
var result = sut.PutDealItem(dealItem.Id, dealItem).Result;
//assertion
Assert.IsInstanceOf <NoContentResult>(result);
var result1 = sut.GetDealItem(dealItem.Id).Result.GetObject <DealItem>();
Assert.AreEqual(result1.MaterialId, material.Id);
Assert.AreEqual(result1.PricePerOne, price);
Assert.AreEqual(result1.Quantity, quantity);
}).QuickCheckThrowOnFailure();
}
private static Gen <IList <IList <int> > > GenSolutionRows(int numCols, int numSolutionRows)
{
return
(from solutionRows in Gen.Constant(0).ListOf(numCols).ListOf(numSolutionRows)
from randomRowIdxs in Gen.Choose(0, numSolutionRows - 1).ListOf(numCols)
select RandomlySprinkleOnesIntoSolutionRows(solutionRows, randomRowIdxs));
}
private static Gen <IList <IList <int> > > GenSolution(int numCols)
{
return
(from numSolutionRows in Gen.Choose(1, Math.Min(5, numCols))
from solutionRows in GenSolutionRows(numCols, numSolutionRows)
select solutionRows);
}
private static Gen <IList <IList <int> > > GenPartitionedSolution(int numCols, int startIdx, int endIdx)
{
return
(from numSolutionRows in Gen.Choose(1, Math.Min(5, endIdx - startIdx))
from solutionRows in GenPartitionedSolutionRows(numCols, startIdx, endIdx, numSolutionRows)
select solutionRows);
}
public static Gen <UnknownKVMap> UnknownKVMap() =>
from itemNum in Gen.Choose(0, 15)
from keys in Gen.ListOf(itemNum, PrimitiveGenerator.RandomBytes())
where PSBTConstants.PSBT_IN_ALL.All(i => keys.Select(k => k.First()).All(k => k != i))
let uniqKeys = keys.Distinct()
from values in Gen.ListOf(uniqKeys.Count(), PrimitiveGenerator.RandomBytes())
select Utils.DictionaryFromList <byte[], byte[]>(uniqKeys.ToList(), values.ToList());
public void GetMaterialAmountOverTime_ShouldBeIntegrated()
{
var dealersResult = dealerController.Dealers().GetObject <PagedResult <Dealer> >().Queryable.ToArray();
var dealersGen = ControllerHelper.ChooseFrom(dealersResult);
var materialsResult = materialController.GetMaterials(1, int.MaxValue).GetObject <PagedResult <Material> >().Queryable.ToArray();
var materialsGen = ControllerHelper.ChooseFrom(materialsResult);
Prop.ForAll <int[]>((i) =>
{
var material = materialsGen.Sample(0, 1).Head;
var dealer = dealersGen.Sample(0, 1).Head;
//100 to 50 days later
var dateEnd = DateTime.Now.AddDays(Gen.Choose(-50, 0).Sample(0, 1).Head);
var dateStart = dateEnd.AddDays(Gen.Choose(-50, 0).Sample(0, 1).Head);
//130 to 20 days later
var dateEndMargin = dateEnd.AddDays(Gen.Choose(0, 30).Sample(0, 1).Head);
var dateStartMargin = dateStart.AddDays(Gen.Choose(-30, 0).Sample(0, 1).Head);
var materialOverTime = sut.GetMaterialAmountOverTime(material.Id, dealer.Id, dateStart, dateEnd).Result.GetObject <IEnumerable <AmountOverDateModel> >();
var materialOverTimeMargined = sut.GetMaterialAmountOverTime(material.Id, dealer.Id, dateStartMargin, dateEndMargin).Result.GetObject <IEnumerable <AmountOverDateModel> >();
foreach (var item in materialOverTime)
{
var marginedItem = materialOverTimeMargined.Where(m => ((DateTime)m.Date).Date == ((DateTime)item.Date).Date).Single();
Assert.AreEqual(item.Amount, marginedItem.Amount);
}
}).QuickCheckThrowOnFailure();
}
private Gen <TimeEntriesLogViewModel> generatorForTimeEntriesLogViewModel(Func <int, bool> filter)
{
var now = new DateTimeOffset(2017, 08, 13, 08, 01, 23, TimeSpan.Zero);
var monthsGenerator = Gen.Choose(1, 12).Where(filter);
var yearGenerator = Gen.Choose(2007, now.Year);
return(Arb.Default
.Array <DateTimeOffset>()
.Generator
.Select(dateTimes =>
{
var viewModel = CreateViewModel();
var year = yearGenerator.Sample(0, 1).First();
var observable = dateTimes
.Select(newDateWithGenerator(monthsGenerator, year))
.Select(d => TimeEntry.Builder
.Create(-1)
.SetUserId(-2)
.SetWorkspaceId(-3)
.SetStart(d)
.SetDescription("")
.SetAt(now).Build())
.Apply(Observable.Return);
InteractorFactory.GetAllNonDeletedTimeEntries().Execute().Returns(observable);
return viewModel;
}));
}
static IEnumerable <int> ExampleOfGenerators(int exampleCount)
{
Gen <int> generator = Gen.Choose(int.MinValue, int.MaxValue);
IEnumerable <int> examples = generator.Sample(exampleCount);
return(examples);
}
public void PostDealItem_InvalidQuantity_ShoulBeBadRequest()
{
//init
var materialsResult = materialController.GetMaterials(1, int.MaxValue).GetObject <PagedResult <Material> >().Queryable.ToArray();
var deals = dealController.Deals(1, int.MaxValue).GetObject <PagedResult <Deal> >().Queryable.ToArray();
var materialsGen = ControllerHelper.ChooseFrom(materialsResult);
var dealsGen = ControllerHelper.ChooseFrom(deals);
Prop.ForAll <int[]>((i) =>
{
var material = materialsGen.Sample(0, 1).Head;
var deal = dealsGen.Sample(0, 1).Head;
var dealItem = new DealItem
{
DealId = deal.Id,
MaterialId = material.Id,
PricePerOne = Gen.Choose(1, 1000000).Sample(0, 1).Head,
Quantity = Gen.Choose(-1000000, -1).Sample(0, 1).Head
};
//execution
var result = sut.PostDealItem(dealItem).Result;
//assertion
Assert.IsInstanceOf <BadRequestResult>(result);
}).QuickCheckThrowOnFailure();
}
public static Gen <Operation <ITcpServerSocketModel, ITcpServerSocketModel> > Generator()
{
Func <int, IEventLoopGroup, Operation <ITcpServerSocketModel, ITcpServerSocketModel> > producer =
(s, e) => new ClientConnect(s, e) as Operation <ITcpServerSocketModel, ITcpServerSocketModel>;
var fsFunc = FsharpDelegateHelper.Create(producer);
return(Gen.Map2(fsFunc, Gen.Choose(1, 10), GenClientEventLoops().Generator));
}
private static Gen <IEnumerable <int> > GenPartitionLengths(int numCols, int numSolutions)
{
return
(from partitionLengths in Gen.Choose(1, numCols / 2).ListOf(numSolutions - 1)
let sum = partitionLengths.Sum()
where sum < numCols
select partitionLengths.Concat(new[] { numCols - sum }));
}
private static Gen <IList <IList <int> > > GenPartitionedSolutionRows(int numCols, int startIdx, int endIdx, int numSolutionRows)
{
return
(from solutionRows in Gen.Constant(InitPartitionedSolutionRows(numCols, startIdx, endIdx, numSolutionRows))
from randomRowIdxs in Gen.Choose(0, numSolutionRows - 1).ListOf(endIdx - startIdx)
where Enumerable.Range(0, numSolutionRows).All(randomRowIdxs.Contains)
select RandomlySprinkleOnesIntoSolutionRows(solutionRows, randomRowIdxs, startIdx));
}
public static Arbitrary <(int[], int d)> Input()
{
var a = A().Generator;
var d = a.SelectMany(av => Gen.Choose(1, av.Length));
var result = a.SelectMany(ax => d.Select(dx => (ax, dx)));
return(result.ToArbitrary());
}
public static Gen <Transaction> TX(Network network) =>
from version in Gen.Choose(0, Int32.MaxValue)
from inputs in NonEmptyInputs()
from outputs in NonEmptyOutputs()
from locktime in PrimitiveGenerator.UInt32()
let tx = LegacyTransactionGenerators.ComposeTx(Transaction.Create(network), inputs, outputs, locktime)
where tx.HasWitness
select tx;
public static Arbitrary <int[]> A()
{
var len = Gen.Choose(1, 100);
var aValue = Gen.Choose(1, 1000);
var a = len.SelectMany(l => Gen.ArrayOf(l, aValue));
return(a.ToArbitrary());
}
public IGen <Test> ItRendersOneLine() =>
from value in Gen.Choose(DomainGen.Any(), DomainGen.AnyList())
select Property.ForThese(() =>
{
var rendering = ExampleRenderer.Render(new object[] { value });
rendering.Should().ContainSingle();
});
private static Func <DateTimeOffset, DateTimeOffset> newDateWithGenerator(Gen <int> monthGenerator, int year)
{
var month = monthGenerator.Sample(0, 1).First();
var day = Gen.Choose(1, DateTime.DaysInMonth(year, month)).Sample(0, 1).First();
return(dateTime =>
new DateTime(year, month, day, dateTime.Hour, dateTime.Minute, dateTime.Second));
}
static Gen <string> Domain()
{
var characters = Gen.Elements("abcdefghijklmnopqrstuvwxyz0123456789".ToCharArray());
return(Gen.Choose(1, 63)
.SelectMany(i => Gen.ArrayOf(i, characters))
.Select(a => new string(a)));
}
private static Gen <int[, ]> GenMatrixOfIntWithNoSolutions()
{
return
(from numCols in Gen.Choose(2, 20)
from numRows in Gen.Choose(2, 20)
from indexOfAlwaysZeroColumn in Gen.Choose(0, numCols - 1)
from rows in GenRowWithZeroInGivenColumn(numCols, indexOfAlwaysZeroColumn).ListOf(numRows)
select rows.To2DArray());
}
// 2. p2sh scriptSig public static Gen <Script> MultiSignatureScriptSig() => from N in Gen.Choose(1, (int)20) from hash in Hash256() from M in Gen.Choose(1, N) from pks in PrivateKeys(M) from hashType in SigHashType() select PayToMultiSigTemplate .Instance .GenerateScriptSig(pks.Select(pk => new TransactionSignature(pk.Sign(hash), hashType)));
public static Gen <string> HexString(int length)
{
var res = from i in Gen.Choose(0, length)
where (i % 2 == 0)
from cl in Gen.ListOf(i, HexChar())
select String.Join("", cl.ToList());
return(res);
}
