To Be Or Not To Be - Practice Coding Problems

To Be Or Not To Be - Problem

JavaScript Easy

Create a testing utility function called expect that mimics the behavior of popular testing frameworks like Jest or Chai. This function is the foundation of how developers write unit tests to verify their code works correctly.

Your task: Write an expect function that takes any value and returns an object with two assertion methods:

toBe(val) - Returns true if both values are strictly equal (===), otherwise throws an error with message "Not Equal"
notToBe(val) - Returns true if both values are NOT strictly equal (!==), otherwise throws an error with message "Equal"

Example usage:

expect(5).toBe(5); // returns true
expect(5).notToBe(10); // returns true
expect(5).toBe(10); // throws "Not Equal"
expect(5).notToBe(5); // throws "Equal"

Input & Output

example_1.js — Successful toBe assertion

$ Input: expect(5).toBe(5)

› Output: true

💡 Note: Both values are 5 and strictly equal (===), so toBe returns true

example_2.js — Successful notToBe assertion

$ Input: expect(5).notToBe(null)

› Output: true

💡 Note: 5 and null are not equal (!==), so notToBe returns true

example_3.js — Failed toBe assertion

$ Input: expect(5).toBe(null)

› Output: Error: "Not Equal"

💡 Note: 5 and null are not strictly equal, so toBe throws an error with message 'Not Equal'

Visualization

Tap to expand

Understanding the Visualization

Capture Expected Value

The expect function stores the value to be tested

Create Assertion Object

Return an object with toBe and notToBe methods

Perform Comparison

Methods compare stored value with provided argument

Return or Throw

Return true if assertion passes, throw error if it fails

Key Takeaway

🎯 Key Insight: Use closures to create a testing framework foundation that captures values and provides assertion methods with proper error handling

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each assertion operation takes constant time regardless of input size

✓ Linear Growth

Space Complexity

O(1)

Only stores the expected value and creates a simple object with two methods

✓ Linear Space

Constraints

The function must return an object with exactly two methods: toBe and notToBe
Use strict equality (===) and strict inequality (!==) for comparisons
Error messages must be exactly "Not Equal" and "Equal"
Methods should return true when assertions pass

Asked in

f Meta 25 G Google 18 N Netflix 15 ⊞ Microsoft 12

The optimal solution uses closures to capture the expected value and return an object with toBe and notToBe methods. Each method performs strict equality comparison and throws appropriate errors when assertions fail, making it a perfect foundation for a testing framework.

Common Approaches

Approach	Time	Space	Notes
✓ Basic Function with Object Return	O(1)	O(1)	Simple function that returns an object with two methods

Basic Function with Object Return — Algorithm Steps

Define the expect function that takes a value parameter
Return an object with toBe and notToBe methods
Implement toBe to check strict equality (===) and throw 'Not Equal' error if false
Implement notToBe to check strict inequality (!==) and throw 'Equal' error if false
Both methods return true when assertions pass

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Value

expect() receives a value to be tested

Create Object

Returns object with toBe and notToBe methods

Method Call

Call toBe or notToBe with expected value

Comparison

Perform strict equality/inequality check

Result

Return true or throw appropriate error

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    void* val;
    int (*toBe)(void* expected);
    int (*notToBe)(void* expected);
} ExpectObject;

int toBe_impl(void* val, void* expected) {
    if (val == expected) {
        return 1;
    }
    printf("Error: Not Equal\n");
    exit(1);
}

int notToBe_impl(void* val, void* expected) {
    if (val != expected) {
        return 1;
    }
    printf("Error: Equal\n");
    exit(1);
}

ExpectObject* expect(void* val) {
    ExpectObject* obj = malloc(sizeof(ExpectObject));
    obj->val = val;
    return obj;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each assertion operation takes constant time regardless of input size

✓ Linear Growth

Space Complexity

O(1)

Only stores the expected value and creates a simple object with two methods

✓ Linear Space

Constraints

The function must return an object with exactly two methods: toBe and notToBe
Use strict equality (===) and strict inequality (!==) for comparisons
Error messages must be exactly "Not Equal" and "Equal"
Methods should return true when assertions pass

28.4K Views

Medium Frequency

~8 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Basic Function with Object Return — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler