dist-javascript-algorithms-and-data-structures/dist/algorithms/graph/depth-first-search/__test__/depthFirstSearch.test.js

Algorithms and data-structures implemented on JavaScript

"use strict";

var _Graph = _interopRequireDefault(require("../../../../data-structures/graph/Graph"));

var _GraphVertex = _interopRequireDefault(require("../../../../data-structures/graph/GraphVertex"));

var _GraphEdge = _interopRequireDefault(require("../../../../data-structures/graph/GraphEdge"));

var _depthFirstSearch = _interopRequireDefault(require("../depthFirstSearch"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

describe('depthFirstSearch', () => {
  it('should perform DFS operation on graph', () => {
    const graph = new _Graph.default(true);
    const vertexA = new _GraphVertex.default('A');
    const vertexB = new _GraphVertex.default('B');
    const vertexC = new _GraphVertex.default('C');
    const vertexD = new _GraphVertex.default('D');
    const vertexE = new _GraphVertex.default('E');
    const vertexF = new _GraphVertex.default('F');
    const vertexG = new _GraphVertex.default('G');
    const edgeAB = new _GraphEdge.default(vertexA, vertexB);
    const edgeBC = new _GraphEdge.default(vertexB, vertexC);
    const edgeCG = new _GraphEdge.default(vertexC, vertexG);
    const edgeAD = new _GraphEdge.default(vertexA, vertexD);
    const edgeAE = new _GraphEdge.default(vertexA, vertexE);
    const edgeEF = new _GraphEdge.default(vertexE, vertexF);
    const edgeFD = new _GraphEdge.default(vertexF, vertexD);
    const edgeDG = new _GraphEdge.default(vertexD, vertexG);
    graph.addEdge(edgeAB).addEdge(edgeBC).addEdge(edgeCG).addEdge(edgeAD).addEdge(edgeAE).addEdge(edgeEF).addEdge(edgeFD).addEdge(edgeDG);
    expect(graph.toString()).toBe('A,B,C,G,D,E,F');
    const enterVertexCallback = jest.fn();
    const leaveVertexCallback = jest.fn(); // Traverse graphs without callbacks first to check default ones.

    (0, _depthFirstSearch.default)(graph, vertexA); // Traverse graph with enterVertex and leaveVertex callbacks.

    (0, _depthFirstSearch.default)(graph, vertexA, {
      enterVertex: enterVertexCallback,
      leaveVertex: leaveVertexCallback
    });
    expect(enterVertexCallback).toHaveBeenCalledTimes(graph.getAllVertices().length);
    expect(leaveVertexCallback).toHaveBeenCalledTimes(graph.getAllVertices().length);
    const enterVertexParamsMap = [{
      currentVertex: vertexA,
      previousVertex: null
    }, {
      currentVertex: vertexB,
      previousVertex: vertexA
    }, {
      currentVertex: vertexC,
      previousVertex: vertexB
    }, {
      currentVertex: vertexG,
      previousVertex: vertexC
    }, {
      currentVertex: vertexD,
      previousVertex: vertexA
    }, {
      currentVertex: vertexE,
      previousVertex: vertexA
    }, {
      currentVertex: vertexF,
      previousVertex: vertexE
    }];

    for (let callIndex = 0; callIndex < graph.getAllVertices().length; callIndex += 1) {
      const params = enterVertexCallback.mock.calls[callIndex][0];
      expect(params.currentVertex).toEqual(enterVertexParamsMap[callIndex].currentVertex);
      expect(params.previousVertex).toEqual(enterVertexParamsMap[callIndex].previousVertex);
    }

    const leaveVertexParamsMap = [{
      currentVertex: vertexG,
      previousVertex: vertexC
    }, {
      currentVertex: vertexC,
      previousVertex: vertexB
    }, {
      currentVertex: vertexB,
      previousVertex: vertexA
    }, {
      currentVertex: vertexD,
      previousVertex: vertexA
    }, {
      currentVertex: vertexF,
      previousVertex: vertexE
    }, {
      currentVertex: vertexE,
      previousVertex: vertexA
    }, {
      currentVertex: vertexA,
      previousVertex: null
    }];

    for (let callIndex = 0; callIndex < graph.getAllVertices().length; callIndex += 1) {
      const params = leaveVertexCallback.mock.calls[callIndex][0];
      expect(params.currentVertex).toEqual(leaveVertexParamsMap[callIndex].currentVertex);
      expect(params.previousVertex).toEqual(leaveVertexParamsMap[callIndex].previousVertex);
    }
  });
  it('allow users to redefine vertex visiting logic', () => {
    const graph = new _Graph.default(true);
    const vertexA = new _GraphVertex.default('A');
    const vertexB = new _GraphVertex.default('B');
    const vertexC = new _GraphVertex.default('C');
    const vertexD = new _GraphVertex.default('D');
    const vertexE = new _GraphVertex.default('E');
    const vertexF = new _GraphVertex.default('F');
    const vertexG = new _GraphVertex.default('G');
    const edgeAB = new _GraphEdge.default(vertexA, vertexB);
    const edgeBC = new _GraphEdge.default(vertexB, vertexC);
    const edgeCG = new _GraphEdge.default(vertexC, vertexG);
    const edgeAD = new _GraphEdge.default(vertexA, vertexD);
    const edgeAE = new _GraphEdge.default(vertexA, vertexE);
    const edgeEF = new _GraphEdge.default(vertexE, vertexF);
    const edgeFD = new _GraphEdge.default(vertexF, vertexD);
    const edgeDG = new _GraphEdge.default(vertexD, vertexG);
    graph.addEdge(edgeAB).addEdge(edgeBC).addEdge(edgeCG).addEdge(edgeAD).addEdge(edgeAE).addEdge(edgeEF).addEdge(edgeFD).addEdge(edgeDG);
    expect(graph.toString()).toBe('A,B,C,G,D,E,F');
    const enterVertexCallback = jest.fn();
    const leaveVertexCallback = jest.fn();
    (0, _depthFirstSearch.default)(graph, vertexA, {
      enterVertex: enterVertexCallback,
      leaveVertex: leaveVertexCallback,
      allowTraversal: ({
        currentVertex,
        nextVertex
      }) => {
        return !(currentVertex === vertexA && nextVertex === vertexB);
      }
    });
    expect(enterVertexCallback).toHaveBeenCalledTimes(7);
    expect(leaveVertexCallback).toHaveBeenCalledTimes(7);
    const enterVertexParamsMap = [{
      currentVertex: vertexA,
      previousVertex: null
    }, {
      currentVertex: vertexD,
      previousVertex: vertexA
    }, {
      currentVertex: vertexG,
      previousVertex: vertexD
    }, {
      currentVertex: vertexE,
      previousVertex: vertexA
    }, {
      currentVertex: vertexF,
      previousVertex: vertexE
    }, {
      currentVertex: vertexD,
      previousVertex: vertexF
    }, {
      currentVertex: vertexG,
      previousVertex: vertexD
    }];

    for (let callIndex = 0; callIndex < graph.getAllVertices().length; callIndex += 1) {
      const params = enterVertexCallback.mock.calls[callIndex][0];
      expect(params.currentVertex).toEqual(enterVertexParamsMap[callIndex].currentVertex);
      expect(params.previousVertex).toEqual(enterVertexParamsMap[callIndex].previousVertex);
    }

    const leaveVertexParamsMap = [{
      currentVertex: vertexG,
      previousVertex: vertexD
    }, {
      currentVertex: vertexD,
      previousVertex: vertexA
    }, {
      currentVertex: vertexG,
      previousVertex: vertexD
    }, {
      currentVertex: vertexD,
      previousVertex: vertexF
    }, {
      currentVertex: vertexF,
      previousVertex: vertexE
    }, {
      currentVertex: vertexE,
      previousVertex: vertexA
    }, {
      currentVertex: vertexA,
      previousVertex: null
    }];

    for (let callIndex = 0; callIndex < graph.getAllVertices().length; callIndex += 1) {
      const params = leaveVertexCallback.mock.calls[callIndex][0];
      expect(params.currentVertex).toEqual(leaveVertexParamsMap[callIndex].currentVertex);
      expect(params.previousVertex).toEqual(leaveVertexParamsMap[callIndex].previousVertex);
    }
  });
});