it("should clear node selections if hit_test result is empty", () => {
        const initial_selection = create_empty_hit_test_result()
        initial_selection["1d"].indices = [0, 1]
        node_source.selected = initial_selection

        const hit_test_result = create_empty_hit_test_result()
        const policy = new EdgesAndLinkedNodes()
        policy.do_selection(hit_test_result, gr, true, false)

        expect(node_source.selected.is_empty()).to.be.true
      })

  protected _hit_point(geometry: PointGeometry): Selection {
    /* Check if the point geometry hits this line glyph and return an object
    that describes the hit result:
      Args:
        * geometry (object): object with the following keys
          * sx (float): screen x coordinate of the point
          * sy (float): screen y coordinate of the point
          * type (str): type of geometry (in this case it's a point)
      Output:
        Object with the following keys:
          * 0d (bool): whether the point hits the glyph or not
          * 1d (array(int)): array with the indices hit by the point
    */
    const result = hittest.create_empty_hit_test_result()
    const point = {x: geometry.sx, y: geometry.sy}
    let shortest = 9999
    const threshold = Math.max(2, this.visuals.line.line_width.value() / 2)

    for (let i = 0, end = this.sx.length-1; i < end; i++) {
      const p0 = {x: this.sx[i],     y: this.sy[i]    }
      const p1 = {x: this.sx[i + 1], y: this.sy[i + 1]}
      const dist = hittest.dist_to_segment(point, p0, p1)

      if (dist < threshold && dist < shortest) {
        shortest = dist
        result.add_to_selected_glyphs(this.model)
        result.get_view = () => this
        result.line_indices = [i]
      }
    }

    return result
  }

  protected _hit_span(geometry: SpanGeometry): Selection {
    const {sx, sy} = geometry
    const {minX, minY, maxX, maxY} = this.bounds()
    const result = hittest.create_empty_hit_test_result()

    let x0: number, x1: number
    let y0: number, y1: number
    if (geometry.direction == 'h') {
      y0 = minY
      y1 = maxY
      const ms = this.max_size/2
      const sx0 = sx - ms
      const sx1 = sx + ms
      ;[x0, x1] = this.renderer.xscale.r_invert(sx0, sx1)
    } else {
      x0 = minX
      x1 = maxX
      const ms = this.max_size/2
      const sy0 = sy - ms
      const sy1 = sy + ms
      ;[y0, y1] = this.renderer.yscale.r_invert(sy0, sy1)
    }

    const bbox = hittest.validate_bbox_coords([x0, x1], [y0, y1])
    const hits = this.index.indices(bbox)

    result.indices = hits
    return result
  }

  protected _hit_span(geometry: SpanGeometry): Selection {
    const {sx, sy} = geometry
    const result = hittest.create_empty_hit_test_result()

    let val: number
    let values: Arrayable<Arrayable<number>>
    if (geometry.direction === 'v') {
      val = this.renderer.yscale.invert(sy)
      values = this._ys
    } else {
      val = this.renderer.xscale.invert(sx)
      values = this._xs
    }

    const hits: {[key: string]: number[]} = {}
    for (let i = 0, end = values.length; i < end; i++) {
      const points = []
      for (let j = 0, endj = values[i].length-1; j < endj; j++) {
        if (values[i][j] <= val && val <= values[i][j+1])
          points.push(j)
      }
      if (points.length > 0)
        hits[i] = points
    }

    result.indices = keys(hits).map((x) => parseInt(x, 10))
    result.multiline_indices = hits

    return result
  }

  protected _hit_span(geometry: SpanGeometry): Selection {
    const [hr, vr] = this.renderer.plot_view.frame.bbox.ranges
    const {sx, sy} = geometry

    let v0: Arrayable<number>
    let v1: Arrayable<number>
    let val: number
    if (geometry.direction == 'v') {
      val = this.renderer.yscale.invert(sy)
      ;[v0, v1] = [this._y0, this._y1]
    } else {
      val = this.renderer.xscale.invert(sx)
      ;[v0, v1] = [this._x0, this._x1]
    }

    const hits = []

    const [minX, maxX] = this.renderer.xscale.r_invert(hr.start, hr.end)
    const [minY, maxY] = this.renderer.yscale.r_invert(vr.start, vr.end)
    const candidates = this.index.indices({minX, minY, maxX, maxY})

    for (const i of candidates) {
      if ((v0[i] <= val && val <= v1[i]) || (v1[i] <= val && val <= v0[i]))
        hits.push(i)
    }

    const result = hittest.create_empty_hit_test_result()
    result.indices = hits
    return result
  }

  protected _hit_point(geometry: PointGeometry): Selection {
    const result = hittest.create_empty_hit_test_result()
    const point = {x: geometry.sx, y: geometry.sy}
    let shortest = 9999

    const hits: {[key: string]: number[]} = {}
    for (let i = 0, end = this.sxs.length; i < end; i++) {
      const threshold = Math.max(2, this.visuals.line.cache_select('line_width', i) / 2)
      let points = null
      for (let j = 0, endj = this.sxs[i].length-1; j < endj; j++) {
        const p0 = {x: this.sxs[i][j],   y: this.sys[i][j]  }
        const p1 = {x: this.sxs[i][j+1], y: this.sys[i][j+1]}
        const dist = hittest.dist_to_segment(point, p0, p1)
        if (dist < threshold && dist < shortest) {
          shortest = dist
          points = [j]
        }
      }
      if (points)
        hits[i] = points
    }

    result.indices = keys(hits).map((x) => parseInt(x, 10))
    result.multiline_indices = hits

    return result
  }

 protected _hit_rect(geometry: RectGeometry): Selection {
   const {sx0, sx1, sy0, sy1} = geometry
   const [x0, x1] = this.renderer.xscale.r_invert(sx0, sx1)
   const [y0, y1] = this.renderer.yscale.r_invert(sy0, sy1)
   const bbox = hittest.validate_bbox_coords([x0, x1], [y0, y1])
   const result = hittest.create_empty_hit_test_result()
   result.indices = this.index.indices(bbox)
   return result
 }