Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/object.values/test/.eslintrc b/node_modules/object.values/test/.eslintrc
new file mode 100644
index 0000000..5562962
--- /dev/null
+++ b/node_modules/object.values/test/.eslintrc
@@ -0,0 +1,11 @@
+{
+ "rules": {
+ "array-bracket-newline": 0,
+ "max-lines-per-function": 0,
+ "max-nested-callbacks": [2, 3],
+ "max-statements": [2, 12],
+ "max-statements-per-line": [2, { "max": 2 }],
+ "no-invalid-this": [1],
+ "object-curly-newline": 0,
+ }
+}
diff --git a/node_modules/object.values/test/implementation.js b/node_modules/object.values/test/implementation.js
new file mode 100644
index 0000000..e3a1e46
--- /dev/null
+++ b/node_modules/object.values/test/implementation.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var implementation = require('../implementation');
+var callBind = require('call-bind');
+var test = require('tape');
+var hasStrictMode = require('has-strict-mode')();
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+ t.test('bad array/this value', { skip: !hasStrictMode }, function (st) {
+ /* eslint no-useless-call: 0 */
+ st['throws'](function () { implementation.call(undefined); }, TypeError, 'undefined is not an object');
+ st['throws'](function () { implementation.call(null); }, TypeError, 'null is not an object');
+ st.end();
+ });
+
+ runTests(callBind(implementation, Object), t);
+
+ t.end();
+});
diff --git a/node_modules/object.values/test/index.js b/node_modules/object.values/test/index.js
new file mode 100644
index 0000000..2c1bba5
--- /dev/null
+++ b/node_modules/object.values/test/index.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var values = require('../');
+var test = require('tape');
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+ t.test('bad array/this value', function (st) {
+ st['throws'](function () { values(undefined); }, TypeError, 'undefined is not an object');
+ st['throws'](function () { values(null); }, TypeError, 'null is not an object');
+ st.end();
+ });
+
+ runTests(values, t);
+
+ t.end();
+});
diff --git a/node_modules/object.values/test/shimmed.js b/node_modules/object.values/test/shimmed.js
new file mode 100644
index 0000000..c5db49b
--- /dev/null
+++ b/node_modules/object.values/test/shimmed.js
@@ -0,0 +1,36 @@
+'use strict';
+
+var values = require('../');
+values.shim();
+
+var test = require('tape');
+var defineProperties = require('define-properties');
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var functionsHaveNames = require('functions-have-names')();
+
+var runTests = require('./tests');
+
+test('shimmed', function (t) {
+ t.equal(Object.values.length, 1, 'Object.values has a length of 1');
+ t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+ st.equal(Object.values.name, 'values', 'Object.values has name "values"');
+ st.end();
+ });
+
+ t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+ et.equal(false, isEnumerable.call(Object, 'values'), 'Object.values is not enumerable');
+ et.end();
+ });
+
+ var supportsStrictMode = (function () { return typeof this === 'undefined'; }());
+
+ t.test('bad object value', { skip: !supportsStrictMode }, function (st) {
+ st['throws'](function () { return Object.values(undefined); }, TypeError, 'undefined is not an object');
+ st['throws'](function () { return Object.values(null); }, TypeError, 'null is not an object');
+ st.end();
+ });
+
+ runTests(Object.values, t);
+
+ t.end();
+});
diff --git a/node_modules/object.values/test/tests.js b/node_modules/object.values/test/tests.js
new file mode 100644
index 0000000..6055983
--- /dev/null
+++ b/node_modules/object.values/test/tests.js
@@ -0,0 +1,82 @@
+'use strict';
+
+var keys = require('object-keys');
+var map = require('array-map');
+var define = require('define-properties');
+
+var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
+
+module.exports = function (values, t) {
+ var a = {};
+ var b = {};
+ var c = {};
+ var obj = { a: a, b: b, c: c };
+
+ t.deepEqual(values(obj), [a, b, c], 'basic support');
+ t.deepEqual(values({ a: a, b: a, c: c }), [a, a, c], 'duplicate values are included');
+
+ t.test('values are in the same order as keys', function (st) {
+ var object = { a: a, b: b };
+ object[0] = 3;
+ object.c = c;
+ object[1] = 4;
+ delete object[0];
+ var objKeys = keys(object);
+ var objValues = map(objKeys, function (key) {
+ return object[key];
+ });
+ st.deepEqual(values(object), objValues, 'values match key order');
+ st.end();
+ });
+
+ t.test('non-enumerable properties are omitted', { skip: !Object.defineProperty }, function (st) {
+ var object = { a: a, b: b };
+ Object.defineProperty(object, 'c', { enumerable: false, value: c });
+ st.deepEqual(values(object), [a, b], 'non-enumerable property‘s value is omitted');
+ st.end();
+ });
+
+ t.test('inherited properties are omitted', function (st) {
+ var F = function G() {};
+ F.prototype.a = a;
+ var f = new F();
+ f.b = b;
+ st.deepEqual(values(f), [b], 'only own properties are included');
+ st.end();
+ });
+
+ t.test('Symbol properties are omitted', { skip: !hasSymbols }, function (st) {
+ var object = { a: a, b: b, c: c };
+ var enumSym = Symbol('enum');
+ var nonEnumSym = Symbol('non enum');
+ object[enumSym] = enumSym;
+ object.d = enumSym;
+ Object.defineProperty(object, nonEnumSym, { enumerable: false, value: nonEnumSym });
+ st.deepEqual(values(object), [a, b, c, enumSym], 'symbol properties are omitted');
+ st.end();
+ });
+
+ t.test('not-yet-visited keys deleted on [[Get]] must not show up in output', { skip: !define.supportsDescriptors }, function (st) {
+ var o = { a: 1, b: 2, c: 3 };
+ Object.defineProperty(o, 'a', {
+ get: function () {
+ delete this.b;
+ return 1;
+ }
+ });
+ st.deepEqual(values(o), [1, 3], 'when "b" is deleted prior to being visited, it should not show up');
+ st.end();
+ });
+
+ t.test('not-yet-visited keys made non-enumerable on [[Get]] must not show up in output', { skip: !define.supportsDescriptors }, function (st) {
+ var o = { a: 'A', b: 'B' };
+ Object.defineProperty(o, 'a', {
+ get: function () {
+ Object.defineProperty(o, 'b', { enumerable: false });
+ return 'A';
+ }
+ });
+ st.deepEqual(values(o), ['A'], 'when "b" is made non-enumerable prior to being visited, it should not show up');
+ st.end();
+ });
+};