Version 1

[yaffs-website] / node_modules / kew / test / closure_test.js

diff --git a/node_modules/kew/test/closure_test.js b/node_modules/kew/test/closure_test.js
new file mode 100644 (file)
index 0000000..624e439
--- /dev/null
+++ b/node_modules/kew/test/closure_test.js
@@ -0,0 +1,135 @@
+/**
+ * @fileoverview A sample file to test type-checking
+ */
+
+var kew = require('../kew')
+var Promise = kew.Promise
+var all = kew.all
+var allSettled = kew.allSettled
+var fcall = kew.fcall
+var nfcall = kew.nfcall
+var bindPromise = kew.bindPromise
+
+/**
+@param {Array} result
+*/
+var callback = function (result) {};
+
+/**
+@param {Array} result
+@param {Array} context
+*/
+var callbackWithContext = function (result, context) {};
+
+/**
+ * @param {number} n
+ * @param {*} result
+ */
+var callbackNeedsBind = function (n, result) {};
+
+/**
+@param {Error} error
+*/
+var errorCallback = function (error) {};
+
+/**
+@param {Error} error
+@param {Array} context
+*/
+var errorCallbackWithContext = function (error, context) {};
+
+/** @return {kew.Promise.<string>} */
+var stringPromise = function () {
+  return kew.resolve('string')
+}
+
+var exampleThen = function () {
+  var examplePromise = new Promise();
+  examplePromise.then(callback);
+  examplePromise.setContext([]);
+  examplePromise.then(callbackWithContext);
+
+  examplePromise.then(null, errorCallback);
+  examplePromise.then(null, errorCallbackWithContext);
+};
+
+
+var thenBound = function () {
+  stringPromise().thenBound(callbackNeedsBind, null, 3).failBound(callbackNeedsBind, null, 3);
+};
+
+var examplePromise = function () {
+  var promise = new Promise(callback);
+  promise = new Promise(callbackWithContext);
+  promise = new Promise(null, errorCallback);
+  promise = new Promise(null, errorCallbackWithContext);
+};
+
+var exampleFail = function () {
+  var promise = new Promise();
+  promise.fail(errorCallback);
+  promise.fail(errorCallbackWithContext);
+};
+
+var exampleResolver = function () {
+  var promise = new Promise();
+  var resolver = promise.makeNodeResolver();
+  // success
+  resolver(null, {});
+  // failure
+  resolver(new Error(), null);
+};
+
+var exampleAll = function () {
+  // should not compile, but does
+  all([5]);
+  all([{}]);
+  all([null]);
+  all([new Promise(), {}]);
+  all([new Promise(), null]);
+
+  // good
+  var promise = all([]);
+  all([new Promise(), new Promise()]);
+};
+
+var exampleAllSettled = function () {
+  allSettled([]);
+  allSettled([5, {}, null, 'string']);
+  var promise = allSettled([new Promise()]);
+  promise.then(function(results){});
+};
+
+var exampleTimeout = function () {
+  var promise = new Promise();
+  var timeoutPromise = promise.timeout(50);
+  timeoutPromise.then(function(result){});
+};
+
+var noArgsFunction = function () {};
+
+var exampleFcall = function () {
+  fcall(noArgsFunction);
+  fcall(callback, []);
+  fcall(callbackWithContext, [], 5);
+};
+
+/** @param {function(Error, *)} nodeCallback */
+var noArgsWithNodeCallback = function (nodeCallback) {};
+
+/**
+@param {!Array} argument
+@param {function(Error, *)} nodeCallback
+*/
+var oneArgWithNodeCallback = function (argument, nodeCallback) {};
+
+var exampleNfcall = function () {
+  var promise = nfcall(noArgsWithNodeCallback);
+  promise = nfcall(oneArgWithNodeCallback, []);
+};
+
+var exampleBindPromise = function () {
+  callback = bindPromise(noArgsWithNodeCallback, null);
+  callback = bindPromise(noArgsWithNodeCallback, {});
+  callback = bindPromise(oneArgWithNodeCallback, null, []);
+};