Select Git revision
membership.test.js
Brady James Garvin authored
membership.test.js 54.22 KiB
/* eslint-disable no-magic-numbers */
import { BinarySearchTree } from './binarySearchTree.js';
describe('membership testing', () => {
test('is accurate for list #0', () => {
const tree = new BinarySearchTree([]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(false);
expect(tree.has(1)).toBe(false);
expect(tree.has(2)).toBe(false);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #1', () => {
const tree = new BinarySearchTree([0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(false);
expect(tree.has(2)).toBe(false);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #2', () => {
const tree = new BinarySearchTree([0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(false);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #3', () => {
const tree = new BinarySearchTree([1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(false);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #4', () => {
const tree = new BinarySearchTree([0, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #5', () => {
const tree = new BinarySearchTree([0, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #6', () => {
const tree = new BinarySearchTree([1, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #7', () => {
const tree = new BinarySearchTree([1, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #8', () => {
const tree = new BinarySearchTree([2, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #9', () => {
const tree = new BinarySearchTree([2, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(false);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #10', () => {
const tree = new BinarySearchTree([0, 1, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #11', () => {
const tree = new BinarySearchTree([0, 1, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #12', () => {
const tree = new BinarySearchTree([0, 2, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #13', () => {
const tree = new BinarySearchTree([0, 2, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #14', () => {
const tree = new BinarySearchTree([0, 3, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #15', () => {
const tree = new BinarySearchTree([0, 3, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #16', () => {
const tree = new BinarySearchTree([1, 0, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #17', () => {
const tree = new BinarySearchTree([1, 0, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #18', () => {
const tree = new BinarySearchTree([1, 2, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #19', () => {
const tree = new BinarySearchTree([1, 2, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #20', () => {
const tree = new BinarySearchTree([1, 3, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #21', () => {
const tree = new BinarySearchTree([1, 3, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #22', () => {
const tree = new BinarySearchTree([2, 0, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #23', () => {
const tree = new BinarySearchTree([2, 0, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #24', () => {
const tree = new BinarySearchTree([2, 1, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #25', () => {
const tree = new BinarySearchTree([2, 1, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #26', () => {
const tree = new BinarySearchTree([2, 3, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #27', () => {
const tree = new BinarySearchTree([2, 3, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #28', () => {
const tree = new BinarySearchTree([3, 0, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #29', () => {
const tree = new BinarySearchTree([3, 0, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #30', () => {
const tree = new BinarySearchTree([3, 1, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #31', () => {
const tree = new BinarySearchTree([3, 1, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #32', () => {
const tree = new BinarySearchTree([3, 2, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #33', () => {
const tree = new BinarySearchTree([3, 2, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(false);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #34', () => {
const tree = new BinarySearchTree([0, 1, 2, 3, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #35', () => {
const tree = new BinarySearchTree([0, 1, 2, 4, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #36', () => {
const tree = new BinarySearchTree([0, 1, 3, 2, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #37', () => {
const tree = new BinarySearchTree([0, 1, 3, 4, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #38', () => {
const tree = new BinarySearchTree([0, 1, 4, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #39', () => {
const tree = new BinarySearchTree([0, 1, 4, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #40', () => {
const tree = new BinarySearchTree([0, 2, 1, 3, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #41', () => {
const tree = new BinarySearchTree([0, 2, 1, 4, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #42', () => {
const tree = new BinarySearchTree([0, 2, 3, 1, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #43', () => {
const tree = new BinarySearchTree([0, 2, 3, 4, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #44', () => {
const tree = new BinarySearchTree([0, 2, 4, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #45', () => {
const tree = new BinarySearchTree([0, 2, 4, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #46', () => {
const tree = new BinarySearchTree([0, 3, 1, 2, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #47', () => {
const tree = new BinarySearchTree([0, 3, 1, 4, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #48', () => {
const tree = new BinarySearchTree([0, 3, 2, 1, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #49', () => {
const tree = new BinarySearchTree([0, 3, 2, 4, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #50', () => {
const tree = new BinarySearchTree([0, 3, 4, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #51', () => {
const tree = new BinarySearchTree([0, 3, 4, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #52', () => {
const tree = new BinarySearchTree([0, 4, 1, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #53', () => {
const tree = new BinarySearchTree([0, 4, 1, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #54', () => {
const tree = new BinarySearchTree([0, 4, 2, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #55', () => {
const tree = new BinarySearchTree([0, 4, 2, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #56', () => {
const tree = new BinarySearchTree([0, 4, 3, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #57', () => {
const tree = new BinarySearchTree([0, 4, 3, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #58', () => {
const tree = new BinarySearchTree([1, 0, 2, 3, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #59', () => {
const tree = new BinarySearchTree([1, 0, 2, 4, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #60', () => {
const tree = new BinarySearchTree([1, 0, 3, 2, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #61', () => {
const tree = new BinarySearchTree([1, 0, 3, 4, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #62', () => {
const tree = new BinarySearchTree([1, 0, 4, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #63', () => {
const tree = new BinarySearchTree([1, 0, 4, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #64', () => {
const tree = new BinarySearchTree([1, 2, 0, 3, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #65', () => {
const tree = new BinarySearchTree([1, 2, 0, 4, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #66', () => {
const tree = new BinarySearchTree([1, 2, 3, 0, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #67', () => {
const tree = new BinarySearchTree([1, 2, 3, 4, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #68', () => {
const tree = new BinarySearchTree([1, 2, 4, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #69', () => {
const tree = new BinarySearchTree([1, 2, 4, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #70', () => {
const tree = new BinarySearchTree([1, 3, 0, 2, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #71', () => {
const tree = new BinarySearchTree([1, 3, 0, 4, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #72', () => {
const tree = new BinarySearchTree([1, 3, 2, 0, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #73', () => {
const tree = new BinarySearchTree([1, 3, 2, 4, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #74', () => {
const tree = new BinarySearchTree([1, 3, 4, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #75', () => {
const tree = new BinarySearchTree([1, 3, 4, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #76', () => {
const tree = new BinarySearchTree([1, 4, 0, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #77', () => {
const tree = new BinarySearchTree([1, 4, 0, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #78', () => {
const tree = new BinarySearchTree([1, 4, 2, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #79', () => {
const tree = new BinarySearchTree([1, 4, 2, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #80', () => {
const tree = new BinarySearchTree([1, 4, 3, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #81', () => {
const tree = new BinarySearchTree([1, 4, 3, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #82', () => {
const tree = new BinarySearchTree([2, 0, 1, 3, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #83', () => {
const tree = new BinarySearchTree([2, 0, 1, 4, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #84', () => {
const tree = new BinarySearchTree([2, 0, 3, 1, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #85', () => {
const tree = new BinarySearchTree([2, 0, 3, 4, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #86', () => {
const tree = new BinarySearchTree([2, 0, 4, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #87', () => {
const tree = new BinarySearchTree([2, 0, 4, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #88', () => {
const tree = new BinarySearchTree([2, 1, 0, 3, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #89', () => {
const tree = new BinarySearchTree([2, 1, 0, 4, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #90', () => {
const tree = new BinarySearchTree([2, 1, 3, 0, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #91', () => {
const tree = new BinarySearchTree([2, 1, 3, 4, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #92', () => {
const tree = new BinarySearchTree([2, 1, 4, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #93', () => {
const tree = new BinarySearchTree([2, 1, 4, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #94', () => {
const tree = new BinarySearchTree([2, 3, 0, 1, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #95', () => {
const tree = new BinarySearchTree([2, 3, 0, 4, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #96', () => {
const tree = new BinarySearchTree([2, 3, 1, 0, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #97', () => {
const tree = new BinarySearchTree([2, 3, 1, 4, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #98', () => {
const tree = new BinarySearchTree([2, 3, 4, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #99', () => {
const tree = new BinarySearchTree([2, 3, 4, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #100', () => {
const tree = new BinarySearchTree([2, 4, 0, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #101', () => {
const tree = new BinarySearchTree([2, 4, 0, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #102', () => {
const tree = new BinarySearchTree([2, 4, 1, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #103', () => {
const tree = new BinarySearchTree([2, 4, 1, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #104', () => {
const tree = new BinarySearchTree([2, 4, 3, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #105', () => {
const tree = new BinarySearchTree([2, 4, 3, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #106', () => {
const tree = new BinarySearchTree([3, 0, 1, 2, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #107', () => {
const tree = new BinarySearchTree([3, 0, 1, 4, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #108', () => {
const tree = new BinarySearchTree([3, 0, 2, 1, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #109', () => {
const tree = new BinarySearchTree([3, 0, 2, 4, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #110', () => {
const tree = new BinarySearchTree([3, 0, 4, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #111', () => {
const tree = new BinarySearchTree([3, 0, 4, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #112', () => {
const tree = new BinarySearchTree([3, 1, 0, 2, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #113', () => {
const tree = new BinarySearchTree([3, 1, 0, 4, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #114', () => {
const tree = new BinarySearchTree([3, 1, 2, 0, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #115', () => {
const tree = new BinarySearchTree([3, 1, 2, 4, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #116', () => {
const tree = new BinarySearchTree([3, 1, 4, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #117', () => {
const tree = new BinarySearchTree([3, 1, 4, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #118', () => {
const tree = new BinarySearchTree([3, 2, 0, 1, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #119', () => {
const tree = new BinarySearchTree([3, 2, 0, 4, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #120', () => {
const tree = new BinarySearchTree([3, 2, 1, 0, 4]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #121', () => {
const tree = new BinarySearchTree([3, 2, 1, 4, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #122', () => {
const tree = new BinarySearchTree([3, 2, 4, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #123', () => {
const tree = new BinarySearchTree([3, 2, 4, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #124', () => {
const tree = new BinarySearchTree([3, 4, 0, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #125', () => {
const tree = new BinarySearchTree([3, 4, 0, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #126', () => {
const tree = new BinarySearchTree([3, 4, 1, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #127', () => {
const tree = new BinarySearchTree([3, 4, 1, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #128', () => {
const tree = new BinarySearchTree([3, 4, 2, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #129', () => {
const tree = new BinarySearchTree([3, 4, 2, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #130', () => {
const tree = new BinarySearchTree([4, 0, 1, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #131', () => {
const tree = new BinarySearchTree([4, 0, 1, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #132', () => {
const tree = new BinarySearchTree([4, 0, 2, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #133', () => {
const tree = new BinarySearchTree([4, 0, 2, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #134', () => {
const tree = new BinarySearchTree([4, 0, 3, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #135', () => {
const tree = new BinarySearchTree([4, 0, 3, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #136', () => {
const tree = new BinarySearchTree([4, 1, 0, 2, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #137', () => {
const tree = new BinarySearchTree([4, 1, 0, 3, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #138', () => {
const tree = new BinarySearchTree([4, 1, 2, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #139', () => {
const tree = new BinarySearchTree([4, 1, 2, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #140', () => {
const tree = new BinarySearchTree([4, 1, 3, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #141', () => {
const tree = new BinarySearchTree([4, 1, 3, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #142', () => {
const tree = new BinarySearchTree([4, 2, 0, 1, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #143', () => {
const tree = new BinarySearchTree([4, 2, 0, 3, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #144', () => {
const tree = new BinarySearchTree([4, 2, 1, 0, 3]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #145', () => {
const tree = new BinarySearchTree([4, 2, 1, 3, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #146', () => {
const tree = new BinarySearchTree([4, 2, 3, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #147', () => {
const tree = new BinarySearchTree([4, 2, 3, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #148', () => {
const tree = new BinarySearchTree([4, 3, 0, 1, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #149', () => {
const tree = new BinarySearchTree([4, 3, 0, 2, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #150', () => {
const tree = new BinarySearchTree([4, 3, 1, 0, 2]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #151', () => {
const tree = new BinarySearchTree([4, 3, 1, 2, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #152', () => {
const tree = new BinarySearchTree([4, 3, 2, 0, 1]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true);
expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
test('is accurate for list #153', () => {
const tree = new BinarySearchTree([4, 3, 2, 1, 0]);
expect(tree.has(-1)).toBe(false);
expect(tree.has(0)).toBe(true);
expect(tree.has(1)).toBe(true); expect(tree.has(2)).toBe(true);
expect(tree.has(3)).toBe(true);
expect(tree.has(4)).toBe(true);
expect(tree.has(5)).toBe(false);
});
});