summaryrefslogtreecommitdiff
path: root/tool/test/testunit/test_sorting.rb
blob: 3e5d7bfdcceb7f7ee27356006b46c628e27c54f0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
# frozen_string_literal: false
require 'test/unit'

class TestTestUnitSorting < Test::Unit::TestCase
  def test_sorting
    result = sorting("--show-skip")
    assert_match(/^  1\) Skipped:/, result)
    assert_match(/^  2\) Failure:/, result)
    assert_match(/^  3\) Error:/,   result)
  end

  def sorting(*args)
    IO.popen([*@__runner_options__[:ruby], "#{File.dirname(__FILE__)}/test4test_sorting.rb",
              "--verbose", *args], err: [:child, :out]) {|f|
      f.read
    }
  end

  Item = Struct.new(:name)
  SEED = 0x50975eed

  def make_test_list
    (1..16).map {"test_%.3x" % rand(0x1000)}.freeze
  end

  def test_sort_alpha
    sorter = Test::Unit::Order::Types[:alpha].new(SEED)
    assert_kind_of(Test::Unit::Order::Types[:sorted], sorter)

    list = make_test_list
    sorted = list.sort
    16.times do
      assert_equal(sorted, sorter.sort_by_string(list))
    end

    list = list.map {|s| Item.new(s)}.freeze
    sorted = list.sort_by(&:name)
    16.times do
      assert_equal(sorted, sorter.sort_by_name(list))
    end
  end

  def test_sort_nosort
    sorter = Test::Unit::Order::Types[:nosort].new(SEED)

    list = make_test_list
    16.times do
      assert_equal(list, sorter.sort_by_string(list))
    end

    list = list.map {|s| Item.new(s)}.freeze
    16.times do
      assert_equal(list, sorter.sort_by_name(list))
    end
  end

  def test_sort_random
    type = Test::Unit::Order::Types[:random]
    sorter = type.new(SEED)

    list = make_test_list
    sorted = type.new(SEED).sort_by_string(list).freeze
    16.times do
      assert_equal(sorted, sorter.sort_by_string(list))
    end
    assert_not_equal(sorted, type.new(SEED+1).sort_by_string(list))

    list = list.map {|s| Item.new(s)}.freeze
    sorted = sorted.map {|s| Item.new(s)}.freeze
    16.times do
      assert_equal(sorted, sorter.sort_by_name(list))
    end
    assert_not_equal(sorted, type.new(SEED+1).sort_by_name(list))
  end
end