Added extremal values to membership tests.

unit_tests/test_membership.js

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