ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename ol.expression to ol.expr

Browse Source
This commit is contained in:
Tim Schaub
2013-06-21 17:29:16 -06:00
parent 9928730bd3
commit 2577d3f7d6
28 changed files with 1550 additions and 1548 deletions
Download Patch File Download Diff File Expand all files Collapse all files

290
test/spec/ol/expression/expression.test.js → test/spec/ol/expr/expression.test.js
View File

@@ -1,33 +1,33 @@
goog.provide('ol.test.expression');
describe('ol.expression.parse()', function() {
describe('ol.expr.parse()', function() {
it('parses a subset of ECMAScript 5.1 expressions', function() {
var expr = ol.expression.parse('foo');
expect(expr).to.be.a(ol.expression.Expression);
var expr = ol.expr.parse('foo');
expect(expr).to.be.a(ol.expr.Expression);
});
describe('11.1 - primary expressions', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.1
it('parses identifier expressions', function() {
var expr = ol.expression.parse('foo');
expect(expr).to.be.a(ol.expression.Identifier);
var expr = ol.expr.parse('foo');
expect(expr).to.be.a(ol.expr.Identifier);
expect(expr.evaluate({foo: 'bar'})).to.be('bar');
});
it('consumes whitespace as expected', function() {
var expr = ol.expression.parse(' foo ');
expect(expr).to.be.a(ol.expression.Identifier);
var expr = ol.expr.parse(' foo ');
expect(expr).to.be.a(ol.expr.Identifier);
expect(expr.evaluate({foo: 'bar'})).to.be('bar');
});
it('throws on invalid identifier expressions', function() {
expect(function() {
ol.expression.parse('3foo');
ol.expr.parse('3foo');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('f');
expect(token.index).to.be(1);
@@ -35,33 +35,33 @@ describe('ol.expression.parse()', function() {
});
it('parses string literal expressions', function() {
var expr = ol.expression.parse('"foo"');
expect(expr).to.be.a(ol.expression.Literal);
var expr = ol.expr.parse('"foo"');
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be('foo');
});
it('throws on unterminated string', function() {
expect(function() {
ol.expression.parse('"foo');
ol.expr.parse('"foo');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.type).to.be(ol.expression.TokenType.EOF);
expect(token.type).to.be(ol.expr.TokenType.EOF);
expect(token.index).to.be(4);
});
});
it('parses numeric literal expressions', function() {
var expr = ol.expression.parse('.42e+2');
expect(expr).to.be.a(ol.expression.Literal);
var expr = ol.expr.parse('.42e+2');
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(42);
});
it('throws on invalid number', function() {
expect(function() {
ol.expression.parse('.42eX');
ol.expr.parse('.42eX');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('X');
expect(token.index).to.be(4);
@@ -69,14 +69,14 @@ describe('ol.expression.parse()', function() {
});
it('parses boolean literal expressions', function() {
var expr = ol.expression.parse('false');
expect(expr).to.be.a(ol.expression.Literal);
var expr = ol.expr.parse('false');
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(false);
});
it('parses null literal expressions', function() {
var expr = ol.expression.parse('null');
expect(expr).to.be.a(ol.expression.Literal);
var expr = ol.expr.parse('null');
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(null);
});
@@ -86,24 +86,24 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.2
it('parses member expressions with dot notation', function() {
var expr = ol.expression.parse('foo.bar.baz');
expect(expr).to.be.a(ol.expression.Member);
var expr = ol.expr.parse('foo.bar.baz');
expect(expr).to.be.a(ol.expr.Member);
var scope = {foo: {bar: {baz: 42}}};
expect(expr.evaluate(scope)).to.be(42);
});
it('consumes whitespace as expected', function() {
var expr = ol.expression.parse(' foo . bar . baz ');
expect(expr).to.be.a(ol.expression.Member);
var expr = ol.expr.parse(' foo . bar . baz ');
expect(expr).to.be.a(ol.expr.Member);
var scope = {foo: {bar: {baz: 42}}};
expect(expr.evaluate(scope)).to.be(42);
});
it('throws on invalid member expression', function() {
expect(function() {
ol.expression.parse('foo.4bar');
ol.expr.parse('foo.4bar');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('b');
expect(token.index).to.be(5);
@@ -111,8 +111,8 @@ describe('ol.expression.parse()', function() {
});
it('parses call expressions with literal arguments', function() {
var expr = ol.expression.parse('foo(42, "bar")');
expect(expr).to.be.a(ol.expression.Call);
var expr = ol.expr.parse('foo(42, "bar")');
expect(expr).to.be.a(ol.expr.Call);
var scope = {
foo: function(num, str) {
expect(num).to.be(42);
@@ -125,9 +125,9 @@ describe('ol.expression.parse()', function() {
it('throws on calls with unterminated arguments', function() {
expect(function() {
ol.expression.parse('foo(42,)');
ol.expr.parse('foo(42,)');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be(')');
expect(token.index).to.be(7);
@@ -146,8 +146,8 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.4
it('parses logical not operator', function() {
var expr = ol.expression.parse('!foo');
expect(expr).to.be.a(ol.expression.Not);
var expr = ol.expr.parse('!foo');
expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({foo: false})).to.be(true);
expect(expr.evaluate({foo: ''})).to.be(true);
@@ -155,8 +155,8 @@ describe('ol.expression.parse()', function() {
});
it('consumes whitespace as expected', function() {
var expr = ol.expression.parse(' ! foo');
expect(expr).to.be.a(ol.expression.Not);
var expr = ol.expr.parse(' ! foo');
expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({foo: false})).to.be(true);
});
@@ -167,38 +167,38 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.5
it('parses * operator', function() {
var expr = ol.expression.parse('foo*bar');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse('foo*bar');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(200);
});
it('consumes whitespace as expected with *', function() {
var expr = ol.expression.parse(' foo * bar ');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse(' foo * bar ');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 15, bar: 2})).to.be(30);
});
it('parses / operator', function() {
var expr = ol.expression.parse('foo/12');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse('foo/12');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10})).to.be(10 / 12);
});
it('consumes whitespace as expected with /', function() {
var expr = ol.expression.parse(' 4 / bar ');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse(' 4 / bar ');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({bar: 3})).to.be(4 / 3);
});
it('parses % operator', function() {
var expr = ol.expression.parse('12%foo');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse('12%foo');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10})).to.be(2);
});
it('consumes whitespace as expected with %', function() {
var expr = ol.expression.parse(' 4 %bar ');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse(' 4 %bar ');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({bar: 3})).to.be(1);
});
@@ -208,26 +208,26 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.6
it('parses + operator', function() {
var expr = ol.expression.parse('foo+bar');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse('foo+bar');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(30);
});
it('consumes whitespace as expected with +', function() {
var expr = ol.expression.parse(' foo +10 ');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse(' foo +10 ');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 15})).to.be(25);
});
it('parses - operator', function() {
var expr = ol.expression.parse('foo-bar');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse('foo-bar');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(-10);
});
it('consumes whitespace as expected with -', function() {
var expr = ol.expression.parse(' foo- 10 ');
expect(expr).to.be.a(ol.expression.Math);
var expr = ol.expr.parse(' foo- 10 ');
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 15})).to.be(5);
});
@@ -242,44 +242,44 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.8
it('parses < operator', function() {
var expr = ol.expression.parse('foo<bar');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('foo<bar');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(true);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(false);
});
it('consumes whitespace as expected with <', function() {
var expr = ol.expression.parse(' foo <10 ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' foo <10 ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(false);
expect(expr.evaluate({foo: 5})).to.be(true);
});
it('parses > operator', function() {
var expr = ol.expression.parse('foo>bar');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('foo>bar');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(false);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(true);
});
it('consumes whitespace as expected with >', function() {
var expr = ol.expression.parse(' foo> 10 ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' foo> 10 ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(true);
expect(expr.evaluate({foo: 5})).to.be(false);
});
it('parses <= operator', function() {
var expr = ol.expression.parse('foo<=bar');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('foo<=bar');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(true);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(false);
expect(expr.evaluate({foo: 20, bar: 20})).to.be(true);
});
it('consumes whitespace as expected with <=', function() {
var expr = ol.expression.parse(' foo<= 10 ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' foo<= 10 ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(false);
expect(expr.evaluate({foo: 5})).to.be(true);
expect(expr.evaluate({foo: 10})).to.be(true);
@@ -287,9 +287,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with <=', function() {
expect(function() {
ol.expression.parse(' foo< = 10 ');
ol.expr.parse(' foo< = 10 ');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('=');
expect(token.index).to.be(6);
@@ -297,16 +297,16 @@ describe('ol.expression.parse()', function() {
});
it('parses >= operator', function() {
var expr = ol.expression.parse('foo>=bar');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('foo>=bar');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(false);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(true);
expect(expr.evaluate({foo: 20, bar: 20})).to.be(true);
});
it('consumes whitespace as expected with >=', function() {
var expr = ol.expression.parse(' foo >=10 ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' foo >=10 ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(true);
expect(expr.evaluate({foo: 5})).to.be(false);
expect(expr.evaluate({foo: 10})).to.be(true);
@@ -314,9 +314,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with >=', function() {
expect(function() {
ol.expression.parse(' 10 > =foo ');
ol.expr.parse(' 10 > =foo ');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('=');
expect(token.index).to.be(6);
@@ -329,16 +329,16 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.9
it('parses == operator', function() {
var expr = ol.expression.parse('foo==42');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('foo==42');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true);
});
it('consumes whitespace as expected with ==', function() {
var expr = ol.expression.parse(' 42 ==foo ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' 42 ==foo ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true);
@@ -346,9 +346,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with ==', function() {
expect(function() {
ol.expression.parse(' 10 = =foo ');
ol.expr.parse(' 10 = =foo ');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('=');
expect(token.index).to.be(4);
@@ -356,16 +356,16 @@ describe('ol.expression.parse()', function() {
});
it('parses != operator', function() {
var expr = ol.expression.parse('foo!=42');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('foo!=42');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false);
});
it('consumes whitespace as expected with !=', function() {
var expr = ol.expression.parse(' 42 !=foo ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' 42 !=foo ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false);
@@ -373,9 +373,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with !=', function() {
expect(function() {
ol.expression.parse(' 10! =foo ');
ol.expr.parse(' 10! =foo ');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('!');
expect(token.index).to.be(3);
@@ -383,16 +383,16 @@ describe('ol.expression.parse()', function() {
});
it('parses === operator', function() {
var expr = ol.expression.parse('42===foo');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('42===foo');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false);
});
it('consumes whitespace as expected with ===', function() {
var expr = ol.expression.parse(' foo ===42 ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' foo ===42 ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false);
@@ -400,9 +400,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with ===', function() {
expect(function() {
ol.expression.parse(' 10 = == foo ');
ol.expr.parse(' 10 = == foo ');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('=');
expect(token.index).to.be(4);
@@ -410,16 +410,16 @@ describe('ol.expression.parse()', function() {
});
it('parses !== operator', function() {
var expr = ol.expression.parse('foo!==42');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse('foo!==42');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true);
});
it('consumes whitespace as expected with !==', function() {
var expr = ol.expression.parse(' 42 !== foo ');
expect(expr).to.be.a(ol.expression.Comparison);
var expr = ol.expr.parse(' 42 !== foo ');
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true);
@@ -427,9 +427,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with !==', function() {
expect(function() {
ol.expression.parse(' 10 != = foo ');
ol.expr.parse(' 10 != = foo ');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('=');
expect(token.index).to.be(7);
@@ -446,8 +446,8 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.11
it('parses && operator', function() {
var expr = ol.expression.parse('foo&&bar');
expect(expr).to.be.a(ol.expression.Logical);
var expr = ol.expr.parse('foo&&bar');
expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false);
@@ -455,8 +455,8 @@ describe('ol.expression.parse()', function() {
});
it('consumes space as expected with &&', function() {
var expr = ol.expression.parse(' foo && bar ');
expect(expr).to.be.a(ol.expression.Logical);
var expr = ol.expr.parse(' foo && bar ');
expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false);
@@ -465,9 +465,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with &&', function() {
expect(function() {
ol.expression.parse('true & & false');
ol.expr.parse('true & & false');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('&');
expect(token.index).to.be(5);
@@ -475,8 +475,8 @@ describe('ol.expression.parse()', function() {
});
it('parses || operator', function() {
var expr = ol.expression.parse('foo||bar');
expect(expr).to.be.a(ol.expression.Logical);
var expr = ol.expr.parse('foo||bar');
expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true);
@@ -484,8 +484,8 @@ describe('ol.expression.parse()', function() {
});
it('consumes space as expected with ||', function() {
var expr = ol.expression.parse(' foo || bar ');
expect(expr).to.be.a(ol.expression.Logical);
var expr = ol.expr.parse(' foo || bar ');
expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true);
@@ -494,9 +494,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with ||', function() {
expect(function() {
ol.expression.parse('true | | false');
ol.expr.parse('true | | false');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('|');
expect(token.index).to.be(5);
@@ -522,10 +522,10 @@ describe('ol.expression.parse()', function() {
});
describe('ol.expression.lib', function() {
describe('ol.expr.lib', function() {
var parse = ol.expression.parse;
var evaluate = ol.expression.evaluateFeature;
var parse = ol.expr.parse;
var evaluate = ol.expr.evaluateFeature;
describe('extent()', function() {
@@ -611,48 +611,50 @@ describe('ol.expression.lib', function() {
});
describe('ol.expression.register()', function() {
describe('ol.expr.register()', function() {
var spy;
beforeEach(function() {
spy = sinon.spy();
});
it('registers custom functions in ol.expression.lib', function() {
ol.expression.register('someFunc', spy);
expect(ol.expression.lib.someFunc).to.be(spy);
it('registers custom functions in ol.expr.lib', function() {
ol.expr.register('someFunc', spy);
expect(ol.expr.lib.someFunc).to.be(spy);
});
it('allows custom functions to be called', function() {
ol.expression.register('myFunc', spy);
var expr = ol.expression.parse('myFunc(42)');
expr.evaluate(null, ol.expression.lib);
ol.expr.register('myFunc', spy);
var expr = ol.expr.parse('myFunc(42)');
expr.evaluate(null, ol.expr.lib);
expect(spy.calledOnce);
expect(spy.calledWithExactly(42));
});
it('allows custom functions to be called with identifiers', function() {
ol.expression.register('myFunc', spy);
var expr = ol.expression.parse('myFunc(foo, 42)');
expr.evaluate({foo: 'bar'}, ol.expression.lib);
ol.expr.register('myFunc', spy);
var expr = ol.expr.parse('myFunc(foo, 42)');
expr.evaluate({foo: 'bar'}, ol.expr.lib);
expect(spy.calledOnce);
expect(spy.calledWithExactly('bar', 42));
});
it('allows custom functions to be called with custom this obj', function() {
ol.expression.register('myFunc', spy);
var expr = ol.expression.parse('myFunc(foo, 42)');
ol.expr.register('myFunc', spy);
var expr = ol.expr.parse('myFunc(foo, 42)');
var that = {};
expr.evaluate({foo: 'bar'}, ol.expression.lib, that);
expr.evaluate({foo: 'bar'}, ol.expr.lib, that);
expect(spy.calledOnce);
expect(spy.calledWithExactly('bar', 42));
expect(spy.calledOn(that));
});
it('allows overriding existing ol.expression.lib functions', function() {
expect(ol.expression.lib.extent).not.to.be(spy);
ol.expression.register('extent', spy);
expect(ol.expression.lib.extent).to.be(spy);
it('allows overriding existing ol.expr.lib functions', function() {
var orig = ol.expr.lib.extent;
expect(orig).not.to.be(spy);
ol.expr.register('extent', spy);
expect(ol.expr.lib.extent).to.be(spy);
ol.expr.lib.extent = orig;
});
});
@@ -660,18 +662,18 @@ describe('ol.expression.register()', function() {
goog.require('ol.Feature');
goog.require('ol.expression');
goog.require('ol.expression.Call');
goog.require('ol.expression.Comparison');
goog.require('ol.expression.Expression');
goog.require('ol.expression.Identifier');
goog.require('ol.expression.Literal');
goog.require('ol.expression.Logical');
goog.require('ol.expression.Math');
goog.require('ol.expression.Member');
goog.require('ol.expression.Not');
goog.require('ol.expression.TokenType');
goog.require('ol.expression.UnexpectedToken');
goog.require('ol.expr');
goog.require('ol.expr.Call');
goog.require('ol.expr.Comparison');
goog.require('ol.expr.Expression');
goog.require('ol.expr.Identifier');
goog.require('ol.expr.Literal');
goog.require('ol.expr.Logical');
goog.require('ol.expr.Math');
goog.require('ol.expr.Member');
goog.require('ol.expr.Not');
goog.require('ol.expr.TokenType');
goog.require('ol.expr.UnexpectedToken');
goog.require('ol.geom.LineString');
goog.require('ol.geom.Point');
goog.require('ol.geom.Polygon');

638
test/spec/ol/expr/expressions.test.js Normal file
View File

@@ -0,0 +1,638 @@
goog.provide('ol.test.expression.Expression');
describe('ol.expr.Call', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('sqrt'),
[new ol.expr.Literal(42)]);
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Call);
});
});
describe('#evaluate()', function() {
var fns = {
sqrt: function(value) {
return Math.sqrt(value);
},
strConcat: function() {
return Array.prototype.join.call(arguments, '');
},
discouraged: function() {
return this.message;
}
};
it('calls method on scope with literal args', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('sqrt'),
[new ol.expr.Literal(42)]);
expect(expr.evaluate(fns)).to.be(Math.sqrt(42));
});
it('accepts a separate scope for functions', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('sqrt'),
[new ol.expr.Identifier('foo')]);
expect(expr.evaluate({foo: 42}, fns)).to.be(Math.sqrt(42));
});
it('accepts multiple expression arguments', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('strConcat'),
[
new ol.expr.Identifier('foo'),
new ol.expr.Literal(' comes after '),
new ol.expr.Math(
ol.expr.MathOp.SUBTRACT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(1))
]);
expect(expr.evaluate({foo: 42}, fns)).to.be('42 comes after 41');
});
it('accepts optional this arg', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('discouraged'), []);
var thisArg = {
message: 'avoid this'
};
expect(expr.evaluate(fns, null, thisArg)).to.be('avoid this');
});
});
var callee = new ol.expr.Identifier('sqrt');
var args = [new ol.expr.Literal(42)];
var expr = new ol.expr.Call(callee, args);
describe('#getArgs()', function() {
it('gets the callee expression', function() {
expect(expr.getArgs()).to.be(args);
});
});
describe('#getCallee()', function() {
it('gets the callee expression', function() {
expect(expr.getCallee()).to.be(callee);
});
});
});
describe('ol.expr.Comparison', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.EQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Comparison);
});
});
describe('#evaluate()', function() {
it('compares with ==', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.EQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !=', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.NEQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with ===', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.STRICT_EQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !==', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.STRICT_NEQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with >', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.GT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.LT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
it('compares with >=', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.GTE,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <=', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.LTE,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expr.Comparison.isValidOp('<')).to.be(true);
expect(ol.expr.Comparison.isValidOp('<')).to.be(true);
expect(ol.expr.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expr.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expr.Comparison.isValidOp('==')).to.be(true);
expect(ol.expr.Comparison.isValidOp('!=')).to.be(true);
expect(ol.expr.Comparison.isValidOp('===')).to.be(true);
expect(ol.expr.Comparison.isValidOp('!==')).to.be(true);
expect(ol.expr.Comparison.isValidOp('')).to.be(false);
expect(ol.expr.Comparison.isValidOp('+')).to.be(false);
expect(ol.expr.Comparison.isValidOp('-')).to.be(false);
expect(ol.expr.Comparison.isValidOp('&&')).to.be(false);
});
});
var op = ol.expr.ComparisonOp.LTE;
var left = new ol.expr.Identifier('foo');
var right = new ol.expr.Literal(42);
var expr = new ol.expr.Comparison(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expr.Identifier', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Identifier('foo');
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Identifier);
});
});
describe('#evaluate()', function() {
it('returns a number from the scope', function() {
var expr = new ol.expr.Identifier('foo');
expect(expr.evaluate({foo: 42})).to.be(42);
});
it('returns a string from the scope', function() {
var expr = new ol.expr.Identifier('foo');
expect(expr.evaluate({foo: 'chicken'})).to.be('chicken');
});
it('returns a boolean from the scope', function() {
var expr = new ol.expr.Identifier('bar');
expect(expr.evaluate({bar: false})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('returns a null from the scope', function() {
var expr = new ol.expr.Identifier('nada');
expect(expr.evaluate({nada: null})).to.be(null);
});
it('works for unicode identifiers', function() {
var expr = new ol.expr.Identifier('\u03c0');
expect(expr.evaluate({'\u03c0': Math.PI})).to.be(Math.PI);
});
});
describe('#getName()', function() {
var expr = new ol.expr.Identifier('asdf');
expect(expr.getName()).to.be('asdf');
});
});
describe('ol.expr.Literal', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Literal(true);
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Literal);
});
});
describe('#evaluate()', function() {
it('works for numeric literal', function() {
var expr = new ol.expr.Literal(42e-11);
expect(expr.evaluate()).to.be(4.2e-10);
});
it('works for string literal', function() {
var expr = new ol.expr.Literal('asdf');
expect(expr.evaluate()).to.be('asdf');
});
it('works for boolean literal', function() {
var expr = new ol.expr.Literal(true);
expect(expr.evaluate()).to.be(true);
});
it('works for null literal', function() {
var expr = new ol.expr.Literal(null);
expect(expr.evaluate()).to.be(null);
});
});
describe('#getValue()', function() {
var expr = new ol.expr.Literal('asdf');
expect(expr.getValue()).to.be('asdf');
});
});
describe('ol.expr.Logical', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Logical(
ol.expr.LogicalOp.OR,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Logical);
});
});
describe('#evaluate()', function() {
it('applies || to resolved identifiers', function() {
var expr = new ol.expr.Logical(
ol.expr.LogicalOp.OR,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
it('applies && to resolved identifiers', function() {
var expr = new ol.expr.Logical(
ol.expr.LogicalOp.AND,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expr.Logical.isValidOp('||')).to.be(true);
expect(ol.expr.Logical.isValidOp('&&')).to.be(true);
expect(ol.expr.Logical.isValidOp('')).to.be(false);
expect(ol.expr.Logical.isValidOp('+')).to.be(false);
expect(ol.expr.Logical.isValidOp('<')).to.be(false);
expect(ol.expr.Logical.isValidOp('|')).to.be(false);
});
});
var op = ol.expr.LogicalOp.AND;
var left = new ol.expr.Identifier('foo');
var right = new ol.expr.Literal(false);
var expr = new ol.expr.Logical(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expr.Math', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Literal(40),
new ol.expr.Literal(2));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Math);
});
});
describe('#evaluate()', function() {
it('does + with numeric literal', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Literal(40),
new ol.expr.Literal(2));
expect(expr.evaluate()).to.be(42);
});
it('does + with string literal (note: subject to change)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Literal('foo'),
new ol.expr.Literal('bar'));
expect(expr.evaluate()).to.be('foobar');
});
it('does + with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr.evaluate({foo: 40, bar: 2})).to.be(42);
});
it('does - with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.SUBTRACT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(2));
expect(expr.evaluate({foo: 40})).to.be(38);
});
it('casts to number with - (note: this may throw later)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.SUBTRACT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(2));
expect(expr.evaluate({foo: '40'})).to.be(38);
});
it('does * with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MULTIPLY,
new ol.expr.Literal(2),
new ol.expr.Identifier('foo'));
expect(expr.evaluate({foo: 21})).to.be(42);
});
it('casts to number with * (note: this may throw later)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MULTIPLY,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(2));
expect(expr.evaluate({foo: '21'})).to.be(42);
});
it('does % with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MOD,
new ol.expr.Literal(97),
new ol.expr.Identifier('foo'));
expect(expr.evaluate({foo: 55})).to.be(42);
});
it('casts to number with % (note: this may throw later)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MOD,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(100));
expect(expr.evaluate({foo: '150'})).to.be(50);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expr.Math.isValidOp('+')).to.be(true);
expect(ol.expr.Math.isValidOp('-')).to.be(true);
expect(ol.expr.Math.isValidOp('*')).to.be(true);
expect(ol.expr.Math.isValidOp('/')).to.be(true);
expect(ol.expr.Math.isValidOp('%')).to.be(true);
expect(ol.expr.Math.isValidOp('')).to.be(false);
expect(ol.expr.Math.isValidOp('|')).to.be(false);
expect(ol.expr.Math.isValidOp('&')).to.be(false);
expect(ol.expr.Math.isValidOp('<')).to.be(false);
expect(ol.expr.Math.isValidOp('||')).to.be(false);
expect(ol.expr.Math.isValidOp('.')).to.be(false);
});
});
var op = ol.expr.MathOp.MOD;
var left = new ol.expr.Identifier('foo');
var right = new ol.expr.Literal(20);
var expr = new ol.expr.Math(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expr.Member', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Member(
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Member);
});
});
describe('#evaluate()', function() {
it('accesses an object property', function() {
var expr = new ol.expr.Member(
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
var scope = {foo: {bar: 42}};
expect(expr.evaluate(scope)).to.be(42);
});
});
var object = new ol.expr.Identifier('foo');
var property = new ol.expr.Identifier('bar');
var expr = new ol.expr.Member(object, property);
describe('#getObject()', function() {
expect(expr.getObject()).to.be(object);
});
describe('#getProperty()', function() {
expect(expr.getProperty()).to.be(property);
});
});
describe('ol.expr.Not', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Not(
new ol.expr.Literal(true));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Not);
});
});
describe('#evaluate()', function() {
it('returns the logical complement', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(true));
expect(expr.evaluate()).to.be(false);
expr = new ol.expr.Not(new ol.expr.Literal(false));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy string', function() {
var expr = new ol.expr.Not(new ol.expr.Literal('asdf'));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy string', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(''));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy number', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(42));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy number', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(NaN));
expect(expr.evaluate()).to.be(true);
});
});
describe('#getArgument()', function() {
var argument = new ol.expr.Literal(true);
var expr = new ol.expr.Not(argument);
expect(expr.getArgument()).to.be(argument);
});
});
goog.require('ol.expr.Call');
goog.require('ol.expr.Comparison');
goog.require('ol.expr.ComparisonOp');
goog.require('ol.expr.Expression');
goog.require('ol.expr.Identifier');
goog.require('ol.expr.Literal');
goog.require('ol.expr.Logical');
goog.require('ol.expr.LogicalOp');
goog.require('ol.expr.Math');
goog.require('ol.expr.MathOp');
goog.require('ol.expr.Member');
goog.require('ol.expr.Not');

166
test/spec/ol/expression/lexer.test.js → test/spec/ol/expr/lexer.test.js
View File

@@ -1,11 +1,11 @@
goog.provide('ol.test.expression.Lexer');
describe('ol.expression.Lexer', function() {
describe('ol.expr.Lexer', function() {
describe('constructor', function() {
it('creates a new lexer', function() {
var lexer = new ol.expression.Lexer('foo');
expect(lexer).to.be.a(ol.expression.Lexer);
var lexer = new ol.expr.Lexer('foo');
expect(lexer).to.be.a(ol.expr.Lexer);
});
});
@@ -13,30 +13,30 @@ describe('ol.expression.Lexer', function() {
it('returns one token at a time', function() {
var source = 'foo === "bar"';
var lexer = new ol.expression.Lexer(source);
var lexer = new ol.expr.Lexer(source);
// scan first token
var token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo');
// scan second token
token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
expect(token.value).to.be('===');
// scan third token
token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
expect(token.value).to.be('bar');
// scan again
token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.EOF);
expect(token.type).to.be(ol.expr.TokenType.EOF);
// and again
token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.EOF);
expect(token.type).to.be(ol.expr.TokenType.EOF);
});
});
@@ -45,45 +45,45 @@ describe('ol.expression.Lexer', function() {
var lexer;
beforeEach(function() {
lexer = new ol.expression.Lexer('foo > 42 && bar == "chicken"');
lexer = new ol.expr.Lexer('foo > 42 && bar == "chicken"');
});
it('looks ahead without consuming token', function() {
var token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo');
token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo');
});
it('works after a couple scans', function() {
var token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo');
token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
expect(token.value).to.be('>');
token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
expect(token.value).to.be(42);
token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
expect(token.value).to.be(42);
});
it('returns the same thing when called multiple times', function() {
var token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo');
for (var i = 0; i < 10; ++i) {
token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo');
}
});
@@ -94,11 +94,11 @@ describe('ol.expression.Lexer', function() {
describe('#scanIdentifier_()', function() {
function scan(source, part) {
var lexer = new ol.expression.Lexer(source);
var lexer = new ol.expr.Lexer(source);
var token = lexer.scanIdentifier_(lexer.getCurrentCharCode_());
if (!part) {
expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
}
return token;
}
@@ -106,61 +106,61 @@ describe('ol.expression.Lexer', function() {
it('works for short identifiers', function() {
var token = scan('a');
expect(token.value).to.be('a');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
});
it('works for longer identifiers', function() {
var token = scan('foo');
expect(token.value).to.be('foo');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
});
it('works for $ anywhere', function() {
var token = scan('$foo$bar$');
expect(token.value).to.be('$foo$bar$');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
});
it('works for _ anywhere', function() {
var token = scan('_foo_bar_');
expect(token.value).to.be('_foo_bar_');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
});
it('works for keywords', function() {
var token = scan('delete');
expect(token.value).to.be('delete');
expect(token.type).to.be(ol.expression.TokenType.KEYWORD);
expect(token.type).to.be(ol.expr.TokenType.KEYWORD);
});
it('works for null', function() {
var token = scan('null');
expect(token.value).to.be('null');
expect(token.type).to.be(ol.expression.TokenType.NULL_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NULL_LITERAL);
});
it('works for boolean true', function() {
var token = scan('true');
expect(token.value).to.be('true');
expect(token.type).to.be(ol.expression.TokenType.BOOLEAN_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.BOOLEAN_LITERAL);
});
it('works for boolean false', function() {
var token = scan('false');
expect(token.value).to.be('false');
expect(token.type).to.be(ol.expression.TokenType.BOOLEAN_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.BOOLEAN_LITERAL);
});
it('works with unicode escape sequences', function() {
var token = scan('\u006f\u006c\u0033');
expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
});
it('works with hex escape sequences', function() {
var token = scan('\x6f\x6c\x33');
expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
});
it('throws for identifiers starting with a number', function() {
@@ -178,7 +178,7 @@ describe('ol.expression.Lexer', function() {
it('only scans valid identifier part', function() {
var token = scan('foo>bar', true);
expect(token.value).to.be('foo');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
});
});
@@ -186,24 +186,24 @@ describe('ol.expression.Lexer', function() {
describe('#scanNumericLiteral_()', function() {
function scan(source) {
var lexer = new ol.expression.Lexer(source);
var lexer = new ol.expr.Lexer(source);
var token = lexer.scanNumericLiteral_(lexer.getCurrentCharCode_());
expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return token;
}
it('works for integers', function() {
var token = scan('123');
expect(token.value).to.be(123);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
});
it('throws for bogus integer', function() {
expect(function() {
scan('123z');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('z');
expect(token.index).to.be(3);
@@ -213,14 +213,14 @@ describe('ol.expression.Lexer', function() {
it('works for float', function() {
var token = scan('123.456');
expect(token.value).to.be(123.456);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
});
it('throws for bogus float', function() {
expect(function() {
scan('123.4x4');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('x');
expect(token.index).to.be(5);
@@ -230,26 +230,26 @@ describe('ol.expression.Lexer', function() {
it('works with exponent', function() {
var token = scan('1.234e5');
expect(token.value).to.be(1.234e5);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
});
it('works with explicit positive exponent', function() {
var token = scan('1.234e+5');
expect(token.value).to.be(1.234e5);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
});
it('works with negative exponent', function() {
var token = scan('1.234e-5');
expect(token.value).to.be(1.234e-5);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
});
it('throws for bogus float', function() {
expect(function() {
scan('1.234eo4');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('o');
expect(token.index).to.be(6);
@@ -259,7 +259,7 @@ describe('ol.expression.Lexer', function() {
it('works with octals', function() {
var token = scan('02322');
expect(token.value).to.be(1234);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
});
it('throws for bogus octal', function() {
@@ -267,7 +267,7 @@ describe('ol.expression.Lexer', function() {
expect(function() {
scan('02392');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('9');
expect(token.index).to.be(3);
@@ -277,7 +277,7 @@ describe('ol.expression.Lexer', function() {
it('works with hex', function() {
var token = scan('0x4d2');
expect(token.value).to.be(1234);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
});
it('throws for bogus hex', function() {
@@ -285,7 +285,7 @@ describe('ol.expression.Lexer', function() {
expect(function() {
scan('0x4G');
}).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.value).to.be('G');
expect(token.index).to.be(3);
@@ -297,89 +297,89 @@ describe('ol.expression.Lexer', function() {
describe('#scanPunctuator_()', function() {
function scan(source) {
var lexer = new ol.expression.Lexer(source);
var lexer = new ol.expr.Lexer(source);
var token = lexer.scanPunctuator_(lexer.getCurrentCharCode_());
expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return token;
}
it('works for dot', function() {
var token = scan('.');
expect(token.value).to.be('.');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for bang', function() {
var token = scan('!');
expect(token.value).to.be('!');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for double equal', function() {
var token = scan('==');
expect(token.value).to.be('==');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for triple equal', function() {
var token = scan('===');
expect(token.value).to.be('===');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for not double equal', function() {
var token = scan('!=');
expect(token.value).to.be('!=');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for not triple equal', function() {
var token = scan('!==');
expect(token.value).to.be('!==');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for logical or', function() {
var token = scan('||');
expect(token.value).to.be('||');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for logical and', function() {
var token = scan('&&');
expect(token.value).to.be('&&');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for plus', function() {
var token = scan('+');
expect(token.value).to.be('+');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for minus', function() {
var token = scan('-');
expect(token.value).to.be('-');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for star', function() {
var token = scan('*');
expect(token.value).to.be('*');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for slash', function() {
var token = scan('/');
expect(token.value).to.be('/');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
it('works for percent', function() {
var token = scan('%');
expect(token.value).to.be('%');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
});
});
@@ -387,62 +387,62 @@ describe('ol.expression.Lexer', function() {
describe('#scanStringLiteral_()', function() {
function scan(source) {
var lexer = new ol.expression.Lexer(source);
var lexer = new ol.expr.Lexer(source);
var token = lexer.scanStringLiteral_(lexer.getCurrentCharCode_());
expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return token;
}
it('parses double quoted string', function() {
var token = scan('"my string"');
expect(token.value).to.be('my string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses double quoted string with internal single quotes', function() {
var token = scan('"my \'quoted\' string"');
expect(token.value).to.be('my \'quoted\' string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses double quoted string with escaped double quotes', function() {
var token = scan('"my \\"quoted\\" string"');
expect(token.value).to.be('my "quoted" string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses double quoted string with escaped backslash', function() {
var token = scan('"my \\\ string"');
expect(token.value).to.be('my \ string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses double quoted string with unicode escape sequences', function() {
var token = scan('"\u006f\u006c\u0033"');
expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses double quoted string with hex escape sequences', function() {
var token = scan('"\x6f\x6c\x33"');
expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses double quoted string with tab', function() {
var token = scan('"a\ttab"');
expect(token.value).to.be('a\ttab');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('throws on unterminated double quote', function() {
expect(function() {
scan('"never \'ending\' string');
}).to.throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.type).to.be(ol.expression.TokenType.EOF);
expect(token.type).to.be(ol.expr.TokenType.EOF);
expect(token.index).to.be(22);
});
});
@@ -450,52 +450,52 @@ describe('ol.expression.Lexer', function() {
it('parses single quoted string', function() {
var token = scan('\'my string\'');
expect(token.value).to.be('my string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses single quoted string with internal double quotes', function() {
var token = scan('\'my "quoted" string\'');
expect(token.value).to.be('my "quoted" string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses single quoted string with escaped single quotes', function() {
var token = scan('\'my \\\'quoted\\\' string\'');
expect(token.value).to.be('my \'quoted\' string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses single quoted string with escaped backslash', function() {
var token = scan('\'my \\\ string\'');
expect(token.value).to.be('my \ string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses single quoted string with unicode escape sequences', function() {
var token = scan('\'\u006f\u006c\u0033\'');
expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses single quoted string with hex escape sequences', function() {
var token = scan('\'\x6f\x6c\x33\'');
expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('parses single quoted string with tab', function() {
var token = scan('\'a\ttab\'');
expect(token.value).to.be('a\ttab');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
});
it('throws on unterminated single quote', function() {
expect(function() {
scan('\'never "ending" string');
}).to.throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken);
expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token;
expect(token.type).to.be(ol.expression.TokenType.EOF);
expect(token.type).to.be(ol.expr.TokenType.EOF);
expect(token.index).to.be(22);
});
});
@@ -504,6 +504,6 @@ describe('ol.expression.Lexer', function() {
});
goog.require('ol.expression.Lexer');
goog.require('ol.expression.TokenType');
goog.require('ol.expression.UnexpectedToken');
goog.require('ol.expr.Lexer');
goog.require('ol.expr.TokenType');
goog.require('ol.expr.UnexpectedToken');

102
test/spec/ol/expression/parser.test.js → test/spec/ol/expr/parser.test.js
View File

@@ -1,21 +1,21 @@
goog.provide('ol.test.expression.Parser');
describe('ol.expression.Parser', function() {
describe('ol.expr.Parser', function() {
describe('constructor', function() {
it('creates a new expression parser', function() {
var parser = new ol.expression.Parser();
expect(parser).to.be.a(ol.expression.Parser);
var parser = new ol.expr.Parser();
expect(parser).to.be.a(ol.expr.Parser);
});
});
describe('#parseArguments_()', function() {
function parse(source) {
var lexer = new ol.expression.Lexer(source);
var parser = new ol.expression.Parser();
var lexer = new ol.expr.Lexer(source);
var parser = new ol.expr.Parser();
var expr = parser.parseArguments_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr;
}
@@ -23,13 +23,13 @@ describe('ol.expression.Parser', function() {
var args = parse('(1/3, "foo", true)');
expect(args).length(3);
expect(args[0]).to.be.a(ol.expression.Math);
expect(args[0]).to.be.a(ol.expr.Math);
expect(args[0].evaluate()).to.be(1 / 3);
expect(args[1]).to.be.a(ol.expression.Literal);
expect(args[1]).to.be.a(ol.expr.Literal);
expect(args[1].evaluate()).to.be('foo');
expect(args[2]).to.be.a(ol.expression.Literal);
expect(args[2]).to.be.a(ol.expr.Literal);
expect(args[2].evaluate()).to.be(true);
});
@@ -50,16 +50,16 @@ describe('ol.expression.Parser', function() {
describe('#parseBinaryExpression_()', function() {
function parse(source) {
var lexer = new ol.expression.Lexer(source);
var parser = new ol.expression.Parser();
var lexer = new ol.expr.Lexer(source);
var parser = new ol.expr.Parser();
var expr = parser.parseBinaryExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr;
}
it('works with multiplicitave operators', function() {
var expr = parse('4 * 1e4');
expect(expr).to.be.a(ol.expression.Math);
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate()).to.be(40000);
expect(parse('10/3').evaluate()).to.be(10 / 3);
@@ -67,7 +67,7 @@ describe('ol.expression.Parser', function() {
it('works with additive operators', function() {
var expr = parse('4 +1e4');
expect(expr).to.be.a(ol.expression.Math);
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate()).to.be(10004);
expect(parse('10-3').evaluate()).to.be(7);
@@ -75,7 +75,7 @@ describe('ol.expression.Parser', function() {
it('works with relational operators', function() {
var expr = parse('4 < 1e4');
expect(expr).to.be.a(ol.expression.Comparison);
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate()).to.be(true);
expect(parse('10<3').evaluate()).to.be(false);
@@ -86,7 +86,7 @@ describe('ol.expression.Parser', function() {
it('works with equality operators', function() {
var expr = parse('4 == 1e4');
expect(expr).to.be.a(ol.expression.Comparison);
expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate()).to.be(false);
expect(parse('10!=3').evaluate()).to.be(true);
@@ -97,7 +97,7 @@ describe('ol.expression.Parser', function() {
it('works with binary logical operators', function() {
var expr = parse('true && false');
expect(expr).to.be.a(ol.expression.Logical);
expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate()).to.be(false);
expect(parse('false||true').evaluate()).to.be(true);
@@ -125,16 +125,16 @@ describe('ol.expression.Parser', function() {
describe('#parseGroupExpression_()', function() {
function parse(source) {
var lexer = new ol.expression.Lexer(source);
var parser = new ol.expression.Parser();
var lexer = new ol.expr.Lexer(source);
var parser = new ol.expr.Parser();
var expr = parser.parseGroupExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr;
}
it('parses grouped expressions', function() {
var expr = parse('(3 * (foo + 2))');
expect(expr).to.be.a(ol.expression.Math);
expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 3})).to.be(15);
});
@@ -143,16 +143,16 @@ describe('ol.expression.Parser', function() {
describe('#parseLeftHandSideExpression_()', function() {
function parse(source) {
var lexer = new ol.expression.Lexer(source);
var parser = new ol.expression.Parser();
var lexer = new ol.expr.Lexer(source);
var parser = new ol.expr.Parser();
var expr = parser.parseLeftHandSideExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr;
}
it('parses member expressions', function() {
var expr = parse('foo.bar.bam');
expect(expr).to.be.a(ol.expression.Member);
expect(expr).to.be.a(ol.expr.Member);
});
it('throws on invalid member expression', function() {
@@ -163,7 +163,7 @@ describe('ol.expression.Parser', function() {
it('parses call expressions', function() {
var expr = parse('foo(bar)');
expect(expr).to.be.a(ol.expression.Call);
expect(expr).to.be.a(ol.expr.Call);
var fns = {
foo: function(arg) {
expect(arguments).length(1);
@@ -189,34 +189,34 @@ describe('ol.expression.Parser', function() {
describe('#parsePrimaryExpression_()', function() {
function parse(source) {
var lexer = new ol.expression.Lexer(source);
var parser = new ol.expression.Parser();
var lexer = new ol.expr.Lexer(source);
var parser = new ol.expr.Parser();
var expr = parser.parsePrimaryExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr;
}
it('parses string literal', function() {
var expr = parse('"foo"');
expect(expr).to.be.a(ol.expression.Literal);
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be('foo');
});
it('parses numeric literal', function() {
var expr = parse('.42e2');
expect(expr).to.be.a(ol.expression.Literal);
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(42);
});
it('parses boolean literal', function() {
var expr = parse('.42e2');
expect(expr).to.be.a(ol.expression.Literal);
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(42);
});
it('parses null literal', function() {
var expr = parse('null');
expect(expr).to.be.a(ol.expression.Literal);
expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(null);
});
@@ -225,34 +225,34 @@ describe('ol.expression.Parser', function() {
describe('#parseUnaryExpression_()', function() {
function parse(source) {
var lexer = new ol.expression.Lexer(source);
var parser = new ol.expression.Parser();
var lexer = new ol.expr.Lexer(source);
var parser = new ol.expr.Parser();
var expr = parser.parseUnaryExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr;
}
it('parses logical not', function() {
var expr = parse('!foo');
expect(expr).to.be.a(ol.expression.Not);
expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate({foo: true})).to.be(false);
});
it('works with string literal', function() {
var expr = parse('!"foo"');
expect(expr).to.be.a(ol.expression.Not);
expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate()).to.be(false);
});
it('works with empty string', function() {
var expr = parse('!""');
expect(expr).to.be.a(ol.expression.Not);
expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate()).to.be(true);
});
it('works with null', function() {
var expr = parse('!null');
expect(expr).to.be.a(ol.expression.Not);
expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate()).to.be(true);
});
@@ -262,14 +262,14 @@ describe('ol.expression.Parser', function() {
});
goog.require('ol.expression.Expression');
goog.require('ol.expression.Call');
goog.require('ol.expression.Comparison');
goog.require('ol.expression.Lexer');
goog.require('ol.expression.Literal');
goog.require('ol.expression.Logical');
goog.require('ol.expression.Math');
goog.require('ol.expression.Member');
goog.require('ol.expression.Not');
goog.require('ol.expression.Parser');
goog.require('ol.expression.TokenType');
goog.require('ol.expr.Expression');
goog.require('ol.expr.Call');
goog.require('ol.expr.Comparison');
goog.require('ol.expr.Lexer');
goog.require('ol.expr.Literal');
goog.require('ol.expr.Logical');
goog.require('ol.expr.Math');
goog.require('ol.expr.Member');
goog.require('ol.expr.Not');
goog.require('ol.expr.Parser');
goog.require('ol.expr.TokenType');

638
test/spec/ol/expression/expressions.test.js
View File

@@ -1,638 +0,0 @@
goog.provide('ol.test.expression.Expression');
describe('ol.expression.Call', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('sqrt'),
[new ol.expression.Literal(42)]);
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Call);
});
});
describe('#evaluate()', function() {
var fns = {
sqrt: function(value) {
return Math.sqrt(value);
},
strConcat: function() {
return Array.prototype.join.call(arguments, '');
},
discouraged: function() {
return this.message;
}
};
it('calls method on scope with literal args', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('sqrt'),
[new ol.expression.Literal(42)]);
expect(expr.evaluate(fns)).to.be(Math.sqrt(42));
});
it('accepts a separate scope for functions', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('sqrt'),
[new ol.expression.Identifier('foo')]);
expect(expr.evaluate({foo: 42}, fns)).to.be(Math.sqrt(42));
});
it('accepts multiple expression arguments', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('strConcat'),
[
new ol.expression.Identifier('foo'),
new ol.expression.Literal(' comes after '),
new ol.expression.Math(
ol.expression.MathOp.SUBTRACT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(1))
]);
expect(expr.evaluate({foo: 42}, fns)).to.be('42 comes after 41');
});
it('accepts optional this arg', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('discouraged'), []);
var thisArg = {
message: 'avoid this'
};
expect(expr.evaluate(fns, null, thisArg)).to.be('avoid this');
});
});
var callee = new ol.expression.Identifier('sqrt');
var args = [new ol.expression.Literal(42)];
var expr = new ol.expression.Call(callee, args);
describe('#getArgs()', function() {
it('gets the callee expression', function() {
expect(expr.getArgs()).to.be(args);
});
});
describe('#getCallee()', function() {
it('gets the callee expression', function() {
expect(expr.getCallee()).to.be(callee);
});
});
});
describe('ol.expression.Comparison', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.EQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Comparison);
});
});
describe('#evaluate()', function() {
it('compares with ==', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.EQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !=', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.NEQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with ===', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.STRICT_EQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !==', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.STRICT_NEQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with >', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.GT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.LT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
it('compares with >=', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.GTE,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <=', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.LTE,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expression.Comparison.isValidOp('<')).to.be(true);
expect(ol.expression.Comparison.isValidOp('<')).to.be(true);
expect(ol.expression.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expression.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expression.Comparison.isValidOp('==')).to.be(true);
expect(ol.expression.Comparison.isValidOp('!=')).to.be(true);
expect(ol.expression.Comparison.isValidOp('===')).to.be(true);
expect(ol.expression.Comparison.isValidOp('!==')).to.be(true);
expect(ol.expression.Comparison.isValidOp('')).to.be(false);
expect(ol.expression.Comparison.isValidOp('+')).to.be(false);
expect(ol.expression.Comparison.isValidOp('-')).to.be(false);
expect(ol.expression.Comparison.isValidOp('&&')).to.be(false);
});
});
var op = ol.expression.ComparisonOp.LTE;
var left = new ol.expression.Identifier('foo');
var right = new ol.expression.Literal(42);
var expr = new ol.expression.Comparison(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expression.Identifier', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Identifier('foo');
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Identifier);
});
});
describe('#evaluate()', function() {
it('returns a number from the scope', function() {
var expr = new ol.expression.Identifier('foo');
expect(expr.evaluate({foo: 42})).to.be(42);
});
it('returns a string from the scope', function() {
var expr = new ol.expression.Identifier('foo');
expect(expr.evaluate({foo: 'chicken'})).to.be('chicken');
});
it('returns a boolean from the scope', function() {
var expr = new ol.expression.Identifier('bar');
expect(expr.evaluate({bar: false})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('returns a null from the scope', function() {
var expr = new ol.expression.Identifier('nada');
expect(expr.evaluate({nada: null})).to.be(null);
});
it('works for unicode identifiers', function() {
var expr = new ol.expression.Identifier('\u03c0');
expect(expr.evaluate({'\u03c0': Math.PI})).to.be(Math.PI);
});
});
describe('#getName()', function() {
var expr = new ol.expression.Identifier('asdf');
expect(expr.getName()).to.be('asdf');
});
});
describe('ol.expression.Literal', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Literal(true);
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Literal);
});
});
describe('#evaluate()', function() {
it('works for numeric literal', function() {
var expr = new ol.expression.Literal(42e-11);
expect(expr.evaluate()).to.be(4.2e-10);
});
it('works for string literal', function() {
var expr = new ol.expression.Literal('asdf');
expect(expr.evaluate()).to.be('asdf');
});
it('works for boolean literal', function() {
var expr = new ol.expression.Literal(true);
expect(expr.evaluate()).to.be(true);
});
it('works for null literal', function() {
var expr = new ol.expression.Literal(null);
expect(expr.evaluate()).to.be(null);
});
});
describe('#getValue()', function() {
var expr = new ol.expression.Literal('asdf');
expect(expr.getValue()).to.be('asdf');
});
});
describe('ol.expression.Logical', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Logical(
ol.expression.LogicalOp.OR,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Logical);
});
});
describe('#evaluate()', function() {
it('applies || to resolved identifiers', function() {
var expr = new ol.expression.Logical(
ol.expression.LogicalOp.OR,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
it('applies && to resolved identifiers', function() {
var expr = new ol.expression.Logical(
ol.expression.LogicalOp.AND,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expression.Logical.isValidOp('||')).to.be(true);
expect(ol.expression.Logical.isValidOp('&&')).to.be(true);
expect(ol.expression.Logical.isValidOp('')).to.be(false);
expect(ol.expression.Logical.isValidOp('+')).to.be(false);
expect(ol.expression.Logical.isValidOp('<')).to.be(false);
expect(ol.expression.Logical.isValidOp('|')).to.be(false);
});
});
var op = ol.expression.LogicalOp.AND;
var left = new ol.expression.Identifier('foo');
var right = new ol.expression.Literal(false);
var expr = new ol.expression.Logical(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expression.Math', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Literal(40),
new ol.expression.Literal(2));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Math);
});
});
describe('#evaluate()', function() {
it('does + with numeric literal', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Literal(40),
new ol.expression.Literal(2));
expect(expr.evaluate()).to.be(42);
});
it('does + with string literal (note: subject to change)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Literal('foo'),
new ol.expression.Literal('bar'));
expect(expr.evaluate()).to.be('foobar');
});
it('does + with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr.evaluate({foo: 40, bar: 2})).to.be(42);
});
it('does - with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.SUBTRACT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(2));
expect(expr.evaluate({foo: 40})).to.be(38);
});
it('casts to number with - (note: this may throw later)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.SUBTRACT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(2));
expect(expr.evaluate({foo: '40'})).to.be(38);
});
it('does * with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MULTIPLY,
new ol.expression.Literal(2),
new ol.expression.Identifier('foo'));
expect(expr.evaluate({foo: 21})).to.be(42);
});
it('casts to number with * (note: this may throw later)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MULTIPLY,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(2));
expect(expr.evaluate({foo: '21'})).to.be(42);
});
it('does % with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MOD,
new ol.expression.Literal(97),
new ol.expression.Identifier('foo'));
expect(expr.evaluate({foo: 55})).to.be(42);
});
it('casts to number with % (note: this may throw later)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MOD,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(100));
expect(expr.evaluate({foo: '150'})).to.be(50);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expression.Math.isValidOp('+')).to.be(true);
expect(ol.expression.Math.isValidOp('-')).to.be(true);
expect(ol.expression.Math.isValidOp('*')).to.be(true);
expect(ol.expression.Math.isValidOp('/')).to.be(true);
expect(ol.expression.Math.isValidOp('%')).to.be(true);
expect(ol.expression.Math.isValidOp('')).to.be(false);
expect(ol.expression.Math.isValidOp('|')).to.be(false);
expect(ol.expression.Math.isValidOp('&')).to.be(false);
expect(ol.expression.Math.isValidOp('<')).to.be(false);
expect(ol.expression.Math.isValidOp('||')).to.be(false);
expect(ol.expression.Math.isValidOp('.')).to.be(false);
});
});
var op = ol.expression.MathOp.MOD;
var left = new ol.expression.Identifier('foo');
var right = new ol.expression.Literal(20);
var expr = new ol.expression.Math(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expression.Member', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Member(
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Member);
});
});
describe('#evaluate()', function() {
it('accesses an object property', function() {
var expr = new ol.expression.Member(
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
var scope = {foo: {bar: 42}};
expect(expr.evaluate(scope)).to.be(42);
});
});
var object = new ol.expression.Identifier('foo');
var property = new ol.expression.Identifier('bar');
var expr = new ol.expression.Member(object, property);
describe('#getObject()', function() {
expect(expr.getObject()).to.be(object);
});
describe('#getProperty()', function() {
expect(expr.getProperty()).to.be(property);
});
});
describe('ol.expression.Not', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Not(
new ol.expression.Literal(true));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Not);
});
});
describe('#evaluate()', function() {
it('returns the logical complement', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(true));
expect(expr.evaluate()).to.be(false);
expr = new ol.expression.Not(new ol.expression.Literal(false));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy string', function() {
var expr = new ol.expression.Not(new ol.expression.Literal('asdf'));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy string', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(''));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy number', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(42));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy number', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(NaN));
expect(expr.evaluate()).to.be(true);
});
});
describe('#getArgument()', function() {
var argument = new ol.expression.Literal(true);
var expr = new ol.expression.Not(argument);
expect(expr.getArgument()).to.be(argument);
});
});
goog.require('ol.expression.Call');
goog.require('ol.expression.Comparison');
goog.require('ol.expression.ComparisonOp');
goog.require('ol.expression.Expression');
goog.require('ol.expression.Identifier');
goog.require('ol.expression.Literal');
goog.require('ol.expression.Logical');
goog.require('ol.expression.LogicalOp');
goog.require('ol.expression.Math');
goog.require('ol.expression.MathOp');
goog.require('ol.expression.Member');
goog.require('ol.expression.Not');

26
test/spec/ol/layer/vectorlayer.test.js
View File

@@ -50,8 +50,8 @@ describe('ol.layer.Vector', function() {
layer.addFeatures(features);
});
var geomFilter = ol.expression.parse('geometryType("linestring")');
var extentFilter = ol.expression.parse('extent(16, 16.3, 48, 48.3)');
var geomFilter = ol.expr.parse('geometryType("linestring")');
var extentFilter = ol.expr.parse('extent(16, 16.3, 48, 48.3)');
it('can filter by geometry type using its GeometryType index', function() {
sinon.spy(geomFilter, 'evaluate');
@@ -70,10 +70,10 @@ describe('ol.layer.Vector', function() {
});
it('can filter by extent and geometry type using its index', function() {
var filter1 = new ol.expression.Logical(
ol.expression.LogicalOp.AND, geomFilter, extentFilter);
var filter2 = new ol.expression.Logical(
ol.expression.LogicalOp.AND, extentFilter, geomFilter);
var filter1 = new ol.expr.Logical(
ol.expr.LogicalOp.AND, geomFilter, extentFilter);
var filter2 = new ol.expr.Logical(
ol.expr.LogicalOp.AND, extentFilter, geomFilter);
sinon.spy(filter1, 'evaluate');
sinon.spy(filter2, 'evaluate');
var subset1 = layer.getFeatures(filter1);
@@ -85,8 +85,8 @@ describe('ol.layer.Vector', function() {
});
it('can handle query using the filter\'s evaluate function', function() {
var filter = new ol.expression.Logical(
ol.expression.LogicalOp.OR, geomFilter, extentFilter);
var filter = new ol.expr.Logical(
ol.expr.LogicalOp.OR, geomFilter, extentFilter);
sinon.spy(filter, 'evaluate');
var subset = layer.getFeatures(filter);
expect(filter.evaluate).to.be.called();
@@ -107,7 +107,7 @@ describe('ol.layer.Vector', function() {
symbolizers: [
new ol.style.Line({
strokeWidth: 2,
strokeColor: ol.expression.parse('colorProperty'),
strokeColor: ol.expr.parse('colorProperty'),
opacity: 1
})
]
@@ -144,7 +144,7 @@ describe('ol.layer.Vector', function() {
it('groups equal symbolizers also when defined on features', function() {
var symbolizer = new ol.style.Line({
strokeWidth: 3,
strokeColor: ol.expression.parse('colorProperty'),
strokeColor: ol.expr.parse('colorProperty'),
opacity: 1
});
var anotherSymbolizer = new ol.style.Line({
@@ -178,9 +178,9 @@ describe('ol.layer.Vector', function() {
goog.require('goog.dispose');
goog.require('ol.Feature');
goog.require('ol.expression');
goog.require('ol.expression.Logical');
goog.require('ol.expression.LogicalOp');
goog.require('ol.expr');
goog.require('ol.expr.Logical');
goog.require('ol.expr.LogicalOp');
goog.require('ol.geom.LineString');
goog.require('ol.geom.Point');
goog.require('ol.proj');

10
test/spec/ol/style/line.test.js
View File

@@ -42,8 +42,8 @@ describe('ol.style.Line', function() {
it('accepts expressions', function() {
var symbolizer = new ol.style.Line({
opacity: ol.expression.parse('value / 100'),
strokeWidth: ol.expression.parse('widthAttr')
opacity: ol.expr.parse('value / 100'),
strokeWidth: ol.expr.parse('widthAttr')
});
expect(symbolizer).to.be.a(ol.style.Line);
});
@@ -54,8 +54,8 @@ describe('ol.style.Line', function() {
it('evaluates expressions with the given feature', function() {
var symbolizer = new ol.style.Line({
opacity: ol.expression.parse('value / 100'),
strokeWidth: ol.expression.parse('widthAttr')
opacity: ol.expr.parse('value / 100'),
strokeWidth: ol.expr.parse('widthAttr')
});
var feature = new ol.Feature({
@@ -74,6 +74,6 @@ describe('ol.style.Line', function() {
});
goog.require('ol.Feature');
goog.require('ol.expression');
goog.require('ol.expr');
goog.require('ol.style.Line');
goog.require('ol.style.LineLiteral');

10
test/spec/ol/style/polygon.test.js
View File

@@ -45,8 +45,8 @@ describe('ol.style.Polygon', function() {
it('accepts expressions', function() {
var symbolizer = new ol.style.Polygon({
opacity: ol.expression.parse('value / 100'),
fillColor: ol.expression.parse('fillAttr')
opacity: ol.expr.parse('value / 100'),
fillColor: ol.expr.parse('fillAttr')
});
expect(symbolizer).to.be.a(ol.style.Polygon);
});
@@ -57,8 +57,8 @@ describe('ol.style.Polygon', function() {
it('evaluates expressions with the given feature', function() {
var symbolizer = new ol.style.Polygon({
opacity: ol.expression.parse('value / 100'),
fillColor: ol.expression.parse('fillAttr')
opacity: ol.expr.parse('value / 100'),
fillColor: ol.expr.parse('fillAttr')
});
var feature = new ol.Feature({
@@ -90,6 +90,6 @@ describe('ol.style.Polygon', function() {
});
goog.require('ol.Feature');
goog.require('ol.expression');
goog.require('ol.expr');
goog.require('ol.style.Polygon');
goog.require('ol.style.PolygonLiteral');

6
test/spec/ol/style/rule.test.js
View File

@@ -13,14 +13,14 @@ describe('ol.style.Rule', function() {
it('returns false when the rule does not apply', function() {
rule = new ol.style.Rule({
filter: new ol.expression.Literal(false)
filter: new ol.expr.Literal(false)
});
expect(rule.applies(feature)).to.be(false);
});
it('returns true when the rule applies', function() {
rule = new ol.style.Rule({
filter: new ol.expression.Literal(true)
filter: new ol.expr.Literal(true)
});
expect(rule.applies(feature)).to.be(true);
});
@@ -29,5 +29,5 @@ describe('ol.style.Rule', function() {
});
goog.require('ol.Feature');
goog.require('ol.expression.Literal');
goog.require('ol.expr.Literal');
goog.require('ol.style.Rule');

14
test/spec/ol/style/shape.test.js
View File

@@ -51,8 +51,8 @@ describe('ol.style.Shape', function() {
it('accepts expressions', function() {
var symbolizer = new ol.style.Shape({
size: ol.expression.parse('sizeAttr'),
strokeColor: ol.expression.parse('color')
size: ol.expr.parse('sizeAttr'),
strokeColor: ol.expr.parse('color')
});
expect(symbolizer).to.be.a(ol.style.Shape);
});
@@ -63,8 +63,8 @@ describe('ol.style.Shape', function() {
it('evaluates expressions with the given feature', function() {
var symbolizer = new ol.style.Shape({
size: ol.expression.parse('sizeAttr'),
opacity: ol.expression.parse('opacityAttr'),
size: ol.expr.parse('sizeAttr'),
opacity: ol.expr.parse('opacityAttr'),
fillColor: '#BADA55'
});
@@ -99,8 +99,8 @@ describe('ol.style.Shape', function() {
it('applies default type if none provided', function() {
var symbolizer = new ol.style.Shape({
size: ol.expression.parse('sizeAttr'),
opacity: ol.expression.parse('opacityAttr'),
size: ol.expr.parse('sizeAttr'),
opacity: ol.expr.parse('opacityAttr'),
fillColor: '#BADA55'
});
@@ -120,7 +120,7 @@ describe('ol.style.Shape', function() {
});
goog.require('ol.Feature');
goog.require('ol.expression');
goog.require('ol.expr');
goog.require('ol.style.Shape');
goog.require('ol.style.ShapeLiteral');
goog.require('ol.style.ShapeType');