describe('minimumOf', () => {
jsv.property('minimumOf empty',
() => R.equals(Fold.minimumOf(Traversal.traversed, []), RF.Maybe.Nothing()));
jsv.property('minimumOf non-empty',
jsv.nearray(jsv.nat),
xs => R.equals(Fold.minimumOf(Traversal.traversed, xs), RF.Maybe.Just(R.reduce(R.min, Infinity, xs))));
});
describe('lastOf', () => {
jsv.property('lastOf empty',
() => R.equals(Fold.lastOf(Traversal.traversed, []), RF.Maybe.Nothing()));
jsv.property('lastOf non-empty',
jsv.nearray(jsv.nat),
xs => R.equals(Fold.lastOf(Traversal.traversed, xs), RF.Maybe.Just(R.last(xs))));
});
describe('notElemOf', () => {
jsv.property('notElemOf',
jsv.json, jsv.array(jsv.json),
(x, xs) => R.equals(Fold.notElemOf(Traversal.traversed, x, xs), !R.contains(x, xs)));
jsv.property('notElemOf does not exist',
jsv.json, jsv.nearray(jsv.json),
(x, xs) => Fold.notElemOf(Traversal.traversed, x, R.without([x], xs)));
});
describe('elemOf', () => {
jsv.property('elemOf',
jsv.json, jsv.array(jsv.json),
(x, xs) => R.equals(Fold.elemOf(Traversal.traversed, x, xs), R.contains(x, xs)));
jsv.property('elemOf does exist',
jsv.nearray(jsv.json),
xs => Fold.elemOf(Traversal.traversed, xs[0], xs));
});
describe('hasnt', () => {
jsv.property('hasnt empty traversal',
() => Fold.hasnt(Traversal.traversed, []));
jsv.property('hasnt non-empty traversal',
jsv.nearray(jsv.json),
xs => !Fold.hasnt(Traversal.traversed, xs));
jsv.property('hasnt empty prism',
() => Fold.hasnt(Prism._Just, RF.Maybe.Nothing()));
jsv.property('hasnt non-empty prism',
jsv.json,
a => !Fold.hasnt(Prism._Just, RF.Maybe.Just(a)));
});
describe('Prime factorization (property-based tests)', function() {
it('1 has no prime factors', function() {
expect(primeFactors(1)).to.eql([]);
});
jsc.property(
"A prime number's only prime factor is itself",
jsc.elements(primes),
function (prime) {
return _.isEqual(primeFactors(prime), [prime]);}
);
jsc.property(
"Factoring 2 * a prime returns 2 and the prime",
jsc.elements(primes),
function (prime) {
return _.isEqual(primeFactors(2 * prime), [2, prime]);}
);
jsc.property(
"Factoring a prime * a prime returns both primes",
jsc.elements(primes),
function (prime) {
return _.isEqual(primeFactors(prime * prime), [prime, prime]);}
);
jsc.property(
"Factoring the product of a series of primes returns all the primes",
jsc.small(jsc.nearray(jsc.elements(primes))),
function (primes) {
var someBigNumber = primes.reduce(function(a, b) {
return a * b;
});
return _.isEqual(primeFactors(someBigNumber).sort(), primes.sort());}
);
});
function neset<A>(arb: Arbitrary<A>): Arbitrary<Set<A>> {
return nearray(arb).smap(
xs => Set(xs),
xs => xs.toArray()
)
}
function nelist<A>(arb: Arbitrary<A>): Arbitrary<List<A>> {
return nearray(arb).smap(
xs => fromJS(xs),
xs => xs.toArray()
)
}
const partyLevel = jsc.integer(1, 10);
const partySize = jsc.integer(1, 10);
const party = jsc.record({
size: partySize,
level: partyLevel
});
const size = jsc.elements(["normal", "large", "huge", "weakling", "elite", "double strength", "triple strength"]);
const kind = jsc.elements(["troop", "mook", "wrecker", "blocker", "archer", "caster", "leader", "spoiler", "stalker"]);
const monsterLevel = jsc.integer(0, 14);
const monster = jsc.record({
name: jsc.nestring,
level: monsterLevel,
size: size,
kind: kind,
attributes: jsc.nearray(jsc.nestring),
book: jsc.nestring,
pageNumber: jsc.nat
}).smap(rec => new manticore.common.data.newMonster(
rec.name,
rec.level,
rec.size,
rec.kind,
rec.attributes,
rec.book,
rec.pageNumber
), v => v);
const monsters = jsc.array(monster);
function genEncounters(party, monsters) {