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

Merge branch 'master' of github.com:openlayers/ol3 into vector

Browse Source
This commit is contained in:
ahocevar
2013-02-06 16:27:45 +01:00
parent 61e4452c83 3692918ed7
commit a13e6bdfda
6 changed files with 425 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ol/renderer/webgl/webglmaprenderer.js
View File

@@ -19,7 +19,7 @@ goog.require('ol.renderer.Map');
goog.require('ol.renderer.webgl.FragmentShader');
goog.require('ol.renderer.webgl.TileLayer');
goog.require('ol.renderer.webgl.VertexShader');
goog.require('ol.structs.LinkedMap');
goog.require('ol.structs.LRUCache');
goog.require('ol.webgl');
goog.require('ol.webgl.WebGLContextEventType');
@@ -183,9 +183,9 @@ ol.renderer.webgl.Map = function(container, map) {
/**
* @private
* @type {ol.structs.LinkedMap}
* @type {ol.structs.LRUCache}
*/
this.textureCache_ = new ol.structs.LinkedMap(undefined, true);
this.textureCache_ = new ol.structs.LRUCache();
/**
* @private

486
src/ol/structs/linkedmap.js
View File

@@ -1,486 +0,0 @@
// Copyright 2007 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// FIXME replace this with goog.structs.LinkedMap when goog.structs.LinkedMap
// adds peekLastKey()
/**
* @fileoverview A LinkedMap data structure that is accessed using key/value
* pairs like an ordinary Map, but which guarantees a consistent iteration
* order over its entries. The iteration order is either insertion order (the
* default) or ordered from most recent to least recent use. By setting a fixed
* size, the LRU version of the LinkedMap makes an effective object cache. This
* data structure is similar to Java's LinkedHashMap.
*
* @author brenneman@google.com (Shawn Brenneman)
*/
goog.provide('ol.structs.LinkedMap');
goog.require('goog.structs.Map');
/**
* Class for a LinkedMap datastructure, which combines O(1) map access for
* key/value pairs with a linked list for a consistent iteration order. Sample
* usage:
*
* <pre>
* var m = new LinkedMap();
* m.set('param1', 'A');
* m.set('param2', 'B');
* m.set('param3', 'C');
* alert(m.getKeys()); // param1, param2, param3
*
* var c = new LinkedMap(5, true);
* for (var i = 0; i < 10; i++) {
* c.set('entry' + i, false);
* }
* alert(c.getKeys()); // entry9, entry8, entry7, entry6, entry5
*
* c.set('entry5', true);
* c.set('entry1', false);
* alert(c.getKeys()); // entry1, entry5, entry9, entry8, entry7
* </pre>
*
* @param {number=} opt_maxCount The maximum number of objects to store in the
* LinkedMap. If unspecified or 0, there is no maximum.
* @param {boolean=} opt_cache When set, the LinkedMap stores items in order
* from most recently used to least recently used, instead of insertion
* order.
* @constructor
*/
ol.structs.LinkedMap = function(opt_maxCount, opt_cache) {
/**
* The maximum number of entries to allow, or null if there is no limit.
* @type {?number}
* @private
*/
this.maxCount_ = opt_maxCount || null;
/**
* @type {boolean}
* @private
*/
this.cache_ = !!opt_cache;
this.map_ = new goog.structs.Map();
this.head_ = new ol.structs.LinkedMap.Node_('', undefined);
this.head_.next = this.head_.prev = this.head_;
};
/**
* Finds a node and updates it to be the most recently used.
* @param {string} key The key of the node.
* @return {ol.structs.LinkedMap.Node_} The node or null if not found.
* @private
*/
ol.structs.LinkedMap.prototype.findAndMoveToTop_ = function(key) {
var node = /** @type {ol.structs.LinkedMap.Node_} */ (this.map_.get(key));
if (node) {
if (this.cache_) {
node.remove();
this.insert_(node);
}
}
return node;
};
/**
* Retrieves the value for a given key. If this is a caching LinkedMap, the
* entry will become the most recently used.
* @param {string} key The key to retrieve the value for.
* @param {*=} opt_val A default value that will be returned if the key is
* not found, defaults to undefined.
* @return {*} The retrieved value.
*/
ol.structs.LinkedMap.prototype.get = function(key, opt_val) {
var node = this.findAndMoveToTop_(key);
return node ? node.value : opt_val;
};
/**
* Retrieves the value for a given key without updating the entry to be the
* most recently used.
* @param {string} key The key to retrieve the value for.
* @param {*=} opt_val A default value that will be returned if the key is
* not found.
* @return {*} The retrieved value.
*/
ol.structs.LinkedMap.prototype.peekValue = function(key, opt_val) {
var node = this.map_.get(key);
return node ? node.value : opt_val;
};
/**
* Sets a value for a given key. If this is a caching LinkedMap, this entry
* will become the most recently used.
* @param {string} key The key to retrieve the value for.
* @param {*} value A default value that will be returned if the key is
* not found.
*/
ol.structs.LinkedMap.prototype.set = function(key, value) {
var node = this.findAndMoveToTop_(key);
if (node) {
node.value = value;
} else {
node = new ol.structs.LinkedMap.Node_(key, value);
this.map_.set(key, node);
this.insert_(node);
}
};
/**
* Returns the value of the first node without making any modifications.
* @return {*} The value of the first node or undefined if the map is empty.
*/
ol.structs.LinkedMap.prototype.peek = function() {
return this.head_.next.value;
};
/**
* Returns the value of the last node without making any modifications.
* @return {*} The value of the last node or undefined if the map is empty.
*/
ol.structs.LinkedMap.prototype.peekLast = function() {
return this.head_.prev.value;
};
/**
* Returns the key of the last node without making any modifications.
* @return {string|undefined} The key of the last node or undefined if the map
* is empty.
*/
ol.structs.LinkedMap.prototype.peekLastKey = function() {
return this.head_.prev.key;
};
/**
* Removes the first node from the list and returns its value.
* @return {*} The value of the popped node, or undefined if the map was empty.
*/
ol.structs.LinkedMap.prototype.shift = function() {
return this.popNode_(this.head_.next);
};
/**
* Removes the last node from the list and returns its value.
* @return {*} The value of the popped node, or undefined if the map was empty.
*/
ol.structs.LinkedMap.prototype.pop = function() {
return this.popNode_(this.head_.prev);
};
/**
* Removes a value from the LinkedMap based on its key.
* @param {string} key The key to remove.
* @return {boolean} True if the entry was removed, false if the key was not
* found.
*/
ol.structs.LinkedMap.prototype.remove = function(key) {
var node = /** @type {ol.structs.LinkedMap.Node_} */ (this.map_.get(key));
if (node) {
this.removeNode(node);
return true;
}
return false;
};
/**
* Removes a node from the {@code LinkedMap}. It can be overridden to do
* further cleanup such as disposing of the node value.
* @param {!ol.structs.LinkedMap.Node_} node The node to remove.
* @protected
*/
ol.structs.LinkedMap.prototype.removeNode = function(node) {
node.remove();
this.map_.remove(node.key);
};
/**
* @return {number} The number of items currently in the LinkedMap.
*/
ol.structs.LinkedMap.prototype.getCount = function() {
return this.map_.getCount();
};
/**
* @return {boolean} True if the cache is empty, false if it contains any items.
*/
ol.structs.LinkedMap.prototype.isEmpty = function() {
return this.map_.isEmpty();
};
/**
* Sets the maximum number of entries allowed in this object, truncating any
* excess objects if necessary.
* @param {number} maxCount The new maximum number of entries to allow.
*/
ol.structs.LinkedMap.prototype.setMaxCount = function(maxCount) {
this.maxCount_ = maxCount || null;
if (this.maxCount_ != null) {
this.truncate_(this.maxCount_);
}
};
/**
* @return {!Array.<string>} The list of the keys in the appropriate order for
* this LinkedMap.
*/
ol.structs.LinkedMap.prototype.getKeys = function() {
return this.map(function(val, key) {
return key;
});
};
/**
* @return {!Array} The list of the values in the appropriate order for
* this LinkedMap.
*/
ol.structs.LinkedMap.prototype.getValues = function() {
return this.map(function(val, key) {
return val;
});
};
/**
* Tests whether a provided value is currently in the LinkedMap. This does not
* affect item ordering in cache-style LinkedMaps.
* @param {Object} value The value to check for.
* @return {boolean} Whether the value is in the LinkedMap.
*/
ol.structs.LinkedMap.prototype.contains = function(value) {
return this.some(function(el) {
return el == value;
});
};
/**
* Tests whether a provided key is currently in the LinkedMap. This does not
* affect item ordering in cache-style LinkedMaps.
* @param {string} key The key to check for.
* @return {boolean} Whether the key is in the LinkedMap.
*/
ol.structs.LinkedMap.prototype.containsKey = function(key) {
return this.map_.containsKey(key);
};
/**
* Removes all entries in this object.
*/
ol.structs.LinkedMap.prototype.clear = function() {
this.truncate_(0);
};
/**
* Calls a function on each item in the LinkedMap.
*
* @see goog.structs.forEach
* @param {Function} f The function to call for each item. The function takes
* three arguments: the value, the key, and the LinkedMap.
* @param {Object=} opt_obj The object context to use as "this" for the
* function.
*/
ol.structs.LinkedMap.prototype.forEach = function(f, opt_obj) {
for (var n = this.head_.next; n != this.head_; n = n.next) {
f.call(opt_obj, n.value, n.key, this);
}
};
/**
* Calls a function on each item in the LinkedMap and returns the results of
* those calls in an array.
*
* @see goog.structs.map
* @param {!Function} f The function to call for each item. The function takes
* three arguments: the value, the key, and the LinkedMap.
* @param {Object=} opt_obj The object context to use as "this" for the
* function.
* @return {!Array} The results of the function calls for each item in the
* LinkedMap.
*/
ol.structs.LinkedMap.prototype.map = function(f, opt_obj) {
var rv = [];
for (var n = this.head_.next; n != this.head_; n = n.next) {
rv.push(f.call(opt_obj, n.value, n.key, this));
}
return rv;
};
/**
* Calls a function on each item in the LinkedMap and returns true if any of
* those function calls returns a true-like value.
*
* @see goog.structs.some
* @param {Function} f The function to call for each item. The function takes
* three arguments: the value, the key, and the LinkedMap, and returns a
* boolean.
* @param {Object=} opt_obj The object context to use as "this" for the
* function.
* @return {boolean} Whether f evaluates to true for at least one item in the
* LinkedMap.
*/
ol.structs.LinkedMap.prototype.some = function(f, opt_obj) {
for (var n = this.head_.next; n != this.head_; n = n.next) {
if (f.call(opt_obj, n.value, n.key, this)) {
return true;
}
}
return false;
};
/**
* Calls a function on each item in the LinkedMap and returns true only if every
* function call returns a true-like value.
*
* @see goog.structs.some
* @param {Function} f The function to call for each item. The function takes
* three arguments: the value, the key, and the Cache, and returns a
* boolean.
* @param {Object=} opt_obj The object context to use as "this" for the
* function.
* @return {boolean} Whether f evaluates to true for every item in the Cache.
*/
ol.structs.LinkedMap.prototype.every = function(f, opt_obj) {
for (var n = this.head_.next; n != this.head_; n = n.next) {
if (!f.call(opt_obj, n.value, n.key, this)) {
return false;
}
}
return true;
};
/**
* Appends a node to the list. LinkedMap in cache mode adds new nodes to
* the head of the list, otherwise they are appended to the tail. If there is a
* maximum size, the list will be truncated if necessary.
*
* @param {ol.structs.LinkedMap.Node_} node The item to insert.
* @private
*/
ol.structs.LinkedMap.prototype.insert_ = function(node) {
if (this.cache_) {
node.next = this.head_.next;
node.prev = this.head_;
this.head_.next = node;
node.next.prev = node;
} else {
node.prev = this.head_.prev;
node.next = this.head_;
this.head_.prev = node;
node.prev.next = node;
}
if (this.maxCount_ != null) {
this.truncate_(this.maxCount_);
}
};
/**
* Removes elements from the LinkedMap if the given count has been exceeded.
* In cache mode removes nodes from the tail of the list. Otherwise removes
* nodes from the head.
* @param {number} count Number of elements to keep.
* @private
*/
ol.structs.LinkedMap.prototype.truncate_ = function(count) {
for (var i = this.map_.getCount(); i > count; i--) {
this.removeNode(this.cache_ ? this.head_.prev : this.head_.next);
}
};
/**
* Removes the node from the LinkedMap if it is not the head, and returns
* the node's value.
* @param {!ol.structs.LinkedMap.Node_} node The item to remove.
* @return {*} The value of the popped node.
* @private
*/
ol.structs.LinkedMap.prototype.popNode_ = function(node) {
if (this.head_ != node) {
this.removeNode(node);
}
return node.value;
};
/**
* Internal class for a doubly-linked list node containing a key/value pair.
* @param {string} key The key.
* @param {*} value The value.
* @constructor
* @private
*/
ol.structs.LinkedMap.Node_ = function(key, value) {
this.key = key;
this.value = value;
};
/**
* The next node in the list.
* @type {!ol.structs.LinkedMap.Node_}
*/
ol.structs.LinkedMap.Node_.prototype.next;
/**
* The previous node in the list.
* @type {!ol.structs.LinkedMap.Node_}
*/
ol.structs.LinkedMap.Node_.prototype.prev;
/**
* Causes this node to remove itself from the list.
*/
ol.structs.LinkedMap.Node_.prototype.remove = function() {
this.prev.next = this.next;
this.next.prev = this.prev;
delete this.prev;
delete this.next;
};

251
src/ol/structs/lrucache.js Normal file
View File

@@ -0,0 +1,251 @@
goog.provide('ol.structs.LRUCache');
goog.require('goog.asserts');
goog.require('goog.object');
/**
* @constructor
* Implements a Least-Recently-Used cache where the keys do not conflict with
* Object's properties (e.g. 'hasOwnProperty' is not allowed as a key). Expiring
* items from the cache is the responsibility of the user.
*/
ol.structs.LRUCache = function() {
/**
* @private
* @type {number}
*/
this.count_ = 0;
/**
* @private
* @type {Object.<string, ol.structs.LRUCacheEntry>}
*/
this.entries_ = {};
/**
* @private
* @type {?ol.structs.LRUCacheEntry}
*/
this.oldest_ = null;
/**
* @private
* @type {?ol.structs.LRUCacheEntry}
*/
this.newest_ = null;
};
/**
* FIXME empty description for jsdoc
*/
ol.structs.LRUCache.prototype.assertValid = function() {
if (this.count_ === 0) {
goog.asserts.assert(goog.object.isEmpty(this.entries_));
goog.asserts.assert(goog.isNull(this.oldest_));
goog.asserts.assert(goog.isNull(this.newest_));
} else {
goog.asserts.assert(goog.object.getCount(this.entries_) == this.count_);
goog.asserts.assert(!goog.isNull(this.oldest_));
goog.asserts.assert(goog.isNull(this.oldest_.older));
goog.asserts.assert(!goog.isNull(this.newest_));
goog.asserts.assert(goog.isNull(this.newest_.newer));
var i, entry;
var older = null;
i = 0;
for (entry = this.oldest_; !goog.isNull(entry); entry = entry.newer) {
goog.asserts.assert(entry.older === older);
older = entry;
++i;
}
goog.asserts.assert(i == this.count_);
var newer = null;
i = 0;
for (entry = this.newest_; !goog.isNull(entry); entry = entry.older) {
goog.asserts.assert(entry.newer === newer);
newer = entry;
++i;
}
goog.asserts.assert(i == this.count_);
}
};
/**
* FIXME empty description for jsdoc
*/
ol.structs.LRUCache.prototype.clear = function() {
this.count_ = 0;
this.entries_ = {};
this.oldest_ = null;
this.newest_ = null;
};
/**
* @param {string} key Key.
* @return {boolean} Contains key.
*/
ol.structs.LRUCache.prototype.containsKey = function(key) {
return key in this.entries_;
};
/**
* @param {Function} f Function.
* @param {Object=} opt_obj Object.
*/
ol.structs.LRUCache.prototype.forEach = function(f, opt_obj) {
var entry = this.oldest_;
while (!goog.isNull(entry)) {
f.call(opt_obj, entry.value_, entry.key_, this);
entry = entry.newer;
}
};
/**
* @param {string} key Key.
* @return {*} Value.
*/
ol.structs.LRUCache.prototype.get = function(key) {
var entry = this.entries_[key];
goog.asserts.assert(goog.isDef(entry));
if (entry === this.newest_) {
return entry.value_;
} else if (entry === this.oldest_) {
this.oldest_ = this.oldest_.newer;
this.oldest_.older = null;
} else {
entry.newer.older = entry.older;
entry.older.newer = entry.newer;
}
entry.newer = null;
entry.older = this.newest_;
this.newest_.newer = entry;
this.newest_ = entry;
return entry.value_;
};
/**
* @return {number} Count.
*/
ol.structs.LRUCache.prototype.getCount = function() {
return this.count_;
};
/**
* @return {Array.<string>} Keys.
*/
ol.structs.LRUCache.prototype.getKeys = function() {
var keys = new Array(this.count_);
var i = 0;
var entry;
for (entry = this.newest_; !goog.isNull(entry); entry = entry.older) {
keys[i++] = entry.key_;
}
goog.asserts.assert(i == this.count_);
return keys;
};
/**
* @return {string} Last key.
*/
ol.structs.LRUCache.prototype.getLastKey = function() {
goog.asserts.assert(!goog.isNull(this.newest_));
return this.newest_.key_;
};
/**
* @return {Array} Values.
*/
ol.structs.LRUCache.prototype.getValues = function() {
var values = new Array(this.count_);
var i = 0;
var entry;
for (entry = this.newest_; !goog.isNull(entry); entry = entry.older) {
values[i++] = entry.value_;
}
goog.asserts.assert(i == this.count_);
return values;
};
/**
* @return {*} Last value.
*/
ol.structs.LRUCache.prototype.peekLast = function() {
goog.asserts.assert(!goog.isNull(this.oldest_));
return this.oldest_.value_;
};
/**
* @return {string} Last key.
*/
ol.structs.LRUCache.prototype.peekLastKey = function() {
goog.asserts.assert(!goog.isNull(this.oldest_));
return this.oldest_.key_;
};
/**
* @return {*} value Value.
*/
ol.structs.LRUCache.prototype.pop = function() {
goog.asserts.assert(!goog.isNull(this.oldest_));
goog.asserts.assert(!goog.isNull(this.newest_));
var entry = this.oldest_;
goog.asserts.assert(entry.key_ in this.entries_);
delete this.entries_[entry.key_];
if (!goog.isNull(entry.newer)) {
entry.newer.older = null;
}
this.oldest_ = entry.newer;
if (goog.isNull(this.oldest_)) {
this.newest_ = null;
}
--this.count_;
return entry.value_;
};
/**
* @param {string} key Key.
* @param {*} value Value.
*/
ol.structs.LRUCache.prototype.set = function(key, value) {
goog.asserts.assert(!(key in {}));
goog.asserts.assert(!(key in this.entries_));
var entry = {
key_: key,
newer: null,
older: this.newest_,
value_: value
};
if (goog.isNull(this.newest_)) {
this.oldest_ = entry;
} else {
this.newest_.newer = entry;
}
this.newest_ = entry;
this.entries_[key] = entry;
++this.count_;
};
/**
* @typedef {{key_: string,
* newer: ol.structs.LRUCacheEntry,
* older: ol.structs.LRUCacheEntry,
* value_: *}}
*/
ol.structs.LRUCacheEntry;

8
src/ol/tilecache.js
View File

@@ -2,7 +2,7 @@ goog.provide('ol.TileCache');
goog.require('ol.Tile');
goog.require('ol.TileRange');
goog.require('ol.structs.LinkedMap');
goog.require('ol.structs.LRUCache');
/**
@@ -14,12 +14,12 @@ ol.DEFAULT_TILE_CACHE_HIGH_WATER_MARK = 512;
/**
* @constructor
* @extends {ol.structs.LinkedMap}
* @extends {ol.structs.LRUCache}
* @param {number=} opt_highWaterMark High water mark.
*/
ol.TileCache = function(opt_highWaterMark) {
goog.base(this, undefined, true);
goog.base(this);
/**
* @private
@@ -29,7 +29,7 @@ ol.TileCache = function(opt_highWaterMark) {
opt_highWaterMark : ol.DEFAULT_TILE_CACHE_HIGH_WATER_MARK;
};
goog.inherits(ol.TileCache, ol.structs.LinkedMap);
goog.inherits(ol.TileCache, ol.structs.LRUCache);
/**

162
test/spec/ol/lrucache.test.js Normal file
View File

@@ -0,0 +1,162 @@
goog.provide('ol.test.LRUCache');
describe('ol.structs.LRUCache', function() {
var lruCache;
function fillLRUCache(lruCache) {
lruCache.set('a', 0);
lruCache.set('b', 1);
lruCache.set('c', 2);
lruCache.set('d', 3);
}
beforeEach(function() {
lruCache = new ol.structs.LRUCache();
});
describe('empty cache', function() {
it('has size zero', function() {
expect(lruCache.getCount()).toEqual(0);
});
it('has no keys', function() {
expect(lruCache.getKeys()).toEqual([]);
});
it('has no values', function() {
expect(lruCache.getValues()).toEqual([]);
});
});
describe('populating', function() {
it('returns the correct size', function() {
fillLRUCache(lruCache);
expect(lruCache.getCount()).toEqual(4);
});
it('contains the correct keys in the correct order', function() {
fillLRUCache(lruCache);
expect(lruCache.getKeys()).toEqual(['d', 'c', 'b', 'a']);
});
it('contains the correct values in the correct order', function() {
fillLRUCache(lruCache);
expect(lruCache.getValues()).toEqual([3, 2, 1, 0]);
});
it('reports which keys are contained', function() {
fillLRUCache(lruCache);
expect(lruCache.containsKey('a')).toBeTruthy();
expect(lruCache.containsKey('b')).toBeTruthy();
expect(lruCache.containsKey('c')).toBeTruthy();
expect(lruCache.containsKey('d')).toBeTruthy();
expect(lruCache.containsKey('e')).toBeFalsy();
});
});
describe('getting the oldest key', function() {
it('moves the key to newest position', function() {
fillLRUCache(lruCache);
lruCache.get('a');
expect(lruCache.getCount()).toEqual(4);
expect(lruCache.getKeys()).toEqual(['a', 'd', 'c', 'b']);
expect(lruCache.getValues()).toEqual([0, 3, 2, 1]);
});
});
describe('getting a key in the middle', function() {
it('moves the key to newest position', function() {
fillLRUCache(lruCache);
lruCache.get('b');
expect(lruCache.getCount()).toEqual(4);
expect(lruCache.getKeys()).toEqual(['b', 'd', 'c', 'a']);
expect(lruCache.getValues()).toEqual([1, 3, 2, 0]);
});
});
describe('getting the newest key', function() {
it('maintains the key to newest position', function() {
fillLRUCache(lruCache);
lruCache.get('d');
expect(lruCache.getCount()).toEqual(4);
expect(lruCache.getKeys()).toEqual(['d', 'c', 'b', 'a']);
expect(lruCache.getValues()).toEqual([3, 2, 1, 0]);
});
});
describe('setting a new value', function() {
it('adds it as the newest value', function() {
fillLRUCache(lruCache);
lruCache.set('e', 4);
expect(lruCache.getKeys()).toEqual(['e', 'd', 'c', 'b', 'a']);
expect(lruCache.getValues()).toEqual([4, 3, 2, 1, 0]);
});
});
describe('setting an existing value', function() {
it('raises an exception', function() {
fillLRUCache(lruCache);
expect(function() {
lruCache.set('a', 0);
}).toThrow();
});
});
describe('setting a disallowed key', function() {
it('raises an exception', function() {
expect(function() {
lruCache.set('hasOwnProperty', 0);
}).toThrow();
});
});
describe('popping a value', function() {
it('returns the least-recent-used value', function() {
fillLRUCache(lruCache);
expect(lruCache.pop()).toEqual(0);
expect(lruCache.getCount()).toEqual(3);
expect(lruCache.containsKey('a')).toBeFalsy();
expect(lruCache.pop()).toEqual(1);
expect(lruCache.getCount()).toEqual(2);
expect(lruCache.containsKey('b')).toBeFalsy();
expect(lruCache.pop()).toEqual(2);
expect(lruCache.getCount()).toEqual(1);
expect(lruCache.containsKey('c')).toBeFalsy();
expect(lruCache.pop()).toEqual(3);
expect(lruCache.getCount()).toEqual(0);
expect(lruCache.containsKey('d')).toBeFalsy();
});
});
describe('peeking at the last value', function() {
it('returns the last key', function() {
fillLRUCache(lruCache);
expect(lruCache.peekLast()).toEqual(0);
});
it('throws an exception when the cache is empty', function() {
expect(function() {
lruCache.peekLast();
}).toThrow();
});
});
describe('peeking at the last key', function() {
it('returns the last key', function() {
fillLRUCache(lruCache);
expect(lruCache.peekLastKey()).toEqual('a');
});
it('throws an exception when the cache is empty', function() {
expect(function() {
lruCache.peekLastKey();
}).toThrow();
});
});
describe('clearing the cache', function() {
it('clears the cache', function() {
fillLRUCache(lruCache);
lruCache.clear();
expect(lruCache.getCount()).toEqual(0);
expect(lruCache.getKeys()).toEqual([]);
expect(lruCache.getValues()).toEqual([]);
});
});
});

8
test/spec/ol/map.test.js
View File

@@ -211,14 +211,16 @@ describe('ol.Map', function() {
// confirm that the center is somewhere between origin and destination
// after a short delay
waits(100);
waits(goog.async.AnimationDelay.TIMEOUT);
runs(function() {
expect(o.callback).toHaveBeenCalled();
var loc = map.getView().getCenter();
expect(loc.x).not.toEqual(origin.x);
expect(loc.y).not.toEqual(origin.y);
expect(loc.x).not.toEqual(destination.x);
expect(loc.y).not.toEqual(destination.y);
if (new Date().getTime() - start < duration) {
expect(loc.x).not.toEqual(destination.x);
expect(loc.y).not.toEqual(destination.y);
}
});
// confirm that the map has reached the destination after the duration