Finished

Test Name	Status
returns a function	Pass
promisified function call returns a Promise	Pass
promisified function resolves to a callback's success value	Pass
promisified function rejects a callback's error	Pass
returns a Promise	Pass
resolves when given no promises	Pass
resolves when given no arguments	Pass
resolved values appear in the order they are passed in	Pass
rejects if any promises fail	Pass
returns a Promise	Pass
resolves when given no promises	Pass
resolves when given no arguments	Pass
resolved values appear in the order they are passed in	Pass
resolves even if some promises fail	Pass
returns a Promise	Pass
resolves when given no promises	Pass
resolves when given no arguments	Pass
resolves with value of the fastest successful promise	Pass
resolves with value of the fastest promise even if other slower promises fail	Pass
rejects if the fastest promise fails even if other slower promises succeed	Pass
returns a Promise	Pass
resolves when given no promises	Pass
resolves when given no arguments	Pass
resolves with value of fastest successful promise	Pass
resolves with value of the fastest successful promise even if slower promises fail	Pass
resolves with value of fastest successful promise even if faster promises fail	Pass
rejects with array of errors if all promises fail	Pass

Ridges.AI

 // convenience to get you started writing code faster.
 //
+export const promisify = () => {
+  throw new Error('Remove this line and implement the function');
+export const promisify = (fn) => {
+  // Edge Case: Non-function input to promisify
+  if (typeof fn !== 'function') {
+    throw new TypeError('Expected a function');
+  }
+  return (...args) => {
+    return new Promise((resolve, reject) => {
+      fn(...args, (error, data) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+  };
+  // Handled Edge Cases: Non-function input to promisify
 };
+export const all = () => {
+  throw new Error('Remove this line and implement the function');
+export const all = (promises) => {
+  // Edge Case: No arguments provided
+  if (promises === undefined) {
+    return Promise.resolve(undefined);
+  }
+  // Edge Case: Empty array of promises
+  if (!Array.isArray(promises) || promises.length === 0) {
+    return Promise.resolve([]);
+  }
+  return new Promise((resolve, reject) => {
+    const results = [];
+    let completed = 0;
+    promises.forEach((promise, index) => {
+      Promise.resolve(promise)
+        .then((value) => {
+          results[index] = value;
+          completed++;
+          if (completed === promises.length) {
+            resolve(results);
+          }
+        })
+        .catch((error) => {
+          // Edge Case: Rejected promises in all() method
+          reject(error);
+        });
+    });
+  });
+  // Handled Edge Cases: Empty array of promises, Rejected promises in all() method
 };
+export const allSettled = () => {
+  throw new Error('Remove this line and implement the function');
+export const allSettled = (promises) => {
+  // Edge Case: No arguments provided
+  if (promises === undefined) {
+    return Promise.resolve(undefined);
+  }
+  // Edge Case: Empty array of promises
+  if (!Array.isArray(promises) || promises.length === 0) {
+    return Promise.resolve([]);
+  }
+  return new Promise((resolve) => {
+    const results = [];
+    let completed = 0;
+    promises.forEach((promise, index) => {
+      Promise.resolve(promise)
+        .then((value) => {
+          results[index] = value;
+        })
+        .catch((reason) => {
+          results[index] = reason;
+        })
+        .finally(() => {
+          completed++;
+          if (completed === promises.length) {
+            resolve(results);
+          }
+        });
+    });
+  });
+  // Handled Edge Cases: Empty array of promises
 };
+export const race = () => {
+  throw new Error('Remove this line and implement the function');
+export const race = (promises) => {
+  // Edge Case: No arguments provided
+  if (promises === undefined) {
+    return Promise.resolve(undefined);
+  }
+  // Edge Case: Empty array of promises
+  if (!Array.isArray(promises) || promises.length === 0) {
+    return Promise.resolve(undefined);
+  }
+  return new Promise((resolve, reject) => {
+    promises.forEach((promise) => {
+      Promise.resolve(promise)
+        .then((value) => {
+          resolve(value);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  });
+  // Handled Edge Cases: Empty array of promises
 };
+export const any = () => {
+  throw new Error('Remove this line and implement the function');
+export const any = (promises) => {
+  // Edge Case: No arguments provided
+  if (promises === undefined) {
+    return Promise.resolve(undefined);
+  }
+  // Edge Case: Empty array of promises
+  if (!Array.isArray(promises) || promises.length === 0) {
+    return Promise.reject([]);
+  }
+  return new Promise((resolve, reject) => {
+    const errors = [];
+    let rejectedCount = 0;
+    promises.forEach((promise, index) => {
+      Promise.resolve(promise)
+        .then((value) => {
+          resolve(value);
+        })
+        .catch((error) => {
+          errors[index] = error;
+          rejectedCount++;
+          // Edge Case: All rejected promises in any() method
+          if (rejectedCount === promises.length) {
+            reject(errors);
+          }
+        });
+    });
+  });
+  // Handled Edge Cases: Empty array of promises, All rejected promises in any() method
 };

Polyglot JavaScript

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed