Code Coverage Tools

1images:
2    stage: build
3    image: docker
4    services:
5        - docker:dind
6    script:
7        - docker login -u gitlab-ci-token -p $CI_JOB_TOKEN $CI_REGISTRY # login
8        # pull the current image or in case the image does not exit, do not stop the script:
9        - docker pull $CI_REGISTRY_IMAGE:latest || true
10        # build with the pulled image as cache:
11        - docker build --pull --cache-from $CI_REGISTRY_IMAGE:latest -t "$CI_REGISTRY_IMAGE:latest" .
12        # push the final image:
13        - docker push "$CI_REGISTRY_IMAGE:latest"
14
15

1Get-ChildItem -Recurse -Filter "*.coverage" | % {
2$outfile = "$([System.IO.Path]::GetFileNameWithoutExtension($_.FullName)).coveragexml"
3$output = [System.IO.Path]::Combine([System.IO.Path]::GetDirectoryName($_.FullName), $outfile)
4"Analyse '$($_.Name)' with output '$outfile'..."
5. "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Team Tools\Dynamic Code Coverage Tools\codecoverage.exe" analyze /output:$output $_.FullName
6}
7Get-ChildItem -Recurse -Filter "*.coverage" | sort LastWriteTime | select -last 1
8

1enum_cases = [:a, :b, :c]
2
3def foo(input)
4    case input
5    when :a then 1
6    when :b then 2
7    when :c then 3
8    else raise NotImplementedError, "Unhandled new case: #{input}"
9    end
10end
11class FooHelperTests < ActionView::TestCase
12  test "foo handles all enum cases" do
13    assert_equal foo(:a), 1
14    assert_equal foo(:b), 2
15    assert_equal foo(:c), 3
16    assert_raises NotImplementedError do
17        foo(:d)
18    end
19  end
20end
21test "foo handles all enum cases" do
22  remaining_cases = enum_cases.to_set
23
24  tester = -> (arg) do
25    remaining_cases.delete(arg)
26    foo(arg)
27  end
28
29  assert_equal tester.call(:a), 1
30  assert_equal tester.call(:b), 2
31  assert_equal tester.call(:c), 3
32  assert_raises NotImplementedError do
33    tester.call(:d)
34  end
35
36  assert_empty remaining_cases, "Not all cases were tested! Remaining: #{remaining_cases}"
37end
38class ExhaustivityChecker
39  def initialize(all_values, proc)
40    @remaining_values = all_values.to_set
41    @proc = proc
42  end
43
44  def run(arg, allow_invalid_args: false)
45    assert @remaining_values.include?(arg) unless allow_invalid_args 
46    @remaining_values.delete(arg)
47    @proc.call(arg)
48  end
49
50  def assert_all_values_checked
51    assert_empty @remaining_values, "Not all values were tested! Remaining: #{@remaining_values}"
52  end
53end
54test "foo handles all enum cases" do
55    tester = ExhaustivityChecker.new(enum_cases, -> (arg) { foo(arg) })
56
57    assert_equal tester.run(:a), 1
58    assert_equal tester.run(:b), 2
59    assert_equal tester.run(:c), 3
60    assert_raises NotImplementedError do
61        tester.run(:d, allow_invalid_args: true)
62    end
63
64    tester.assert_all_values_checked
65end
66def foo_handlers
67  {
68    a: 1,
69    b: 2,
70    c: 3
71  }.freeze
72end
73
74def foo(input)
75  foo_handlers.fetch(input)
76rescue KeyError
77  raise NotImplementedError, "Unhandled new case: #{input}"
78end
79

1enum_cases = [:a, :b, :c]
2
3def foo(input)
4    case input
5    when :a then 1
6    when :b then 2
7    when :c then 3
8    else raise NotImplementedError, "Unhandled new case: #{input}"
9    end
10end
11class FooHelperTests < ActionView::TestCase
12  test "foo handles all enum cases" do
13    assert_equal foo(:a), 1
14    assert_equal foo(:b), 2
15    assert_equal foo(:c), 3
16    assert_raises NotImplementedError do
17        foo(:d)
18    end
19  end
20end
21test "foo handles all enum cases" do
22  remaining_cases = enum_cases.to_set
23
24  tester = -> (arg) do
25    remaining_cases.delete(arg)
26    foo(arg)
27  end
28
29  assert_equal tester.call(:a), 1
30  assert_equal tester.call(:b), 2
31  assert_equal tester.call(:c), 3
32  assert_raises NotImplementedError do
33    tester.call(:d)
34  end
35
36  assert_empty remaining_cases, "Not all cases were tested! Remaining: #{remaining_cases}"
37end
38class ExhaustivityChecker
39  def initialize(all_values, proc)
40    @remaining_values = all_values.to_set
41    @proc = proc
42  end
43
44  def run(arg, allow_invalid_args: false)
45    assert @remaining_values.include?(arg) unless allow_invalid_args 
46    @remaining_values.delete(arg)
47    @proc.call(arg)
48  end
49
50  def assert_all_values_checked
51    assert_empty @remaining_values, "Not all values were tested! Remaining: #{@remaining_values}"
52  end
53end
54test "foo handles all enum cases" do
55    tester = ExhaustivityChecker.new(enum_cases, -> (arg) { foo(arg) })
56
57    assert_equal tester.run(:a), 1
58    assert_equal tester.run(:b), 2
59    assert_equal tester.run(:c), 3
60    assert_raises NotImplementedError do
61        tester.run(:d, allow_invalid_args: true)
62    end
63
64    tester.assert_all_values_checked
65end
66def foo_handlers
67  {
68    a: 1,
69    b: 2,
70    c: 3
71  }.freeze
72end
73
74def foo(input)
75  foo_handlers.fetch(input)
76rescue KeyError
77  raise NotImplementedError, "Unhandled new case: #{input}"
78end
79class FooHelperTests < ActionView::TestCase
80  test "foo handles all expected inputs" do
81    expected = {
82      a: 1,
83      b: 2,
84      c: 3
85    }.freeze
86
87    # Verify expect has all the cases.
88    assert_equal expect.keys.sort, foo_handlers.keys.sort
89
90    # Drive the test with the expected results, not with the production data.
91    expected.keys do |key|
92      # Again, using `fetch` to get a clear KeyError rather than nil.
93      assert_equal foo(key), expected.fetch(value)
94    end
95  end
96
97  # Simplify the tests by separating happy path from error path.
98  test "foo raises NotImplementedError if the input is not handled" do
99    assert_raises NotImplementedError do
100      # Use something that obviously does not exist to future proof the test.
101      foo(:does_not_exist)
102    end
103  end
104end
105

1enum_cases = [:a, :b, :c]
2
3def foo(input)
4    case input
5    when :a then 1
6    when :b then 2
7    when :c then 3
8    else raise NotImplementedError, "Unhandled new case: #{input}"
9    end
10end
11class FooHelperTests < ActionView::TestCase
12  test "foo handles all enum cases" do
13    assert_equal foo(:a), 1
14    assert_equal foo(:b), 2
15    assert_equal foo(:c), 3
16    assert_raises NotImplementedError do
17        foo(:d)
18    end
19  end
20end
21test "foo handles all enum cases" do
22  remaining_cases = enum_cases.to_set
23
24  tester = -> (arg) do
25    remaining_cases.delete(arg)
26    foo(arg)
27  end
28
29  assert_equal tester.call(:a), 1
30  assert_equal tester.call(:b), 2
31  assert_equal tester.call(:c), 3
32  assert_raises NotImplementedError do
33    tester.call(:d)
34  end
35
36  assert_empty remaining_cases, "Not all cases were tested! Remaining: #{remaining_cases}"
37end
38class ExhaustivityChecker
39  def initialize(all_values, proc)
40    @remaining_values = all_values.to_set
41    @proc = proc
42  end
43
44  def run(arg, allow_invalid_args: false)
45    assert @remaining_values.include?(arg) unless allow_invalid_args 
46    @remaining_values.delete(arg)
47    @proc.call(arg)
48  end
49
50  def assert_all_values_checked
51    assert_empty @remaining_values, "Not all values were tested! Remaining: #{@remaining_values}"
52  end
53end
54test "foo handles all enum cases" do
55    tester = ExhaustivityChecker.new(enum_cases, -> (arg) { foo(arg) })
56
57    assert_equal tester.run(:a), 1
58    assert_equal tester.run(:b), 2
59    assert_equal tester.run(:c), 3
60    assert_raises NotImplementedError do
61        tester.run(:d, allow_invalid_args: true)
62    end
63
64    tester.assert_all_values_checked
65end
66def foo_handlers
67  {
68    a: 1,
69    b: 2,
70    c: 3
71  }.freeze
72end
73
74def foo(input)
75  foo_handlers.fetch(input)
76rescue KeyError
77  raise NotImplementedError, "Unhandled new case: #{input}"
78end
79class FooHelperTests < ActionView::TestCase
80  test "foo handles all expected inputs" do
81    expected = {
82      a: 1,
83      b: 2,
84      c: 3
85    }.freeze
86
87    # Verify expect has all the cases.
88    assert_equal expect.keys.sort, foo_handlers.keys.sort
89
90    # Drive the test with the expected results, not with the production data.
91    expected.keys do |key|
92      # Again, using `fetch` to get a clear KeyError rather than nil.
93      assert_equal foo(key), expected.fetch(value)
94    end
95  end
96
97  # Simplify the tests by separating happy path from error path.
98  test "foo raises NotImplementedError if the input is not handled" do
99    assert_raises NotImplementedError do
100      # Use something that obviously does not exist to future proof the test.
101      foo(:does_not_exist)
102    end
103  end
104end
105class Thing
106  attr_accessor :foo_handlers
107
108  # This can use a constant, as long as the method call is canonical.
109  def default_foo_handlers
110    {
111      a: 1,
112      b: 2,
113      c: 3
114    }.freeze
115  end
116
117  def initialize
118    @foo_handlers = default_foo_handlers
119  end
120
121  def foo(input)
122    foo_handlers.fetch(input)
123  rescue KeyError
124    raise NotImplementedError, "Unhandled new case: #{input}"
125  end
126end
127

1enum_cases = [:a, :b, :c]
2
3def foo(input)
4    case input
5    when :a then 1
6    when :b then 2
7    when :c then 3
8    else raise NotImplementedError, "Unhandled new case: #{input}"
9    end
10end
11class FooHelperTests < ActionView::TestCase
12  test "foo handles all enum cases" do
13    assert_equal foo(:a), 1
14    assert_equal foo(:b), 2
15    assert_equal foo(:c), 3
16    assert_raises NotImplementedError do
17        foo(:d)
18    end
19  end
20end
21test "foo handles all enum cases" do
22  remaining_cases = enum_cases.to_set
23
24  tester = -> (arg) do
25    remaining_cases.delete(arg)
26    foo(arg)
27  end
28
29  assert_equal tester.call(:a), 1
30  assert_equal tester.call(:b), 2
31  assert_equal tester.call(:c), 3
32  assert_raises NotImplementedError do
33    tester.call(:d)
34  end
35
36  assert_empty remaining_cases, "Not all cases were tested! Remaining: #{remaining_cases}"
37end
38class ExhaustivityChecker
39  def initialize(all_values, proc)
40    @remaining_values = all_values.to_set
41    @proc = proc
42  end
43
44  def run(arg, allow_invalid_args: false)
45    assert @remaining_values.include?(arg) unless allow_invalid_args 
46    @remaining_values.delete(arg)
47    @proc.call(arg)
48  end
49
50  def assert_all_values_checked
51    assert_empty @remaining_values, "Not all values were tested! Remaining: #{@remaining_values}"
52  end
53end
54test "foo handles all enum cases" do
55    tester = ExhaustivityChecker.new(enum_cases, -> (arg) { foo(arg) })
56
57    assert_equal tester.run(:a), 1
58    assert_equal tester.run(:b), 2
59    assert_equal tester.run(:c), 3
60    assert_raises NotImplementedError do
61        tester.run(:d, allow_invalid_args: true)
62    end
63
64    tester.assert_all_values_checked
65end
66def foo_handlers
67  {
68    a: 1,
69    b: 2,
70    c: 3
71  }.freeze
72end
73
74def foo(input)
75  foo_handlers.fetch(input)
76rescue KeyError
77  raise NotImplementedError, "Unhandled new case: #{input}"
78end
79class FooHelperTests < ActionView::TestCase
80  test "foo handles all expected inputs" do
81    expected = {
82      a: 1,
83      b: 2,
84      c: 3
85    }.freeze
86
87    # Verify expect has all the cases.
88    assert_equal expect.keys.sort, foo_handlers.keys.sort
89
90    # Drive the test with the expected results, not with the production data.
91    expected.keys do |key|
92      # Again, using `fetch` to get a clear KeyError rather than nil.
93      assert_equal foo(key), expected.fetch(value)
94    end
95  end
96
97  # Simplify the tests by separating happy path from error path.
98  test "foo raises NotImplementedError if the input is not handled" do
99    assert_raises NotImplementedError do
100      # Use something that obviously does not exist to future proof the test.
101      foo(:does_not_exist)
102    end
103  end
104end
105class Thing
106  attr_accessor :foo_handlers
107
108  # This can use a constant, as long as the method call is canonical.
109  def default_foo_handlers
110    {
111      a: 1,
112      b: 2,
113      c: 3
114    }.freeze
115  end
116
117  def initialize
118    @foo_handlers = default_foo_handlers
119  end
120
121  def foo(input)
122    foo_handlers.fetch(input)
123  rescue KeyError
124    raise NotImplementedError, "Unhandled new case: #{input}"
125  end
126end
127thing = Thing.new
128puts thing.foo(:a) # 1
129puts thing.foo(:b) # 2
130
131thing.foo_handlers = { a: 23 }
132puts thing.foo(:a) # 23
133puts thing.foo(:b) # NotImplementedError
134

1enum_cases = [:a, :b, :c]
2
3def foo(input)
4    case input
5    when :a then 1
6    when :b then 2
7    when :c then 3
8    else raise NotImplementedError, "Unhandled new case: #{input}"
9    end
10end
11class FooHelperTests < ActionView::TestCase
12  test "foo handles all enum cases" do
13    assert_equal foo(:a), 1
14    assert_equal foo(:b), 2
15    assert_equal foo(:c), 3
16    assert_raises NotImplementedError do
17        foo(:d)
18    end
19  end
20end
21test "foo handles all enum cases" do
22  remaining_cases = enum_cases.to_set
23
24  tester = -> (arg) do
25    remaining_cases.delete(arg)
26    foo(arg)
27  end
28
29  assert_equal tester.call(:a), 1
30  assert_equal tester.call(:b), 2
31  assert_equal tester.call(:c), 3
32  assert_raises NotImplementedError do
33    tester.call(:d)
34  end
35
36  assert_empty remaining_cases, "Not all cases were tested! Remaining: #{remaining_cases}"
37end
38class ExhaustivityChecker
39  def initialize(all_values, proc)
40    @remaining_values = all_values.to_set
41    @proc = proc
42  end
43
44  def run(arg, allow_invalid_args: false)
45    assert @remaining_values.include?(arg) unless allow_invalid_args 
46    @remaining_values.delete(arg)
47    @proc.call(arg)
48  end
49
50  def assert_all_values_checked
51    assert_empty @remaining_values, "Not all values were tested! Remaining: #{@remaining_values}"
52  end
53end
54test "foo handles all enum cases" do
55    tester = ExhaustivityChecker.new(enum_cases, -> (arg) { foo(arg) })
56
57    assert_equal tester.run(:a), 1
58    assert_equal tester.run(:b), 2
59    assert_equal tester.run(:c), 3
60    assert_raises NotImplementedError do
61        tester.run(:d, allow_invalid_args: true)
62    end
63
64    tester.assert_all_values_checked
65end
66def foo_handlers
67  {
68    a: 1,
69    b: 2,
70    c: 3
71  }.freeze
72end
73
74def foo(input)
75  foo_handlers.fetch(input)
76rescue KeyError
77  raise NotImplementedError, "Unhandled new case: #{input}"
78end
79class FooHelperTests < ActionView::TestCase
80  test "foo handles all expected inputs" do
81    expected = {
82      a: 1,
83      b: 2,
84      c: 3
85    }.freeze
86
87    # Verify expect has all the cases.
88    assert_equal expect.keys.sort, foo_handlers.keys.sort
89
90    # Drive the test with the expected results, not with the production data.
91    expected.keys do |key|
92      # Again, using `fetch` to get a clear KeyError rather than nil.
93      assert_equal foo(key), expected.fetch(value)
94    end
95  end
96
97  # Simplify the tests by separating happy path from error path.
98  test "foo raises NotImplementedError if the input is not handled" do
99    assert_raises NotImplementedError do
100      # Use something that obviously does not exist to future proof the test.
101      foo(:does_not_exist)
102    end
103  end
104end
105class Thing
106  attr_accessor :foo_handlers
107
108  # This can use a constant, as long as the method call is canonical.
109  def default_foo_handlers
110    {
111      a: 1,
112      b: 2,
113      c: 3
114    }.freeze
115  end
116
117  def initialize
118    @foo_handlers = default_foo_handlers
119  end
120
121  def foo(input)
122    foo_handlers.fetch(input)
123  rescue KeyError
124    raise NotImplementedError, "Unhandled new case: #{input}"
125  end
126end
127thing = Thing.new
128puts thing.foo(:a) # 1
129puts thing.foo(:b) # 2
130
131thing.foo_handlers = { a: 23 }
132puts thing.foo(:a) # 23
133puts thing.foo(:b) # NotImplementedError
134class Thing::More < Thing
135  def default_foo_handlers
136    super.merge(
137      d: 4,
138      e: 5
139    )
140  end
141end
142
143thing = Thing.new
144more = Thing::More.new
145
146puts more.foo(:d)  # 4
147puts thing.foo(:d) # NotImplementedError
148

1enum_cases = [:a, :b, :c]
2
3def foo(input)
4    case input
5    when :a then 1
6    when :b then 2
7    when :c then 3
8    else raise NotImplementedError, "Unhandled new case: #{input}"
9    end
10end
11class FooHelperTests < ActionView::TestCase
12  test "foo handles all enum cases" do
13    assert_equal foo(:a), 1
14    assert_equal foo(:b), 2
15    assert_equal foo(:c), 3
16    assert_raises NotImplementedError do
17        foo(:d)
18    end
19  end
20end
21test "foo handles all enum cases" do
22  remaining_cases = enum_cases.to_set
23
24  tester = -> (arg) do
25    remaining_cases.delete(arg)
26    foo(arg)
27  end
28
29  assert_equal tester.call(:a), 1
30  assert_equal tester.call(:b), 2
31  assert_equal tester.call(:c), 3
32  assert_raises NotImplementedError do
33    tester.call(:d)
34  end
35
36  assert_empty remaining_cases, "Not all cases were tested! Remaining: #{remaining_cases}"
37end
38class ExhaustivityChecker
39  def initialize(all_values, proc)
40    @remaining_values = all_values.to_set
41    @proc = proc
42  end
43
44  def run(arg, allow_invalid_args: false)
45    assert @remaining_values.include?(arg) unless allow_invalid_args 
46    @remaining_values.delete(arg)
47    @proc.call(arg)
48  end
49
50  def assert_all_values_checked
51    assert_empty @remaining_values, "Not all values were tested! Remaining: #{@remaining_values}"
52  end
53end
54test "foo handles all enum cases" do
55    tester = ExhaustivityChecker.new(enum_cases, -> (arg) { foo(arg) })
56
57    assert_equal tester.run(:a), 1
58    assert_equal tester.run(:b), 2
59    assert_equal tester.run(:c), 3
60    assert_raises NotImplementedError do
61        tester.run(:d, allow_invalid_args: true)
62    end
63
64    tester.assert_all_values_checked
65end
66def foo_handlers
67  {
68    a: 1,
69    b: 2,
70    c: 3
71  }.freeze
72end
73
74def foo(input)
75  foo_handlers.fetch(input)
76rescue KeyError
77  raise NotImplementedError, "Unhandled new case: #{input}"
78end
79class FooHelperTests < ActionView::TestCase
80  test "foo handles all expected inputs" do
81    expected = {
82      a: 1,
83      b: 2,
84      c: 3
85    }.freeze
86
87    # Verify expect has all the cases.
88    assert_equal expect.keys.sort, foo_handlers.keys.sort
89
90    # Drive the test with the expected results, not with the production data.
91    expected.keys do |key|
92      # Again, using `fetch` to get a clear KeyError rather than nil.
93      assert_equal foo(key), expected.fetch(value)
94    end
95  end
96
97  # Simplify the tests by separating happy path from error path.
98  test "foo raises NotImplementedError if the input is not handled" do
99    assert_raises NotImplementedError do
100      # Use something that obviously does not exist to future proof the test.
101      foo(:does_not_exist)
102    end
103  end
104end
105class Thing
106  attr_accessor :foo_handlers
107
108  # This can use a constant, as long as the method call is canonical.
109  def default_foo_handlers
110    {
111      a: 1,
112      b: 2,
113      c: 3
114    }.freeze
115  end
116
117  def initialize
118    @foo_handlers = default_foo_handlers
119  end
120
121  def foo(input)
122    foo_handlers.fetch(input)
123  rescue KeyError
124    raise NotImplementedError, "Unhandled new case: #{input}"
125  end
126end
127thing = Thing.new
128puts thing.foo(:a) # 1
129puts thing.foo(:b) # 2
130
131thing.foo_handlers = { a: 23 }
132puts thing.foo(:a) # 23
133puts thing.foo(:b) # NotImplementedError
134class Thing::More < Thing
135  def default_foo_handlers
136    super.merge(
137      d: 4,
138      e: 5
139    )
140  end
141end
142
143thing = Thing.new
144more = Thing::More.new
145
146puts more.foo(:d)  # 4
147puts thing.foo(:d) # NotImplementedError
148def foo_handlers
149  {
150    a: :handle_a,
151    b: :handle_b,
152    c: :handle_c
153  }.freeze
154end
155
156def foo(input)
157  public_send(foo_handlers.fetch(input), input)
158rescue KeyError
159  raise NotImplementedError, "Unhandled new case: #{input}"
160end
161
162def handle_a(input)
163  ...
164end
165
166def handle_b(input)
167  ...
168end
169
170def handle_c(input)
171  ...
172end
173