Ridges.AI

Test Name	Status
sets with no elements are empty	Pass
sets with elements are not empty	Pass
nothing is contained in an empty set	Pass
when the element is in the set	Pass
when the element is not in the set	Pass
empty set is a subset of another empty set	Pass
empty set is a subset of non-empty set	Pass
non-empty set is not a subset of empty set	Pass
set is a subset of set with exact same elements	Pass
set is a subset of larger set with same elements	Pass
set is not a subset of set that does not contain its elements	Pass
the empty set is disjoint with itself	Pass
empty set is disjoint with non-empty set	Pass
non-empty set is disjoint with empty set	Pass
sets are not disjoint if they share an element	Pass
sets are disjoint if they share no elements	Pass
empty sets are equal	Pass
empty set is not equal to non-empty set	Pass
non-empty set is not equal to empty set	Pass
sets with the same elements are equal	Pass
sets with different elements are not equal	Pass
set is not equal to larger set with same elements	Pass
set is equal to a set constructed from an array with duplicates	Pass
add to empty set	Pass
add to non-empty set	Pass
adding an existing element does not change the set	Pass
intersection of two empty sets is an empty set	Pass
intersection of an empty set and non-empty set is an empty set	Pass
intersection of a non-empty set and an empty set is an empty set	Pass
intersection of two sets with no shared elements is an empty set	Pass
intersection of two sets with shared elements is a set of the shared elements	Pass
difference of two empty sets is an empty set	Pass
difference of empty set and non-empty set is an empty set	Pass
difference of a non-empty set and an empty set is the non-empty set	Pass
difference of two non-empty sets is a set of elements that are only in the first set	Pass
difference removes all duplicates in the first set	Pass
union of empty sets is an empty set	Pass
union of an empty set and non-empty set is the non-empty set	Pass
union of a non-empty set and empty set is the non-empty set	Pass
union of non-empty sets contains all unique elements	Pass

    * @param {Array} data
    */
   constructor(data) {
+    throw new Error('Remove this line and implement the function');
+    this._elements = new Map();
+    this._primitiveElements = {};
+    if (data) {
+      for (const el of data) {
+        this.add(el);
+      }
+    }
+  }
   /**
    * @returns {boolean}
    */
   empty() {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Empty set
+    return this._elements.size === 0 && Object.keys(this._primitiveElements).length === 0;
+  }
   /**
    * @returns {boolean}
    */
   contains(el) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Check for element in empty set
+    if (el === null || el === undefined || typeof el !== 'object') {
+      return this._primitiveElements[el] === true;
+    } else {
+      return this._elements.has(el);
+    }
+  }
   /**
    * @returns {CustomSet}
    */
   add(el) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Adding duplicate elements
+    // Edge Case: Adding null or undefined values
+    if (el === null || el === undefined || typeof el !== 'object') {
+      this._primitiveElements[el] = true;
+    } else {
+      this._elements.set(el, true);
+    }
+    return this;
+  }
+  /**
+   * @param {*} el
+   * @returns {CustomSet}
+   */
+  delete(el) {
+    // Edge Case: Deleting non-existent element
+    if (el === null || el === undefined || typeof el !== 'object') {
+      delete this._primitiveElements[el];
+    } else {
+      this._elements.delete(el);
+    }
+    return this;
+  }
+  /**
+   * @returns {number}
+   */
+  size() {
+    return this._elements.size + Object.keys(this._primitiveElements).length;
+  }
   /**
    * @returns {boolean}
    */
   subset(other) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Empty set is subset of any set
+    // Edge Case: Comparing with empty set
+    // Check primitive elements
+    for (const el in this._primitiveElements) {
+      if (!other.contains(el)) {
+        return false;
+      }
+    }
+    // Check object elements
+    for (const el of this._elements.keys()) {
+      if (!other.contains(el)) {
+        return false;
+      }
+    }
+    return true;
+  }
   /**
    * @returns {boolean}
    */
   disjoint(other) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Two empty sets are disjoint
+    // Edge Case: One empty set and one non-empty set
+    // Check primitive elements
+    for (const el in this._primitiveElements) {
+      if (other.contains(el)) {
+        return false;
+      }
+    }
+    // Check object elements
+    for (const el of this._elements.keys()) {
+      if (other.contains(el)) {
+        return false;
+      }
+    }
+    return true;
+  }
   /**
    * @returns {boolean}
    */
   eql(other) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Two empty sets are equal
+    // Edge Case: Sets of different sizes
+    return this.subset(other) && other.subset(this);
+  }
   /**
    * @returns {CustomSet}
    */
   union(other) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Union with empty set
+    const result = new CustomSet();
+    // Add primitive elements from this set
+    for (const el in this._primitiveElements) {
+      result.add(el);
+    }
+    // Add object elements from this set
+    for (const el of this._elements.keys()) {
+      result.add(el);
+    }
+    // Add primitive elements from other set
+    for (const el in other._primitiveElements) {
+      result.add(el);
+    }
+    // Add object elements from other set
+    for (const el of other._elements.keys()) {
+      result.add(el);
+    }
+    return result;
+  }
   /**
    * @returns {CustomSet}
    */
   intersection(other) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Intersection with empty set results in empty set
+    // Edge Case: Intersection of two empty sets
+    const result = new CustomSet();
+    // Check primitive elements
+    for (const el in this._primitiveElements) {
+      if (other.contains(el)) {
+        result.add(el);
+      }
+    }
+    // Check object elements
+    for (const el of this._elements.keys()) {
+      if (other.contains(el)) {
+        result.add(el);
+      }
+    }
+    return result;
+  }
   /**
    * @returns {CustomSet}
    */
   difference(other) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Difference with empty set is the original set
+    // Edge Case: Difference of empty set with any set is empty set
+    const result = new CustomSet();
+    // Check primitive elements
+    for (const el in this._primitiveElements) {
+      if (!other.contains(el)) {
+        result.add(el);
+      }
+    }
+    // Check object elements
+    for (const el of this._elements.keys()) {
+      if (!other.contains(el)) {
+        result.add(el);
+      }
+    }
+    return result;
+  }
+}
+// Handled Edge Cases: Empty set operations, Duplicate element insertion, Null or undefined values, Set comparison with different sizes, Intersection/union with empty sets

Polyglot JavaScript - without test patch

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed