it('cartesian product has more priority', function () {
var a = MSet('(2, 4)')
var b = MSet('{1, 2}')
var power = 3
// ((2, 4) x {1, 2})^3
var lex = List([
createToken('(', '('),
createToken(a, 'set'),
createToken('x', 'x'),
createToken(b, 'set'),
createToken(')', ')'),
createToken('^', '^'),
createToken(power, 'number'),
createEndToken()
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
var result = parser(parserIterator)
expect(result.map(function (product) {
return product.map(rawSet)
})).to.be.deep.equal([
[a, b].map(rawSet),
[a, b].map(rawSet),
[a, b].map(rawSet)
])
})
it('returns the array of sets that means', function () {
var a = MSet('{1}')
var b = MSet('(-1, 2)')
var c = MSet('{2, 0}')
var d = MSet('{5} U [3, 4]')
// ({1} x (-1, 2)) x ({2, 0} x {5} U [3, 4])
var lex = List([
createToken('(', '('),
createToken(a, 'set'),
createToken('x', 'x'),
createToken(b, 'set'),
createToken(')', ')'),
createToken('x', 'x'),
createToken('(', '('),
createToken(c, 'set'),
createToken('x', 'x'),
createToken(d, 'set'),
createToken(')', ')'),
createEndToken()
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
var result = parser(parserIterator)
expect(result.length).to.be.equal(2)
expect(result[0].length).to.be.equal(2)
expect(result[1].length).to.be.equal(2)
expect(result[0].map(rawSet)).to.be.deep.equal([a, b].map(rawSet))
expect(result[1].map(rawSet)).to.be.deep.equal([c, d].map(rawSet))
})
function test () {
//
var lex = List([
createEndToken(column)
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
parser(parserIterator)
}
function test () {
// 5
var lex = List([
createToken(number, 'number', column, key),
createEndToken()
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
parser(parserIterator)
}
it('returns an array with the same set that means', function () {
var set = MSet('(2, 3)')
// (2, 3)
var lex = List([
createToken(set, 'set'),
createEndToken()
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
var result = parser(parserIterator)
expect(rawSet(result[0])).to.be.deep.equal(rawSet(set))
})
function test () {
var a = MSet('(2, 4)')
//
var lex = List([
createToken(a, 'set'),
createToken('x', 'x'),
createEndToken(column)
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
parser(parserIterator)
}
it('returns the array of sets that means', function () {
var a = MSet('(2, 4)')
var power = 3
// (2, 4)^3
var lex = List([
createToken(a, 'set'),
createToken('^', '^'),
createToken(power, 'number'),
createEndToken()
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
var result = parser(parserIterator)
expect(result.map(rawSet)).to.be.deep.equal([a, a, a].map(rawSet))
})
it('returns the array of sets that means wrapped in array', function () {
var a = MSet('{1, 2, 5}')
var b = MSet('[0, 1)')
// ({1, 2, 5} x [0, 1))
var lex = List([
createToken('(', '('),
createToken(a, 'set'),
createToken('x', 'x'),
createToken(b, 'set'),
createToken(')', ')'),
createEndToken()
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
var result = parser(parserIterator)
expect(result.length).to.be.equal(1)
expect(result[0].map(rawSet)).to.be.deep.equal([a, b].map(rawSet))
})
it('returns the array of sets that means', function () {
var a = MSet('(2, 3)')
var b = MSet('[1, 4)')
var c = MSet('{1, 2, 5}')
// (2, 3) x [1, 4) x {1, 2, 5}
var lex = List([
createToken(a, 'set'),
createToken('x', 'x'),
createToken(b, 'set'),
createToken('x', 'x'),
createToken(c, 'set'),
createEndToken()
])
var parserIterator = parserGenerator(lex.build()(), parserTokenClasses, parserStatus('START_EXPR'))
var result = parser(parserIterator)
expect(rawSet(result[0])).to.be.deep.equal(rawSet(a))
expect(rawSet(result[1])).to.be.deep.equal(rawSet(b))
expect(rawSet(result[2])).to.be.deep.equal(rawSet(c))
})