├── .gitignore
├── LICENSE-min.txt
├── LICENSE.txt
├── README.md
├── js-murmur3-128-1.0.0.js
├── js-murmur3-128-1.0.0.min.js
├── pom.xml
├── src
└── murmurhash3_128.js
└── test
├── data
├── README.md
└── murmur_bigint.csv
├── lib
├── d3.v3.js
├── goog.math.Long.js
├── qunit-1.11.0.css
└── qunit-1.11.0.js
├── murmurhash3_128-test.js
└── qunit-test.html
/.gitignore:
--------------------------------------------------------------------------------
1 | .project
2 | *.jar
3 | target
4 |
--------------------------------------------------------------------------------
/LICENSE-min.txt:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2013 Aggregate Knowledge, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
1 | Apache License
2 |
3 | Version 2.0, January 2004
4 |
5 | http://www.apache.org/licenses/
6 |
7 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
8 |
9 | 1. Definitions.
10 |
11 | "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
12 |
13 | "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
16 |
17 | "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
18 |
19 | "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
20 |
21 | "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
22 |
23 | "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
24 |
25 | "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
26 |
27 | "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
28 |
29 | "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
30 |
31 | 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
32 |
33 | 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
34 |
35 | 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
36 |
37 | You must give any other recipients of the Work or Derivative Works a copy of this License; and
38 |
39 | You must cause any modified files to carry prominent notices stating that You changed the files; and
40 |
41 | You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
42 |
43 | If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
44 |
45 | 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
46 |
47 | 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
48 |
49 | 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
50 |
51 | 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
52 |
53 | 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
54 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | js-murmur3-128
2 | ==============
3 |
4 | A JavaScript implementation of the 128bit variant of [Murmur3](http://en.wikipedia.org/wiki/MurmurHash).
5 | It was written with the following constraints in mind:
6 |
7 | 1. For the same input, it must produce a hash that is equivalent to:
8 | * [C++](https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp)
9 | * [Java (Guava)](http://guava-libraries.googlecode.com/git/guava/src/com/google/common/hash/Murmur3_128HashFunction.java)
10 | 2. It must be usable in the browser
11 |
12 |
13 | Latest Version
14 | ---------------
15 |
16 | * [v1.0.0](https://github.com/aggregateknowledge/js-murmur3-128/blob/master/js-murmur3-128-1.0.0.js)
17 | * [v1.0.0 (minified)](https://github.com/aggregateknowledge/js-murmur3-128/blob/master/js-murmur3-128-1.0.0.min.js)
18 |
19 |
20 | Notes
21 | -----
22 |
23 | Under the covers this implementation uses [Closure Library's](https://code.google.com/p/closure-library/)
24 | [goog.math.Long](https://code.google.com/p/closure-library/source/browse/closure/goog/math/long.js).
25 | Either the entire Closure library can be included or a dependency free
26 | [copy](https://github.com/aggregateknowledge/js-murmur3-128/blob/master/test/lib/goog.math.Long.js)
27 | can be used.
28 |
29 | Performance tests have not yet been run. There are places in which there are a
30 | few different ways to use `goog.math.Long` which may affect performance. These
31 | have not yet been investigated (though some of them have been noted).
32 |
33 |
34 | Usage
35 | -----
36 |
37 | The equivalent Java ([Guava](https://code.google.com/p/guava-libraries/)) and
38 | JavaScript are provided as an example:
39 |
40 | Java ([Guava](http://guava-libraries.googlecode.com/git/guava/src/com/google/common/hash/Murmur3_128HashFunction.java)):
41 | ```java
42 | final int seed = 0;
43 | final byte[] bytes = { (byte)0xDE, (byte)0xAD, (byte)0xBE, (byte)0xEF,
44 | (byte)0xFE, (byte)0xED, (byte)0xFA, (byte)0xCE };
45 | com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
46 | com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
47 | .putBytes(bytes)
48 | .hash();
49 | System.err.println(hashCode.asLong());
50 | ```
51 |
52 | JavaScript:
53 | ```javascript
54 | var seed = 0;
55 | var rawKey = new ArrayBuffer(8);
56 | var byteView = new Int8Array(rawKey);
57 | byteView[0] = 0xDE; byteView[1] = 0xAD; byteView[2] = 0xBE; byteView[3] = 0xEF;
58 | byteView[4] = 0xFE; byteView[5] = 0xED; byteView[6] = 0xFA; byteView[7] = 0xCE;
59 | console.log(murmur3.hash128(rawKey, seed));
60 | ```
61 |
62 | Refer to the unit tests for more examples.
63 |
64 |
65 | Other JavaScript Implementations
66 | --------------------------------
67 |
68 | * [murmurhash-js](https://github.com/garycourt/murmurhash-js) only contains
69 | the 32bit variant.
70 | * [node-murmurhash](https://github.com/perezd/node-murmurhash) is based off
71 | of [murmurhash-js](https://github.com/garycourt/murmurhash-js) and as a
72 | result only contains the 32bit variant.
73 | * [murmur3](https://github.com/zmarcantel/murmur3) did not seem to match the
74 | Java (Guava) output. (The first 8 bytes would match but the remaining would
75 | not.)
76 | * [murmurhash3-js](https://github.com/whitequark/murmurhash3-js) only contains
77 | the 32bit variant.
78 | * [node-murmurhash3](https://github.com/hideo55/node-murmurhash3) provides both
79 | the 32bit and 128bit variants (through its binding to the C++ implementation)
80 | but cannot be used in the browser.
81 |
--------------------------------------------------------------------------------
/js-murmur3-128-1.0.0.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2013 Aggregate Knowledge, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | /**
18 | * @fileoverview A JavaScript implementation of the 128bit version of MurmurHash3
19 | * whose intent is to produce hashes that are binary equivalent to:
20 | *
21 | * {@link https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp}
22 | * {@link http://guava-libraries.googlecode.com/git/guava/src/com/google/common/hash/Murmur3_128HashFunction.java}
23 | *
24 | *
25 | * {@link https://code.google.com/p/closure-library/source/browse/closure/goog/math/long.js goog.math.Long}
26 | * from {@link https://code.google.com/p/closure-library/ Closure} is required.
27 | *
28 | * Example usage:
29 | *
30 | * var seed = 0;
31 | * var rawKey = new ArrayBuffer(1);
32 | * var byteView = new Int8Array(rawKey);
33 | * byteView[0] = 0xDE;
34 | * var hashed = murmur3.hash128(rawKey, seed);
35 | * console.log(hashed);
36 | *
37 | *
38 | * {@link http://en.wikipedia.org/wiki/MurmurHash}
39 | */
40 | // NOTE: https://github.com/zmarcantel/murmur3/blob/master/murmur3.js deviated
41 | // from the Java Guava results so this version was written.
42 | if(murmur3 === undefined) {
43 | var murmur3 = {
44 | version: "1.0.0"
45 | };
46 | }
47 | (function() {
48 | 'use strict';
49 |
50 | // ***************************************************************************
51 | function rotl(number, bits) {
52 | return (number.shiftLeft(bits)).or(number.shiftRightUnsigned(-bits));
53 | }
54 |
55 | // =========================================================================
56 | var FMIX1 = new goog.math.Long(0xED558CCD, 0xFF51AFD7),
57 | FMIX2 = new goog.math.Long(0x1A85EC53, 0xC4CEB9FE);
58 | function fmix(number) {
59 | number = number.xor(number.shiftRightUnsigned(33));
60 | number = number.multiply(FMIX1);
61 | number = number.xor(number.shiftRightUnsigned(33));
62 | number = number.multiply(FMIX2);
63 | number = number.xor(number.shiftRightUnsigned(33));
64 | return number;
65 | }
66 |
67 | // .........................................................................
68 | var C1 = new goog.math.Long(0x114253D5, 0x87C37B91),
69 | C2 = new goog.math.Long(0x2745937F, 0x4CF5AD43);
70 | function mixk1(k1) {
71 | k1 = k1.multiply(C1);
72 | k1 = rotl(k1, 31);
73 | return k1.multiply(C2);
74 | }
75 | function mixk2(k2) {
76 | k2 = k2.multiply(C2);
77 | k2 = rotl(k2, 33);
78 | return k2.multiply(C1);
79 | }
80 |
81 | // *************************************************************************
82 | // NOTE: the chunk (or block) size is 16 bytes (for the 128bit Murmur3)
83 | var CHUNK_SIZE_INTS = 4/*ints = 16bytes*/;
84 | var ZERO = new goog.math.Long.fromInt(0)/*for convenience*/,
85 | FIVE = new goog.math.Long.fromInt(5)/*for convenience*/;
86 | var BMIX1 = new goog.math.Long.fromInt(0x52DCE729),
87 | BMIX2 = new goog.math.Long.fromInt(0x38495AB5);
88 |
89 | // =========================================================================
90 | /**
91 | * @param key an {@link ArrayBuffer} that is to be hashed. If not specified
92 | * then a zero length buffer is used.
93 | * @param seed a 32bit seed value. If not specified then 0 is used.
94 | * @return the first 8 bytes of the hash result as a {@link Long} (to match
95 | * that of {@link http://guava-libraries.googlecode.com/git/guava/src/com/google/common/hash/Murmur3_128HashFunction.java Guava's}
96 | * {@link #asLong()}).
97 | */
98 | murmur3.hash128 = function(key, seed) {
99 | key = key || new ArrayBuffer(0/*by contract*/)/*default*/;
100 | seed = seed || 0/*default*/;
101 |
102 | var byteBuffer = new Uint8Array(key);
103 | var chunkCount = byteBuffer.length >> 4/*div by CHUNK_SIZE_BYTES*/;
104 | var chunkCountInInts = chunkCount << 2/*4 ints per chunk*/;
105 |
106 | var lengthLong = new goog.math.Long.fromInt(byteBuffer.length);
107 |
108 | var seedLong = new goog.math.Long.fromInt(seed);
109 | var h1 = seedLong,
110 | h2 = seedLong;
111 |
112 | var k1, k2;
113 |
114 | var intBuffer = new Uint32Array(key, 0/*offset*/, chunkCountInInts/*length*/);
115 | for(var i=0; i>4;var y=t<<2;var p=new goog.math.Long.fromInt(o.length);var B=new goog.math.Long.fromInt(r);var x=B,w=B;var v,u;var n=new Uint32Array(z,0,y);for(var q=0;q
14 |
17 | 4.0.0
18 | net.agkn
19 | js-murmur3-128
20 | jar
21 | 1.0.0
22 |
23 | js-murmur3-128
24 |
25 |
26 |
27 | ${project.artifactId}-${project.version}
28 |
29 |
30 |
31 | net.alchim31.maven
32 | yuicompressor-maven-plugin
33 | 1.3.0
34 |
35 |
36 |
37 | compress
38 |
39 |
40 |
41 |
42 | false
43 | ${basedir}/src
44 | ${basedir}/min
45 | -1
46 |
47 |
48 |
49 | true
50 | ${basedir}/${project.build.finalName}.min.js
51 |
52 | **/LICENSE-min.txt
53 | **/min/*-min.js
54 |
55 |
56 |
57 |
58 | true
59 | ${basedir}/${project.build.finalName}.js
60 |
61 | **/src/*
62 |
63 |
64 |
65 |
66 |
67 |
68 | maven-antrun-plugin
69 | 1.6
70 |
71 |
72 | package
73 |
74 |
75 |
77 |
78 |
81 |
82 |
85 |
86 |
88 |
89 |
90 | run
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
--------------------------------------------------------------------------------
/src/murmurhash3_128.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2013 Aggregate Knowledge, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | /**
18 | * @fileoverview A JavaScript implementation of the 128bit version of MurmurHash3
19 | * whose intent is to produce hashes that are binary equivalent to:
20 | *
21 | * {@link https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp}
22 | * {@link http://guava-libraries.googlecode.com/git/guava/src/com/google/common/hash/Murmur3_128HashFunction.java}
23 | *
24 | *
25 | * {@link https://code.google.com/p/closure-library/source/browse/closure/goog/math/long.js goog.math.Long}
26 | * from {@link https://code.google.com/p/closure-library/ Closure} is required.
27 | *
28 | * Example usage:
29 | *
30 | * var seed = 0;
31 | * var rawKey = new ArrayBuffer(1);
32 | * var byteView = new Int8Array(rawKey);
33 | * byteView[0] = 0xDE;
34 | * var hashed = murmur3.hash128(rawKey, seed);
35 | * console.log(hashed);
36 | *
37 | *
38 | * {@link http://en.wikipedia.org/wiki/MurmurHash}
39 | */
40 | // NOTE: https://github.com/zmarcantel/murmur3/blob/master/murmur3.js deviated
41 | // from the Java Guava results so this version was written.
42 | if(murmur3 === undefined) {
43 | var murmur3 = {
44 | version: "1.0.0"
45 | };
46 | }
47 | (function() {
48 | 'use strict';
49 |
50 | // ***************************************************************************
51 | function rotl(number, bits) {
52 | return (number.shiftLeft(bits)).or(number.shiftRightUnsigned(-bits));
53 | }
54 |
55 | // =========================================================================
56 | var FMIX1 = new goog.math.Long(0xED558CCD, 0xFF51AFD7),
57 | FMIX2 = new goog.math.Long(0x1A85EC53, 0xC4CEB9FE);
58 | function fmix(number) {
59 | number = number.xor(number.shiftRightUnsigned(33));
60 | number = number.multiply(FMIX1);
61 | number = number.xor(number.shiftRightUnsigned(33));
62 | number = number.multiply(FMIX2);
63 | number = number.xor(number.shiftRightUnsigned(33));
64 | return number;
65 | }
66 |
67 | // .........................................................................
68 | var C1 = new goog.math.Long(0x114253D5, 0x87C37B91),
69 | C2 = new goog.math.Long(0x2745937F, 0x4CF5AD43);
70 | function mixk1(k1) {
71 | k1 = k1.multiply(C1);
72 | k1 = rotl(k1, 31);
73 | return k1.multiply(C2);
74 | }
75 | function mixk2(k2) {
76 | k2 = k2.multiply(C2);
77 | k2 = rotl(k2, 33);
78 | return k2.multiply(C1);
79 | }
80 |
81 | // *************************************************************************
82 | // NOTE: the chunk (or block) size is 16 bytes (for the 128bit Murmur3)
83 | var CHUNK_SIZE_INTS = 4/*ints = 16bytes*/;
84 | var ZERO = new goog.math.Long.fromInt(0)/*for convenience*/,
85 | FIVE = new goog.math.Long.fromInt(5)/*for convenience*/;
86 | var BMIX1 = new goog.math.Long.fromInt(0x52DCE729),
87 | BMIX2 = new goog.math.Long.fromInt(0x38495AB5);
88 |
89 | // =========================================================================
90 | /**
91 | * @param {ArrayBuffer} [key=0] the key (as an ArrayBuffer)
92 | * that is to be hashed.
93 | * @param {Number} [seed=0] a 32bit seed value.
94 | * @returns {goog.math.Long} the first 8 bytes of the hash result as a
95 | * goog.math.Long (to match that of
96 | * {@link http://guava-libraries.googlecode.com/git/guava/src/com/google/common/hash/Murmur3_128HashFunction.java Guava's}
97 | * asLong()).
98 | */
99 | murmur3.hash128 = function(key, seed) {
100 | key = key || new ArrayBuffer(0/*by contract*/)/*default*/;
101 | seed = seed || 0/*default*/;
102 |
103 | var byteBuffer = new Uint8Array(key);
104 | var chunkCount = byteBuffer.length >> 4/*div by CHUNK_SIZE_BYTES*/;
105 | var chunkCountInInts = chunkCount << 2/*4 ints per chunk*/;
106 |
107 | var lengthLong = new goog.math.Long.fromInt(byteBuffer.length);
108 |
109 | var seedLong = new goog.math.Long.fromInt(seed);
110 | var h1 = seedLong,
111 | h2 = seedLong;
112 |
113 | var k1, k2;
114 |
115 | var intBuffer = new Uint32Array(key, 0/*offset*/, chunkCountInInts/*length*/);
116 | for(var i=0; i= goog.math.Long.TWO_PWR_63_DBL_) {
116 | return goog.math.Long.MAX_VALUE;
117 | } else if (value < 0) {
118 | return goog.math.Long.fromNumber(-value).negate();
119 | } else {
120 | return new goog.math.Long(
121 | (value % goog.math.Long.TWO_PWR_32_DBL_) | 0,
122 | (value / goog.math.Long.TWO_PWR_32_DBL_) | 0);
123 | }
124 | };
125 |
126 |
127 | /**
128 | * Returns a Long representing the 64-bit integer that comes by concatenating
129 | * the given high and low bits. Each is assumed to use 32 bits.
130 | * @param {number} lowBits The low 32-bits.
131 | * @param {number} highBits The high 32-bits.
132 | * @return {!goog.math.Long} The corresponding Long value.
133 | */
134 | goog.math.Long.fromBits = function(lowBits, highBits) {
135 | return new goog.math.Long(lowBits, highBits);
136 | };
137 |
138 |
139 | /**
140 | * Returns a Long representation of the given string, written using the given
141 | * radix.
142 | * @param {string} str The textual representation of the Long.
143 | * @param {number=} opt_radix The radix in which the text is written.
144 | * @return {!goog.math.Long} The corresponding Long value.
145 | */
146 | goog.math.Long.fromString = function(str, opt_radix) {
147 | if (str.length == 0) {
148 | throw Error('number format error: empty string');
149 | }
150 |
151 | var radix = opt_radix || 10;
152 | if (radix < 2 || 36 < radix) {
153 | throw Error('radix out of range: ' + radix);
154 | }
155 |
156 | if (str.charAt(0) == '-') {
157 | return goog.math.Long.fromString(str.substring(1), radix).negate();
158 | } else if (str.indexOf('-') >= 0) {
159 | throw Error('number format error: interior "-" character: ' + str);
160 | }
161 |
162 | // Do several (8) digits each time through the loop, so as to
163 | // minimize the calls to the very expensive emulated div.
164 | var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8));
165 |
166 | var result = goog.math.Long.ZERO;
167 | for (var i = 0; i < str.length; i += 8) {
168 | var size = Math.min(8, str.length - i);
169 | var value = parseInt(str.substring(i, i + size), radix);
170 | if (size < 8) {
171 | var power = goog.math.Long.fromNumber(Math.pow(radix, size));
172 | result = result.multiply(power).add(goog.math.Long.fromNumber(value));
173 | } else {
174 | result = result.multiply(radixToPower);
175 | result = result.add(goog.math.Long.fromNumber(value));
176 | }
177 | }
178 | return result;
179 | };
180 |
181 |
182 | // NOTE: the compiler should inline these constant values below and then remove
183 | // these variables, so there should be no runtime penalty for these.
184 |
185 |
186 | /**
187 | * Number used repeated below in calculations. This must appear before the
188 | * first call to any from* function below.
189 | * @type {number}
190 | * @private
191 | */
192 | goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16;
193 |
194 |
195 | /**
196 | * @type {number}
197 | * @private
198 | */
199 | goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24;
200 |
201 |
202 | /**
203 | * @type {number}
204 | * @private
205 | */
206 | goog.math.Long.TWO_PWR_32_DBL_ =
207 | goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
208 |
209 |
210 | /**
211 | * @type {number}
212 | * @private
213 | */
214 | goog.math.Long.TWO_PWR_31_DBL_ =
215 | goog.math.Long.TWO_PWR_32_DBL_ / 2;
216 |
217 |
218 | /**
219 | * @type {number}
220 | * @private
221 | */
222 | goog.math.Long.TWO_PWR_48_DBL_ =
223 | goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
224 |
225 |
226 | /**
227 | * @type {number}
228 | * @private
229 | */
230 | goog.math.Long.TWO_PWR_64_DBL_ =
231 | goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_;
232 |
233 |
234 | /**
235 | * @type {number}
236 | * @private
237 | */
238 | goog.math.Long.TWO_PWR_63_DBL_ =
239 | goog.math.Long.TWO_PWR_64_DBL_ / 2;
240 |
241 |
242 | /** @type {!goog.math.Long} */
243 | goog.math.Long.ZERO = goog.math.Long.fromInt(0);
244 |
245 |
246 | /** @type {!goog.math.Long} */
247 | goog.math.Long.ONE = goog.math.Long.fromInt(1);
248 |
249 |
250 | /** @type {!goog.math.Long} */
251 | goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1);
252 |
253 |
254 | /** @type {!goog.math.Long} */
255 | goog.math.Long.MAX_VALUE =
256 | goog.math.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
257 |
258 |
259 | /** @type {!goog.math.Long} */
260 | goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 0x80000000 | 0);
261 |
262 |
263 | /**
264 | * @type {!goog.math.Long}
265 | * @private
266 | */
267 | goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24);
268 |
269 |
270 | /** @return {number} The value, assuming it is a 32-bit integer. */
271 | goog.math.Long.prototype.toInt = function() {
272 | return this.low_;
273 | };
274 |
275 |
276 | /** @return {number} The closest floating-point representation to this value. */
277 | goog.math.Long.prototype.toNumber = function() {
278 | return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ +
279 | this.getLowBitsUnsigned();
280 | };
281 |
282 |
283 | /**
284 | * @param {number=} opt_radix The radix in which the text should be written.
285 | * @return {string} The textual representation of this value.
286 | * @override
287 | */
288 | goog.math.Long.prototype.toString = function(opt_radix) {
289 | var radix = opt_radix || 10;
290 | if (radix < 2 || 36 < radix) {
291 | throw Error('radix out of range: ' + radix);
292 | }
293 |
294 | if (this.isZero()) {
295 | return '0';
296 | }
297 |
298 | if (this.isNegative()) {
299 | if (this.equals(goog.math.Long.MIN_VALUE)) {
300 | // We need to change the Long value before it can be negated, so we remove
301 | // the bottom-most digit in this base and then recurse to do the rest.
302 | var radixLong = goog.math.Long.fromNumber(radix);
303 | var div = this.div(radixLong);
304 | var rem = div.multiply(radixLong).subtract(this);
305 | return div.toString(radix) + rem.toInt().toString(radix);
306 | } else {
307 | return '-' + this.negate().toString(radix);
308 | }
309 | }
310 |
311 | // Do several (6) digits each time through the loop, so as to
312 | // minimize the calls to the very expensive emulated div.
313 | var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6));
314 |
315 | var rem = this;
316 | var result = '';
317 | while (true) {
318 | var remDiv = rem.div(radixToPower);
319 | var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
320 | var digits = intval.toString(radix);
321 |
322 | rem = remDiv;
323 | if (rem.isZero()) {
324 | return digits + result;
325 | } else {
326 | while (digits.length < 6) {
327 | digits = '0' + digits;
328 | }
329 | result = '' + digits + result;
330 | }
331 | }
332 | };
333 |
334 |
335 | /** @return {number} The high 32-bits as a signed value. */
336 | goog.math.Long.prototype.getHighBits = function() {
337 | return this.high_;
338 | };
339 |
340 |
341 | /** @return {number} The low 32-bits as a signed value. */
342 | goog.math.Long.prototype.getLowBits = function() {
343 | return this.low_;
344 | };
345 |
346 |
347 | /** @return {number} The low 32-bits as an unsigned value. */
348 | goog.math.Long.prototype.getLowBitsUnsigned = function() {
349 | return (this.low_ >= 0) ?
350 | this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_;
351 | };
352 |
353 |
354 | /**
355 | * @return {number} Returns the number of bits needed to represent the absolute
356 | * value of this Long.
357 | */
358 | goog.math.Long.prototype.getNumBitsAbs = function() {
359 | if (this.isNegative()) {
360 | if (this.equals(goog.math.Long.MIN_VALUE)) {
361 | return 64;
362 | } else {
363 | return this.negate().getNumBitsAbs();
364 | }
365 | } else {
366 | var val = this.high_ != 0 ? this.high_ : this.low_;
367 | for (var bit = 31; bit > 0; bit--) {
368 | if ((val & (1 << bit)) != 0) {
369 | break;
370 | }
371 | }
372 | return this.high_ != 0 ? bit + 33 : bit + 1;
373 | }
374 | };
375 |
376 |
377 | /** @return {boolean} Whether this value is zero. */
378 | goog.math.Long.prototype.isZero = function() {
379 | return this.high_ == 0 && this.low_ == 0;
380 | };
381 |
382 |
383 | /** @return {boolean} Whether this value is negative. */
384 | goog.math.Long.prototype.isNegative = function() {
385 | return this.high_ < 0;
386 | };
387 |
388 |
389 | /** @return {boolean} Whether this value is odd. */
390 | goog.math.Long.prototype.isOdd = function() {
391 | return (this.low_ & 1) == 1;
392 | };
393 |
394 |
395 | /**
396 | * @param {goog.math.Long} other Long to compare against.
397 | * @return {boolean} Whether this Long equals the other.
398 | */
399 | goog.math.Long.prototype.equals = function(other) {
400 | return (this.high_ == other.high_) && (this.low_ == other.low_);
401 | };
402 |
403 |
404 | /**
405 | * @param {goog.math.Long} other Long to compare against.
406 | * @return {boolean} Whether this Long does not equal the other.
407 | */
408 | goog.math.Long.prototype.notEquals = function(other) {
409 | return (this.high_ != other.high_) || (this.low_ != other.low_);
410 | };
411 |
412 |
413 | /**
414 | * @param {goog.math.Long} other Long to compare against.
415 | * @return {boolean} Whether this Long is less than the other.
416 | */
417 | goog.math.Long.prototype.lessThan = function(other) {
418 | return this.compare(other) < 0;
419 | };
420 |
421 |
422 | /**
423 | * @param {goog.math.Long} other Long to compare against.
424 | * @return {boolean} Whether this Long is less than or equal to the other.
425 | */
426 | goog.math.Long.prototype.lessThanOrEqual = function(other) {
427 | return this.compare(other) <= 0;
428 | };
429 |
430 |
431 | /**
432 | * @param {goog.math.Long} other Long to compare against.
433 | * @return {boolean} Whether this Long is greater than the other.
434 | */
435 | goog.math.Long.prototype.greaterThan = function(other) {
436 | return this.compare(other) > 0;
437 | };
438 |
439 |
440 | /**
441 | * @param {goog.math.Long} other Long to compare against.
442 | * @return {boolean} Whether this Long is greater than or equal to the other.
443 | */
444 | goog.math.Long.prototype.greaterThanOrEqual = function(other) {
445 | return this.compare(other) >= 0;
446 | };
447 |
448 |
449 | /**
450 | * Compares this Long with the given one.
451 | * @param {goog.math.Long} other Long to compare against.
452 | * @return {number} 0 if they are the same, 1 if the this is greater, and -1
453 | * if the given one is greater.
454 | */
455 | goog.math.Long.prototype.compare = function(other) {
456 | if (this.equals(other)) {
457 | return 0;
458 | }
459 |
460 | var thisNeg = this.isNegative();
461 | var otherNeg = other.isNegative();
462 | if (thisNeg && !otherNeg) {
463 | return -1;
464 | }
465 | if (!thisNeg && otherNeg) {
466 | return 1;
467 | }
468 |
469 | // at this point, the signs are the same, so subtraction will not overflow
470 | if (this.subtract(other).isNegative()) {
471 | return -1;
472 | } else {
473 | return 1;
474 | }
475 | };
476 |
477 |
478 | /** @return {!goog.math.Long} The negation of this value. */
479 | goog.math.Long.prototype.negate = function() {
480 | if (this.equals(goog.math.Long.MIN_VALUE)) {
481 | return goog.math.Long.MIN_VALUE;
482 | } else {
483 | return this.not().add(goog.math.Long.ONE);
484 | }
485 | };
486 |
487 |
488 | /**
489 | * Returns the sum of this and the given Long.
490 | * @param {goog.math.Long} other Long to add to this one.
491 | * @return {!goog.math.Long} The sum of this and the given Long.
492 | */
493 | goog.math.Long.prototype.add = function(other) {
494 | // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
495 |
496 | var a48 = this.high_ >>> 16;
497 | var a32 = this.high_ & 0xFFFF;
498 | var a16 = this.low_ >>> 16;
499 | var a00 = this.low_ & 0xFFFF;
500 |
501 | var b48 = other.high_ >>> 16;
502 | var b32 = other.high_ & 0xFFFF;
503 | var b16 = other.low_ >>> 16;
504 | var b00 = other.low_ & 0xFFFF;
505 |
506 | var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
507 | c00 += a00 + b00;
508 | c16 += c00 >>> 16;
509 | c00 &= 0xFFFF;
510 | c16 += a16 + b16;
511 | c32 += c16 >>> 16;
512 | c16 &= 0xFFFF;
513 | c32 += a32 + b32;
514 | c48 += c32 >>> 16;
515 | c32 &= 0xFFFF;
516 | c48 += a48 + b48;
517 | c48 &= 0xFFFF;
518 | return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
519 | };
520 |
521 |
522 | /**
523 | * Returns the difference of this and the given Long.
524 | * @param {goog.math.Long} other Long to subtract from this.
525 | * @return {!goog.math.Long} The difference of this and the given Long.
526 | */
527 | goog.math.Long.prototype.subtract = function(other) {
528 | return this.add(other.negate());
529 | };
530 |
531 |
532 | /**
533 | * Returns the product of this and the given long.
534 | * @param {goog.math.Long} other Long to multiply with this.
535 | * @return {!goog.math.Long} The product of this and the other.
536 | */
537 | goog.math.Long.prototype.multiply = function(other) {
538 | if (this.isZero()) {
539 | return goog.math.Long.ZERO;
540 | } else if (other.isZero()) {
541 | return goog.math.Long.ZERO;
542 | }
543 |
544 | if (this.equals(goog.math.Long.MIN_VALUE)) {
545 | return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
546 | } else if (other.equals(goog.math.Long.MIN_VALUE)) {
547 | return this.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
548 | }
549 |
550 | if (this.isNegative()) {
551 | if (other.isNegative()) {
552 | return this.negate().multiply(other.negate());
553 | } else {
554 | return this.negate().multiply(other).negate();
555 | }
556 | } else if (other.isNegative()) {
557 | return this.multiply(other.negate()).negate();
558 | }
559 |
560 | // If both longs are small, use float multiplication
561 | if (this.lessThan(goog.math.Long.TWO_PWR_24_) &&
562 | other.lessThan(goog.math.Long.TWO_PWR_24_)) {
563 | return goog.math.Long.fromNumber(this.toNumber() * other.toNumber());
564 | }
565 |
566 | // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
567 | // We can skip products that would overflow.
568 |
569 | var a48 = this.high_ >>> 16;
570 | var a32 = this.high_ & 0xFFFF;
571 | var a16 = this.low_ >>> 16;
572 | var a00 = this.low_ & 0xFFFF;
573 |
574 | var b48 = other.high_ >>> 16;
575 | var b32 = other.high_ & 0xFFFF;
576 | var b16 = other.low_ >>> 16;
577 | var b00 = other.low_ & 0xFFFF;
578 |
579 | var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
580 | c00 += a00 * b00;
581 | c16 += c00 >>> 16;
582 | c00 &= 0xFFFF;
583 | c16 += a16 * b00;
584 | c32 += c16 >>> 16;
585 | c16 &= 0xFFFF;
586 | c16 += a00 * b16;
587 | c32 += c16 >>> 16;
588 | c16 &= 0xFFFF;
589 | c32 += a32 * b00;
590 | c48 += c32 >>> 16;
591 | c32 &= 0xFFFF;
592 | c32 += a16 * b16;
593 | c48 += c32 >>> 16;
594 | c32 &= 0xFFFF;
595 | c32 += a00 * b32;
596 | c48 += c32 >>> 16;
597 | c32 &= 0xFFFF;
598 | c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
599 | c48 &= 0xFFFF;
600 | return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
601 | };
602 |
603 |
604 | /**
605 | * Returns this Long divided by the given one.
606 | * @param {goog.math.Long} other Long by which to divide.
607 | * @return {!goog.math.Long} This Long divided by the given one.
608 | */
609 | goog.math.Long.prototype.div = function(other) {
610 | if (other.isZero()) {
611 | throw Error('division by zero');
612 | } else if (this.isZero()) {
613 | return goog.math.Long.ZERO;
614 | }
615 |
616 | if (this.equals(goog.math.Long.MIN_VALUE)) {
617 | if (other.equals(goog.math.Long.ONE) ||
618 | other.equals(goog.math.Long.NEG_ONE)) {
619 | return goog.math.Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
620 | } else if (other.equals(goog.math.Long.MIN_VALUE)) {
621 | return goog.math.Long.ONE;
622 | } else {
623 | // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
624 | var halfThis = this.shiftRight(1);
625 | var approx = halfThis.div(other).shiftLeft(1);
626 | if (approx.equals(goog.math.Long.ZERO)) {
627 | return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE;
628 | } else {
629 | var rem = this.subtract(other.multiply(approx));
630 | var result = approx.add(rem.div(other));
631 | return result;
632 | }
633 | }
634 | } else if (other.equals(goog.math.Long.MIN_VALUE)) {
635 | return goog.math.Long.ZERO;
636 | }
637 |
638 | if (this.isNegative()) {
639 | if (other.isNegative()) {
640 | return this.negate().div(other.negate());
641 | } else {
642 | return this.negate().div(other).negate();
643 | }
644 | } else if (other.isNegative()) {
645 | return this.div(other.negate()).negate();
646 | }
647 |
648 | // Repeat the following until the remainder is less than other: find a
649 | // floating-point that approximates remainder / other *from below*, add this
650 | // into the result, and subtract it from the remainder. It is critical that
651 | // the approximate value is less than or equal to the real value so that the
652 | // remainder never becomes negative.
653 | var res = goog.math.Long.ZERO;
654 | var rem = this;
655 | while (rem.greaterThanOrEqual(other)) {
656 | // Approximate the result of division. This may be a little greater or
657 | // smaller than the actual value.
658 | var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
659 |
660 | // We will tweak the approximate result by changing it in the 48-th digit or
661 | // the smallest non-fractional digit, whichever is larger.
662 | var log2 = Math.ceil(Math.log(approx) / Math.LN2);
663 | var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);
664 |
665 | // Decrease the approximation until it is smaller than the remainder. Note
666 | // that if it is too large, the product overflows and is negative.
667 | var approxRes = goog.math.Long.fromNumber(approx);
668 | var approxRem = approxRes.multiply(other);
669 | while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
670 | approx -= delta;
671 | approxRes = goog.math.Long.fromNumber(approx);
672 | approxRem = approxRes.multiply(other);
673 | }
674 |
675 | // We know the answer can't be zero... and actually, zero would cause
676 | // infinite recursion since we would make no progress.
677 | if (approxRes.isZero()) {
678 | approxRes = goog.math.Long.ONE;
679 | }
680 |
681 | res = res.add(approxRes);
682 | rem = rem.subtract(approxRem);
683 | }
684 | return res;
685 | };
686 |
687 |
688 | /**
689 | * Returns this Long modulo the given one.
690 | * @param {goog.math.Long} other Long by which to mod.
691 | * @return {!goog.math.Long} This Long modulo the given one.
692 | */
693 | goog.math.Long.prototype.modulo = function(other) {
694 | return this.subtract(this.div(other).multiply(other));
695 | };
696 |
697 |
698 | /** @return {!goog.math.Long} The bitwise-NOT of this value. */
699 | goog.math.Long.prototype.not = function() {
700 | return goog.math.Long.fromBits(~this.low_, ~this.high_);
701 | };
702 |
703 |
704 | /**
705 | * Returns the bitwise-AND of this Long and the given one.
706 | * @param {goog.math.Long} other The Long with which to AND.
707 | * @return {!goog.math.Long} The bitwise-AND of this and the other.
708 | */
709 | goog.math.Long.prototype.and = function(other) {
710 | return goog.math.Long.fromBits(this.low_ & other.low_,
711 | this.high_ & other.high_);
712 | };
713 |
714 |
715 | /**
716 | * Returns the bitwise-OR of this Long and the given one.
717 | * @param {goog.math.Long} other The Long with which to OR.
718 | * @return {!goog.math.Long} The bitwise-OR of this and the other.
719 | */
720 | goog.math.Long.prototype.or = function(other) {
721 | return goog.math.Long.fromBits(this.low_ | other.low_,
722 | this.high_ | other.high_);
723 | };
724 |
725 |
726 | /**
727 | * Returns the bitwise-XOR of this Long and the given one.
728 | * @param {goog.math.Long} other The Long with which to XOR.
729 | * @return {!goog.math.Long} The bitwise-XOR of this and the other.
730 | */
731 | goog.math.Long.prototype.xor = function(other) {
732 | return goog.math.Long.fromBits(this.low_ ^ other.low_,
733 | this.high_ ^ other.high_);
734 | };
735 |
736 |
737 | /**
738 | * Returns this Long with bits shifted to the left by the given amount.
739 | * @param {number} numBits The number of bits by which to shift.
740 | * @return {!goog.math.Long} This shifted to the left by the given amount.
741 | */
742 | goog.math.Long.prototype.shiftLeft = function(numBits) {
743 | numBits &= 63;
744 | if (numBits == 0) {
745 | return this;
746 | } else {
747 | var low = this.low_;
748 | if (numBits < 32) {
749 | var high = this.high_;
750 | return goog.math.Long.fromBits(
751 | low << numBits,
752 | (high << numBits) | (low >>> (32 - numBits)));
753 | } else {
754 | return goog.math.Long.fromBits(0, low << (numBits - 32));
755 | }
756 | }
757 | };
758 |
759 |
760 | /**
761 | * Returns this Long with bits shifted to the right by the given amount.
762 | * @param {number} numBits The number of bits by which to shift.
763 | * @return {!goog.math.Long} This shifted to the right by the given amount.
764 | */
765 | goog.math.Long.prototype.shiftRight = function(numBits) {
766 | numBits &= 63;
767 | if (numBits == 0) {
768 | return this;
769 | } else {
770 | var high = this.high_;
771 | if (numBits < 32) {
772 | var low = this.low_;
773 | return goog.math.Long.fromBits(
774 | (low >>> numBits) | (high << (32 - numBits)),
775 | high >> numBits);
776 | } else {
777 | return goog.math.Long.fromBits(
778 | high >> (numBits - 32),
779 | high >= 0 ? 0 : -1);
780 | }
781 | }
782 | };
783 |
784 |
785 | /**
786 | * Returns this Long with bits shifted to the right by the given amount, with
787 | * the new top bits matching the current sign bit.
788 | * @param {number} numBits The number of bits by which to shift.
789 | * @return {!goog.math.Long} This shifted to the right by the given amount, with
790 | * zeros placed into the new leading bits.
791 | */
792 | goog.math.Long.prototype.shiftRightUnsigned = function(numBits) {
793 | numBits &= 63;
794 | if (numBits == 0) {
795 | return this;
796 | } else {
797 | var high = this.high_;
798 | if (numBits < 32) {
799 | var low = this.low_;
800 | return goog.math.Long.fromBits(
801 | (low >>> numBits) | (high << (32 - numBits)),
802 | high >>> numBits);
803 | } else if (numBits == 32) {
804 | return goog.math.Long.fromBits(high, 0);
805 | } else {
806 | return goog.math.Long.fromBits(high >>> (numBits - 32), 0);
807 | }
808 | }
809 | };
810 |
--------------------------------------------------------------------------------
/test/lib/qunit-1.11.0.css:
--------------------------------------------------------------------------------
1 | /**
2 | * QUnit v1.11.0 - A JavaScript Unit Testing Framework
3 | *
4 | * http://qunitjs.com
5 | *
6 | * Copyright 2012 jQuery Foundation and other contributors
7 | * Released under the MIT license.
8 | * http://jquery.org/license
9 | */
10 |
11 | /** Font Family and Sizes */
12 |
13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
14 | font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
15 | }
16 |
17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
18 | #qunit-tests { font-size: smaller; }
19 |
20 |
21 | /** Resets */
22 |
23 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
24 | margin: 0;
25 | padding: 0;
26 | }
27 |
28 |
29 | /** Header */
30 |
31 | #qunit-header {
32 | padding: 0.5em 0 0.5em 1em;
33 |
34 | color: #8699a4;
35 | background-color: #0d3349;
36 |
37 | font-size: 1.5em;
38 | line-height: 1em;
39 | font-weight: normal;
40 |
41 | border-radius: 5px 5px 0 0;
42 | -moz-border-radius: 5px 5px 0 0;
43 | -webkit-border-top-right-radius: 5px;
44 | -webkit-border-top-left-radius: 5px;
45 | }
46 |
47 | #qunit-header a {
48 | text-decoration: none;
49 | color: #c2ccd1;
50 | }
51 |
52 | #qunit-header a:hover,
53 | #qunit-header a:focus {
54 | color: #fff;
55 | }
56 |
57 | #qunit-testrunner-toolbar label {
58 | display: inline-block;
59 | padding: 0 .5em 0 .1em;
60 | }
61 |
62 | #qunit-banner {
63 | height: 5px;
64 | }
65 |
66 | #qunit-testrunner-toolbar {
67 | padding: 0.5em 0 0.5em 2em;
68 | color: #5E740B;
69 | background-color: #eee;
70 | overflow: hidden;
71 | }
72 |
73 | #qunit-userAgent {
74 | padding: 0.5em 0 0.5em 2.5em;
75 | background-color: #2b81af;
76 | color: #fff;
77 | text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
78 | }
79 |
80 | #qunit-modulefilter-container {
81 | float: right;
82 | }
83 |
84 | /** Tests: Pass/Fail */
85 |
86 | #qunit-tests {
87 | list-style-position: inside;
88 | }
89 |
90 | #qunit-tests li {
91 | padding: 0.4em 0.5em 0.4em 2.5em;
92 | border-bottom: 1px solid #fff;
93 | list-style-position: inside;
94 | }
95 |
96 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running {
97 | display: none;
98 | }
99 |
100 | #qunit-tests li strong {
101 | cursor: pointer;
102 | }
103 |
104 | #qunit-tests li a {
105 | padding: 0.5em;
106 | color: #c2ccd1;
107 | text-decoration: none;
108 | }
109 | #qunit-tests li a:hover,
110 | #qunit-tests li a:focus {
111 | color: #000;
112 | }
113 |
114 | #qunit-tests li .runtime {
115 | float: right;
116 | font-size: smaller;
117 | }
118 |
119 | .qunit-assert-list {
120 | margin-top: 0.5em;
121 | padding: 0.5em;
122 |
123 | background-color: #fff;
124 |
125 | border-radius: 5px;
126 | -moz-border-radius: 5px;
127 | -webkit-border-radius: 5px;
128 | }
129 |
130 | .qunit-collapsed {
131 | display: none;
132 | }
133 |
134 | #qunit-tests table {
135 | border-collapse: collapse;
136 | margin-top: .2em;
137 | }
138 |
139 | #qunit-tests th {
140 | text-align: right;
141 | vertical-align: top;
142 | padding: 0 .5em 0 0;
143 | }
144 |
145 | #qunit-tests td {
146 | vertical-align: top;
147 | }
148 |
149 | #qunit-tests pre {
150 | margin: 0;
151 | white-space: pre-wrap;
152 | word-wrap: break-word;
153 | }
154 |
155 | #qunit-tests del {
156 | background-color: #e0f2be;
157 | color: #374e0c;
158 | text-decoration: none;
159 | }
160 |
161 | #qunit-tests ins {
162 | background-color: #ffcaca;
163 | color: #500;
164 | text-decoration: none;
165 | }
166 |
167 | /*** Test Counts */
168 |
169 | #qunit-tests b.counts { color: black; }
170 | #qunit-tests b.passed { color: #5E740B; }
171 | #qunit-tests b.failed { color: #710909; }
172 |
173 | #qunit-tests li li {
174 | padding: 5px;
175 | background-color: #fff;
176 | border-bottom: none;
177 | list-style-position: inside;
178 | }
179 |
180 | /*** Passing Styles */
181 |
182 | #qunit-tests li li.pass {
183 | color: #3c510c;
184 | background-color: #fff;
185 | border-left: 10px solid #C6E746;
186 | }
187 |
188 | #qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; }
189 | #qunit-tests .pass .test-name { color: #366097; }
190 |
191 | #qunit-tests .pass .test-actual,
192 | #qunit-tests .pass .test-expected { color: #999999; }
193 |
194 | #qunit-banner.qunit-pass { background-color: #C6E746; }
195 |
196 | /*** Failing Styles */
197 |
198 | #qunit-tests li li.fail {
199 | color: #710909;
200 | background-color: #fff;
201 | border-left: 10px solid #EE5757;
202 | white-space: pre;
203 | }
204 |
205 | #qunit-tests > li:last-child {
206 | border-radius: 0 0 5px 5px;
207 | -moz-border-radius: 0 0 5px 5px;
208 | -webkit-border-bottom-right-radius: 5px;
209 | -webkit-border-bottom-left-radius: 5px;
210 | }
211 |
212 | #qunit-tests .fail { color: #000000; background-color: #EE5757; }
213 | #qunit-tests .fail .test-name,
214 | #qunit-tests .fail .module-name { color: #000000; }
215 |
216 | #qunit-tests .fail .test-actual { color: #EE5757; }
217 | #qunit-tests .fail .test-expected { color: green; }
218 |
219 | #qunit-banner.qunit-fail { background-color: #EE5757; }
220 |
221 |
222 | /** Result */
223 |
224 | #qunit-testresult {
225 | padding: 0.5em 0.5em 0.5em 2.5em;
226 |
227 | color: #2b81af;
228 | background-color: #D2E0E6;
229 |
230 | border-bottom: 1px solid white;
231 | }
232 | #qunit-testresult .module-name {
233 | font-weight: bold;
234 | }
235 |
236 | /** Fixture */
237 |
238 | #qunit-fixture {
239 | position: absolute;
240 | top: -10000px;
241 | left: -10000px;
242 | width: 1000px;
243 | height: 1000px;
244 | }
--------------------------------------------------------------------------------
/test/lib/qunit-1.11.0.js:
--------------------------------------------------------------------------------
1 | /**
2 | * QUnit v1.11.0 - A JavaScript Unit Testing Framework
3 | *
4 | * http://qunitjs.com
5 | *
6 | * Copyright 2012 jQuery Foundation and other contributors
7 | * Released under the MIT license.
8 | * http://jquery.org/license
9 | */
10 |
11 | (function( window ) {
12 |
13 | var QUnit,
14 | assert,
15 | config,
16 | onErrorFnPrev,
17 | testId = 0,
18 | fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
19 | toString = Object.prototype.toString,
20 | hasOwn = Object.prototype.hasOwnProperty,
21 | // Keep a local reference to Date (GH-283)
22 | Date = window.Date,
23 | defined = {
24 | setTimeout: typeof window.setTimeout !== "undefined",
25 | sessionStorage: (function() {
26 | var x = "qunit-test-string";
27 | try {
28 | sessionStorage.setItem( x, x );
29 | sessionStorage.removeItem( x );
30 | return true;
31 | } catch( e ) {
32 | return false;
33 | }
34 | }())
35 | },
36 | /**
37 | * Provides a normalized error string, correcting an issue
38 | * with IE 7 (and prior) where Error.prototype.toString is
39 | * not properly implemented
40 | *
41 | * Based on http://es5.github.com/#x15.11.4.4
42 | *
43 | * @param {String|Error} error
44 | * @return {String} error message
45 | */
46 | errorString = function( error ) {
47 | var name, message,
48 | errorString = error.toString();
49 | if ( errorString.substring( 0, 7 ) === "[object" ) {
50 | name = error.name ? error.name.toString() : "Error";
51 | message = error.message ? error.message.toString() : "";
52 | if ( name && message ) {
53 | return name + ": " + message;
54 | } else if ( name ) {
55 | return name;
56 | } else if ( message ) {
57 | return message;
58 | } else {
59 | return "Error";
60 | }
61 | } else {
62 | return errorString;
63 | }
64 | },
65 | /**
66 | * Makes a clone of an object using only Array or Object as base,
67 | * and copies over the own enumerable properties.
68 | *
69 | * @param {Object} obj
70 | * @return {Object} New object with only the own properties (recursively).
71 | */
72 | objectValues = function( obj ) {
73 | // Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
74 | /*jshint newcap: false */
75 | var key, val,
76 | vals = QUnit.is( "array", obj ) ? [] : {};
77 | for ( key in obj ) {
78 | if ( hasOwn.call( obj, key ) ) {
79 | val = obj[key];
80 | vals[key] = val === Object(val) ? objectValues(val) : val;
81 | }
82 | }
83 | return vals;
84 | };
85 |
86 | function Test( settings ) {
87 | extend( this, settings );
88 | this.assertions = [];
89 | this.testNumber = ++Test.count;
90 | }
91 |
92 | Test.count = 0;
93 |
94 | Test.prototype = {
95 | init: function() {
96 | var a, b, li,
97 | tests = id( "qunit-tests" );
98 |
99 | if ( tests ) {
100 | b = document.createElement( "strong" );
101 | b.innerHTML = this.nameHtml;
102 |
103 | // `a` initialized at top of scope
104 | a = document.createElement( "a" );
105 | a.innerHTML = "Rerun";
106 | a.href = QUnit.url({ testNumber: this.testNumber });
107 |
108 | li = document.createElement( "li" );
109 | li.appendChild( b );
110 | li.appendChild( a );
111 | li.className = "running";
112 | li.id = this.id = "qunit-test-output" + testId++;
113 |
114 | tests.appendChild( li );
115 | }
116 | },
117 | setup: function() {
118 | if ( this.module !== config.previousModule ) {
119 | if ( config.previousModule ) {
120 | runLoggingCallbacks( "moduleDone", QUnit, {
121 | name: config.previousModule,
122 | failed: config.moduleStats.bad,
123 | passed: config.moduleStats.all - config.moduleStats.bad,
124 | total: config.moduleStats.all
125 | });
126 | }
127 | config.previousModule = this.module;
128 | config.moduleStats = { all: 0, bad: 0 };
129 | runLoggingCallbacks( "moduleStart", QUnit, {
130 | name: this.module
131 | });
132 | } else if ( config.autorun ) {
133 | runLoggingCallbacks( "moduleStart", QUnit, {
134 | name: this.module
135 | });
136 | }
137 |
138 | config.current = this;
139 |
140 | this.testEnvironment = extend({
141 | setup: function() {},
142 | teardown: function() {}
143 | }, this.moduleTestEnvironment );
144 |
145 | this.started = +new Date();
146 | runLoggingCallbacks( "testStart", QUnit, {
147 | name: this.testName,
148 | module: this.module
149 | });
150 |
151 | // allow utility functions to access the current test environment
152 | // TODO why??
153 | QUnit.current_testEnvironment = this.testEnvironment;
154 |
155 | if ( !config.pollution ) {
156 | saveGlobal();
157 | }
158 | if ( config.notrycatch ) {
159 | this.testEnvironment.setup.call( this.testEnvironment );
160 | return;
161 | }
162 | try {
163 | this.testEnvironment.setup.call( this.testEnvironment );
164 | } catch( e ) {
165 | QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
166 | }
167 | },
168 | run: function() {
169 | config.current = this;
170 |
171 | var running = id( "qunit-testresult" );
172 |
173 | if ( running ) {
174 | running.innerHTML = "Running: (" + bad + " , " + good + " , " + this.assertions.length + ") ";
279 |
280 | addEvent(b, "click", function() {
281 | var next = b.parentNode.lastChild,
282 | collapsed = hasClass( next, "qunit-collapsed" );
283 | ( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
284 | });
285 |
286 | addEvent(b, "dblclick", function( e ) {
287 | var target = e && e.target ? e.target : window.event.srcElement;
288 | if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
289 | target = target.parentNode;
290 | }
291 | if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
292 | window.location = QUnit.url({ testNumber: test.testNumber });
293 | }
294 | });
295 |
296 | // `time` initialized at top of scope
297 | time = document.createElement( "span" );
298 | time.className = "runtime";
299 | time.innerHTML = this.runtime + " ms";
300 |
301 | // `li` initialized at top of scope
302 | li = id( this.id );
303 | li.className = bad ? "fail" : "pass";
304 | li.removeChild( li.firstChild );
305 | a = li.firstChild;
306 | li.appendChild( b );
307 | li.appendChild( a );
308 | li.appendChild( time );
309 | li.appendChild( ol );
310 |
311 | } else {
312 | for ( i = 0; i < this.assertions.length; i++ ) {
313 | if ( !this.assertions[i].result ) {
314 | bad++;
315 | config.stats.bad++;
316 | config.moduleStats.bad++;
317 | }
318 | }
319 | }
320 |
321 | runLoggingCallbacks( "testDone", QUnit, {
322 | name: this.testName,
323 | module: this.module,
324 | failed: bad,
325 | passed: this.assertions.length - bad,
326 | total: this.assertions.length,
327 | duration: this.runtime
328 | });
329 |
330 | QUnit.reset();
331 |
332 | config.current = undefined;
333 | },
334 |
335 | queue: function() {
336 | var bad,
337 | test = this;
338 |
339 | synchronize(function() {
340 | test.init();
341 | });
342 | function run() {
343 | // each of these can by async
344 | synchronize(function() {
345 | test.setup();
346 | });
347 | synchronize(function() {
348 | test.run();
349 | });
350 | synchronize(function() {
351 | test.teardown();
352 | });
353 | synchronize(function() {
354 | test.finish();
355 | });
356 | }
357 |
358 | // `bad` initialized at top of scope
359 | // defer when previous test run passed, if storage is available
360 | bad = QUnit.config.reorder && defined.sessionStorage &&
361 | +sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
362 |
363 | if ( bad ) {
364 | run();
365 | } else {
366 | synchronize( run, true );
367 | }
368 | }
369 | };
370 |
371 | // Root QUnit object.
372 | // `QUnit` initialized at top of scope
373 | QUnit = {
374 |
375 | // call on start of module test to prepend name to all tests
376 | module: function( name, testEnvironment ) {
377 | config.currentModule = name;
378 | config.currentModuleTestEnvironment = testEnvironment;
379 | config.modules[name] = true;
380 | },
381 |
382 | asyncTest: function( testName, expected, callback ) {
383 | if ( arguments.length === 2 ) {
384 | callback = expected;
385 | expected = null;
386 | }
387 |
388 | QUnit.test( testName, expected, callback, true );
389 | },
390 |
391 | test: function( testName, expected, callback, async ) {
392 | var test,
393 | nameHtml = "" + escapeText( testName ) + " ";
394 |
395 | if ( arguments.length === 2 ) {
396 | callback = expected;
397 | expected = null;
398 | }
399 |
400 | if ( config.currentModule ) {
401 | nameHtml = "" + escapeText( config.currentModule ) + " : " + nameHtml;
402 | }
403 |
404 | test = new Test({
405 | nameHtml: nameHtml,
406 | testName: testName,
407 | expected: expected,
408 | async: async,
409 | callback: callback,
410 | module: config.currentModule,
411 | moduleTestEnvironment: config.currentModuleTestEnvironment,
412 | stack: sourceFromStacktrace( 2 )
413 | });
414 |
415 | if ( !validTest( test ) ) {
416 | return;
417 | }
418 |
419 | test.queue();
420 | },
421 |
422 | // Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
423 | expect: function( asserts ) {
424 | if (arguments.length === 1) {
425 | config.current.expected = asserts;
426 | } else {
427 | return config.current.expected;
428 | }
429 | },
430 |
431 | start: function( count ) {
432 | // QUnit hasn't been initialized yet.
433 | // Note: RequireJS (et al) may delay onLoad
434 | if ( config.semaphore === undefined ) {
435 | QUnit.begin(function() {
436 | // This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
437 | setTimeout(function() {
438 | QUnit.start( count );
439 | });
440 | });
441 | return;
442 | }
443 |
444 | config.semaphore -= count || 1;
445 | // don't start until equal number of stop-calls
446 | if ( config.semaphore > 0 ) {
447 | return;
448 | }
449 | // ignore if start is called more often then stop
450 | if ( config.semaphore < 0 ) {
451 | config.semaphore = 0;
452 | QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
453 | return;
454 | }
455 | // A slight delay, to avoid any current callbacks
456 | if ( defined.setTimeout ) {
457 | window.setTimeout(function() {
458 | if ( config.semaphore > 0 ) {
459 | return;
460 | }
461 | if ( config.timeout ) {
462 | clearTimeout( config.timeout );
463 | }
464 |
465 | config.blocking = false;
466 | process( true );
467 | }, 13);
468 | } else {
469 | config.blocking = false;
470 | process( true );
471 | }
472 | },
473 |
474 | stop: function( count ) {
475 | config.semaphore += count || 1;
476 | config.blocking = true;
477 |
478 | if ( config.testTimeout && defined.setTimeout ) {
479 | clearTimeout( config.timeout );
480 | config.timeout = window.setTimeout(function() {
481 | QUnit.ok( false, "Test timed out" );
482 | config.semaphore = 1;
483 | QUnit.start();
484 | }, config.testTimeout );
485 | }
486 | }
487 | };
488 |
489 | // `assert` initialized at top of scope
490 | // Asssert helpers
491 | // All of these must either call QUnit.push() or manually do:
492 | // - runLoggingCallbacks( "log", .. );
493 | // - config.current.assertions.push({ .. });
494 | // We attach it to the QUnit object *after* we expose the public API,
495 | // otherwise `assert` will become a global variable in browsers (#341).
496 | assert = {
497 | /**
498 | * Asserts rough true-ish result.
499 | * @name ok
500 | * @function
501 | * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
502 | */
503 | ok: function( result, msg ) {
504 | if ( !config.current ) {
505 | throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
506 | }
507 | result = !!result;
508 |
509 | var source,
510 | details = {
511 | module: config.current.module,
512 | name: config.current.testName,
513 | result: result,
514 | message: msg
515 | };
516 |
517 | msg = escapeText( msg || (result ? "okay" : "failed" ) );
518 | msg = "" + msg + " ";
519 |
520 | if ( !result ) {
521 | source = sourceFromStacktrace( 2 );
522 | if ( source ) {
523 | details.source = source;
524 | msg += "Source: " + escapeText( source ) + "
";
525 | }
526 | }
527 | runLoggingCallbacks( "log", QUnit, details );
528 | config.current.assertions.push({
529 | result: result,
530 | message: msg
531 | });
532 | },
533 |
534 | /**
535 | * Assert that the first two arguments are equal, with an optional message.
536 | * Prints out both actual and expected values.
537 | * @name equal
538 | * @function
539 | * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
540 | */
541 | equal: function( actual, expected, message ) {
542 | /*jshint eqeqeq:false */
543 | QUnit.push( expected == actual, actual, expected, message );
544 | },
545 |
546 | /**
547 | * @name notEqual
548 | * @function
549 | */
550 | notEqual: function( actual, expected, message ) {
551 | /*jshint eqeqeq:false */
552 | QUnit.push( expected != actual, actual, expected, message );
553 | },
554 |
555 | /**
556 | * @name propEqual
557 | * @function
558 | */
559 | propEqual: function( actual, expected, message ) {
560 | actual = objectValues(actual);
561 | expected = objectValues(expected);
562 | QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
563 | },
564 |
565 | /**
566 | * @name notPropEqual
567 | * @function
568 | */
569 | notPropEqual: function( actual, expected, message ) {
570 | actual = objectValues(actual);
571 | expected = objectValues(expected);
572 | QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
573 | },
574 |
575 | /**
576 | * @name deepEqual
577 | * @function
578 | */
579 | deepEqual: function( actual, expected, message ) {
580 | QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
581 | },
582 |
583 | /**
584 | * @name notDeepEqual
585 | * @function
586 | */
587 | notDeepEqual: function( actual, expected, message ) {
588 | QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
589 | },
590 |
591 | /**
592 | * @name strictEqual
593 | * @function
594 | */
595 | strictEqual: function( actual, expected, message ) {
596 | QUnit.push( expected === actual, actual, expected, message );
597 | },
598 |
599 | /**
600 | * @name notStrictEqual
601 | * @function
602 | */
603 | notStrictEqual: function( actual, expected, message ) {
604 | QUnit.push( expected !== actual, actual, expected, message );
605 | },
606 |
607 | "throws": function( block, expected, message ) {
608 | var actual,
609 | expectedOutput = expected,
610 | ok = false;
611 |
612 | // 'expected' is optional
613 | if ( typeof expected === "string" ) {
614 | message = expected;
615 | expected = null;
616 | }
617 |
618 | config.current.ignoreGlobalErrors = true;
619 | try {
620 | block.call( config.current.testEnvironment );
621 | } catch (e) {
622 | actual = e;
623 | }
624 | config.current.ignoreGlobalErrors = false;
625 |
626 | if ( actual ) {
627 | // we don't want to validate thrown error
628 | if ( !expected ) {
629 | ok = true;
630 | expectedOutput = null;
631 | // expected is a regexp
632 | } else if ( QUnit.objectType( expected ) === "regexp" ) {
633 | ok = expected.test( errorString( actual ) );
634 | // expected is a constructor
635 | } else if ( actual instanceof expected ) {
636 | ok = true;
637 | // expected is a validation function which returns true is validation passed
638 | } else if ( expected.call( {}, actual ) === true ) {
639 | expectedOutput = null;
640 | ok = true;
641 | }
642 |
643 | QUnit.push( ok, actual, expectedOutput, message );
644 | } else {
645 | QUnit.pushFailure( message, null, 'No exception was thrown.' );
646 | }
647 | }
648 | };
649 |
650 | /**
651 | * @deprecate since 1.8.0
652 | * Kept assertion helpers in root for backwards compatibility.
653 | */
654 | extend( QUnit, assert );
655 |
656 | /**
657 | * @deprecated since 1.9.0
658 | * Kept root "raises()" for backwards compatibility.
659 | * (Note that we don't introduce assert.raises).
660 | */
661 | QUnit.raises = assert[ "throws" ];
662 |
663 | /**
664 | * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
665 | * Kept to avoid TypeErrors for undefined methods.
666 | */
667 | QUnit.equals = function() {
668 | QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
669 | };
670 | QUnit.same = function() {
671 | QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
672 | };
673 |
674 | // We want access to the constructor's prototype
675 | (function() {
676 | function F() {}
677 | F.prototype = QUnit;
678 | QUnit = new F();
679 | // Make F QUnit's constructor so that we can add to the prototype later
680 | QUnit.constructor = F;
681 | }());
682 |
683 | /**
684 | * Config object: Maintain internal state
685 | * Later exposed as QUnit.config
686 | * `config` initialized at top of scope
687 | */
688 | config = {
689 | // The queue of tests to run
690 | queue: [],
691 |
692 | // block until document ready
693 | blocking: true,
694 |
695 | // when enabled, show only failing tests
696 | // gets persisted through sessionStorage and can be changed in UI via checkbox
697 | hidepassed: false,
698 |
699 | // by default, run previously failed tests first
700 | // very useful in combination with "Hide passed tests" checked
701 | reorder: true,
702 |
703 | // by default, modify document.title when suite is done
704 | altertitle: true,
705 |
706 | // when enabled, all tests must call expect()
707 | requireExpects: false,
708 |
709 | // add checkboxes that are persisted in the query-string
710 | // when enabled, the id is set to `true` as a `QUnit.config` property
711 | urlConfig: [
712 | {
713 | id: "noglobals",
714 | label: "Check for Globals",
715 | tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
716 | },
717 | {
718 | id: "notrycatch",
719 | label: "No try-catch",
720 | tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
721 | }
722 | ],
723 |
724 | // Set of all modules.
725 | modules: {},
726 |
727 | // logging callback queues
728 | begin: [],
729 | done: [],
730 | log: [],
731 | testStart: [],
732 | testDone: [],
733 | moduleStart: [],
734 | moduleDone: []
735 | };
736 |
737 | // Export global variables, unless an 'exports' object exists,
738 | // in that case we assume we're in CommonJS (dealt with on the bottom of the script)
739 | if ( typeof exports === "undefined" ) {
740 | extend( window, QUnit );
741 |
742 | // Expose QUnit object
743 | window.QUnit = QUnit;
744 | }
745 |
746 | // Initialize more QUnit.config and QUnit.urlParams
747 | (function() {
748 | var i,
749 | location = window.location || { search: "", protocol: "file:" },
750 | params = location.search.slice( 1 ).split( "&" ),
751 | length = params.length,
752 | urlParams = {},
753 | current;
754 |
755 | if ( params[ 0 ] ) {
756 | for ( i = 0; i < length; i++ ) {
757 | current = params[ i ].split( "=" );
758 | current[ 0 ] = decodeURIComponent( current[ 0 ] );
759 | // allow just a key to turn on a flag, e.g., test.html?noglobals
760 | current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
761 | urlParams[ current[ 0 ] ] = current[ 1 ];
762 | }
763 | }
764 |
765 | QUnit.urlParams = urlParams;
766 |
767 | // String search anywhere in moduleName+testName
768 | config.filter = urlParams.filter;
769 |
770 | // Exact match of the module name
771 | config.module = urlParams.module;
772 |
773 | config.testNumber = parseInt( urlParams.testNumber, 10 ) || null;
774 |
775 | // Figure out if we're running the tests from a server or not
776 | QUnit.isLocal = location.protocol === "file:";
777 | }());
778 |
779 | // Extend QUnit object,
780 | // these after set here because they should not be exposed as global functions
781 | extend( QUnit, {
782 | assert: assert,
783 |
784 | config: config,
785 |
786 | // Initialize the configuration options
787 | init: function() {
788 | extend( config, {
789 | stats: { all: 0, bad: 0 },
790 | moduleStats: { all: 0, bad: 0 },
791 | started: +new Date(),
792 | updateRate: 1000,
793 | blocking: false,
794 | autostart: true,
795 | autorun: false,
796 | filter: "",
797 | queue: [],
798 | semaphore: 1
799 | });
800 |
801 | var tests, banner, result,
802 | qunit = id( "qunit" );
803 |
804 | if ( qunit ) {
805 | qunit.innerHTML =
806 | "" +
807 | "
" +
809 | "" + message + " ";
914 | output = message;
915 |
916 | if ( !result ) {
917 | expected = escapeText( QUnit.jsDump.parse(expected) );
918 | actual = escapeText( QUnit.jsDump.parse(actual) );
919 | output += "Expected: " + expected + " Result: " + actual + " Diff: " + QUnit.diff( expected, actual ) + " Source: " + escapeText( source ) + "
";
934 | }
935 |
936 | runLoggingCallbacks( "log", QUnit, details );
937 |
938 | config.current.assertions.push({
939 | result: !!result,
940 | message: output
941 | });
942 | },
943 |
944 | pushFailure: function( message, source, actual ) {
945 | if ( !config.current ) {
946 | throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
947 | }
948 |
949 | var output,
950 | details = {
951 | module: config.current.module,
952 | name: config.current.testName,
953 | result: false,
954 | message: message
955 | };
956 |
957 | message = escapeText( message ) || "error";
958 | message = "" + message + " ";
959 | output = message;
960 |
961 | output += "";
962 |
963 | if ( actual ) {
964 | output += "Result: " + escapeText( actual ) + " Source: " + escapeText( source ) + "
";
973 |
974 | runLoggingCallbacks( "log", QUnit, details );
975 |
976 | config.current.assertions.push({
977 | result: false,
978 | message: output
979 | });
980 | },
981 |
982 | url: function( params ) {
983 | params = extend( extend( {}, QUnit.urlParams ), params );
984 | var key,
985 | querystring = "?";
986 |
987 | for ( key in params ) {
988 | if ( !hasOwn.call( params, key ) ) {
989 | continue;
990 | }
991 | querystring += encodeURIComponent( key ) + "=" +
992 | encodeURIComponent( params[ key ] ) + "&";
993 | }
994 | return window.location.protocol + "//" + window.location.host +
995 | window.location.pathname + querystring.slice( 0, -1 );
996 | },
997 |
998 | extend: extend,
999 | id: id,
1000 | addEvent: addEvent
1001 | // load, equiv, jsDump, diff: Attached later
1002 | });
1003 |
1004 | /**
1005 | * @deprecated: Created for backwards compatibility with test runner that set the hook function
1006 | * into QUnit.{hook}, instead of invoking it and passing the hook function.
1007 | * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
1008 | * Doing this allows us to tell if the following methods have been overwritten on the actual
1009 | * QUnit object.
1010 | */
1011 | extend( QUnit.constructor.prototype, {
1012 |
1013 | // Logging callbacks; all receive a single argument with the listed properties
1014 | // run test/logs.html for any related changes
1015 | begin: registerLoggingCallback( "begin" ),
1016 |
1017 | // done: { failed, passed, total, runtime }
1018 | done: registerLoggingCallback( "done" ),
1019 |
1020 | // log: { result, actual, expected, message }
1021 | log: registerLoggingCallback( "log" ),
1022 |
1023 | // testStart: { name }
1024 | testStart: registerLoggingCallback( "testStart" ),
1025 |
1026 | // testDone: { name, failed, passed, total, duration }
1027 | testDone: registerLoggingCallback( "testDone" ),
1028 |
1029 | // moduleStart: { name }
1030 | moduleStart: registerLoggingCallback( "moduleStart" ),
1031 |
1032 | // moduleDone: { name, failed, passed, total }
1033 | moduleDone: registerLoggingCallback( "moduleDone" )
1034 | });
1035 |
1036 | if ( typeof document === "undefined" || document.readyState === "complete" ) {
1037 | config.autorun = true;
1038 | }
1039 |
1040 | QUnit.load = function() {
1041 | runLoggingCallbacks( "begin", QUnit, {} );
1042 |
1043 | // Initialize the config, saving the execution queue
1044 | var banner, filter, i, label, len, main, ol, toolbar, userAgent, val,
1045 | urlConfigCheckboxesContainer, urlConfigCheckboxes, moduleFilter,
1046 | numModules = 0,
1047 | moduleFilterHtml = "",
1048 | urlConfigHtml = "",
1049 | oldconfig = extend( {}, config );
1050 |
1051 | QUnit.init();
1052 | extend(config, oldconfig);
1053 |
1054 | config.blocking = false;
1055 |
1056 | len = config.urlConfig.length;
1057 |
1058 | for ( i = 0; i < len; i++ ) {
1059 | val = config.urlConfig[i];
1060 | if ( typeof val === "string" ) {
1061 | val = {
1062 | id: val,
1063 | label: val,
1064 | tooltip: "[no tooltip available]"
1065 | };
1066 | }
1067 | config[ val.id ] = QUnit.urlParams[ val.id ];
1068 | urlConfigHtml += "" + val.label + " ";
1074 | }
1075 |
1076 | moduleFilterHtml += "Module: < All Modules > ";
1079 |
1080 | for ( i in config.modules ) {
1081 | if ( config.modules.hasOwnProperty( i ) ) {
1082 | numModules += 1;
1083 | moduleFilterHtml += "" + escapeText(i) + " ";
1086 | }
1087 | }
1088 | moduleFilterHtml += "" + banner.innerHTML + " ";
1100 | }
1101 |
1102 | // `toolbar` initialized at top of scope
1103 | toolbar = id( "qunit-testrunner-toolbar" );
1104 | if ( toolbar ) {
1105 | // `filter` initialized at top of scope
1106 | filter = document.createElement( "input" );
1107 | filter.type = "checkbox";
1108 | filter.id = "qunit-filter-pass";
1109 |
1110 | addEvent( filter, "click", function() {
1111 | var tmp,
1112 | ol = document.getElementById( "qunit-tests" );
1113 |
1114 | if ( filter.checked ) {
1115 | ol.className = ol.className + " hidepass";
1116 | } else {
1117 | tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
1118 | ol.className = tmp.replace( / hidepass /, " " );
1119 | }
1120 | if ( defined.sessionStorage ) {
1121 | if (filter.checked) {
1122 | sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
1123 | } else {
1124 | sessionStorage.removeItem( "qunit-filter-passed-tests" );
1125 | }
1126 | }
1127 | });
1128 |
1129 | if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
1130 | filter.checked = true;
1131 | // `ol` initialized at top of scope
1132 | ol = document.getElementById( "qunit-tests" );
1133 | ol.className = ol.className + " hidepass";
1134 | }
1135 | toolbar.appendChild( filter );
1136 |
1137 | // `label` initialized at top of scope
1138 | label = document.createElement( "label" );
1139 | label.setAttribute( "for", "qunit-filter-pass" );
1140 | label.setAttribute( "title", "Only show tests and assertons that fail. Stored in sessionStorage." );
1141 | label.innerHTML = "Hide passed tests";
1142 | toolbar.appendChild( label );
1143 |
1144 | urlConfigCheckboxesContainer = document.createElement("span");
1145 | urlConfigCheckboxesContainer.innerHTML = urlConfigHtml;
1146 | urlConfigCheckboxes = urlConfigCheckboxesContainer.getElementsByTagName("input");
1147 | // For oldIE support:
1148 | // * Add handlers to the individual elements instead of the container
1149 | // * Use "click" instead of "change"
1150 | // * Fallback from event.target to event.srcElement
1151 | addEvents( urlConfigCheckboxes, "click", function( event ) {
1152 | var params = {},
1153 | target = event.target || event.srcElement;
1154 | params[ target.name ] = target.checked ? true : undefined;
1155 | window.location = QUnit.url( params );
1156 | });
1157 | toolbar.appendChild( urlConfigCheckboxesContainer );
1158 |
1159 | if (numModules > 1) {
1160 | moduleFilter = document.createElement( 'span' );
1161 | moduleFilter.setAttribute( 'id', 'qunit-modulefilter-container' );
1162 | moduleFilter.innerHTML = moduleFilterHtml;
1163 | addEvent( moduleFilter.lastChild, "change", function() {
1164 | var selectBox = moduleFilter.getElementsByTagName("select")[0],
1165 | selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
1166 |
1167 | window.location = QUnit.url( { module: ( selectedModule === "" ) ? undefined : selectedModule } );
1168 | });
1169 | toolbar.appendChild(moduleFilter);
1170 | }
1171 | }
1172 |
1173 | // `main` initialized at top of scope
1174 | main = id( "qunit-fixture" );
1175 | if ( main ) {
1176 | config.fixture = main.innerHTML;
1177 | }
1178 |
1179 | if ( config.autostart ) {
1180 | QUnit.start();
1181 | }
1182 | };
1183 |
1184 | addEvent( window, "load", QUnit.load );
1185 |
1186 | // `onErrorFnPrev` initialized at top of scope
1187 | // Preserve other handlers
1188 | onErrorFnPrev = window.onerror;
1189 |
1190 | // Cover uncaught exceptions
1191 | // Returning true will surpress the default browser handler,
1192 | // returning false will let it run.
1193 | window.onerror = function ( error, filePath, linerNr ) {
1194 | var ret = false;
1195 | if ( onErrorFnPrev ) {
1196 | ret = onErrorFnPrev( error, filePath, linerNr );
1197 | }
1198 |
1199 | // Treat return value as window.onerror itself does,
1200 | // Only do our handling if not surpressed.
1201 | if ( ret !== true ) {
1202 | if ( QUnit.config.current ) {
1203 | if ( QUnit.config.current.ignoreGlobalErrors ) {
1204 | return true;
1205 | }
1206 | QUnit.pushFailure( error, filePath + ":" + linerNr );
1207 | } else {
1208 | QUnit.test( "global failure", extend( function() {
1209 | QUnit.pushFailure( error, filePath + ":" + linerNr );
1210 | }, { validTest: validTest } ) );
1211 | }
1212 | return false;
1213 | }
1214 |
1215 | return ret;
1216 | };
1217 |
1218 | function done() {
1219 | config.autorun = true;
1220 |
1221 | // Log the last module results
1222 | if ( config.currentModule ) {
1223 | runLoggingCallbacks( "moduleDone", QUnit, {
1224 | name: config.currentModule,
1225 | failed: config.moduleStats.bad,
1226 | passed: config.moduleStats.all - config.moduleStats.bad,
1227 | total: config.moduleStats.all
1228 | });
1229 | }
1230 |
1231 | var i, key,
1232 | banner = id( "qunit-banner" ),
1233 | tests = id( "qunit-tests" ),
1234 | runtime = +new Date() - config.started,
1235 | passed = config.stats.all - config.stats.bad,
1236 | html = [
1237 | "Tests completed in ",
1238 | runtime,
1239 | " milliseconds.",
1241 | passed,
1242 | " assertions of ",
1243 | config.stats.all,
1244 | " passed, ",
1245 | config.stats.bad,
1246 | " failed."
1247 | ].join( "" );
1248 |
1249 | if ( banner ) {
1250 | banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
1251 | }
1252 |
1253 | if ( tests ) {
1254 | id( "qunit-testresult" ).innerHTML = html;
1255 | }
1256 |
1257 | if ( config.altertitle && typeof document !== "undefined" && document.title ) {
1258 | // show ✖ for good, ✔ for bad suite result in title
1259 | // use escape sequences in case file gets loaded with non-utf-8-charset
1260 | document.title = [
1261 | ( config.stats.bad ? "\u2716" : "\u2714" ),
1262 | document.title.replace( /^[\u2714\u2716] /i, "" )
1263 | ].join( " " );
1264 | }
1265 |
1266 | // clear own sessionStorage items if all tests passed
1267 | if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
1268 | // `key` & `i` initialized at top of scope
1269 | for ( i = 0; i < sessionStorage.length; i++ ) {
1270 | key = sessionStorage.key( i++ );
1271 | if ( key.indexOf( "qunit-test-" ) === 0 ) {
1272 | sessionStorage.removeItem( key );
1273 | }
1274 | }
1275 | }
1276 |
1277 | // scroll back to top to show results
1278 | if ( window.scrollTo ) {
1279 | window.scrollTo(0, 0);
1280 | }
1281 |
1282 | runLoggingCallbacks( "done", QUnit, {
1283 | failed: config.stats.bad,
1284 | passed: passed,
1285 | total: config.stats.all,
1286 | runtime: runtime
1287 | });
1288 | }
1289 |
1290 | /** @return Boolean: true if this test should be ran */
1291 | function validTest( test ) {
1292 | var include,
1293 | filter = config.filter && config.filter.toLowerCase(),
1294 | module = config.module && config.module.toLowerCase(),
1295 | fullName = (test.module + ": " + test.testName).toLowerCase();
1296 |
1297 | // Internally-generated tests are always valid
1298 | if ( test.callback && test.callback.validTest === validTest ) {
1299 | delete test.callback.validTest;
1300 | return true;
1301 | }
1302 |
1303 | if ( config.testNumber ) {
1304 | return test.testNumber === config.testNumber;
1305 | }
1306 |
1307 | if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
1308 | return false;
1309 | }
1310 |
1311 | if ( !filter ) {
1312 | return true;
1313 | }
1314 |
1315 | include = filter.charAt( 0 ) !== "!";
1316 | if ( !include ) {
1317 | filter = filter.slice( 1 );
1318 | }
1319 |
1320 | // If the filter matches, we need to honour include
1321 | if ( fullName.indexOf( filter ) !== -1 ) {
1322 | return include;
1323 | }
1324 |
1325 | // Otherwise, do the opposite
1326 | return !include;
1327 | }
1328 |
1329 | // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
1330 | // Later Safari and IE10 are supposed to support error.stack as well
1331 | // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
1332 | function extractStacktrace( e, offset ) {
1333 | offset = offset === undefined ? 3 : offset;
1334 |
1335 | var stack, include, i;
1336 |
1337 | if ( e.stacktrace ) {
1338 | // Opera
1339 | return e.stacktrace.split( "\n" )[ offset + 3 ];
1340 | } else if ( e.stack ) {
1341 | // Firefox, Chrome
1342 | stack = e.stack.split( "\n" );
1343 | if (/^error$/i.test( stack[0] ) ) {
1344 | stack.shift();
1345 | }
1346 | if ( fileName ) {
1347 | include = [];
1348 | for ( i = offset; i < stack.length; i++ ) {
1349 | if ( stack[ i ].indexOf( fileName ) !== -1 ) {
1350 | break;
1351 | }
1352 | include.push( stack[ i ] );
1353 | }
1354 | if ( include.length ) {
1355 | return include.join( "\n" );
1356 | }
1357 | }
1358 | return stack[ offset ];
1359 | } else if ( e.sourceURL ) {
1360 | // Safari, PhantomJS
1361 | // hopefully one day Safari provides actual stacktraces
1362 | // exclude useless self-reference for generated Error objects
1363 | if ( /qunit.js$/.test( e.sourceURL ) ) {
1364 | return;
1365 | }
1366 | // for actual exceptions, this is useful
1367 | return e.sourceURL + ":" + e.line;
1368 | }
1369 | }
1370 | function sourceFromStacktrace( offset ) {
1371 | try {
1372 | throw new Error();
1373 | } catch ( e ) {
1374 | return extractStacktrace( e, offset );
1375 | }
1376 | }
1377 |
1378 | /**
1379 | * Escape text for attribute or text content.
1380 | */
1381 | function escapeText( s ) {
1382 | if ( !s ) {
1383 | return "";
1384 | }
1385 | s = s + "";
1386 | // Both single quotes and double quotes (for attributes)
1387 | return s.replace( /['"<>&]/g, function( s ) {
1388 | switch( s ) {
1389 | case '\'':
1390 | return ''';
1391 | case '"':
1392 | return '"';
1393 | case '<':
1394 | return '<';
1395 | case '>':
1396 | return '>';
1397 | case '&':
1398 | return '&';
1399 | }
1400 | });
1401 | }
1402 |
1403 | function synchronize( callback, last ) {
1404 | config.queue.push( callback );
1405 |
1406 | if ( config.autorun && !config.blocking ) {
1407 | process( last );
1408 | }
1409 | }
1410 |
1411 | function process( last ) {
1412 | function next() {
1413 | process( last );
1414 | }
1415 | var start = new Date().getTime();
1416 | config.depth = config.depth ? config.depth + 1 : 1;
1417 |
1418 | while ( config.queue.length && !config.blocking ) {
1419 | if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
1420 | config.queue.shift()();
1421 | } else {
1422 | window.setTimeout( next, 13 );
1423 | break;
1424 | }
1425 | }
1426 | config.depth--;
1427 | if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
1428 | done();
1429 | }
1430 | }
1431 |
1432 | function saveGlobal() {
1433 | config.pollution = [];
1434 |
1435 | if ( config.noglobals ) {
1436 | for ( var key in window ) {
1437 | // in Opera sometimes DOM element ids show up here, ignore them
1438 | if ( !hasOwn.call( window, key ) || /^qunit-test-output/.test( key ) ) {
1439 | continue;
1440 | }
1441 | config.pollution.push( key );
1442 | }
1443 | }
1444 | }
1445 |
1446 | function checkPollution() {
1447 | var newGlobals,
1448 | deletedGlobals,
1449 | old = config.pollution;
1450 |
1451 | saveGlobal();
1452 |
1453 | newGlobals = diff( config.pollution, old );
1454 | if ( newGlobals.length > 0 ) {
1455 | QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
1456 | }
1457 |
1458 | deletedGlobals = diff( old, config.pollution );
1459 | if ( deletedGlobals.length > 0 ) {
1460 | QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
1461 | }
1462 | }
1463 |
1464 | // returns a new Array with the elements that are in a but not in b
1465 | function diff( a, b ) {
1466 | var i, j,
1467 | result = a.slice();
1468 |
1469 | for ( i = 0; i < result.length; i++ ) {
1470 | for ( j = 0; j < b.length; j++ ) {
1471 | if ( result[i] === b[j] ) {
1472 | result.splice( i, 1 );
1473 | i--;
1474 | break;
1475 | }
1476 | }
1477 | }
1478 | return result;
1479 | }
1480 |
1481 | function extend( a, b ) {
1482 | for ( var prop in b ) {
1483 | if ( b[ prop ] === undefined ) {
1484 | delete a[ prop ];
1485 |
1486 | // Avoid "Member not found" error in IE8 caused by setting window.constructor
1487 | } else if ( prop !== "constructor" || a !== window ) {
1488 | a[ prop ] = b[ prop ];
1489 | }
1490 | }
1491 |
1492 | return a;
1493 | }
1494 |
1495 | /**
1496 | * @param {HTMLElement} elem
1497 | * @param {string} type
1498 | * @param {Function} fn
1499 | */
1500 | function addEvent( elem, type, fn ) {
1501 | // Standards-based browsers
1502 | if ( elem.addEventListener ) {
1503 | elem.addEventListener( type, fn, false );
1504 | // IE
1505 | } else {
1506 | elem.attachEvent( "on" + type, fn );
1507 | }
1508 | }
1509 |
1510 | /**
1511 | * @param {Array|NodeList} elems
1512 | * @param {string} type
1513 | * @param {Function} fn
1514 | */
1515 | function addEvents( elems, type, fn ) {
1516 | var i = elems.length;
1517 | while ( i-- ) {
1518 | addEvent( elems[i], type, fn );
1519 | }
1520 | }
1521 |
1522 | function hasClass( elem, name ) {
1523 | return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
1524 | }
1525 |
1526 | function addClass( elem, name ) {
1527 | if ( !hasClass( elem, name ) ) {
1528 | elem.className += (elem.className ? " " : "") + name;
1529 | }
1530 | }
1531 |
1532 | function removeClass( elem, name ) {
1533 | var set = " " + elem.className + " ";
1534 | // Class name may appear multiple times
1535 | while ( set.indexOf(" " + name + " ") > -1 ) {
1536 | set = set.replace(" " + name + " " , " ");
1537 | }
1538 | // If possible, trim it for prettiness, but not neccecarily
1539 | elem.className = window.jQuery ? jQuery.trim( set ) : ( set.trim ? set.trim() : set );
1540 | }
1541 |
1542 | function id( name ) {
1543 | return !!( typeof document !== "undefined" && document && document.getElementById ) &&
1544 | document.getElementById( name );
1545 | }
1546 |
1547 | function registerLoggingCallback( key ) {
1548 | return function( callback ) {
1549 | config[key].push( callback );
1550 | };
1551 | }
1552 |
1553 | // Supports deprecated method of completely overwriting logging callbacks
1554 | function runLoggingCallbacks( key, scope, args ) {
1555 | var i, callbacks;
1556 | if ( QUnit.hasOwnProperty( key ) ) {
1557 | QUnit[ key ].call(scope, args );
1558 | } else {
1559 | callbacks = config[ key ];
1560 | for ( i = 0; i < callbacks.length; i++ ) {
1561 | callbacks[ i ].call( scope, args );
1562 | }
1563 | }
1564 | }
1565 |
1566 | // Test for equality any JavaScript type.
1567 | // Author: Philippe Rathé
1568 | QUnit.equiv = (function() {
1569 |
1570 | // Call the o related callback with the given arguments.
1571 | function bindCallbacks( o, callbacks, args ) {
1572 | var prop = QUnit.objectType( o );
1573 | if ( prop ) {
1574 | if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
1575 | return callbacks[ prop ].apply( callbacks, args );
1576 | } else {
1577 | return callbacks[ prop ]; // or undefined
1578 | }
1579 | }
1580 | }
1581 |
1582 | // the real equiv function
1583 | var innerEquiv,
1584 | // stack to decide between skip/abort functions
1585 | callers = [],
1586 | // stack to avoiding loops from circular referencing
1587 | parents = [],
1588 |
1589 | getProto = Object.getPrototypeOf || function ( obj ) {
1590 | return obj.__proto__;
1591 | },
1592 | callbacks = (function () {
1593 |
1594 | // for string, boolean, number and null
1595 | function useStrictEquality( b, a ) {
1596 | /*jshint eqeqeq:false */
1597 | if ( b instanceof a.constructor || a instanceof b.constructor ) {
1598 | // to catch short annotaion VS 'new' annotation of a
1599 | // declaration
1600 | // e.g. var i = 1;
1601 | // var j = new Number(1);
1602 | return a == b;
1603 | } else {
1604 | return a === b;
1605 | }
1606 | }
1607 |
1608 | return {
1609 | "string": useStrictEquality,
1610 | "boolean": useStrictEquality,
1611 | "number": useStrictEquality,
1612 | "null": useStrictEquality,
1613 | "undefined": useStrictEquality,
1614 |
1615 | "nan": function( b ) {
1616 | return isNaN( b );
1617 | },
1618 |
1619 | "date": function( b, a ) {
1620 | return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
1621 | },
1622 |
1623 | "regexp": function( b, a ) {
1624 | return QUnit.objectType( b ) === "regexp" &&
1625 | // the regex itself
1626 | a.source === b.source &&
1627 | // and its modifers
1628 | a.global === b.global &&
1629 | // (gmi) ...
1630 | a.ignoreCase === b.ignoreCase &&
1631 | a.multiline === b.multiline &&
1632 | a.sticky === b.sticky;
1633 | },
1634 |
1635 | // - skip when the property is a method of an instance (OOP)
1636 | // - abort otherwise,
1637 | // initial === would have catch identical references anyway
1638 | "function": function() {
1639 | var caller = callers[callers.length - 1];
1640 | return caller !== Object && typeof caller !== "undefined";
1641 | },
1642 |
1643 | "array": function( b, a ) {
1644 | var i, j, len, loop;
1645 |
1646 | // b could be an object literal here
1647 | if ( QUnit.objectType( b ) !== "array" ) {
1648 | return false;
1649 | }
1650 |
1651 | len = a.length;
1652 | if ( len !== b.length ) {
1653 | // safe and faster
1654 | return false;
1655 | }
1656 |
1657 | // track reference to avoid circular references
1658 | parents.push( a );
1659 | for ( i = 0; i < len; i++ ) {
1660 | loop = false;
1661 | for ( j = 0; j < parents.length; j++ ) {
1662 | if ( parents[j] === a[i] ) {
1663 | loop = true;// dont rewalk array
1664 | }
1665 | }
1666 | if ( !loop && !innerEquiv(a[i], b[i]) ) {
1667 | parents.pop();
1668 | return false;
1669 | }
1670 | }
1671 | parents.pop();
1672 | return true;
1673 | },
1674 |
1675 | "object": function( b, a ) {
1676 | var i, j, loop,
1677 | // Default to true
1678 | eq = true,
1679 | aProperties = [],
1680 | bProperties = [];
1681 |
1682 | // comparing constructors is more strict than using
1683 | // instanceof
1684 | if ( a.constructor !== b.constructor ) {
1685 | // Allow objects with no prototype to be equivalent to
1686 | // objects with Object as their constructor.
1687 | if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
1688 | ( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
1689 | return false;
1690 | }
1691 | }
1692 |
1693 | // stack constructor before traversing properties
1694 | callers.push( a.constructor );
1695 | // track reference to avoid circular references
1696 | parents.push( a );
1697 |
1698 | for ( i in a ) { // be strict: don't ensures hasOwnProperty
1699 | // and go deep
1700 | loop = false;
1701 | for ( j = 0; j < parents.length; j++ ) {
1702 | if ( parents[j] === a[i] ) {
1703 | // don't go down the same path twice
1704 | loop = true;
1705 | }
1706 | }
1707 | aProperties.push(i); // collect a's properties
1708 |
1709 | if (!loop && !innerEquiv( a[i], b[i] ) ) {
1710 | eq = false;
1711 | break;
1712 | }
1713 | }
1714 |
1715 | callers.pop(); // unstack, we are done
1716 | parents.pop();
1717 |
1718 | for ( i in b ) {
1719 | bProperties.push( i ); // collect b's properties
1720 | }
1721 |
1722 | // Ensures identical properties name
1723 | return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
1724 | }
1725 | };
1726 | }());
1727 |
1728 | innerEquiv = function() { // can take multiple arguments
1729 | var args = [].slice.apply( arguments );
1730 | if ( args.length < 2 ) {
1731 | return true; // end transition
1732 | }
1733 |
1734 | return (function( a, b ) {
1735 | if ( a === b ) {
1736 | return true; // catch the most you can
1737 | } else if ( a === null || b === null || typeof a === "undefined" ||
1738 | typeof b === "undefined" ||
1739 | QUnit.objectType(a) !== QUnit.objectType(b) ) {
1740 | return false; // don't lose time with error prone cases
1741 | } else {
1742 | return bindCallbacks(a, callbacks, [ b, a ]);
1743 | }
1744 |
1745 | // apply transition with (1..n) arguments
1746 | }( args[0], args[1] ) && arguments.callee.apply( this, args.splice(1, args.length - 1 )) );
1747 | };
1748 |
1749 | return innerEquiv;
1750 | }());
1751 |
1752 | /**
1753 | * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
1754 | * http://flesler.blogspot.com Licensed under BSD
1755 | * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
1756 | *
1757 | * @projectDescription Advanced and extensible data dumping for Javascript.
1758 | * @version 1.0.0
1759 | * @author Ariel Flesler
1760 | * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
1761 | */
1762 | QUnit.jsDump = (function() {
1763 | function quote( str ) {
1764 | return '"' + str.toString().replace( /"/g, '\\"' ) + '"';
1765 | }
1766 | function literal( o ) {
1767 | return o + "";
1768 | }
1769 | function join( pre, arr, post ) {
1770 | var s = jsDump.separator(),
1771 | base = jsDump.indent(),
1772 | inner = jsDump.indent(1);
1773 | if ( arr.join ) {
1774 | arr = arr.join( "," + s + inner );
1775 | }
1776 | if ( !arr ) {
1777 | return pre + post;
1778 | }
1779 | return [ pre, inner + arr, base + post ].join(s);
1780 | }
1781 | function array( arr, stack ) {
1782 | var i = arr.length, ret = new Array(i);
1783 | this.up();
1784 | while ( i-- ) {
1785 | ret[i] = this.parse( arr[i] , undefined , stack);
1786 | }
1787 | this.down();
1788 | return join( "[", ret, "]" );
1789 | }
1790 |
1791 | var reName = /^function (\w+)/,
1792 | jsDump = {
1793 | // type is used mostly internally, you can fix a (custom)type in advance
1794 | parse: function( obj, type, stack ) {
1795 | stack = stack || [ ];
1796 | var inStack, res,
1797 | parser = this.parsers[ type || this.typeOf(obj) ];
1798 |
1799 | type = typeof parser;
1800 | inStack = inArray( obj, stack );
1801 |
1802 | if ( inStack !== -1 ) {
1803 | return "recursion(" + (inStack - stack.length) + ")";
1804 | }
1805 | if ( type === "function" ) {
1806 | stack.push( obj );
1807 | res = parser.call( this, obj, stack );
1808 | stack.pop();
1809 | return res;
1810 | }
1811 | return ( type === "string" ) ? parser : this.parsers.error;
1812 | },
1813 | typeOf: function( obj ) {
1814 | var type;
1815 | if ( obj === null ) {
1816 | type = "null";
1817 | } else if ( typeof obj === "undefined" ) {
1818 | type = "undefined";
1819 | } else if ( QUnit.is( "regexp", obj) ) {
1820 | type = "regexp";
1821 | } else if ( QUnit.is( "date", obj) ) {
1822 | type = "date";
1823 | } else if ( QUnit.is( "function", obj) ) {
1824 | type = "function";
1825 | } else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
1826 | type = "window";
1827 | } else if ( obj.nodeType === 9 ) {
1828 | type = "document";
1829 | } else if ( obj.nodeType ) {
1830 | type = "node";
1831 | } else if (
1832 | // native arrays
1833 | toString.call( obj ) === "[object Array]" ||
1834 | // NodeList objects
1835 | ( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
1836 | ) {
1837 | type = "array";
1838 | } else if ( obj.constructor === Error.prototype.constructor ) {
1839 | type = "error";
1840 | } else {
1841 | type = typeof obj;
1842 | }
1843 | return type;
1844 | },
1845 | separator: function() {
1846 | return this.multiline ? this.HTML ? "brown fox jumped jumps over"
2010 | */
2011 | QUnit.diff = (function() {
2012 | /*jshint eqeqeq:false, eqnull:true */
2013 | function diff( o, n ) {
2014 | var i,
2015 | ns = {},
2016 | os = {};
2017 |
2018 | for ( i = 0; i < n.length; i++ ) {
2019 | if ( !hasOwn.call( ns, n[i] ) ) {
2020 | ns[ n[i] ] = {
2021 | rows: [],
2022 | o: null
2023 | };
2024 | }
2025 | ns[ n[i] ].rows.push( i );
2026 | }
2027 |
2028 | for ( i = 0; i < o.length; i++ ) {
2029 | if ( !hasOwn.call( os, o[i] ) ) {
2030 | os[ o[i] ] = {
2031 | rows: [],
2032 | n: null
2033 | };
2034 | }
2035 | os[ o[i] ].rows.push( i );
2036 | }
2037 |
2038 | for ( i in ns ) {
2039 | if ( !hasOwn.call( ns, i ) ) {
2040 | continue;
2041 | }
2042 | if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
2043 | n[ ns[i].rows[0] ] = {
2044 | text: n[ ns[i].rows[0] ],
2045 | row: os[i].rows[0]
2046 | };
2047 | o[ os[i].rows[0] ] = {
2048 | text: o[ os[i].rows[0] ],
2049 | row: ns[i].rows[0]
2050 | };
2051 | }
2052 | }
2053 |
2054 | for ( i = 0; i < n.length - 1; i++ ) {
2055 | if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
2056 | n[ i + 1 ] == o[ n[i].row + 1 ] ) {
2057 |
2058 | n[ i + 1 ] = {
2059 | text: n[ i + 1 ],
2060 | row: n[i].row + 1
2061 | };
2062 | o[ n[i].row + 1 ] = {
2063 | text: o[ n[i].row + 1 ],
2064 | row: i + 1
2065 | };
2066 | }
2067 | }
2068 |
2069 | for ( i = n.length - 1; i > 0; i-- ) {
2070 | if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
2071 | n[ i - 1 ] == o[ n[i].row - 1 ]) {
2072 |
2073 | n[ i - 1 ] = {
2074 | text: n[ i - 1 ],
2075 | row: n[i].row - 1
2076 | };
2077 | o[ n[i].row - 1 ] = {
2078 | text: o[ n[i].row - 1 ],
2079 | row: i - 1
2080 | };
2081 | }
2082 | }
2083 |
2084 | return {
2085 | o: o,
2086 | n: n
2087 | };
2088 | }
2089 |
2090 | return function( o, n ) {
2091 | o = o.replace( /\s+$/, "" );
2092 | n = n.replace( /\s+$/, "" );
2093 |
2094 | var i, pre,
2095 | str = "",
2096 | out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
2097 | oSpace = o.match(/\s+/g),
2098 | nSpace = n.match(/\s+/g);
2099 |
2100 | if ( oSpace == null ) {
2101 | oSpace = [ " " ];
2102 | }
2103 | else {
2104 | oSpace.push( " " );
2105 | }
2106 |
2107 | if ( nSpace == null ) {
2108 | nSpace = [ " " ];
2109 | }
2110 | else {
2111 | nSpace.push( " " );
2112 | }
2113 |
2114 | if ( out.n.length === 0 ) {
2115 | for ( i = 0; i < out.o.length; i++ ) {
2116 | str += "" + out.o[i] + oSpace[i] + "";
2117 | }
2118 | }
2119 | else {
2120 | if ( out.n[0].text == null ) {
2121 | for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
2122 | str += "" + out.o[n] + oSpace[n] + "";
2123 | }
2124 | }
2125 |
2126 | for ( i = 0; i < out.n.length; i++ ) {
2127 | if (out.n[i].text == null) {
2128 | str += "" + out.n[i] + nSpace[i] + " ";
2129 | }
2130 | else {
2131 | // `pre` initialized at top of scope
2132 | pre = "";
2133 |
2134 | for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
2135 | pre += "" + out.o[n] + oSpace[n] + "";
2136 | }
2137 | str += " " + out.n[i].text + nSpace[i] + pre;
2138 | }
2139 | }
2140 | }
2141 |
2142 | return str;
2143 | };
2144 | }());
2145 |
2146 | // for CommonJS enviroments, export everything
2147 | if ( typeof exports !== "undefined" ) {
2148 | extend( exports, QUnit );
2149 | }
2150 |
2151 | // get at whatever the global object is, like window in browsers
2152 | }( (function() {return this;}.call()) ));
--------------------------------------------------------------------------------
/test/murmurhash3_128-test.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2013 Aggregate Knowledge, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | // Unit and data tests for murmurhash3_128.js
18 |
19 | // *****************************************************************************
20 | // canned data (processed via the Guava Java (Murmur3_128HashFunction) version)
21 | // for sanity. The Java calls are provided for reference.
22 | test("murmur3.hash128", function() {
23 | // .. empty ................................................................
24 | // Java (Guava):
25 | // final int seed = 0;
26 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
27 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
28 | // .hash();
29 | // System.err.println(hashCode.asLong());
30 | (function() {
31 | var seed = 0;
32 | var rawKey = new ArrayBuffer(0);
33 | var hashed = murmur3.hash128(rawKey, seed);
34 | ok((new goog.math.Long.fromString("0")).equals(hashed));
35 | })();
36 | (function() {
37 | var hashed = murmur3.hash128(/*no parameters = use defaults*/);
38 | ok((new goog.math.Long.fromString("0")).equals(hashed));
39 | })();
40 |
41 | // .. byte .................................................................
42 | // Java (Guava):
43 | // final int seed = 0;
44 | // final byte[] bytes = { (byte)0x00 };
45 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
46 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
47 | // .putBytes(bytes)
48 | // .hash();
49 | // System.err.println(hashCode.asLong());
50 | (function() {
51 | var seed = 0;
52 | var rawKey = new ArrayBuffer(1);
53 | var byteView = new Int8Array(rawKey);
54 | byteView[0] = 0x00;
55 | var hashed = murmur3.hash128(rawKey, seed);
56 | ok((new goog.math.Long.fromString("5048724184180415669")).equals(hashed));
57 | })();
58 | // Java (Guava):
59 | // final int seed = 0;
60 | // final byte[] bytes = { (byte)0xDE };
61 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
62 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
63 | // .putBytes(bytes)
64 | // .hash();
65 | // System.err.println(hashCode.asLong());
66 | (function() {
67 | var seed = 0;
68 | var rawKey = new ArrayBuffer(1);
69 | var byteView = new Int8Array(rawKey);
70 | byteView[0] = 0xDE/*'signed'*/;
71 | var hashed = murmur3.hash128(rawKey, seed);
72 | ok((new goog.math.Long.fromString("839819032933588501")).equals(hashed));
73 | })();
74 |
75 | // .. int ..................................................................
76 | // Java (Guava):
77 | // final int seed = 0;
78 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
79 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
80 | // .putInt(0xDE)
81 | // .hash();
82 | // System.err.println(hashCode.asLong());
83 | (function() {
84 | var seed = 0;
85 | var rawKey = new ArrayBuffer(4);
86 | var intView = new Int32Array(rawKey);
87 | intView[0] = 0xDE;
88 | var hashed = murmur3.hash128(rawKey, seed);
89 | ok((new goog.math.Long.fromString("-3146645291160985385")).equals(hashed));
90 | })();
91 | // Java (Guava):
92 | // final int seed = 0;
93 | // final byte[] bytes = { (byte)0xDE, (byte)0x00, (byte)0x00, (byte)0x00 };
94 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
95 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
96 | // .putBytes(bytes)
97 | // .hash();
98 | // System.err.println(hashCode.asLong());
99 | (function() {
100 | var seed = 0;
101 | var rawKey = new ArrayBuffer(4);
102 | var byteView = new Int8Array(rawKey);
103 | byteView[0] = 0xDE/*'signed'*/;
104 | byteView[1] = 0x00;
105 | byteView[2] = 0x00;
106 | byteView[3] = 0x00;
107 | var hashed = murmur3.hash128(rawKey, seed);
108 | ok((new goog.math.Long.fromString("-3146645291160985385")).equals(hashed));
109 | })();
110 |
111 | // .. int ..................................................................
112 | // Java (Guava):
113 | // final int seed = 0;
114 | // final byte[] bytes = { (byte)0xDE, (byte)0xAD, (byte)0xBE, (byte)0xEF };
115 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
116 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
117 | // .putBytes(bytes)
118 | // .hash();
119 | // System.err.println(hashCode.asLong());
120 | (function() {
121 | var seed = 0;
122 | var rawKey = new ArrayBuffer(4);
123 | var byteView = new Int8Array(rawKey);
124 | byteView[0] = 0xDE;
125 | byteView[1] = 0xAD;
126 | byteView[2] = 0xBE;
127 | byteView[3] = 0xEF;
128 | var hashed = murmur3.hash128(rawKey, seed);
129 | ok((new goog.math.Long.fromString("6487796989963411242")).equals(hashed));
130 | })();
131 | // Java (Guava):
132 | // final int seed = 0;
133 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
134 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
135 | // .putInt(0xEFBEADDE/*little endian*/)
136 | // .hash();
137 | // System.err.println(hashCode.asLong());
138 | (function() {
139 | var seed = 0;
140 | var rawKey = new ArrayBuffer(4);
141 | var intView = new Int32Array(rawKey);
142 | intView[0] = 0xEFBEADDE/*little endian*/;
143 | var hashed = murmur3.hash128(rawKey, seed);
144 | ok((new goog.math.Long.fromString("6487796989963411242")).equals(hashed));
145 | })();
146 | // Java (Guava):
147 | // final int seed = 0;
148 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
149 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
150 | // .putInt(0xDEADBEEF/*big endian*/)
151 | // .hash();
152 | // System.err.println(hashCode.asLong());
153 | (function() {
154 | var seed = 0;
155 | var rawKey = new ArrayBuffer(4);
156 | var intView = new Int32Array(rawKey);
157 | intView[0] = 0xDEADBEEF/*big endian*/;
158 | var hashed = murmur3.hash128(rawKey, seed);
159 | ok((new goog.math.Long.fromString("8603483835171163158")).equals(hashed));
160 | })();
161 |
162 | // .. long .................................................................
163 | // Java (Guava):
164 | // final int seed = 0;
165 | // final byte[] bytes = { (byte)0xDE, (byte)0xAD, (byte)0xBE, (byte)0xEF,
166 | // (byte)0xFE, (byte)0xED, (byte)0xFA, (byte)0xCE };
167 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
168 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
169 | // .putBytes(bytes)
170 | // .hash();
171 | // System.err.println(hashCode.asLong());
172 | (function() {
173 | var seed = 0;
174 | var rawKey = new ArrayBuffer(8);
175 | var byteView = new Int8Array(rawKey);
176 | byteView[0] = 0xDE; byteView[1] = 0xAD; byteView[2] = 0xBE; byteView[3] = 0xEF;
177 | byteView[4] = 0xFE; byteView[5] = 0xED; byteView[6] = 0xFA; byteView[7] = 0xCE;
178 | var hashed = murmur3.hash128(rawKey, seed);
179 | ok((new goog.math.Long.fromString("-4440616832553550142")).equals(hashed));
180 | })();
181 | // Java (Guava):
182 | // final int seed = 0;
183 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
184 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
185 | // .putInt(0xEFBEADDE/*little endian*/)
186 | // .putInt(0xCEFAEDFE/*little endian*/)
187 | // .hash();
188 | // System.err.println(hashCode.asLong());
189 | // Equivalent to:
190 | // final int seed = 0;
191 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
192 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
193 | // .putLong(0xCEFAEDFEEFBEADDEL/*little endian*/)
194 | // .hash();
195 | // System.err.println(hashCode.asLong());
196 | (function() {
197 | var seed = 0;
198 | var rawKey = new ArrayBuffer(8);
199 | var intView = new Int32Array(rawKey);
200 | intView[0] = 0xEFBEADDE/*little endian*/;
201 | intView[1] = 0xCEFAEDFE/*little endian*/;
202 | var hashed = murmur3.hash128(rawKey, seed);
203 | ok((new goog.math.Long.fromString("-4440616832553550142")).equals(hashed));
204 | })();
205 | // Java (Guava):
206 | // final int seed = 0;
207 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
208 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
209 | // .putInt(0xDEADBEEF/*big endian*/)
210 | // .putInt(0xFEEDFACE/*big endian*/)
211 | // .hash();
212 | // System.err.println(hashCode.asLong());
213 | // Equivalent to:
214 | // final int seed = 0;
215 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
216 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
217 | // .putLong(0xFEEDFACEDEADBEEFL/*big endian*/)
218 | // .hash();
219 | // System.err.println(hashCode.asLong());
220 | (function() {
221 | var seed = 0;
222 | var rawKey = new ArrayBuffer(8);
223 | var intView = new Int32Array(rawKey);
224 | intView[0] = 0xDEADBEEF/*big endian*/;
225 | intView[1] = 0xFEEDFACE/*big endian*/;
226 | var hashed = murmur3.hash128(rawKey, seed);
227 | ok((new goog.math.Long.fromString("8782020912388259033")).equals(hashed));
228 | })();
229 |
230 | // .. enough bytes to test blocking ........................................
231 | // NOTE: blocking occurs where there are at least 16 bytes
232 | // NOTE: an odd number of bytes are tested (>16) so that both blocking and
233 | // the remainder code paths are exercised
234 | // Java (Guava):
235 | // final int seed = 0;
236 | // final byte[] bytes = { (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04,
237 | // (byte)0x05, (byte)0x06, (byte)0x07, (byte)0x08,
238 | // (byte)0x09, (byte)0x0A, (byte)0x0B, (byte)0x0C,
239 | // (byte)0x0D, (byte)0x0E, (byte)0x0F, (byte)0x10,
240 | // (byte)0x11, (byte)0x12, (byte)0x13, (byte)0x14,
241 | // (byte)0x15, (byte)0x16, (byte)0x17, (byte)0x18,
242 | // (byte)0x19, (byte)0x1A, (byte)0x1B, (byte)0x1C,
243 | // (byte)0x1D, (byte)0x1E, (byte)0x1F, (byte)0x20,
244 | // (byte)0x21 }/*odd number of bytes*/;
245 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
246 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
247 | // .putBytes(bytes)
248 | // .hash();
249 | // System.err.println(hashCode.asLong());
250 | (function() {
251 | var seed = 0;
252 | var rawKey = new ArrayBuffer(33);
253 | var byteView = new Int8Array(rawKey);
254 | byteView[ 0] = 0x01; byteView[ 1] = 0x02; byteView[ 2] = 0x03; byteView[ 3] = 0x04;
255 | byteView[ 4] = 0x05; byteView[ 5] = 0x06; byteView[ 6] = 0x07; byteView[ 7] = 0x08;
256 | byteView[ 8] = 0x09; byteView[ 9] = 0x0A; byteView[10] = 0x0B; byteView[11] = 0x0C;
257 | byteView[12] = 0x0D; byteView[13] = 0x0E; byteView[14] = 0x0F; byteView[15] = 0x10;
258 | byteView[16] = 0x11; byteView[17] = 0x12; byteView[18] = 0x13; byteView[19] = 0x14;
259 | byteView[20] = 0x15; byteView[21] = 0x16; byteView[22] = 0x17; byteView[23] = 0x18;
260 | byteView[24] = 0x19; byteView[25] = 0x1A; byteView[26] = 0x1B; byteView[27] = 0x1C;
261 | byteView[28] = 0x1D; byteView[29] = 0x1E; byteView[30] = 0x1F; byteView[31] = 0x20;
262 | byteView[32] = 0x21;
263 | var hashed = murmur3.hash128(rawKey, seed);
264 | ok((new goog.math.Long.fromString("-7031486286803411836")).equals(hashed));
265 | })();
266 |
267 | // non-zero seed (for sanity)
268 | // Java (Guava):
269 | // final int seed = 1234567;
270 | // final byte[] bytes = { (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04,
271 | // (byte)0x05, (byte)0x06, (byte)0x07, (byte)0x08,
272 | // (byte)0x09, (byte)0x0A, (byte)0x0B, (byte)0x0C,
273 | // (byte)0x0D, (byte)0x0E, (byte)0x0F, (byte)0x10,
274 | // (byte)0x11, (byte)0x12, (byte)0x13, (byte)0x14,
275 | // (byte)0x15, (byte)0x16, (byte)0x17, (byte)0x18,
276 | // (byte)0x19, (byte)0x1A, (byte)0x1B, (byte)0x1C,
277 | // (byte)0x1D, (byte)0x1E, (byte)0x1F, (byte)0x20,
278 | // (byte)0x21 }/*odd number of bytes*/;
279 | // com.google.common.hash.HashFunction hashFunction = com.google.common.hash.Hashing.murmur3_128(seed);
280 | // com.google.common.hash.HashCode hashCode = hashFunction.newHasher()
281 | // .putBytes(bytes)
282 | // .hash();
283 | // System.err.println(hashCode.asLong());
284 | (function() {
285 | var seed = 1234567;
286 | var rawKey = new ArrayBuffer(33);
287 | var byteView = new Int8Array(rawKey);
288 | byteView[ 0] = 0x01; byteView[ 1] = 0x02; byteView[ 2] = 0x03; byteView[ 3] = 0x04;
289 | byteView[ 4] = 0x05; byteView[ 5] = 0x06; byteView[ 6] = 0x07; byteView[ 7] = 0x08;
290 | byteView[ 8] = 0x09; byteView[ 9] = 0x0A; byteView[10] = 0x0B; byteView[11] = 0x0C;
291 | byteView[12] = 0x0D; byteView[13] = 0x0E; byteView[14] = 0x0F; byteView[15] = 0x10;
292 | byteView[16] = 0x11; byteView[17] = 0x12; byteView[18] = 0x13; byteView[19] = 0x14;
293 | byteView[20] = 0x15; byteView[21] = 0x16; byteView[22] = 0x17; byteView[23] = 0x18;
294 | byteView[24] = 0x19; byteView[25] = 0x1A; byteView[26] = 0x1B; byteView[27] = 0x1C;
295 | byteView[28] = 0x1D; byteView[29] = 0x1E; byteView[30] = 0x1F; byteView[31] = 0x20;
296 | byteView[32] = 0x21;
297 | var hashed = murmur3.hash128(rawKey, seed);
298 | ok((new goog.math.Long.fromString("863881327554208428")).equals(hashed));
299 | })();
300 | });
301 |
302 | //==============================================================================
303 | // file-based data
304 | asyncTest("murmur3.hash128", function() {
305 | d3.text("data/murmur_bigint.csv", function(error, text) {
306 | if(error)
307 | ok(false/*failed*/, error);
308 | else /*no error*/
309 | assertHash128(text);
310 |
311 | start()/*allow qunit to continue*/;
312 | });
313 | });
314 |
315 | // -----------------------------------------------------------------------------
316 | // parses and asserts that the parsed seed and value matches that of the
317 | // {@link #hash128() hashed} result
318 | function assertHash128(text) {
319 | var csv = text.split("\n");
320 | csv = csv.map(function(line) { return line.split(","); });
321 | for(var i=1/*skip the file header*/; i
2 |
3 |
4 |
19 | Murmur3 Unit Tests
21 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
34 |
35 |
36 |
37 |
38 |
--------------------------------------------------------------------------------