algorithms 0.6.1 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -21,9 +21,9 @@ if !(defined? RUBY_ENGINE && RUBY_ENGINE == 'jruby')
21
21
  # Check if any instances were swept
22
22
  count = 0
23
23
  ObjectSpace.each_object(anon_key_class) { |x| count += 1 }
24
- count.should eql(200)
24
+ expect(count).to eql(200)
25
25
  ObjectSpace.each_object(anon_val_class) { |x| count += 1 }
26
- count.should eql(400)
26
+ expect(count).to eql(400)
27
27
  end
28
28
  end
29
29
  end
@@ -8,32 +8,32 @@ describe Containers::PriorityQueue do
8
8
 
9
9
  describe "(empty priority queue)" do
10
10
  it "should return 0 for size and be empty" do
11
- @q.size.should eql(0)
12
- @q.should be_empty
11
+ expect(@q.size).to eql(0)
12
+ expect(@q).to be_empty
13
13
  end
14
14
 
15
15
  it "should not return anything" do
16
- @q.next.should be_nil
17
- @q.pop.should be_nil
18
- @q.delete(1).should be_nil
19
- @q.has_priority?(1).should be_false
16
+ expect(@q.next).to be_nil
17
+ expect(@q.pop).to be_nil
18
+ expect(@q.delete(1)).to be_nil
19
+ expect(@q.has_priority?(1)).to be false
20
20
  end
21
21
 
22
22
  it "should give the correct size when adding items" do
23
23
  20.times do |i|
24
- @q.size.should eql(i)
24
+ expect(@q.size).to eql(i)
25
25
  @q.push(i, i)
26
26
  end
27
27
  10.times do |i|
28
- @q.size.should eql(20-i)
28
+ expect(@q.size).to eql(20-i)
29
29
  @q.pop
30
30
  end
31
31
  10.times do |i|
32
- @q.size.should eql(i+10)
32
+ expect(@q.size).to eql(i+10)
33
33
  @q.push(i, i)
34
34
  end
35
35
  @q.delete(5)
36
- @q.size.should eql(19)
36
+ expect(@q.size).to eql(19)
37
37
  end
38
38
  end
39
39
 
@@ -45,31 +45,31 @@ describe Containers::PriorityQueue do
45
45
  end
46
46
 
47
47
  it "should next/pop the highest priority" do
48
- @q.next.should eql("Alaska")
49
- @q.size.should eql(3)
50
- @q.pop.should eql("Alaska")
51
- @q.size.should eql(2)
48
+ expect(@q.next).to eql("Alaska")
49
+ expect(@q.size).to eql(3)
50
+ expect(@q.pop).to eql("Alaska")
51
+ expect(@q.size).to eql(2)
52
52
  end
53
53
 
54
54
  it "should not be empty" do
55
- @q.should_not be_empty
55
+ expect(@q).not_to be_empty
56
56
  end
57
57
 
58
58
  it "should has_priority? priorities it has" do
59
- @q.has_priority?(50).should be_true
60
- @q.has_priority?(10).should be_false
59
+ expect(@q.has_priority?(50)).to be true
60
+ expect(@q.has_priority?(10)).to be false
61
61
  end
62
62
 
63
63
  it "should return nil after popping everything" do
64
64
  3.times do
65
65
  @q.pop
66
66
  end
67
- @q.pop.should be_nil
67
+ expect(@q.pop).to be_nil
68
68
  end
69
69
 
70
70
  it "should delete things it has and not things it doesn't" do
71
- @q.delete(50).should eql("Alaska")
72
- @q.delete(10).should eql(nil)
71
+ expect(@q.delete(50)).to eql("Alaska")
72
+ expect(@q.delete(10)).to eql(nil)
73
73
  end
74
74
  end
75
75
  end
data/spec/queue_spec.rb CHANGED
@@ -8,20 +8,20 @@ describe "empty queue" do
8
8
 
9
9
 
10
10
  it "should return nil when sent #pop" do
11
- @queue.pop.should be_nil
11
+ expect(@queue.pop).to be_nil
12
12
  end
13
13
 
14
14
  it "should return a size of 1 when sent #push" do
15
15
  @queue.push(1)
16
- @queue.size.should eql(1)
16
+ expect(@queue.size).to eql(1)
17
17
  end
18
18
 
19
19
  it "should return nil when sent #next" do
20
- @queue.next.should be_nil
20
+ expect(@queue.next).to be_nil
21
21
  end
22
22
 
23
23
  it "should return empty?" do
24
- @queue.empty?.should be_true
24
+ expect(@queue.empty?).to be true
25
25
  end
26
26
  end
27
27
 
@@ -33,29 +33,29 @@ describe "non-empty queue" do
33
33
  end
34
34
 
35
35
  it "should return first pushed object" do
36
- @queue.pop.should eql(10)
36
+ expect(@queue.pop).to eql(10)
37
37
  end
38
38
 
39
39
  it "should return the size" do
40
- @queue.size.should eql(2)
40
+ expect(@queue.size).to eql(2)
41
41
  end
42
42
 
43
43
  it "should not return empty?" do
44
- @queue.empty?.should be_false
44
+ expect(@queue.empty?).to be false
45
45
  end
46
46
 
47
47
  it "should iterate in FIFO order" do
48
48
  arr = []
49
49
  @queue.each { |obj| arr << obj }
50
- arr.should eql([10, "10"])
50
+ expect(arr).to eql([10, "10"])
51
51
  end
52
52
 
53
53
  it "should return nil after all gets" do
54
54
  2.times do
55
55
  @queue.pop
56
56
  end
57
- @queue.pop.should be_nil
58
- @queue.next.should be_nil
57
+ expect(@queue.pop).to be_nil
58
+ expect(@queue.next).to be_nil
59
59
  end
60
60
 
61
61
  end
@@ -4,30 +4,30 @@ require 'algorithms'
4
4
  shared_examples "empty rbtree" do
5
5
  it "should let you push stuff in" do
6
6
  100.times { |x| @tree[x] = x }
7
- @tree.size.should eql(100)
7
+ expect(@tree.size).to eql(100)
8
8
  end
9
9
 
10
10
  it "should be empty?" do
11
- @tree.empty?.should be_true
11
+ expect(@tree.empty?).to be true
12
12
  end
13
13
 
14
14
  it "should return 0 for height" do
15
- @tree.height.should eql(0)
15
+ expect(@tree.height).to eql(0)
16
16
  end
17
17
 
18
18
  it "should return 0 for size" do
19
- @tree.size.should eql(0)
19
+ expect(@tree.size).to eql(0)
20
20
  end
21
21
 
22
22
  it "should return nil for max and min" do
23
- @tree.min.should be_nil
24
- @tree.max.should be_nil
25
- @tree.min_key.should be_nil
26
- @tree.max_key.should be_nil
23
+ expect(@tree.min).to be_nil
24
+ expect(@tree.max).to be_nil
25
+ expect(@tree.min_key).to be_nil
26
+ expect(@tree.max_key).to be_nil
27
27
  end
28
28
 
29
29
  it "should not delete" do
30
- @tree.delete(:non_existing).should be_nil
30
+ expect(@tree.delete(:non_existing)).to be_nil
31
31
  end
32
32
  end
33
33
 
@@ -39,52 +39,52 @@ shared_examples "non-empty rbtree" do
39
39
  end
40
40
 
41
41
  it "should return correct size (uniqify items first)" do
42
- @tree.should_not be_empty
43
- @tree.size.should eql(@random_array.uniq.size)
42
+ expect(@tree).not_to be_empty
43
+ expect(@tree.size).to eql(@random_array.uniq.size)
44
44
  end
45
45
 
46
46
  it "should return correct max and min" do
47
- @tree.min_key.should eql(@random_array.min)
48
- @tree.max_key.should eql(@random_array.max)
49
- @tree.min[0].should eql(@random_array.min)
50
- @tree.max[0].should eql(@random_array.max)
47
+ expect(@tree.min_key).to eql(@random_array.min)
48
+ expect(@tree.max_key).to eql(@random_array.max)
49
+ expect(@tree.min[0]).to eql(@random_array.min)
50
+ expect(@tree.max[0]).to eql(@random_array.max)
51
51
  end
52
52
 
53
53
  it "should not #has_key? keys it doesn't have" do
54
- @tree.has_key?(100000).should be_false
54
+ expect(@tree.has_key?(100000)).to be false
55
55
  end
56
56
 
57
57
  it "should #has_key? keys it does have" do
58
- @tree.has_key?(@random_array[0]).should be_true
58
+ expect(@tree.has_key?(@random_array[0])).to be true
59
59
  end
60
60
 
61
61
  it "should remove all keys" do
62
62
  ordered = []
63
63
  @random_array.uniq.each do |key|
64
- @tree.has_key?(key).should eql(true)
64
+ expect(@tree.has_key?(key)).to eql(true)
65
65
  ordered << @tree.delete(key)
66
- @tree.has_key?(key).should eql(false)
66
+ expect(@tree.has_key?(key)).to eql(false)
67
67
  end
68
- ordered.should eql(@random_array.uniq)
68
+ expect(ordered).to eql(@random_array.uniq)
69
69
  end
70
70
 
71
71
  it "should delete_min keys correctly" do
72
72
  ascending = []
73
73
  ascending << @tree.delete_min until @tree.empty?
74
- ascending.should eql(@random_array.uniq.sort)
74
+ expect(ascending).to eql(@random_array.uniq.sort)
75
75
  end
76
76
 
77
77
  it "should delete_max keys correctly" do
78
78
  descending = []
79
79
  descending << @tree.delete_max until @tree.empty?
80
- descending.should eql(@random_array.uniq.sort.reverse)
80
+ expect(descending).to eql(@random_array.uniq.sort.reverse)
81
81
  end
82
82
 
83
83
  it "should let you iterate with #each" do
84
84
  counter = 0
85
85
  sorted_array = @random_array.uniq.sort
86
86
  @tree.each do |key, val|
87
- key.should eql(sorted_array[counter])
87
+ expect(key).to eql(sorted_array[counter])
88
88
  counter += 1
89
89
  end
90
90
  end
data/spec/search_spec.rb CHANGED
@@ -8,21 +8,21 @@ describe "search algorithms" do
8
8
  n = 1000
9
9
  @rand_array = Array.new(n) { rand(n) }.sort
10
10
 
11
- Algorithms::Search.binary_search(@rand_array, @rand_array.first).should eql(@rand_array.first)
12
- Algorithms::Search.binary_search(@rand_array, 999999).should be_nil
13
- Algorithms::Search.binary_search(@rand_array, nil).should be_nil
11
+ expect(Algorithms::Search.binary_search(@rand_array, @rand_array.first)).to eql(@rand_array.first)
12
+ expect(Algorithms::Search.binary_search(@rand_array, 999999)).to be_nil
13
+ expect(Algorithms::Search.binary_search(@rand_array, nil)).to be_nil
14
14
  end
15
15
 
16
16
  it "should use kmp_search to find substrings it has" do
17
17
  string = "ABC ABCDAB ABCDABCDABDE"
18
- Algorithms::Search.kmp_search(string, "ABCDABD").should eql(15)
19
- Algorithms::Search.kmp_search(string, "ABCDEF").should be_nil
20
- Algorithms::Search.kmp_search(string, nil).should be_nil
21
- Algorithms::Search.kmp_search(string, "").should be_nil
22
- Algorithms::Search.kmp_search(nil, "ABCD").should be_nil
18
+ expect(Algorithms::Search.kmp_search(string, "ABCDABD")).to eql(15)
19
+ expect(Algorithms::Search.kmp_search(string, "ABCDEF")).to be_nil
20
+ expect(Algorithms::Search.kmp_search(string, nil)).to be_nil
21
+ expect(Algorithms::Search.kmp_search(string, "")).to be_nil
22
+ expect(Algorithms::Search.kmp_search(nil, "ABCD")).to be_nil
23
23
  end
24
24
 
25
25
  it "should let you include Search in String to enable instance methods" do
26
- "ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD").should eql(15)
26
+ expect("ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD")).to eql(15)
27
27
  end
28
28
  end
data/spec/sort_spec.rb CHANGED
@@ -4,17 +4,18 @@ include Algorithms
4
4
 
5
5
  describe "sort algorithms" do
6
6
  before(:each) do
7
- @sorts = %w(bubble_sort comb_sort selection_sort heapsort insertion_sort shell_sort quicksort mergesort)
7
+ @sorts = %w(bubble_sort comb_sort selection_sort heapsort insertion_sort
8
+ shell_sort quicksort mergesort dualpivotquicksort)
8
9
  end
9
10
 
10
11
  it "should work for empty containers" do
11
12
  empty_array = []
12
- @sorts.each { |sort| Sort.send(sort, empty_array).should eql([]) }
13
+ @sorts.each { |sort| expect(Sort.send(sort, empty_array)).to eql([]) }
13
14
  end
14
15
 
15
16
  it "should work for a container of size 1" do
16
17
  one_array = [1]
17
- @sorts.each { |sort| Sort.send(sort, one_array).should eql(one_array) }
18
+ @sorts.each { |sort| expect(Sort.send(sort, one_array)).to eql([1]) }
18
19
  end
19
20
 
20
21
  it "should work for random arrays of numbers" do
@@ -22,7 +23,7 @@ describe "sort algorithms" do
22
23
  rand_array = Array.new(n) { rand(n) }
23
24
  sorted_array = rand_array.sort
24
25
 
25
- @sorts.each { |sort| Sort.send(sort, rand_array.dup).should eql(sorted_array) }
26
+ @sorts.each { |sort| expect(Sort.send(sort, rand_array.dup)).to eql(sorted_array) }
26
27
  end
27
28
 
28
- end
29
+ end
@@ -4,24 +4,24 @@ require 'algorithms'
4
4
  shared_examples "empty splaytree" do
5
5
  it "should let you push stuff in" do
6
6
  100.times { |x| @tree[x] = x }
7
- @tree.size.should eql(100)
7
+ expect(@tree.size).to eql(100)
8
8
  end
9
9
 
10
10
  it "should return 0 for size" do
11
- @tree.size.should eql(0)
11
+ expect(@tree.size).to eql(0)
12
12
  end
13
13
 
14
14
  it "should return nil for #min and #max" do
15
- @tree.min.should be_nil
16
- @tree.max.should be_nil
15
+ expect(@tree.min).to be_nil
16
+ expect(@tree.max).to be_nil
17
17
  end
18
18
 
19
19
  it "should return nil for #delete" do
20
- @tree.delete(:non_existing).should be_nil
20
+ expect(@tree.delete(:non_existing)).to be_nil
21
21
  end
22
22
 
23
23
  it "should return nil for #get" do
24
- @tree[4235].should be_nil
24
+ expect(@tree[4235]).to be_nil
25
25
  end
26
26
  end
27
27
 
@@ -34,40 +34,40 @@ shared_examples "non-empty splaytree" do
34
34
  end
35
35
 
36
36
  it "should return correct size (uniqify items first)" do
37
- @tree.size.should eql(@random_array.uniq.size)
37
+ expect(@tree.size).to eql(@random_array.uniq.size)
38
38
  end
39
39
 
40
40
  it "should have correct height (worst case is when items are inserted in order, and height = num items inserted)" do
41
41
  @tree.clear
42
42
  10.times { |x| @tree[x] = x }
43
- @tree.height.should eql(10)
43
+ expect(@tree.height).to eql(10)
44
44
  end
45
45
 
46
46
  it "should return correct max and min keys" do
47
- @tree.min[0].should eql(@random_array.min)
48
- @tree.max[0].should eql(@random_array.max)
47
+ expect(@tree.min[0]).to eql(@random_array.min)
48
+ expect(@tree.max[0]).to eql(@random_array.max)
49
49
  end
50
50
 
51
51
  it "should not #has_key? keys it doesn't have" do
52
- @tree.has_key?(10000).should be_false
52
+ expect(@tree.has_key?(10000)).to be false
53
53
  end
54
54
 
55
55
  it "should #has_key? keys it does have" do
56
- @tree.has_key?(@random_array[0]).should be_true
56
+ expect(@tree.has_key?(@random_array[0])).to be true
57
57
  end
58
58
 
59
59
  it "should remove any key" do
60
60
  random_key = @random_array[rand(@num_items)]
61
- @tree.has_key?(random_key).should be_true
62
- @tree.delete(random_key).should eql(random_key)
63
- @tree.has_key?(random_key).should be_false
61
+ expect(@tree.has_key?(random_key)).to be true
62
+ expect(@tree.delete(random_key)).to eql(random_key)
63
+ expect(@tree.has_key?(random_key)).to be false
64
64
  end
65
65
 
66
66
  it "should let you iterate with #each" do
67
67
  counter = 0
68
68
  sorted_array = @random_array.uniq.sort
69
69
  @tree.each do |key, val|
70
- key.should eql(sorted_array[counter])
70
+ expect(key).to eql(sorted_array[counter])
71
71
  counter += 1
72
72
  end
73
73
  end
data/spec/stack_spec.rb CHANGED
@@ -7,20 +7,20 @@ describe "empty stack" do
7
7
  end
8
8
 
9
9
  it "should return nil when sent #pop" do
10
- @stack.pop.should be_nil
10
+ expect(@stack.pop).to be_nil
11
11
  end
12
12
 
13
13
  it "should return a size of 1 when sent #push" do
14
14
  @stack.push(1)
15
- @stack.size.should eql(1)
15
+ expect(@stack.size).to eql(1)
16
16
  end
17
17
 
18
18
  it "should return nil when sent #next" do
19
- @stack.next.should be_nil
19
+ expect(@stack.next).to be_nil
20
20
  end
21
21
 
22
22
  it "should return empty?" do
23
- @stack.empty?.should be_true
23
+ expect(@stack.empty?).to be true
24
24
  end
25
25
  end
26
26
 
@@ -32,29 +32,29 @@ describe "non-empty stack" do
32
32
  end
33
33
 
34
34
  it "should return last pushed object" do
35
- @stack.pop.should eql("10")
35
+ expect(@stack.pop).to eql("10")
36
36
  end
37
37
 
38
38
  it "should return the size" do
39
- @stack.size.should eql(2)
39
+ expect(@stack.size).to eql(2)
40
40
  end
41
41
 
42
42
  it "should not return empty?" do
43
- @stack.empty?.should be_false
43
+ expect(@stack.empty?).to be false
44
44
  end
45
45
 
46
46
 
47
47
  it "should iterate in LIFO order" do
48
48
  arr = []
49
49
  @stack.each { |obj| arr << obj }
50
- arr.should eql(["10", 10])
50
+ expect(arr).to eql(["10", 10])
51
51
  end
52
52
 
53
53
  it "should return nil after all pops" do
54
54
  @stack.pop
55
55
  @stack.pop
56
- @stack.pop.should be_nil
57
- @stack.next.should be_nil
56
+ expect(@stack.pop).to be_nil
57
+ expect(@stack.next).to be_nil
58
58
  end
59
59
 
60
60
  end
data/spec/string_spec.rb CHANGED
@@ -4,12 +4,12 @@ require 'algorithms'
4
4
  if defined? Algorithms::String
5
5
  describe "string algorithms" do
6
6
  it "should do levenshtein distance" do
7
- Algorithms::String.levenshtein_dist("Hello", "Hel").should eql(2)
8
- Algorithms::String.levenshtein_dist("Hello", "").should eql(5)
9
- Algorithms::String.levenshtein_dist("", "Hello").should eql(5)
10
- Algorithms::String.levenshtein_dist("Hello", "Hello").should eql(0)
11
- Algorithms::String.levenshtein_dist("Hello", "ello").should eql(1)
12
- Algorithms::String.levenshtein_dist("Hello", "Mello").should eql(1)
7
+ expect(Algorithms::String.levenshtein_dist("Hello", "Hel")).to eql(2)
8
+ expect(Algorithms::String.levenshtein_dist("Hello", "")).to eql(5)
9
+ expect(Algorithms::String.levenshtein_dist("", "Hello")).to eql(5)
10
+ expect(Algorithms::String.levenshtein_dist("Hello", "Hello")).to eql(0)
11
+ expect(Algorithms::String.levenshtein_dist("Hello", "ello")).to eql(1)
12
+ expect(Algorithms::String.levenshtein_dist("Hello", "Mello")).to eql(1)
13
13
  end
14
14
  end
15
15
  end
@@ -3,7 +3,7 @@ require 'algorithms'
3
3
 
4
4
  describe "empty suffix array" do
5
5
  it "should not initialize with empty string" do
6
- lambda { Containers::SuffixArray.new("") }.should raise_error
6
+ expect { Containers::SuffixArray.new("") }.to raise_error(ArgumentError)
7
7
  end
8
8
  end
9
9
 
@@ -13,28 +13,28 @@ describe "non-empty suffix array" do
13
13
  end
14
14
 
15
15
  it "should has_substring? each possible substring" do
16
- @s_array.has_substring?("a").should be_true
17
- @s_array.has_substring?("abra").should be_true
18
- @s_array.has_substring?("abracadabra").should be_true
19
- @s_array.has_substring?("acadabra").should be_true
20
- @s_array.has_substring?("adabra").should be_true
21
- @s_array.has_substring?("bra").should be_true
22
- @s_array.has_substring?("bracadabra").should be_true
23
- @s_array.has_substring?("cadabra").should be_true
24
- @s_array.has_substring?("dabra").should be_true
25
- @s_array.has_substring?("ra").should be_true
26
- @s_array.has_substring?("racadabra").should be_true
16
+ expect(@s_array.has_substring?("a")).to be true
17
+ expect(@s_array.has_substring?("abra")).to be true
18
+ expect(@s_array.has_substring?("abracadabra")).to be true
19
+ expect(@s_array.has_substring?("acadabra")).to be true
20
+ expect(@s_array.has_substring?("adabra")).to be true
21
+ expect(@s_array.has_substring?("bra")).to be true
22
+ expect(@s_array.has_substring?("bracadabra")).to be true
23
+ expect(@s_array.has_substring?("cadabra")).to be true
24
+ expect(@s_array.has_substring?("dabra")).to be true
25
+ expect(@s_array.has_substring?("ra")).to be true
26
+ expect(@s_array.has_substring?("racadabra")).to be true
27
27
  end
28
28
 
29
29
  it "should not has_substring? substrings it does not have" do
30
- @s_array.has_substring?("nope").should be_false
31
- @s_array.has_substring?(nil).should be_false
30
+ expect(@s_array.has_substring?("nope")).to be false
31
+ expect(@s_array.has_substring?(nil)).to be false
32
32
  end
33
33
 
34
34
  it "should work with numbers (calls to_s)" do
35
35
  number = Containers::SuffixArray.new(123456789)
36
- number[1].should be_true
37
- number.has_substring?(12).should be_true
38
- number.has_substring?(13).should be_false
36
+ expect(number[1]).to be true
37
+ expect(number.has_substring?(12)).to be true
38
+ expect(number.has_substring?(13)).to be false
39
39
  end
40
40
  end
data/spec/trie_spec.rb CHANGED
@@ -7,13 +7,13 @@ describe "empty trie" do
7
7
  end
8
8
 
9
9
  it "should not get or has_key?" do
10
- @trie.get("anything").should be_nil
11
- @trie.has_key?("anything").should be_false
10
+ expect(@trie.get("anything")).to be_nil
11
+ expect(@trie.has_key?("anything")).to be false
12
12
  end
13
13
 
14
14
  it "should not have longest_prefix or match wildcards" do
15
- @trie.wildcard("an*thing").should eql([])
16
- @trie.longest_prefix("an*thing").should eql("")
15
+ expect(@trie.wildcard("an*thing")).to eql([])
16
+ expect(@trie.longest_prefix("an*thing")).to eql("")
17
17
  end
18
18
  end
19
19
 
@@ -27,33 +27,33 @@ describe "non-empty trie" do
27
27
  end
28
28
 
29
29
  it "should has_key? keys it has" do
30
- @trie.has_key?("Hello").should be_true
31
- @trie.has_key?("Hello, brother").should be_true
32
- @trie.has_key?("Hello, bob").should be_true
30
+ expect(@trie.has_key?("Hello")).to be true
31
+ expect(@trie.has_key?("Hello, brother")).to be true
32
+ expect(@trie.has_key?("Hello, bob")).to be true
33
33
  end
34
34
 
35
35
  it "should not has_key? keys it doesn't have" do
36
- @trie.has_key?("Nope").should be_false
36
+ expect(@trie.has_key?("Nope")).to be false
37
37
  end
38
38
 
39
39
  it "should get values" do
40
- @trie.get("Hello").should eql("World")
40
+ expect(@trie.get("Hello")).to eql("World")
41
41
  end
42
42
 
43
43
  it "should overwrite values" do
44
44
  @trie.push("Hello", "John")
45
- @trie.get("Hello").should eql("John")
45
+ expect(@trie.get("Hello")).to eql("John")
46
46
  end
47
47
 
48
48
  it "should return longest prefix" do
49
- @trie.longest_prefix("Hello, brandon").should eql("Hello")
50
- @trie.longest_prefix("Hel").should eql("")
51
- @trie.longest_prefix("Hello").should eql("Hello")
52
- @trie.longest_prefix("Hello, bob").should eql("Hello, bob")
49
+ expect(@trie.longest_prefix("Hello, brandon")).to eql("Hello")
50
+ expect(@trie.longest_prefix("Hel")).to eql("")
51
+ expect(@trie.longest_prefix("Hello")).to eql("Hello")
52
+ expect(@trie.longest_prefix("Hello, bob")).to eql("Hello, bob")
53
53
  end
54
54
 
55
55
  it "should match wildcards" do
56
- @trie.wildcard("H*ll.").should eql(["Hello", "Hilly"])
57
- @trie.wildcard("Hel").should eql([])
56
+ expect(@trie.wildcard("H*ll.")).to eql(["Hello", "Hilly"])
57
+ expect(@trie.wildcard("Hel")).to eql([])
58
58
  end
59
59
  end