suffix_tree 0.0.1

data/spec/location_spec.rb

@@ -0,0 +1,149 @@
+require 'rspec'
+require_relative '../lib/location'
+require_relative '../lib/node'
+require_relative '../lib/node_factory'
+require_relative '../lib/data/string_data_source'
+
+describe 'Location class' do
+
+  let(:dataSource)  { StringDataSource.new("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")}
+  let(:nodeFactory) { NodeFactory.new dataSource }
+  let(:root) { nodeFactory.newRoot }
+  let(:level1) { nodeFactory.addLeaf(root, 'a', 0) }    # level1 is entire string
+  let(:level2) { nodeFactory.splitEdgeAt(level1, 26) }  # root -> level2(0, 25) -> level1(26, 51)
+  let(:level3) { nodeFactory.splitEdgeAt(level1, 29) }  # root -> level2(0, 25) -> level3(26,28) -> level1 (29,51)
+  let(:linkNode) { nodeFactory.addLeaf(root, 'b', 2) }
+
+  def forceLazyLoad
+    location = Location.new(root)
+    location = Location.new(level1)
+    location = Location.new(level2)
+    location = Location.new(level3)
+  end
+
+  describe "#new" do
+    it "starts at a node" do
+      location = Location.new(root)
+      expect(location.node).to eq root
+      expect(location.onNode).to eq true
+      expect(location.incomingEdgeOffset).to eq Node::UNSPECIFIED_OFFSET
+    end
+  end
+
+  describe "#jumpToNode" do
+    it "sets location to node starting at another" do
+      location = Location.new(level1)
+      location.jumpToNode(level2)
+      expect(location.node).to eq level2
+      expect(location.onNode).to eq true
+      expect(location.incomingEdgeOffset).to eq Node::UNSPECIFIED_OFFSET
+    end
+  end
+
+  describe "#traverseUp" do
+    # root -> level2(0, 25) -> level3(26,28) -> level1 (29,51)
+    it "goes to parent node starting from node" do
+      # this is weird, but if I don't force the lazy loading test failes
+      forceLazyLoad
+      location = Location.new(level3)
+      startOffset, endOffset = location.traverseUp
+      expect(location.node).to eq level2
+      expect(location.onNode).to eq true
+      expect(location.incomingEdgeOffset).to eq Node::UNSPECIFIED_OFFSET
+      expect(startOffset).to eq 26
+      expect(endOffset).to eq 28
+    end
+
+    # root -> level2(0, 25) -> level3(26,28) -> level1 (29,51)
+    it "goes to parent node starting from leaf" do
+      forceLazyLoad
+      leafNode = nodeFactory.addLeaf(level3, 'c', 3)
+      location = Location.new(leafNode, false, 6)
+      startOffset, endOffset = location.traverseUp
+      expect(location.node).to eq level3
+      expect(location.onNode).to eq true
+      expect(location.incomingEdgeOffset).to eq Node::UNSPECIFIED_OFFSET
+      expect(startOffset).to eq 3
+      expect(endOffset).to eq 5
+    end
+
+    # root -> level2(0, 25) -> level3(26,28) -> level1 (29,51)
+    it "goes to parent node starting at mid-edge from internal node" do
+      forceLazyLoad
+      leafNode = nodeFactory.addLeaf(level3, 'x', 38)
+      location = Location.new(leafNode, false, 48)
+      startOffset, endOffset = location.traverseUp
+      expect(location.node).to eq level3
+      expect(location.onNode).to eq true
+      expect(location.incomingEdgeOffset).to eq Node::UNSPECIFIED_OFFSET
+      expect(startOffset).to eq 38
+      expect(endOffset).to eq 47
+    end
+  end
+
+  describe "#traverseSuffixLink" do
+    it "follows suffix link" do
+      forceLazyLoad
+      level3.suffixLink = linkNode
+      location = Location.new(level3)
+      location.traverseSuffixLink
+      expect(location.node).to eq linkNode
+      expect(location.onNode).to eq true
+      expect(location.incomingEdgeOffset).to eq Node::UNSPECIFIED_OFFSET
+    end
+  end
+
+  # root -> level2(0, 25) -> level3(26,28) -> level1 (29,51)
+  #                a, z             a,c               d,z
+  describe "#traverseDownChildValue" do
+    it "ends on child node if child edge has one value" do
+      forceLazyLoad
+      testNode = nodeFactory.addLeaf(level2, 'c', 2)
+      location = Location.new(level2)
+      location.traverseDownChildValue('c')
+      expect(location.node).to eq testNode
+      expect(location.onNode).to eq false
+      expect(location.incomingEdgeOffset).to eq 3
+    end
+
+    it "ends on second character of child edge when that edge has more than one value" do
+      forceLazyLoad
+      leafNode = nodeFactory.addLeaf(level2, 'c', 2)
+      internalNode = nodeFactory.splitEdgeAt(leafNode, 7)
+      location = Location.new(internalNode)
+      location.traverseDownChildValue('h')
+      expect(location.node).to eq leafNode
+      expect(location.onNode).to eq false
+      expect(location.incomingEdgeOffset).to eq 8
+    end
+  end
+
+  # root -> level2(0, 25) -> level3(26,28) -> level1 (29,51)
+  #                a, z   "a"       a,c    "d"        d,z
+  describe "#traverseSkipDownCount" do
+    it "checks single character to get to next node" do
+      forceLazyLoad
+      leaf = nodeFactory.addLeaf(level2, 'c', 2)
+      # root -> level2(0, 25) -> level3(26,28) -> level1 (29,51)
+      #                a, z   "a"       a,c    "d"        d,z
+      #                       "c"  leaf(2,51)
+      location = Location.new(level2)
+      location.traverseSkipCountDown(dataSource, 2, 10)
+      expect(location.node).to eq leaf
+      expect(location.onNode).to eq false
+      expect(location.incomingEdgeOffset).to eq 11
+    end
+
+    # 1:root -> 3:level2(0, 25) -> 4:level3(26,28) -> 2:level1 (29,-1)
+    #                    a, z   "a"         a,c    "d"          d,z
+    it "traverses multiple nodes down" do
+      forceLazyLoad
+      location = Location.new(root)
+      location.traverseSkipCountDown(dataSource, 0, 33)
+      expect(location.node).to eq level1
+      expect(location.incomingEdgeOffset).to eq 34
+      expect(location.onNode).to eq false
+    end
+  end
+
+end

data/spec/node_factory_spec.rb

@@ -0,0 +1,199 @@
+require 'rspec'
+require_relative '../lib/node'
+require_relative '../lib/node_factory'
+require_relative '../lib/data/string_data_source'
+
+describe "NodeFactory class" do
+
+  let(:dataSource) { StringDataSource.new "mississippi" }
+  let(:alphaDataSource) { StringDataSource.new "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" }
+  let(:alphaNodeFactory) { NodeFactory.new alphaDataSource }
+
+  describe '#initialize' do
+    it "accepts a dataSource" do
+      nodeFactory = NodeFactory.new dataSource
+      expect(nodeFactory.dataSource).to eq dataSource
+    end
+  end
+
+  describe '#configure' do
+    it "keeps a hash of configuration options for how nodes get built" do
+      nodeFactory = NodeFactory.new dataSource
+      hash = {
+          :generalized_suffix_tree => true,
+          :track_value_depth => true,
+#          :save_previous_value => true, for this test we verify default "false" remains
+      }
+      nodeFactory.setConfiguration(hash)
+      configuration = nodeFactory.configuration
+      expect(configuration[:generalized_suffix_tree]).to eq hash[:generalized_suffix_tree]
+      expect(configuration[:track_character_depth]).to eq hash[:track_character_depth]
+      expect(configuration[:previousValue]).to eq false
+    end
+
+    it "by default does not save previous value" do
+      nodeFactory = NodeFactory.new dataSource
+      root = nodeFactory.newRoot
+      leaf = nodeFactory.addLeaf(root, 'i', 1)
+      internal = nodeFactory.splitEdgeAt(leaf, 4)
+      leaf2 = nodeFactory.addLeaf(internal, 'x', 7)
+      expect(defined? leaf.previousValue).to eq nil
+      expect(defined? internal.previousValue).to eq nil
+      expect(defined? leaf2.previousValue).to eq nil
+    end
+
+    it "configuration turns on previous value saving" do
+      nodeFactory = NodeFactory.new dataSource
+      hash = {
+          :previousValue => true
+      }
+      nodeFactory.setConfiguration(hash)
+      root = nodeFactory.newRoot
+      leaf = nodeFactory.addLeaf(root, 'm', 0)
+      expect(leaf.previousValue).to eq nil
+
+      leaf = nodeFactory.addLeaf(root, 'i', 1)
+      expect(leaf.previousValue).to eq 'm'
+
+      leaf2 = nodeFactory.addLeaf(root, 's', 2)
+      expect(leaf2.previousValue).to eq 'i'
+
+      internal = nodeFactory.splitEdgeAt(leaf, 4)
+      expect(internal.previousValue).to eq nil
+
+      leaf3 = nodeFactory.addLeaf(internal, 'x', 7)
+      expect(leaf3.previousValue).to eq 's'
+      leaf3 = nodeFactory.addLeaf(internal, 'x', 7)
+      expect(leaf3.previousValue).to eq 's'
+    end
+
+    it "tracks value depth of nodes" do
+      nodeFactory = NodeFactory.new dataSource
+      hash = {
+          :valueDepth => true
+      }
+      nodeFactory.setConfiguration(hash)
+      root = nodeFactory.newRoot
+      leaf = nodeFactory.addLeaf(root, 'i', 1)
+      internal = nodeFactory.splitEdgeAt(leaf, 4)
+      expect(internal.valueDepth).to eq 3
+    end
+
+    it "tracks value depth of nodes" do
+      nodeFactory = NodeFactory.new dataSource
+      nodeFactory.setConfiguration({
+                                       :valueDepth => true
+                                   })
+      root = nodeFactory.newRoot
+      expect(root.valueDepth).to eq 0
+      leaf = nodeFactory.addLeaf(root, 'i', 1)
+      internal = nodeFactory.splitEdgeAt(leaf, 8)
+      internal2 = nodeFactory.splitEdgeAt(internal, 4)
+      expect(internal.valueDepth).to eq 7
+      expect(internal2.valueDepth).to eq 3
+      internal3 = nodeFactory.splitEdgeAt(internal, 6)
+      expect(internal3.valueDepth).to eq 5
+    end
+  end
+
+  describe "#newRoot" do
+    it "creates a new root node with node_id=1" do
+      nodeFactory = NodeFactory.new dataSource
+      root = nodeFactory.newRoot
+      expect(root.nodeId).to eq 1
+      expect(root.children.length).to eq 0
+      expect(nodeFactory.nextNodeId).to eq 2
+    end
+
+    it "resets each time newRoot is called" do
+      nodeFactory = NodeFactory.new dataSource
+      root1 = nodeFactory.newRoot
+      root2 = nodeFactory.newRoot
+      expect(root1.nodeId).to eq 1
+      expect(root2.nodeId).to eq 1
+    end
+  end
+
+  describe "#addLeaf" do
+    it "adds a leaf node" do
+      nodeFactory = NodeFactory.new dataSource
+      root = nodeFactory.newRoot
+      child = nodeFactory.addLeaf(root, 'a', 3)
+      aChild = root.children['a']
+      expect(aChild).to eq child
+      expect(root.children['a'].parent).to eq root
+    end
+  end
+
+  describe "#splitEdgeAtOffset" do
+    it "splits a long edge" do
+
+      root = alphaNodeFactory.newRoot
+      level1 = alphaNodeFactory.addLeaf(root, 'a', 0)
+      expect(level1.parent).to eq root
+      expect(level1.incomingEdgeStartOffset).to eq 0
+      expect(level1.incomingEdgeEndOffset).to eq Node::CURRENT_ENDING_OFFSET
+      level2 = alphaNodeFactory.splitEdgeAt(level1, 26)
+      expect(level2.parent).to eq root
+      expect(level1.parent).to eq level2
+      expect(level2.incomingEdgeStartOffset).to eq 0
+      expect(level2.incomingEdgeEndOffset).to eq 25
+      expect(level1.incomingEdgeStartOffset).to eq 26
+      expect(level1.incomingEdgeEndOffset).to eq Node::CURRENT_ENDING_OFFSET
+      level3 = alphaNodeFactory.splitEdgeAt(level1, 29)
+      expect(level3.parent).to eq level2
+      expect(level2.parent).to eq root
+      expect(level3.incomingEdgeStartOffset).to eq 26
+      expect(level3.incomingEdgeEndOffset).to eq 28
+      expect(level1.incomingEdgeStartOffset).to eq 29
+      expect(level1.incomingEdgeEndOffset).to eq Node::CURRENT_ENDING_OFFSET
+    end
+
+    it "splits edge and returns that node" do
+      nodeFactory = NodeFactory.new dataSource
+      root = nodeFactory.newRoot
+      child = nodeFactory.addLeaf(root, 'm', 0)
+      middleNode = nodeFactory.splitEdgeAt(child, 3)
+      expect(middleNode.parent).to eq (root)
+      expect(middleNode.incomingEdgeStartOffset).to eq 0
+      expect(middleNode.incomingEdgeEndOffset).to eq 2
+      expect(middleNode.isInternal).to eq true
+      expect(child.parent).to eq (middleNode)
+      expect(child.incomingEdgeStartOffset).to eq 3
+      expect(child.incomingEdgeEndOffset).to eq Node::CURRENT_ENDING_OFFSET
+      expect(child.isLeaf).to eq true
+    end
+
+    it "splits nodes correctly" do
+      root = nodeFactory2.newRoot
+      level1 = nodeFactory2.addLeaf(root, 'a', 0)
+      expect(root.children['a']).to eq level1
+      level2 = nodeFactory2.splitEdgeAt(level1, 26)
+      expect(root.children['a']).to eq level2
+      expect(level2.parent).to eq root
+      expect(level2.incomingEdgeStartOffset).to eq 0
+      expect(level2.incomingEdgeEndOffset).to eq 25
+      expect(level1.parent).to eq level2
+      expect(level1.incomingEdgeStartOffset).to eq 26
+      expect(level1.incomingEdgeEndOffset).to eq Node::CURRENT_ENDING_OFFSET
+    end
+
+    it "handles multiple splits" do
+      root2 = nodeFactory2.newRoot
+      rLevel1 = nodeFactory2.addLeaf(root2, 'a', 0)
+      expect(rLevel1.incomingEdgeStartOffset).to eq 0
+      expect(rLevel1.incomingEdgeEndOffset).to eq Node::CURRENT_ENDING_OFFSET
+      rLevel2 = nodeFactory2.splitEdgeAt(rLevel1, 26)
+      expect(rLevel2.children.length).to eq 1
+      expect(rLevel2.isInternal).to eq true
+      expect(rLevel2.incomingEdgeStartOffset).to eq 0
+      expect(rLevel2.incomingEdgeEndOffset).to eq 25
+      expect(rLevel1.isLeaf).to eq true
+      expect(rLevel1.incomingEdgeStartOffset).to eq 26
+      expect(rLevel1.incomingEdgeEndOffset).to eq Node::CURRENT_ENDING_OFFSET
+    end
+
+    let(:dataSource2)  { StringDataSource.new("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")}
+    let(:nodeFactory2) { NodeFactory.new dataSource2 }
+  end
+end

data/spec/search_spec.rb

@@ -0,0 +1,182 @@
+require 'rspec'
+require_relative '../lib/location'
+require_relative '../lib/node'
+require_relative '../lib/node_factory'
+require_relative '../lib/data/string_data_source'
+require_relative '../lib/data/file_data_source'
+require_relative '../lib/visitor/bfs'
+require_relative '../lib/visitor/leaf_count_visitor'
+require_relative '../lib/visitor/value_depth_visitor'
+require_relative '../lib/visitor/dfs'
+require_relative '../lib/visitor/node_count_visitor'
+require_relative '../lib/search/searcher'
+require_relative '../lib/suffix_tree'
+
+describe "Search class" do
+
+  let (:dataSource) { StringDataSource.new("mississippi") }
+  let (:nodeFactory) { NodeFactory.new dataSource }
+  let (:rootNodeId) { nodeFactory.nextNodeId }
+  let (:fileDataSource) { FileDataSource.new(File.join('spec', 'fixtures', "mississippi.txt")) }
+  let (:fileNodeFactory) { NodeFactory.new fileDataSource }
+
+  describe '#find' do
+
+    it 'finds all substrings' do
+      hash = {
+          :valueDepth => true
+      }
+      st = SuffixTree.new(nil, hash)
+      st.addDataSource(dataSource)
+
+      searcher = Searcher.new(dataSource, st.root)
+      expect(searcher.findString("m")).to eq ([0])
+      expect(searcher.findString("i")).to eq ([1,4,7])
+      expect(searcher.findString("s")).to eq ([2,3,5,6])
+      expect(searcher.findString("p")).to eq ([8,9])
+      expect(searcher.findString("x")).to eq ([])
+      expect(searcher.findString("mi")).to eq ([0])
+      expect(searcher.findString("is")).to eq ([1,4])
+      expect(searcher.findString("ss")).to eq ([2,5])
+      expect(searcher.findString("si")).to eq ([3,6])
+      expect(searcher.findString("ip")).to eq ([7])
+      expect(searcher.findString("pp")).to eq ([8])
+      expect(searcher.findString("pi")).to eq ([9])
+      expect(searcher.findString("mis")).to eq ([0])
+      expect(searcher.findString("iss")).to eq ([1,4])
+      expect(searcher.findString("ssi")).to eq ([2,5])
+      expect(searcher.findString("ssx")).to eq ([])
+      expect(searcher.findString("sis")).to eq ([3])
+      expect(searcher.findString("sip")).to eq ([6])
+      expect(searcher.findString("ipp")).to eq ([7])
+      expect(searcher.findString("ppi")).to eq ([8])
+      expect(searcher.findString("miss")).to eq ([0])
+      expect(searcher.findString("issi")).to eq ([1,4])
+      expect(searcher.findString("ssis")).to eq ([2])
+      expect(searcher.findString("siss")).to eq ([3])
+      expect(searcher.findString("ssip")).to eq ([5])
+      expect(searcher.findString("sipp")).to eq ([6])
+      expect(searcher.findString("ippi")).to eq ([7])
+      expect(searcher.findString("missi")).to eq ([0])
+      expect(searcher.findString("issis")).to eq ([1])
+      expect(searcher.findString("ssiss")).to eq ([2])
+      expect(searcher.findString("sissi")).to eq ([3])
+      expect(searcher.findString("issip")).to eq ([4])
+      expect(searcher.findString("ssipp")).to eq ([5])
+      expect(searcher.findString("sippi")).to eq ([6])
+      expect(searcher.findString("missis")).to eq ([0])
+      expect(searcher.findString("ississ")).to eq ([1])
+      expect(searcher.findString("ssissi")).to eq ([2])
+      expect(searcher.findString("sissip")).to eq ([3])
+      expect(searcher.findString("issipp")).to eq ([4])
+      expect(searcher.findString("ssippi")).to eq ([5])
+      expect(searcher.findString("mississ")).to eq ([0])
+      expect(searcher.findString("ississi")).to eq ([1])
+      expect(searcher.findString("ssissip")).to eq ([2])
+      expect(searcher.findString("sissipp")).to eq ([3])
+      expect(searcher.findString("issippi")).to eq ([4])
+      expect(searcher.findString("mississi")).to eq ([0])
+      expect(searcher.findString("ississip")).to eq ([1])
+      expect(searcher.findString("ssissipp")).to eq ([2])
+      expect(searcher.findString("sissippi")).to eq ([3])
+      expect(searcher.findString("mississip")).to eq ([0])
+      expect(searcher.findString("ississipp")).to eq ([1])
+      expect(searcher.findString("ssissippi")).to eq ([2])
+      expect(searcher.findString("ssissippix")).to eq ([])
+      expect(searcher.findString("mississipp")).to eq ([0])
+      expect(searcher.findString("ississippi")).to eq ([1])
+      expect(searcher.findString("mississippi")).to eq ([0])
+    end
+
+    it 'finds all substrings' do
+      st = SuffixTree.new(nil, { :valueDepth => true })
+      st.addDataSource(fileDataSource)
+
+      st.addValue('m',11)
+      st.addValue('i',12)
+      st.addValue('$',13)
+      searcher = Searcher.new(dataSource, st.root)
+      expect(searcher.findString("m")).to eq ([0,11])         # 2 m's now
+      expect(searcher.findString("i")).to eq ([1,4,7,10,12])  # final "i" of mississippi now explicit, and there's another as well
+      expect(searcher.findString("s")).to eq ([2,3,5,6])
+      expect(searcher.findString("p")).to eq ([8,9])
+      expect(searcher.findString("x")).to eq ([])
+      expect(searcher.findString("mi")).to eq ([0,11])        # "mi" is now at end as well
+      expect(searcher.findString("is")).to eq ([1,4])
+      expect(searcher.findString("ss")).to eq ([2,5])
+      expect(searcher.findString("si")).to eq ([3,6])
+      expect(searcher.findString("ip")).to eq ([7])
+      expect(searcher.findString("pp")).to eq ([8])
+      expect(searcher.findString("pi")).to eq ([9])
+      expect(searcher.findString("mis")).to eq ([0])
+      expect(searcher.findString("iss")).to eq ([1,4])
+      expect(searcher.findString("ssi")).to eq ([2,5])
+      expect(searcher.findString("ssx")).to eq ([])
+      expect(searcher.findString("sis")).to eq ([3])
+      expect(searcher.findString("sip")).to eq ([6])
+      expect(searcher.findString("ipp")).to eq ([7])
+      expect(searcher.findString("ppi")).to eq ([8])
+      expect(searcher.findString("miss")).to eq ([0])
+      expect(searcher.findString("issi")).to eq ([1,4])
+      expect(searcher.findString("ssis")).to eq ([2])
+      expect(searcher.findString("siss")).to eq ([3])
+      expect(searcher.findString("ssip")).to eq ([5])
+      expect(searcher.findString("sipp")).to eq ([6])
+      expect(searcher.findString("ippi")).to eq ([7])
+      expect(searcher.findString("missi")).to eq ([0])
+      expect(searcher.findString("issis")).to eq ([1])
+      expect(searcher.findString("ssiss")).to eq ([2])
+      expect(searcher.findString("sissi")).to eq ([3])
+      expect(searcher.findString("issip")).to eq ([4])
+      expect(searcher.findString("ssipp")).to eq ([5])
+      expect(searcher.findString("sippi")).to eq ([6])
+      expect(searcher.findString("missis")).to eq ([0])
+      expect(searcher.findString("ississ")).to eq ([1])
+      expect(searcher.findString("ssissi")).to eq ([2])
+      expect(searcher.findString("sissip")).to eq ([3])
+      expect(searcher.findString("issipp")).to eq ([4])
+      expect(searcher.findString("ssippi")).to eq ([5])
+      expect(searcher.findString("mississ")).to eq ([0])
+      expect(searcher.findString("ississi")).to eq ([1])
+      expect(searcher.findString("ssissip")).to eq ([2])
+      expect(searcher.findString("sissipp")).to eq ([3])
+      expect(searcher.findString("issippi")).to eq ([4])
+      expect(searcher.findString("mississi")).to eq ([0])
+      expect(searcher.findString("ississip")).to eq ([1])
+      expect(searcher.findString("ssissipp")).to eq ([2])
+      expect(searcher.findString("sissippi")).to eq ([3])
+      expect(searcher.findString("mississip")).to eq ([0])
+      expect(searcher.findString("ississipp")).to eq ([1])
+      expect(searcher.findString("ssissippi")).to eq ([2])
+      expect(searcher.findString("ssissippix")).to eq ([])
+      expect(searcher.findString("mississipp")).to eq ([0])
+      expect(searcher.findString("ississippi")).to eq ([1])
+      expect(searcher.findString("mississippi")).to eq ([0])
+    end
+  end
+
+  describe "#matchDataSource" do
+    it "returns root location if nothing matches" do
+      st = SuffixTree.new(nil, { :valueDepth => true })
+      st.addDataSource(dataSource)
+      searcher = Searcher.new(dataSource, st.root)
+      xDataSource = StringDataSource.new("xxx")
+      location = searcher.matchDataSource(xDataSource)
+      expect(location.onNode).to eq true
+      expect(location.node).to eq st.root
+      expect(location.depth).to eq 0
+    end
+
+    it "finds location that we can use to get suffix offset" do
+      st = SuffixTree.new('$', { :valueDepth => true })
+      st.addDataSource(dataSource)
+      searcher = Searcher.new(dataSource, st.root)
+      location = searcher.matchDataSource(StringDataSource.new "i")
+      result = []
+      location.node.each_suffix do |suffixOffset|
+        result << suffixOffset
+      end
+      expect(result).to eq [ 10, 7, 4, 1 ]
+    end
+  end
+end