suffix_tree 0.0.1

data/spec/suffix_tree_spec.rb

@@ -0,0 +1,270 @@
+require 'rspec'
+
+require_relative '../lib/data/string_data_source'
+require_relative '../lib/data/word_data_source'
+require_relative '../lib/suffix_tree'
+require_relative '../lib/visitor/data_source_visitor'
+require_relative '../lib/visitor/dfs'
+require_relative '../lib/visitor/leaf_count_visitor'
+require_relative '../lib/visitor/tree_print_visitor'
+require_relative '../lib/visitor/value_depth_visitor'
+
+
+describe 'suffix tree' do
+
+  it 'should create suffix tree' do
+
+    st = SuffixTree.new('$')
+    stringData = StringDataSource.new("mississippi")
+    st.addDataSource(stringData)
+    expect(st.root).to_not eq(nil)
+    expect(st.root.children.length).to eq(5)
+    mChild = st.root.children['m']
+    expect(mChild).to_not eq(nil)
+    expect(mChild.isLeaf).to eq(true)
+    expect(mChild.suffixOffset).to eq(0)
+    iChild = st.root.children['i']
+    expect(iChild).to_not eq(nil)
+    expect(iChild.isInternal).to eq(true)
+    expect(iChild.children.length).to eq(3)
+    expect(iChild.suffixOffset).to eq(1)
+    sChild = st.root.children['s']
+    expect(sChild.isInternal).to eq(true)
+    expect(sChild.children.length).to eq(2)
+    pChild = st.root.children['p']
+    expect(pChild.isInternal).to eq(true)
+    expect(pChild.children.length).to eq(2)
+  end
+
+  it "builds tree with one leaf" do
+    dataSource = StringDataSource.new("a")
+    st = SuffixTree.new
+    st.addDataSource(dataSource)
+    expect(st.root.children.length).to eq (1)
+    location = st.location
+    expect(location.onNode).to eq (true)
+    expect(location.node).to eq(st.root)
+  end
+
+  it "builds tree with two leaf" do
+    dataSource = StringDataSource.new("ab")
+    st = SuffixTree.new
+    st.addDataSource(dataSource)
+    expect(st.root.children.length).to eq (2)
+    child1 = st.root.children['a']
+    expect(child1.suffixOffset).to eq(0)
+    child2 = st.root.children['b']
+    expect(child2.suffixOffset).to eq(1)
+    location = st.location
+    expect(location.onNode).to eq (true)
+    expect(location.node).to eq(st.root)
+  end
+
+  it "builds mississippi tree" do
+    dataSource = StringDataSource.new("mississippi")
+    st = SuffixTree.new
+    st.setDataSource(dataSource)
+
+    sio = StringIO.new()
+    tpv = TreePrintVisitor.new(dataSource, sio)
+    dfs = DFS.new(tpv)
+
+    st.addValue('m', 0)
+
+    expect(st.root.children['m'].nodeId).to eq(2)
+    location = st.location
+    expect(location.onNode).to eq (true)
+    expect(location.node.nodeId).to eq (1)
+
+    st.addValue('i', 1)
+
+    expect(st.root.children['i'].nodeId).to eq(3)
+    expect(location.onNode).to eq (true)
+    expect(location.node.nodeId).to eq (st.root.nodeId)
+
+    st.addValue('s', 2)
+
+    expect(st.root.children['s'].nodeId).to eq(4)
+    expect(location.onNode).to eq (true)
+    expect(location.node.nodeId).to eq (st.root.nodeId)
+
+    st.addValue('s', 3)
+
+    rootSchild = st.root.children['s']
+    expect(rootSchild.nodeId).to eq (4)
+    expect(rootSchild.incomingEdgeStartOffset).to eq(2)
+    expect(rootSchild.incomingEdgeEndOffset).to eq(Node::CURRENT_ENDING_OFFSET)
+    expect(location.onNode).to eq (false)
+    expect(location.incomingEdgeOffset).to eq (3)
+
+    st.addValue('i', 4)
+
+    # should have added an internal node and a leaf node
+    # internal node should be the 's' child of root, with a suffix link pointing to root
+    rootSchild = st.root.children['s']
+    expect(rootSchild.suffixLink).not_to eq (nil)
+    expect(rootSchild.suffixLink).to eq(st.root)
+    expect(location.onNode).to eq (false)
+    expect(location.incomingEdgeOffset).to eq (2)
+    rootSchild = st.root.children['s']
+    suffix3_nodeId = rootSchild.children['s'].nodeId
+    expect(rootSchild.incomingEdgeStartOffset).to eq(2)
+    expect(rootSchild.incomingEdgeEndOffset).to eq(2)
+
+    # these next 3 should not should only update the location incomingEdgeOffset
+    st.addValue('s', 5)
+
+    expect(location.incomingEdgeOffset).to eq (3)
+    expect(location.onNode).to eq (false)
+
+    st.addValue('s', 6)
+
+    expect(location.incomingEdgeOffset).to eq (4)
+    expect(location.onNode).to eq (false)
+
+    st.addValue('i', 7)
+
+    expect(location.incomingEdgeOffset).to eq (5)
+    expect(location.onNode).to eq (false)
+
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(true)
+    slNode = location.node
+    expect(slNode.suffixLink).to eq(nil)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(false)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(true)
+    expect(slNode.suffixLink).not_to eq(nil)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(false)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(true)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(false)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(true)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (true)
+    expect(location.onNode).to eq(true)
+    result = st.extend('p', 8)
+
+    expect(result).to eq (false)
+    expect(location.onNode).to eq(true)
+
+    st.addValue('p', 9)
+
+    expect(location.onNode).to eq (false)
+    expect(location.incomingEdgeOffset).to eq(9)
+
+    st.addValue('i', 10)
+
+    dfs.traverse(st.root)
+    expected_tree = <<-TREESTR
+ROOT
+ mississippi
+ i
+  ssi
+   ssippi
+   ppi
+  ppi
+ s
+  si
+   ssippi
+   ppi
+  i
+   ssippi
+   ppi
+ p
+  pi
+  i
+TREESTR
+    expect(sio.string).to eq (expected_tree)
+
+    expect(location.onNode).to eq (true)
+    expect(location.node.nodeId).to eq (13)
+  end
+
+  it "builds suffix tree of words" do
+    wordDataSource = WordDataSource.new File.join('spec', 'fixtures', "chapter1.txt")
+    st = SuffixTree.new(nil, { :leafCount => true, :valueDepth => true })
+    st.addDataSource(wordDataSource)
+
+    root = st.root
+    expect(root.nodeId).to eq 1
+    lcv = DFS.new(LeafCountVisitor.new)
+    lcv.traverse(st.root)
+    deepVal = DeepestValueDepthVisitor.new
+    dfs = DFS.new(deepVal)
+    dfs.traverse(st.root)
+    expect(st.nodeFactory.valuePath(deepVal.deepestValueDepthNode)).to eq "in spite of his"
+  end
+
+  it "converts tree to suffix array" do
+    dataSource = StringDataSource.new "mississippi"
+    st = SuffixTree.new('$')
+    st.addDataSource dataSource
+
+    suffix_array = []
+    st.root.each_suffix do |suffixOffset|
+      suffix_array << suffixOffset
+    end
+    expect(suffix_array).to eq [11, 10, 7, 4, 1, 0, 9, 8, 6, 3, 5, 2]
+  end
+
+  describe "builds generalized suffix trees" do
+    let(:alphaDataSource) { StringDataSource.new "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqr" }
+    let(:alphaNodeFactory) { NodeFactory.new alphaDataSource }
+    let(:secondDataSource) { StringDataSource.new "asjdfkjaskdjfkajlxxxxxxxjklmnopqrstuvwxyzabcsdf;laksjdf aksjd"}
+
+    it "builds generalized suffix tree" do
+      st = SuffixTree.new('$', {:valueDepth => true})
+      st.addDataSource alphaDataSource
+      st.addDataSource secondDataSource
+
+      deepVal = DeepestValueDepthVisitor.new
+      dfs = DFS.new(deepVal)
+      dfs.traverse(st.root)
+      expect(st.nodeFactory.valuePath(deepVal.deepestValueDepthNode,'')).to eq "jklmnopqrstuvwxyzabc"
+    end
+
+    let(:src1) { StringDataSource.new "abcd" }
+    let(:src2) { StringDataSource.new "cxyz" }
+
+    it "uses multiple data sources" do
+      st = SuffixTree.new(nil, {:valueDepth => true, :dataSourceBit => true})
+      st.addDataSource src1
+      st.addDataSource src2
+
+      deepVal = DeepestValueDepthVisitor.new
+      dfs = DFS.new(deepVal)
+      dfs.traverse(st.root)
+      expect(st.nodeFactory.valuePath(deepVal.deepestValueDepthNode,'')).to eq "c"
+      dataSourceVisitor = DataSourceVisitor.new
+      dfs = DFS.new(dataSourceVisitor)
+      dfs.traverse(st.root)
+      expect(deepVal.deepestValueDepthNode.dataSourceBit).to eq 3
+      expect(st.root.dataSourceBit).to eq 3
+      expect(st.root.children['a'].dataSourceBit).to eq 1
+      expect(st.root.children['x'].dataSourceBit).to eq 2
+      expect(deepVal.deepestValueDepthNode.children['d'].dataSourceBit).to eq 1
+      expect(deepVal.deepestValueDepthNode.children['x'].dataSourceBit).to eq 2
+    end
+  end
+
+end

data/spec/util_spec.rb

@@ -0,0 +1,47 @@
+require 'rspec'
+require_relative '../lib/visitor/numbering_visitor'
+
+
+describe 'utility' do
+  it 'should find right-most 1-bit' do
+    bu = BitUtil.new
+    (0..63).each do |n|
+      expect(bu.rightBit(2**n)).to eq (n+1)
+    end
+    expect(bu.rightBit(65)).to eq (1)
+    expect(bu.rightBit(66)).to eq (2)
+  end
+
+  it 'should find left-most 1-bit' do
+    bu = BitUtil.new
+    (0..63).each do |n|
+      expect(bu.leftBit(2**n)).to eq (n+1)
+    end
+    expect(bu.leftBit(65)).to eq (7)
+    expect(bu.leftBit(66)).to eq (7)
+    expect(bu.leftBit(129)).to eq (8)
+    expect(bu.leftBit(280)).to eq (9)
+  end
+
+  it 'finds bit common to two values greater than or equal to a given value' do
+    bu = BitUtil.new
+    expect(bu.bitGreaterThanOrEqualTo(1, 1, 1)).to eq 1
+    expect(bu.bitGreaterThanOrEqualTo(1, 2, 2)).to eq 2
+    expect(bu.bitGreaterThanOrEqualTo(1, 3, 3)).to eq 1
+    expect(bu.bitGreaterThanOrEqualTo(1, 4, 4)).to eq 3
+    expect(bu.bitGreaterThanOrEqualTo(1, 8, 8)).to eq 4
+    expect(bu.bitGreaterThanOrEqualTo(1, 7, 6)).to eq 2
+    expect(bu.bitGreaterThanOrEqualTo(2, 5, 6)).to eq 3
+    expect(bu.bitGreaterThanOrEqualTo(10, 1024+2048, 2049)).to eq 12
+  end
+
+  it 'finds left most bit to right of a given bit' do
+    bu = BitUtil.new
+    expect(bu.leftMostBitToRightOf(2, 1)).to eq 1
+    expect(bu.leftMostBitToRightOf(4, 1)).to eq 1
+    expect(bu.leftMostBitToRightOf(8, 3)).to eq 2
+    expect(bu.leftMostBitToRightOf(8, 15)).to eq 4
+    expect(bu.leftMostBitToRightOf(8, 22)).to eq 5
+    expect(bu.leftMostBitToRightOf(8, 33)).to eq 6
+  end
+end

data/spec/visitor_spec.rb

@@ -0,0 +1,310 @@
+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/suffix_tree'
+require_relative '../lib/visitor/bfs'
+require_relative '../lib/visitor/data_source_visitor'
+require_relative '../lib/visitor/k_common_visitor'
+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/visitor/suffix_offset_visitor'
+require_relative '../lib/visitor/numbering_visitor'
+require_relative '../lib/visitor/tree_print_visitor'
+
+describe 'character depth visitor' do
+
+  let (:dataSource) { StringDataSource.new("mississippi") }
+  let (:stringNodeFactory) { NodeFactory.new dataSource }
+  let (:stringRootNodeId) { stringNodeFactory.nextNodeId }
+  let (:fileDataSource) { FileDataSource.new(File.join('spec', 'fixtures', "mississippi.txt")) }
+  let (:fileNodeFactory) { NodeFactory.new fileDataSource }
+
+  def verifyValueDepth(root)
+    expect(root.valueDepth).to eq (0)
+    mChild = root.children['m']
+    iChild = root.children['i']
+    sChild = root.children['s']
+    pChild = root.children['p']
+    expect(pChild.valueDepth).to eq (1)
+    expect(pChild.children['p'].valueDepth).to eq (Node::LEAF_DEPTH)
+    expect(pChild.children['i'].valueDepth).to eq (Node::LEAF_DEPTH)
+    expect(mChild.valueDepth).to eq (Node::LEAF_DEPTH)
+    expect(iChild.valueDepth).to eq (1)
+    expect(iChild.children['p'].valueDepth).to eq (Node::LEAF_DEPTH)
+    isChild = iChild.children['s']
+    expect(isChild.valueDepth).to eq (4)
+    expect(isChild.children['s'].valueDepth).to eq(Node::LEAF_DEPTH)
+    expect(isChild.children['p'].valueDepth).to eq(Node::LEAF_DEPTH)
+    expect(sChild.valueDepth).to eq (1)
+    siChild = sChild.children['i']
+    ssChild = sChild.children['s']
+    expect(siChild.valueDepth).to eq (2)
+    expect(ssChild.valueDepth).to eq (3)
+    expect(siChild.children['p'].valueDepth).to eq(Node::LEAF_DEPTH)
+    expect(siChild.children['s'].valueDepth).to eq(Node::LEAF_DEPTH)
+    expect(ssChild.children['s'].valueDepth).to eq(Node::LEAF_DEPTH)
+    expect(ssChild.children['p'].valueDepth).to eq(Node::LEAF_DEPTH)
+  end
+
+  context "DFS traversal" do
+    it "sets character depth using depth first traversal" do
+
+      hash = {
+          :valueDepth => true
+      }
+      st = SuffixTree.new(nil, hash)
+      st.addDataSource(dataSource)
+
+      cdv = DFS.new(ValueDepthVisitor.new)
+      cdv.traverse(st.root)
+      self.verifyValueDepth(st.root)
+    end
+  end
+
+  context "BFS traversal" do
+    it "sets character depth using breadth first traversal" do
+      st = SuffixTree.new(nil, { :valueDepth => true })
+      st.addDataSource(dataSource)
+      cdv = BFS.new(ValueDepthVisitor.new)
+      cdv.traverse(st.root)
+      self.verifyValueDepth(st.root)
+    end
+  end
+
+  def verifyLeafCount(root)
+    lcv = DFS.new(LeafCountVisitor.new)
+    lcv.traverse(root)
+    expect(root.leafCount).to eq (10)  # final 'i' is implicit
+    mChild = root.children['m']
+    iChild = root.children['i']
+    sChild = root.children['s']
+    pChild = root.children['p']
+    expect(mChild.leafCount).to eq (1)
+    expect(iChild.leafCount).to eq (3)
+    expect(sChild.leafCount).to eq (4)
+    expect(pChild.leafCount).to eq (2)
+  end
+
+  context "DFS traversal" do
+    it "sets leaf count for suffix tree created from string" do
+      hash = {
+          :leafCount => true
+      }
+      st = SuffixTree.new(nil, hash)
+      st.addDataSource(dataSource)
+      self.verifyLeafCount(st.root)
+    end
+  end
+
+  context "DFS traversal" do
+    it "sets leaf count for suffix tree loaded from file" do
+      hash = {
+          :leafCount => true
+      }
+      st = SuffixTree.new(nil, hash)
+      st.addDataSource(fileDataSource)
+      self.verifyLeafCount(st.root)
+    end
+  end
+
+  def verifyNodeCount(dataSource)
+    st = SuffixTree.new(nil, nil)
+    st.addDataSource(fileDataSource)
+    ncv = NodeCountVisitor.new
+    bt = DFS.new(ncv)
+    bt.traverse(st.root)
+    expect(ncv.count).to eq (17)
+    bncv = NodeCountVisitor.new
+    bfst = BFS.new(bncv)
+    bfst.traverse(st.root)
+    expect(bncv.count).to eq (17)
+  end
+
+  context "Count nodes" do
+    it "counts nodes with DFS traversal of file data source" do
+      verifyNodeCount(fileDataSource)
+    end
+  end
+
+  context "Count nodes" do
+    it "counts nodes with DFS traversal of string data source" do
+      verifyNodeCount(dataSource)
+    end
+  end
+
+  context "collect suffix offsets" do
+    it "traverses suffix tree and collects suffix offsets" do
+      soCollector = SuffixOffsetVisitor.new
+      so = BFS.new(soCollector)
+      st = SuffixTree.new(nil, nil)
+      st.addDataSource(dataSource)
+      so.traverse(st.root)
+      expect(soCollector.result.sort).to eq ([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ])
+    end
+  end
+
+  describe "generalized suffix tree" do
+    let(:s1) { StringDataSource.new "sandollar" }
+    let(:s2) { StringDataSource.new "sandlot" }
+    let(:s3) { StringDataSource.new "handler" }
+    let(:s4) { StringDataSource.new "grand" }
+    let(:s5) { StringDataSource.new "pantry" }
+
+    it "KCommonVisitor finds longest substring common to k strings" do
+      # make the generalized suffix tree
+      st = SuffixTree.new("$", {:valueDepth => true, :dataSourceBit => true})
+      st.addDataSource(s1)
+      st.addDataSource(s2)
+      st.addDataSource(s3)
+      st.addDataSource(s4)
+      st.addDataSource(s5)
+
+      dataSourceVisitor = DataSourceVisitor.new
+      dfs = DFS.new(dataSourceVisitor)
+      dfs.traverse(st.root)
+      kCommonVisitor = KCommonVisitor.new(s1)
+      dfs = DFS.new(kCommonVisitor)
+      dfs.traverse(st.root)
+      longestLength,sample = kCommonVisitor.longestStringCommonTo(2)
+      expect(longestLength).to eq 4
+      expect(sample).to eq "sand"
+      longestLength,sample = kCommonVisitor.longestStringCommonTo(3)
+      expect(longestLength).to eq 3
+      expect(sample).to eq "and"
+      longestLength,sample = kCommonVisitor.longestStringCommonTo(4)
+      expect(longestLength).to eq 3
+      expect(sample).to eq "and"
+      longestLength,sample = kCommonVisitor.longestStringCommonTo(5)
+      expect(longestLength).to eq 2
+      expect(sample).to eq "an"
+    end
+  end
+
+  describe "DFS depth number" do
+    it "sets sets depth numbers and count of nodes in subtree for nodes" do
+      st = SuffixTree.new
+      st.addDataSource(dataSource)
+      dfs = OrderedDFS.new(NumberingVisitor.new)
+      dfs.traverse(st.root)
+      expect(st.root.dfsNumber).to eq 1
+      expect(st.root.numberNodesInSubtree).to eq 17
+
+      iChild = st.root.children['i']
+      expect(iChild.dfsNumber).to eq 2
+      expect(iChild.numberNodesInSubtree).to eq 5
+      expect(iChild.children['p'].dfsNumber).to eq 3
+      expect(iChild.children['p'].numberNodesInSubtree).to eq 1
+      expect(iChild.children['s'].dfsNumber).to eq 4
+      expect(iChild.children['s'].numberNodesInSubtree).to eq 3
+      expect(iChild.children['s'].children['p'].dfsNumber).to eq 5
+      expect(iChild.children['s'].children['p'].numberNodesInSubtree).to eq 1
+      expect(iChild.children['s'].children['s'].dfsNumber).to eq 6
+      expect(iChild.children['s'].children['s'].numberNodesInSubtree).to eq 1
+
+      mChild = st.root.children['m']
+      expect(mChild.dfsNumber).to eq 7
+      expect(mChild.numberNodesInSubtree).to eq 1
+
+      pChild = st.root.children['p']
+      expect(pChild.dfsNumber).to eq 8
+      expect(pChild.numberNodesInSubtree).to eq 3
+      expect(pChild.children['i'].dfsNumber).to eq 9
+      expect(pChild.children['p'].dfsNumber).to eq 10
+
+      sChild = st.root.children['s']
+      expect(sChild.dfsNumber).to eq 11
+      expect(sChild.numberNodesInSubtree).to eq 7
+      expect(sChild.children['i'].dfsNumber).to eq 12
+      expect(sChild.children['i'].numberNodesInSubtree).to eq 3
+      expect(sChild.children['i'].children['p'].dfsNumber).to eq 13
+      expect(sChild.children['i'].children['p'].numberNodesInSubtree).to eq 1
+      expect(sChild.children['i'].children['s'].dfsNumber).to eq 14
+      expect(sChild.children['i'].children['s'].numberNodesInSubtree).to eq 1
+      expect(sChild.children['s'].dfsNumber).to eq 15
+      expect(sChild.children['s'].numberNodesInSubtree).to eq 3
+      expect(sChild.children['s'].children['p'].dfsNumber).to eq 16
+      expect(sChild.children['s'].children['p'].numberNodesInSubtree).to eq 1
+      expect(sChild.children['s'].children['s'].dfsNumber).to eq 17
+      expect(sChild.children['s'].children['s'].numberNodesInSubtree).to eq 1
+    end
+  end
+
+  describe "DFS node path numbers number" do
+    it "sets sets node depth numbers then path numbers" do
+      st = SuffixTree.new
+      st.addDataSource(dataSource)
+      dfs = OrderedDFS.new(NumberingVisitor.new)
+      dfs.traverse(st.root)
+      dfs = OrderedDFS.new(RunDefiningVisitor.new)
+      dfs.traverse(st.root)
+      dfs = DFS.new(RunBitVisitor.new(st.root))
+      dfs.traverse(st.root)
+
+      expect(st.root.runTail.binaryTreeHeight).to eq 5
+      expect(st.root.runTail.dfsNumber).to eq 16
+      expect(st.root.runBits).to eq 16
+
+      iChild = st.root.children['i']
+      expect(iChild.runTail.binaryTreeHeight).to eq 3
+      expect(iChild.runTail.dfsNumber).to eq 4
+      expect(iChild.runBits).to eq 20  # 16 (binaryTreeHeight 5) + 4 (binaryTreeHeight 3)
+
+      expect(iChild.children['p'].runTail.binaryTreeHeight).to eq 1
+      expect(iChild.children['p'].runTail.dfsNumber).to eq 3
+      expect(iChild.children['p'].runBits).to eq 21
+      expect(iChild.children['s'].runTail.binaryTreeHeight).to eq 3
+      expect(iChild.children['s'].runTail.dfsNumber).to eq 4
+      expect(iChild.children['s'].runBits).to eq 20
+      expect(iChild.children['s'].children['p'].runTail.binaryTreeHeight).to eq 1
+      expect(iChild.children['s'].children['p'].runTail.dfsNumber).to eq 5
+      expect(iChild.children['s'].children['p'].runBits).to eq 21
+      expect(iChild.children['s'].children['s'].runTail.binaryTreeHeight).to eq 2
+      expect(iChild.children['s'].children['s'].runTail.dfsNumber).to eq 6
+      expect(iChild.children['s'].children['s'].runBits).to eq 22
+
+      mChild = st.root.children['m']
+      expect(mChild.runTail.binaryTreeHeight).to eq 1
+      expect(mChild.runTail.dfsNumber).to eq 7
+      expect(mChild.runBits).to eq 17
+
+      pChild = st.root.children['p']
+      expect(pChild.runTail.binaryTreeHeight).to eq 4
+      expect(pChild.runTail.dfsNumber).to eq 8
+      expect(pChild.runBits).to eq 24
+      expect(pChild.children['i'].runTail.binaryTreeHeight).to eq 1
+      expect(pChild.children['i'].runTail.dfsNumber).to eq 9
+      expect(pChild.children['i'].runBits).to eq 25
+      expect(pChild.children['p'].runTail.binaryTreeHeight).to eq 2
+      expect(pChild.children['p'].runTail.dfsNumber).to eq 10
+      expect(pChild.children['p'].runBits).to eq 26
+
+      sChild = st.root.children['s']
+      expect(sChild.runTail.binaryTreeHeight).to eq 5
+      expect(sChild.runTail.dfsNumber).to eq 16
+      expect(sChild.runBits).to eq 16
+      expect(sChild.children['i'].runTail.binaryTreeHeight).to eq 3
+      expect(sChild.children['i'].runTail.dfsNumber).to eq 12
+      expect(sChild.children['i'].runBits).to eq 20
+      expect(sChild.children['i'].children['p'].runTail.binaryTreeHeight).to eq 1
+      expect(sChild.children['i'].children['p'].runTail.dfsNumber).to eq 13
+      expect(sChild.children['i'].children['p'].runBits).to eq 21
+      expect(sChild.children['i'].children['s'].runTail.binaryTreeHeight).to eq 2
+      expect(sChild.children['i'].children['s'].runTail.dfsNumber).to eq 14
+      expect(sChild.children['i'].children['s'].runBits).to eq 22
+      expect(sChild.children['s'].runTail.binaryTreeHeight).to eq 5
+      expect(sChild.children['s'].runTail.dfsNumber).to eq 16
+      expect(sChild.children['s'].runBits).to eq 16
+      expect(sChild.children['s'].children['p'].runTail.binaryTreeHeight).to eq 5
+      expect(sChild.children['s'].children['p'].runTail.dfsNumber).to eq 16
+      expect(sChild.children['s'].children['p'].runBits).to eq 16
+      expect(sChild.children['s'].children['s'].runTail.binaryTreeHeight).to eq 1
+      expect(sChild.children['s'].children['s'].runTail.dfsNumber).to eq 17
+      expect(sChild.children['s'].children['s'].runBits).to eq 17
+    end
+  end
+end