Back to Repositories

Testing Jump Search Algorithm Implementation in javascript-algorithms

This test suite validates the implementation of the Jump Search algorithm in JavaScript, covering both numeric arrays and object arrays with custom comparators. The tests ensure the algorithm correctly handles various input scenarios and edge cases in sorted collections.

Test Coverage Overview

The test suite provides comprehensive coverage of the Jump Search implementation across multiple scenarios.

Tests empty arrays, single-element arrays, and multi-element arrays
Validates search functionality for both existing and non-existing elements
Covers edge cases including boundary values and duplicate elements
Tests object arrays using custom comparator functions

Implementation Analysis

The testing approach utilizes Jest’s describe/it pattern for structured test organization.

The implementation employs expect().toBe() assertions to verify exact index matches, with particular attention to:

Array boundary conditions (-1 for not found)
Multiple test cases within single test blocks
Custom comparator function implementation for object searching

Technical Details

Testing Framework: Jest

Uses Jest’s built-in assertion library
Implements describe and it blocks for test organization
Employs function imports for modular testing
Utilizes custom comparator functions for complex data types

Best Practices Demonstrated

The test suite exemplifies several testing best practices in algorithm validation.

Comprehensive edge case coverage
Clear test case organization
Consistent assertion patterns
Separate test blocks for different data types
Modular test structure with focused test cases

trekhleb/javascript-algorithms

src/algorithms/search/jump-search/__test__/jumpSearch.test.js

            
import jumpSearch from '../jumpSearch';

describe('jumpSearch', () => {
  it('should search for an element in sorted array', () => {
    expect(jumpSearch([], 1)).toBe(-1);
    expect(jumpSearch([1], 2)).toBe(-1);
    expect(jumpSearch([1], 1)).toBe(0);
    expect(jumpSearch([1, 2], 1)).toBe(0);
    expect(jumpSearch([1, 2], 1)).toBe(0);
    expect(jumpSearch([1, 1, 1], 1)).toBe(0);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 2)).toBe(1);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 0)).toBe(-1);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 0)).toBe(-1);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 7)).toBe(-1);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 5)).toBe(2);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 20)).toBe(4);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 30)).toBe(7);
    expect(jumpSearch([1, 2, 5, 10, 20, 21, 24, 30, 48], 48)).toBe(8);
  });

  it('should search object in sorted array', () => {
    const sortedArrayOfObjects = [
      { key: 1, value: 'value1' },
      { key: 2, value: 'value2' },
      { key: 3, value: 'value3' },
    ];

    const comparator = (a, b) => {
      if (a.key === b.key) return 0;
      return a.key < b.key ? -1 : 1;
    };

    expect(jumpSearch([], { key: 1 }, comparator)).toBe(-1);
    expect(jumpSearch(sortedArrayOfObjects, { key: 4 }, comparator)).toBe(-1);
    expect(jumpSearch(sortedArrayOfObjects, { key: 1 }, comparator)).toBe(0);
    expect(jumpSearch(sortedArrayOfObjects, { key: 2 }, comparator)).toBe(1);
    expect(jumpSearch(sortedArrayOfObjects, { key: 3 }, comparator)).toBe(2);
  });
});