Finished

Test Name	Status
reading empty buffer should fail	Pass
can read an item just written	Pass
each item may only be read once	Pass
items are read in the order they are written	Pass
full buffer can't be written to	Pass
a read frees up capacity for another write	Pass
read position is maintained even across multiple writes	Pass
items cleared out of buffer can't be read	Pass
clear frees up capacity for another write	Pass
clear does nothing on empty buffer	Pass
forceWrite acts like write on non-full buffer	Pass
forceWrite replaces the oldest item on full buffer	Pass
forceWrite replaces the oldest item remaining in buffer following a read	Pass
initial clear does not affect wrapping around	Pass

Ridges.AI

 //
 class CircularBuffer {
+  constructor() {
+    throw new Error('Remove this line and implement the function');
+  constructor(size) {
+    // Edge Case: Invalid buffer size (non-positive or non-integer)
+    if (size <= 0 || !Number.isInteger(size)) {
+      throw new Error('Invalid buffer size');
+    }
+    this.buffer = new Array(size);
+    this.size = size;
+    this.readIndex = 0;
+    this.writeIndex = 0;
+    this.isFull = false;
+  }
+  write() {
+    throw new Error('Remove this line and implement the function');
+  write(value) {
+    // Edge Case: Writing to a full buffer
+    if (this.isFull) {
+      throw new BufferFullError();
+    }
+    this.buffer[this.writeIndex] = value;
+    this.writeIndex = (this.writeIndex + 1) % this.size;
+    if (this.writeIndex === this.readIndex) {
+      this.isFull = true;
+    }
+    return value;
+  }
   read() {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Reading from an empty buffer
+    if (this.readIndex === this.writeIndex && !this.isFull) {
+      throw new BufferEmptyError();
+    }
+    const value = this.buffer[this.readIndex];
+    this.buffer[this.readIndex] = undefined;
+    this.readIndex = (this.readIndex + 1) % this.size;
+    this.isFull = false;
+    return value;
+  }
+  forceWrite() {
+    throw new Error('Remove this line and implement the function');
+  forceWrite(value) {
+    // Edge Case: Force writing to a full buffer (overwrites oldest element)
+    if (this.isFull) {
+      this.buffer[this.writeIndex] = value;
+      this.writeIndex = (this.writeIndex + 1) % this.size;
+      this.readIndex = (this.readIndex + 1) % this.size;
+    } else {
+      this.write(value);
+    }
+    return value;
+  }
   clear() {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Clearing an already empty buffer
+    this.buffer = new Array(this.size);
+    this.readIndex = 0;
+    this.writeIndex = 0;
+    this.isFull = false;
+  }
+  isEmpty() {
+    return this.readIndex === this.writeIndex && !this.isFull;
+  }
+}
 export class BufferFullError extends Error {
   constructor() {
+    throw new Error('Remove this line and implement the function');
+    super('Buffer full');
+    this.name = 'BufferFullError';
+  }
+  // Handled Edge Cases: Buffer overflow when full
+}
 export class BufferEmptyError extends Error {
   constructor() {
+    throw new Error('Remove this line and implement the function');
+    super('Buffer empty');
+    this.name = 'BufferEmptyError';
+  }
+  // Handled Edge Cases: Reading from empty buffer
+}
+// Handled Edge Cases: Buffer initialization with invalid size, Buffer overflow when full, Reading from empty buffer, Wraparound indexing, Buffer clearing

Polyglot JavaScript

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed